diff options
Diffstat (limited to 'vendor/github.com')
155 files changed, 39502 insertions, 550 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 new file mode 100644 index 00000000..3eca02cd --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/chat.go @@ -0,0 +1,651 @@ +package kbchat + +import ( + "encoding/json" + "errors" + "fmt" + + "github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1" + "github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1" +) + +type Thread struct { + Result chat1.Thread `json:"result"` + Error *Error `json:"error,omitempty"` +} + +type Inbox struct { + Result Result `json:"result"` + Error *Error `json:"error,omitempty"` +} + +type sendMessageBody struct { + Body string +} + +type sendMessageOptions struct { + Channel chat1.ChatChannel `json:"channel,omitempty"` + ConversationID chat1.ConvIDStr `json:"conversation_id,omitempty"` + Message sendMessageBody `json:",omitempty"` + Filename string `json:"filename,omitempty"` + Title string `json:"title,omitempty"` + MsgID chat1.MessageID `json:"message_id,omitempty"` + ConfirmLumenSend bool `json:"confirm_lumen_send"` + ReplyTo *chat1.MessageID `json:"reply_to,omitempty"` +} + +type sendMessageParams struct { + Options sendMessageOptions +} + +type sendMessageArg struct { + Method string + Params sendMessageParams +} + +func newSendArg(options sendMessageOptions) sendMessageArg { + return sendMessageArg{ + Method: "send", + Params: sendMessageParams{ + Options: options, + }, + } +} + +// GetConversations reads all conversations from the current user's inbox. +func (a *API) GetConversations(unreadOnly bool) ([]chat1.ConvSummary, error) { + apiInput := fmt.Sprintf(`{"method":"list", "params": { "options": { "unread_only": %v}}}`, unreadOnly) + output, err := a.doFetch(apiInput) + if err != nil { + return nil, err + } + + var inbox Inbox + if err := json.Unmarshal(output, &inbox); err != nil { + return nil, err + } else if inbox.Error != nil { + return nil, errors.New(inbox.Error.Message) + } + return inbox.Result.Convs, nil +} + +func (a *API) GetConversation(convID chat1.ConvIDStr) (res chat1.ConvSummary, err error) { + apiInput := fmt.Sprintf(`{"method":"list", "params": { "options": { "conversation_id": "%s"}}}`, convID) + output, err := a.doFetch(apiInput) + if err != nil { + return res, err + } + + var inbox Inbox + if err := json.Unmarshal(output, &inbox); err != nil { + return res, err + } else if inbox.Error != nil { + return res, errors.New(inbox.Error.Message) + } else if len(inbox.Result.Convs) == 0 { + return res, errors.New("conversation not found") + } + return inbox.Result.Convs[0], nil +} + +// GetTextMessages fetches all text messages from a given channel. Optionally can filter +// ont unread status. +func (a *API) GetTextMessages(channel chat1.ChatChannel, unreadOnly bool) ([]chat1.MsgSummary, error) { + channelBytes, err := json.Marshal(channel) + if err != nil { + return nil, err + } + apiInput := fmt.Sprintf(`{"method": "read", "params": {"options": {"channel": %s}}}`, string(channelBytes)) + output, err := a.doFetch(apiInput) + if err != nil { + return nil, err + } + + var thread Thread + + if err := json.Unmarshal(output, &thread); err != nil { + return nil, fmt.Errorf("unable to decode thread: %v", err) + } else if thread.Error != nil { + return nil, errors.New(thread.Error.Message) + } + + var res []chat1.MsgSummary + for _, msg := range thread.Result.Messages { + if msg.Msg.Content.TypeName == "text" { + res = append(res, *msg.Msg) + } + } + + return res, nil +} + +func (a *API) SendMessage(channel chat1.ChatChannel, body string, args ...interface{}) (SendResponse, error) { + arg := newSendArg(sendMessageOptions{ + Channel: channel, + Message: sendMessageBody{ + Body: fmt.Sprintf(body, args...), + }, + }) + return a.doSend(arg) +} + +func (a *API) Broadcast(body string, args ...interface{}) (SendResponse, error) { + return a.SendMessage(chat1.ChatChannel{ + Name: a.GetUsername(), + Public: true, + }, fmt.Sprintf(body, args...)) +} + +func (a *API) SendMessageByConvID(convID chat1.ConvIDStr, body string, args ...interface{}) (SendResponse, error) { + arg := newSendArg(sendMessageOptions{ + ConversationID: convID, + Message: sendMessageBody{ + Body: fmt.Sprintf(body, args...), + }, + }) + return a.doSend(arg) +} + +// SendMessageByTlfName sends a message on the given TLF name +func (a *API) SendMessageByTlfName(tlfName string, body string, args ...interface{}) (SendResponse, error) { + arg := newSendArg(sendMessageOptions{ + Channel: chat1.ChatChannel{ + Name: tlfName, + }, + Message: sendMessageBody{ + Body: fmt.Sprintf(body, args...), + }, + }) + return a.doSend(arg) +} + +func (a *API) SendMessageByTeamName(teamName string, inChannel *string, body string, args ...interface{}) (SendResponse, error) { + channel := "general" + if inChannel != nil { + channel = *inChannel + } + arg := newSendArg(sendMessageOptions{ + Channel: chat1.ChatChannel{ + MembersType: "team", + Name: teamName, + TopicName: channel, + }, + Message: sendMessageBody{ + Body: fmt.Sprintf(body, args...), + }, + }) + return a.doSend(arg) +} + +func (a *API) SendReply(channel chat1.ChatChannel, replyTo *chat1.MessageID, body string, args ...interface{}) (SendResponse, error) { + arg := newSendArg(sendMessageOptions{ + Channel: channel, + Message: sendMessageBody{ + Body: fmt.Sprintf(body, args...), + }, + ReplyTo: replyTo, + }) + return a.doSend(arg) +} + +func (a *API) SendReplyByConvID(convID chat1.ConvIDStr, replyTo *chat1.MessageID, body string, args ...interface{}) (SendResponse, error) { + arg := newSendArg(sendMessageOptions{ + ConversationID: convID, + Message: sendMessageBody{ + Body: fmt.Sprintf(body, args...), + }, + ReplyTo: replyTo, + }) + return a.doSend(arg) +} + +func (a *API) SendReplyByTlfName(tlfName string, replyTo *chat1.MessageID, body string, args ...interface{}) (SendResponse, error) { + arg := newSendArg(sendMessageOptions{ + Channel: chat1.ChatChannel{ + Name: tlfName, + }, + Message: sendMessageBody{ + Body: fmt.Sprintf(body, args...), + }, + ReplyTo: replyTo, + }) + return a.doSend(arg) +} + +func (a *API) SendAttachmentByTeam(teamName string, inChannel *string, filename string, title string) (SendResponse, error) { + channel := "general" + if inChannel != nil { + channel = *inChannel + } + arg := sendMessageArg{ + Method: "attach", + Params: sendMessageParams{ + Options: sendMessageOptions{ + Channel: chat1.ChatChannel{ + MembersType: "team", + Name: teamName, + TopicName: channel, + }, + Filename: filename, + Title: title, + }, + }, + } + return a.doSend(arg) +} + +func (a *API) SendAttachmentByConvID(convID chat1.ConvIDStr, filename string, title string) (SendResponse, error) { + arg := sendMessageArg{ + Method: "attach", + Params: sendMessageParams{ + Options: sendMessageOptions{ + ConversationID: convID, + Filename: filename, + Title: title, + }, + }, + } + return a.doSend(arg) +} + +//////////////////////////////////////////////////////// +// React to chat /////////////////////////////////////// +//////////////////////////////////////////////////////// + +type reactionOptions struct { + ConversationID chat1.ConvIDStr `json:"conversation_id"` + Message sendMessageBody + MsgID chat1.MessageID `json:"message_id"` + Channel chat1.ChatChannel `json:"channel"` +} + +type reactionParams struct { + Options reactionOptions +} + +type reactionArg struct { + Method string + Params reactionParams +} + +func newReactionArg(options reactionOptions) reactionArg { + return reactionArg{ + Method: "reaction", + Params: reactionParams{Options: options}, + } +} + +func (a *API) ReactByChannel(channel chat1.ChatChannel, msgID chat1.MessageID, reaction string) (SendResponse, error) { + arg := newReactionArg(reactionOptions{ + Message: sendMessageBody{Body: reaction}, + MsgID: msgID, + Channel: channel, + }) + return a.doSend(arg) +} + +func (a *API) ReactByConvID(convID chat1.ConvIDStr, msgID chat1.MessageID, reaction string) (SendResponse, error) { + arg := newReactionArg(reactionOptions{ + Message: sendMessageBody{Body: reaction}, + MsgID: msgID, + ConversationID: convID, + }) + return a.doSend(arg) +} + +func (a *API) EditByConvID(convID chat1.ConvIDStr, msgID chat1.MessageID, text string) (SendResponse, error) { + arg := reactionArg{ + Method: "edit", + Params: reactionParams{Options: reactionOptions{ + Message: sendMessageBody{Body: text}, + MsgID: msgID, + ConversationID: convID, + }}, + } + return a.doSend(arg) +} + +//////////////////////////////////////////////////////// +// Manage channels ///////////////////////////////////// +//////////////////////////////////////////////////////// + +type ChannelsList struct { + Result Result `json:"result"` + Error *Error `json:"error,omitempty"` +} + +type JoinChannel struct { + Error *Error `json:"error,omitempty"` + Result chat1.EmptyRes `json:"result"` +} + +type LeaveChannel struct { + Error *Error `json:"error,omitempty"` + Result chat1.EmptyRes `json:"result"` +} + +func (a *API) ListChannels(teamName string) ([]string, error) { + apiInput := fmt.Sprintf(`{"method": "listconvsonname", "params": {"options": {"topic_type": "CHAT", "members_type": "team", "name": "%s"}}}`, teamName) + output, err := a.doFetch(apiInput) + if err != nil { + return nil, err + } + + var channelsList ChannelsList + if err := json.Unmarshal(output, &channelsList); err != nil { + return nil, err + } else if channelsList.Error != nil { + return nil, errors.New(channelsList.Error.Message) + } + + var channels []string + for _, conv := range channelsList.Result.Convs { + channels = append(channels, conv.Channel.TopicName) + } + return channels, nil +} + +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) + output, err := a.doFetch(apiInput) + if err != nil { + return empty, err + } + + joinChannel := JoinChannel{} + err = json.Unmarshal(output, &joinChannel) + if err != nil { + return empty, fmt.Errorf("failed to parse output from keybase team api: %v", err) + } else if joinChannel.Error != nil { + return empty, errors.New(joinChannel.Error.Message) + } + + return joinChannel.Result, nil +} + +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) + output, err := a.doFetch(apiInput) + if err != nil { + return empty, err + } + + leaveChannel := LeaveChannel{} + err = json.Unmarshal(output, &leaveChannel) + if err != nil { + return empty, fmt.Errorf("failed to parse output from keybase team api: %v", err) + } else if leaveChannel.Error != nil { + return empty, errors.New(leaveChannel.Error.Message) + } + + return leaveChannel.Result, nil +} + +//////////////////////////////////////////////////////// +// Send lumens in chat ///////////////////////////////// +//////////////////////////////////////////////////////// + +func (a *API) InChatSend(channel chat1.ChatChannel, body string, args ...interface{}) (SendResponse, error) { + arg := newSendArg(sendMessageOptions{ + Channel: channel, + Message: sendMessageBody{ + Body: fmt.Sprintf(body, args...), + }, + ConfirmLumenSend: true, + }) + return a.doSend(arg) +} + +func (a *API) InChatSendByConvID(convID chat1.ConvIDStr, body string, args ...interface{}) (SendResponse, error) { + arg := newSendArg(sendMessageOptions{ + ConversationID: convID, + Message: sendMessageBody{ + Body: fmt.Sprintf(body, args...), + }, + ConfirmLumenSend: true, + }) + return a.doSend(arg) +} + +func (a *API) InChatSendByTlfName(tlfName string, body string, args ...interface{}) (SendResponse, error) { + arg := newSendArg(sendMessageOptions{ + Channel: chat1.ChatChannel{ + Name: tlfName, + }, + Message: sendMessageBody{ + Body: fmt.Sprintf(body, args...), + }, + ConfirmLumenSend: true, + }) + return a.doSend(arg) +} + +//////////////////////////////////////////////////////// +// Misc commands /////////////////////////////////////// +//////////////////////////////////////////////////////// + +type Advertisement struct { + Alias string `json:"alias,omitempty"` + Advertisements []chat1.AdvertiseCommandAPIParam +} + +type ListCommandsResponse struct { + Result struct { + Commands []chat1.UserBotCommandOutput `json:"commands"` + } `json:"result"` + Error *Error `json:"error,omitempty"` +} + +type advertiseCmdsParams struct { + Options Advertisement +} + +type advertiseCmdsMsgArg struct { + Method string + Params advertiseCmdsParams +} + +func newAdvertiseCmdsMsgArg(ad Advertisement) advertiseCmdsMsgArg { + return advertiseCmdsMsgArg{ + Method: "advertisecommands", + Params: advertiseCmdsParams{ + Options: ad, + }, + } +} + +func (a *API) AdvertiseCommands(ad Advertisement) (SendResponse, error) { + return a.doSend(newAdvertiseCmdsMsgArg(ad)) +} + +func (a *API) ClearCommands() error { + arg := struct { + Method string + }{ + Method: "clearcommands", + } + _, err := a.doSend(arg) + return err +} + +type listCmdsOptions struct { + Channel chat1.ChatChannel `json:"channel,omitempty"` + ConversationID chat1.ConvIDStr `json:"conversation_id,omitempty"` +} + +type listCmdsParams struct { + Options listCmdsOptions +} + +type listCmdsArg struct { + Method string + Params listCmdsParams +} + +func newListCmdsArg(options listCmdsOptions) listCmdsArg { + return listCmdsArg{ + Method: "listcommands", + Params: listCmdsParams{ + Options: options, + }, + } +} + +func (a *API) ListCommands(channel chat1.ChatChannel) ([]chat1.UserBotCommandOutput, error) { + arg := newListCmdsArg(listCmdsOptions{ + Channel: channel, + }) + return a.listCommands(arg) +} + +func (a *API) ListCommandsByConvID(convID chat1.ConvIDStr) ([]chat1.UserBotCommandOutput, error) { + arg := newListCmdsArg(listCmdsOptions{ + ConversationID: convID, + }) + return a.listCommands(arg) +} + +func (a *API) listCommands(arg listCmdsArg) ([]chat1.UserBotCommandOutput, error) { + bArg, err := json.Marshal(arg) + if err != nil { + return nil, err + } + output, err := a.doFetch(string(bArg)) + if err != nil { + return nil, err + } + var res ListCommandsResponse + if err := json.Unmarshal(output, &res); err != nil { + return nil, err + } else if res.Error != nil { + return nil, errors.New(res.Error.Message) + } + return res.Result.Commands, nil +} + +type listMembersOptions struct { + Channel chat1.ChatChannel `json:"channel,omitempty"` + ConversationID chat1.ConvIDStr `json:"conversation_id,omitempty"` +} + +type listMembersParams struct { + Options listMembersOptions +} + +type listMembersArg struct { + Method string + Params listMembersParams +} + +func newListMembersArg(options listMembersOptions) listMembersArg { + return listMembersArg{ + Method: "listmembers", + Params: listMembersParams{ + Options: options, + }, + } +} + +func (a *API) ListMembers(channel chat1.ChatChannel) (keybase1.TeamMembersDetails, error) { + arg := newListMembersArg(listMembersOptions{ + Channel: channel, + }) + return a.listMembers(arg) +} + +func (a *API) ListMembersByConvID(conversationID chat1.ConvIDStr) (keybase1.TeamMembersDetails, error) { + arg := newListMembersArg(listMembersOptions{ + ConversationID: conversationID, + }) + return a.listMembers(arg) +} + +func (a *API) listMembers(arg listMembersArg) (res keybase1.TeamMembersDetails, err error) { + bArg, err := json.Marshal(arg) + if err != nil { + return res, err + } + output, err := a.doFetch(string(bArg)) + if err != nil { + return res, err + } + members := ListTeamMembers{} + err = json.Unmarshal(output, &members) + if err != nil { + return res, UnmarshalError{err} + } + if members.Error.Message != "" { + return res, members.Error + } + return members.Result.Members, nil +} + +type GetMessagesResult struct { + Result struct { + Messages []chat1.Message `json:"messages"` + } `json:"result"` + Error *Error `json:"error,omitempty"` +} + +type getMessagesOptions struct { + Channel chat1.ChatChannel `json:"channel,omitempty"` + ConversationID chat1.ConvIDStr `json:"conversation_id,omitempty"` + MessageIDs []chat1.MessageID `json:"message_ids,omitempty"` +} + +type getMessagesParams struct { + Options getMessagesOptions +} + +type getMessagesArg struct { + Method string + Params getMessagesParams +} + +func newGetMessagesArg(options getMessagesOptions) getMessagesArg { + return getMessagesArg{ + Method: "get", + Params: getMessagesParams{ + Options: options, + }, + } +} + +func (a *API) GetMessages(channel chat1.ChatChannel, msgIDs []chat1.MessageID) ([]chat1.Message, error) { + arg := newGetMessagesArg(getMessagesOptions{ + Channel: channel, + MessageIDs: msgIDs, + }) + return a.getMessages(arg) +} + +func (a *API) GetMessagesByConvID(conversationID chat1.ConvIDStr, msgIDs []chat1.MessageID) ([]chat1.Message, error) { + arg := newGetMessagesArg(getMessagesOptions{ + ConversationID: conversationID, + MessageIDs: msgIDs, + }) + return a.getMessages(arg) +} + +func (a *API) getMessages(arg getMessagesArg) ([]chat1.Message, error) { + bArg, err := json.Marshal(arg) + if err != nil { + return nil, err + } + output, err := a.doFetch(string(bArg)) + if err != nil { + return nil, err + } + var res GetMessagesResult + err = json.Unmarshal(output, &res) + if err != nil { + return nil, UnmarshalError{err} + } + if res.Error != nil { + return nil, res.Error + } + return res.Result.Messages, nil +} 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 new file mode 100644 index 00000000..2b8e929d --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/errors.go @@ -0,0 +1,36 @@ +package kbchat + +import "fmt" + +type ErrorCode int + +const ( + RevisionErrorCode ErrorCode = 2760 + DeleteNonExistentErrorCode ErrorCode = 2762 +) + +// Error is for unmarshaling CLI json responses +type Error struct { + Code ErrorCode `json:"code"` + Message string `json:"message"` +} + +func (e Error) Error() string { + return fmt.Sprintf("received error response from keybase api: %s", e.Message) +} + +type APIError struct { + err error +} + +func (e APIError) Error() string { + return fmt.Sprintf("failed to call keybase api: %v", e.err) +} + +type UnmarshalError struct { + err error +} + +func (e UnmarshalError) Error() string { + return fmt.Sprintf("failed to parse output from keybase api: %v", e.err) +} 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 c735052c..0a74dd90 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 @@ -6,21 +6,26 @@ import ( "errors" "fmt" "io" + "io/ioutil" "log" "os/exec" "strings" "sync" "time" + + "github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1" + "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 { sync.Mutex - apiInput io.Writer - apiOutput *bufio.Reader - apiCmd *exec.Cmd - username string - runOpts RunOptions + apiInput io.Writer + apiOutput *bufio.Reader + apiCmd *exec.Cmd + username string + runOpts RunOptions + subscriptions []*NewSubscription } func getUsername(runOpts RunOptions) (username string, err error) { @@ -40,9 +45,10 @@ func getUsername(runOpts RunOptions) (username string, err error) { doneCh <- errors.New("unable to find Keybase username") return } - toks := strings.Fields(scanner.Text()) + text := scanner.Text() + toks := strings.Fields(text) if len(toks) != 2 { - doneCh <- errors.New("invalid Keybase username output") + doneCh <- fmt.Errorf("invalid Keybase username output: %q", text) return } username = toks[1] @@ -71,6 +77,10 @@ type RunOptions struct { HomeDir string Oneshot *OneshotOptions StartService bool + // Have the bot send/receive typing notifications + EnableTyping bool + // Disable bot lite mode + DisableBotLiteMode bool } func (r RunOptions) Location() string { @@ -100,6 +110,10 @@ func Start(runOpts RunOptions) (*API, error) { return api, nil } +func (a *API) Command(args ...string) *exec.Cmd { + return a.runOpts.Command(args...) +} + func (a *API) auth() (string, error) { username, err := getUsername(a.runOpts) if err == nil { @@ -132,17 +146,28 @@ func (a *API) startPipes() (err error) { a.Lock() defer a.Unlock() if a.apiCmd != nil { - a.apiCmd.Process.Kill() + if err := a.apiCmd.Process.Kill(); err != nil { + return err + } } a.apiCmd = nil if a.runOpts.StartService { - a.runOpts.Command("service").Start() + args := []string{fmt.Sprintf("-enable-bot-lite-mode=%v", a.runOpts.DisableBotLiteMode), "service"} + if err := a.runOpts.Command(args...).Start(); err != nil { + return err + } } if a.username, err = a.auth(); err != nil { return err } + + cmd := a.runOpts.Command("chat", "notification-settings", fmt.Sprintf("-disable-typing=%v", !a.runOpts.EnableTyping)) + if err = cmd.Run(); err != nil { + return err + } + a.apiCmd = a.runOpts.Command("chat", "api") if a.apiInput, err = a.apiCmd.StdinPipe(); err != nil { return err @@ -168,73 +193,11 @@ func (a *API) getAPIPipesLocked() (io.Writer, *bufio.Reader, error) { return a.apiInput, a.apiOutput, nil } -// GetConversations reads all conversations from the current user's inbox. -func (a *API) GetConversations(unreadOnly bool) ([]Conversation, error) { - apiInput := fmt.Sprintf(`{"method":"list", "params": { "options": { "unread_only": %v}}}`, unreadOnly) - output, err := a.doFetch(apiInput) - if err != nil { - return nil, err - } - - var inbox Inbox - if err := json.Unmarshal(output, &inbox); err != nil { - return nil, err - } - return inbox.Result.Convs, nil -} - -// GetTextMessages fetches all text messages from a given channel. Optionally can filter -// ont unread status. -func (a *API) GetTextMessages(channel Channel, unreadOnly bool) ([]Message, error) { - channelBytes, err := json.Marshal(channel) - if err != nil { - return nil, err - } - apiInput := fmt.Sprintf(`{"method": "read", "params": {"options": {"channel": %s}}}`, string(channelBytes)) - output, err := a.doFetch(apiInput) - if err != nil { - return nil, err - } - - var thread Thread - - if err := json.Unmarshal(output, &thread); err != nil { - return nil, fmt.Errorf("unable to decode thread: %s", err.Error()) - } - - var res []Message - for _, msg := range thread.Result.Messages { - if msg.Msg.Content.Type == "text" { - res = append(res, msg.Msg) - } - } - - return res, nil -} - -type sendMessageBody struct { - Body string -} - -type sendMessageOptions struct { - Channel Channel `json:"channel,omitempty"` - ConversationID string `json:"conversation_id,omitempty"` - Message sendMessageBody `json:",omitempty"` - Filename string `json:"filename,omitempty"` - Title string `json:"title,omitempty"` - MsgID int `json:"message_id,omitempty"` -} - -type sendMessageParams struct { - Options sendMessageOptions -} - -type sendMessageArg struct { - Method string - Params sendMessageParams +func (a *API) GetUsername() string { + return a.username } -func (a *API) doSend(arg interface{}) (response SendResponse, err error) { +func (a *API) doSend(arg interface{}) (resp SendResponse, err error) { a.Lock() defer a.Unlock() @@ -253,10 +216,12 @@ func (a *API) doSend(arg interface{}) (response SendResponse, err error) { if err != nil { return SendResponse{}, err } - if err := json.Unmarshal(responseRaw, &response); err != nil { - return SendResponse{}, fmt.Errorf("failed to decode API response: %s", err) + if err := json.Unmarshal(responseRaw, &resp); err != nil { + return resp, fmt.Errorf("failed to decode API response: %s", err) + } else if resp.Error != nil { + return resp, errors.New(resp.Error.Message) } - return response, nil + return resp, nil } func (a *API) doFetch(apiInput string) ([]byte, error) { @@ -278,234 +243,121 @@ func (a *API) doFetch(apiInput string) ([]byte, error) { return byteOutput, nil } -func (a *API) SendMessage(channel Channel, body string) (SendResponse, error) { - arg := sendMessageArg{ - Method: "send", - Params: sendMessageParams{ - Options: sendMessageOptions{ - Channel: channel, - Message: sendMessageBody{ - Body: body, - }, - }, - }, - } - return a.doSend(arg) -} - -func (a *API) SendMessageByConvID(convID string, body string) (SendResponse, error) { - arg := sendMessageArg{ - Method: "send", - Params: sendMessageParams{ - Options: sendMessageOptions{ - ConversationID: convID, - Message: sendMessageBody{ - Body: body, - }, - }, - }, - } - return a.doSend(arg) -} - -// SendMessageByTlfName sends a message on the given TLF name -func (a *API) SendMessageByTlfName(tlfName string, body string) (SendResponse, error) { - arg := sendMessageArg{ - Method: "send", - Params: sendMessageParams{ - Options: sendMessageOptions{ - Channel: Channel{ - Name: tlfName, - }, - Message: sendMessageBody{ - Body: body, - }, - }, - }, - } - return a.doSend(arg) -} - -func (a *API) SendMessageByTeamName(teamName string, body string, inChannel *string) (SendResponse, error) { - channel := "general" - if inChannel != nil { - channel = *inChannel - } - arg := sendMessageArg{ - Method: "send", - Params: sendMessageParams{ - Options: sendMessageOptions{ - Channel: Channel{ - MembersType: "team", - Name: teamName, - TopicName: channel, - }, - Message: sendMessageBody{ - Body: body, - }, - }, - }, - } - return a.doSend(arg) -} - -func (a *API) SendAttachmentByTeam(teamName string, filename string, title string, inChannel *string) (SendResponse, error) { - channel := "general" - if inChannel != nil { - channel = *inChannel - } - arg := sendMessageArg{ - Method: "attach", - Params: sendMessageParams{ - Options: sendMessageOptions{ - Channel: Channel{ - MembersType: "team", - Name: teamName, - TopicName: channel, - }, - Filename: filename, - Title: title, - }, - }, - } - return a.doSend(arg) -} - -type reactionOptions struct { - ConversationID string `json:"conversation_id"` - Message sendMessageBody - MsgID int `json:"message_id"` - Channel Channel `json:"channel"` -} - -type reactionParams struct { - Options reactionOptions -} - -type reactionArg struct { - Method string - Params reactionParams -} - -func newReactionArg(options reactionOptions) reactionArg { - return reactionArg{ - Method: "reaction", - Params: reactionParams{Options: options}, - } -} - -func (a *API) ReactByChannel(channel Channel, msgID int, reaction string) (SendResponse, error) { - arg := newReactionArg(reactionOptions{ - Message: sendMessageBody{Body: reaction}, - MsgID: msgID, - Channel: channel, - }) - return a.doSend(arg) -} - -func (a *API) ReactByConvID(convID string, msgID int, reaction string) (SendResponse, error) { - arg := newReactionArg(reactionOptions{ - Message: sendMessageBody{Body: reaction}, - MsgID: msgID, - ConversationID: convID, - }) - return a.doSend(arg) -} - -type advertiseParams struct { - Options Advertisement -} - -type advertiseMsgArg struct { - Method string - Params advertiseParams -} - -func newAdvertiseMsgArg(ad Advertisement) advertiseMsgArg { - return advertiseMsgArg{ - Method: "advertisecommands", - Params: advertiseParams{ - Options: ad, - }, - } -} - -func (a *API) AdvertiseCommands(ad Advertisement) (SendResponse, error) { - return a.doSend(newAdvertiseMsgArg(ad)) -} - -func (a *API) Username() string { - return a.username -} - // SubscriptionMessage contains a message and conversation object type SubscriptionMessage struct { - Message Message - Conversation Conversation + Message chat1.MsgSummary + Conversation chat1.ConvSummary +} + +type SubscriptionConversation struct { + Conversation chat1.ConvSummary } type SubscriptionWalletEvent struct { - Payment Payment + 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) { +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) { +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.shutdownCh <- struct{}{} +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() (*NewSubscription, error) { opts := ListenOptions{Wallet: false} return a.Listen(opts) } +func (a *API) registerSubscription(sub *NewSubscription) { + a.Lock() + defer a.Unlock() + a.subscriptions = append(a.subscriptions, sub) +} + // Listen fires of a background loop and puts chat messages and wallet // events into channels -func (a *API) Listen(opts ListenOptions) (NewSubscription, error) { - newMsgCh := make(chan SubscriptionMessage, 100) +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{}) done := make(chan struct{}) - sub := NewSubscription{ - newMsgsCh: newMsgCh, + sub := &NewSubscription{ + newMsgsCh: newMsgsCh, + newConvsCh: newConvsCh, newWalletCh: newWalletCh, shutdownCh: shutdownCh, errorCh: errorCh, + running: true, } + a.registerSubscription(sub) pause := 2 * time.Second readScanner := func(boutput *bufio.Scanner) { for { @@ -518,28 +370,44 @@ func (a *API) Listen(opts ListenOptions) (NewSubscription, error) { } switch typeHolder.Type { case "chat": - var holder MessageHolder - if err := json.Unmarshal([]byte(t), &holder); err != nil { + var notification chat1.MsgNotification + if err := json.Unmarshal([]byte(t), ¬ification); err != nil { errorCh <- err break } - subscriptionMessage := SubscriptionMessage{ - Message: holder.Msg, - Conversation: Conversation{ - ID: holder.Msg.ConversationID, - Channel: holder.Msg.Channel, - }, + if notification.Error != nil { + log.Printf("error message received: %s", *notification.Error) + } else if notification.Msg != nil { + subscriptionMessage := SubscriptionMessage{ + Message: *notification.Msg, + Conversation: chat1.ConvSummary{ + Id: notification.Msg.ConvID, + Channel: notification.Msg.Channel, + }, + } + newMsgsCh <- subscriptionMessage + } + case "chat_conv": + var notification chat1.ConvNotification + if err := json.Unmarshal([]byte(t), ¬ification); err != nil { + errorCh <- err + break + } + if notification.Error != nil { + log.Printf("error message received: %s", *notification.Error) + } else if notification.Conv != nil { + subscriptionConv := SubscriptionConversation{ + Conversation: *notification.Conv, + } + newConvsCh <- subscriptionConv } - newMsgCh <- subscriptionMessage case "wallet": var holder PaymentHolder if err := json.Unmarshal([]byte(t), &holder); err != nil { errorCh <- err break } - subscriptionPayment := SubscriptionWalletEvent{ - Payment: holder.Payment, - } + subscriptionPayment := SubscriptionWalletEvent(holder) newWalletCh <- subscriptionPayment default: continue @@ -552,6 +420,13 @@ func (a *API) Listen(opts ListenOptions) (NewSubscription, error) { maxAttempts := 1800 go func() { for { + select { + case <-shutdownCh: + log.Printf("Listen: received shutdown") + return + default: + } + if attempts >= maxAttempts { panic("Listen: failed to auth, giving up") } @@ -565,6 +440,9 @@ func (a *API) Listen(opts ListenOptions) (NewSubscription, error) { if opts.Wallet { cmdElements = append(cmdElements, "--wallet") } + if opts.Convs { + cmdElements = append(cmdElements, "--convs") + } p := a.runOpts.Command(cmdElements...) output, err := p.StdoutPipe() if err != nil { @@ -572,6 +450,12 @@ func (a *API) Listen(opts ListenOptions) (NewSubscription, error) { time.Sleep(pause) continue } + stderr, err := p.StderrPipe() + if err != nil { + log.Printf("Listen: failed to listen to stderr: %s", err) + time.Sleep(pause) + continue + } boutput := bufio.NewScanner(output) if err := p.Start(); err != nil { log.Printf("Listen: failed to make listen scanner: %s", err) @@ -581,78 +465,19 @@ func (a *API) Listen(opts ListenOptions) (NewSubscription, error) { attempts = 0 go readScanner(boutput) <-done - p.Wait() + if err := p.Wait(); err != nil { + stderrBytes, rerr := ioutil.ReadAll(stderr) + if rerr != nil { + stderrBytes = []byte("failed to get stderr") + } + log.Printf("Listen: failed to Wait for command: %s (```%s```)", err, stderrBytes) + } time.Sleep(pause) } }() return sub, nil } -func (a *API) GetUsername() string { - return a.username -} - -func (a *API) ListChannels(teamName string) ([]string, error) { - apiInput := fmt.Sprintf(`{"method": "listconvsonname", "params": {"options": {"topic_type": "CHAT", "members_type": "team", "name": "%s"}}}`, teamName) - output, err := a.doFetch(apiInput) - if err != nil { - return nil, err - } - - var channelsList ChannelsList - if err := json.Unmarshal(output, &channelsList); err != nil { - return nil, err - } - - var channels []string - for _, conv := range channelsList.Result.Convs { - channels = append(channels, conv.Channel.TopicName) - } - return channels, nil -} - -func (a *API) JoinChannel(teamName string, channelName string) (JoinChannelResult, error) { - empty := JoinChannelResult{} - - apiInput := fmt.Sprintf(`{"method": "join", "params": {"options": {"channel": {"name": "%s", "members_type": "team", "topic_name": "%s"}}}}`, teamName, channelName) - output, err := a.doFetch(apiInput) - if err != nil { - return empty, err - } - - joinChannel := JoinChannel{} - err = json.Unmarshal(output, &joinChannel) - if err != nil { - return empty, fmt.Errorf("failed to parse output from keybase team api: %v", err) - } - if joinChannel.Error.Message != "" { - return empty, fmt.Errorf("received error from keybase team api: %s", joinChannel.Error.Message) - } - - return joinChannel.Result, nil -} - -func (a *API) LeaveChannel(teamName string, channelName string) (LeaveChannelResult, error) { - empty := LeaveChannelResult{} - - apiInput := fmt.Sprintf(`{"method": "leave", "params": {"options": {"channel": {"name": "%s", "members_type": "team", "topic_name": "%s"}}}}`, teamName, channelName) - output, err := a.doFetch(apiInput) - if err != nil { - return empty, err - } - - leaveChannel := LeaveChannel{} - err = json.Unmarshal(output, &leaveChannel) - if err != nil { - return empty, fmt.Errorf("failed to parse output from keybase team api: %v", err) - } - if leaveChannel.Error.Message != "" { - return empty, fmt.Errorf("received error from keybase team api: %s", leaveChannel.Error.Message) - } - - return leaveChannel.Result, nil -} - func (a *API) LogSend(feedback string) error { feedback = "go-keybase-chat-bot log send\n" + "username: " + a.GetUsername() + "\n" + @@ -675,6 +500,12 @@ func (a *API) LogSend(feedback string) error { } func (a *API) Shutdown() error { + a.Lock() + defer a.Unlock() + for _, sub := range a.subscriptions { + sub.Shutdown() + } + if a.runOpts.Oneshot != nil { err := a.runOpts.Command("logout", "--force").Run() if err != nil { diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/kvstore.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/kvstore.go new file mode 100644 index 00000000..d7112936 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/kvstore.go @@ -0,0 +1,228 @@ +package kbchat + +import ( + "encoding/json" + "strings" + + "github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1" +) + +type kvstoreMethod string + +type kvstoreOptions struct { + Team *string `json:"team"` + Namespace *string `json:"namespace,omitempty"` + EntryKey *string `json:"entryKey,omitempty"` + EntryValue *string `json:"entryValue,omitempty"` + Revision *int `json:"revision,omitempty"` +} + +type kvstoreParams struct { + Options kvstoreOptions `json:"options"` +} + +type kvstoreAPIReq struct { + Method kvstoreMethod `json:"method"` + Params kvstoreParams `json:"params"` +} + +type GetEntryRes struct { + Result keybase1.KVGetResult `json:"result"` + Error Error `json:"error,omitempty"` +} + +type PutEntryRes struct { + Result keybase1.KVPutResult `json:"result"` + Error Error `json:"error,omitempty"` +} + +type DeleteEntryRes struct { + Result keybase1.KVDeleteEntryResult `json:"result"` + Error Error `json:"error,omitempty"` +} + +type ListNamespacesRes struct { + Result keybase1.KVListNamespaceResult `json:"result"` + Error Error `json:"error,omitempty"` +} + +type ListEntryKeysRes struct { + Result keybase1.KVListEntryResult `json:"result"` + Error Error `json:"error,omitempty"` +} + +type KVStoreAPI interface { + PutEntry(teamName *string, namespace string, entryKey string, entryValue string) (keybase1.KVPutResult, error) + PutEntryWithRevision(teamName *string, namespace string, entryKey string, entryValue string, revision int) (keybase1.KVPutResult, error) + DeleteEntry(teamName *string, namespace string, entryKey string) (keybase1.KVDeleteEntryResult, error) + DeleteEntryWithRevision(teamName *string, namespace string, entryKey string, revision int) (keybase1.KVDeleteEntryResult, error) + GetEntry(teamName *string, namespace string, entryKey string) (keybase1.KVGetResult, error) + ListNamespaces(teamName *string) (keybase1.KVListNamespaceResult, error) + ListEntryKeys(teamName *string, namespace string) (keybase1.KVListEntryResult, error) +} + +func (a *API) PutEntry(teamName *string, namespace string, entryKey string, entryValue string) (result keybase1.KVPutResult, err error) { + return a.PutEntryWithRevision(teamName, namespace, entryKey, entryValue, 0) +} + +func (a *API) PutEntryWithRevision(teamName *string, namespace string, entryKey string, entryValue string, revision int) (result keybase1.KVPutResult, err error) { + + opts := kvstoreOptions{ + Team: teamName, + Namespace: &namespace, + EntryKey: &entryKey, + EntryValue: &entryValue, + } + if revision != 0 { + opts.Revision = &revision + } + args := kvstoreAPIReq{Method: "put", Params: kvstoreParams{Options: opts}} + apiInput, err := json.Marshal(args) + if err != nil { + return result, err + } + + cmd := a.runOpts.Command("kvstore", "api") + cmd.Stdin = strings.NewReader(string(apiInput)) + bytes, err := cmd.Output() + if err != nil { + return result, APIError{err} + } + + entry := PutEntryRes{} + err = json.Unmarshal(bytes, &entry) + if err != nil { + return result, UnmarshalError{err} + } + if entry.Error.Message != "" { + return result, entry.Error + } + return entry.Result, nil +} + +func (a *API) DeleteEntry(teamName *string, namespace string, entryKey string) (result keybase1.KVDeleteEntryResult, err error) { + return a.DeleteEntryWithRevision(teamName, namespace, entryKey, 0) +} + +func (a *API) DeleteEntryWithRevision(teamName *string, namespace string, entryKey string, revision int) (result keybase1.KVDeleteEntryResult, err error) { + + opts := kvstoreOptions{ + Team: teamName, + Namespace: &namespace, + EntryKey: &entryKey, + } + if revision != 0 { + opts.Revision = &revision + } + args := kvstoreAPIReq{Method: "del", Params: kvstoreParams{Options: opts}} + apiInput, err := json.Marshal(args) + if err != nil { + return result, err + } + + cmd := a.runOpts.Command("kvstore", "api") + cmd.Stdin = strings.NewReader(string(apiInput)) + bytes, err := cmd.Output() + if err != nil { + return result, APIError{err} + } + + entry := DeleteEntryRes{} + err = json.Unmarshal(bytes, &entry) + if err != nil { + return result, UnmarshalError{err} + } + if entry.Error.Message != "" { + return result, entry.Error + } + return entry.Result, nil +} + +func (a *API) GetEntry(teamName *string, namespace string, entryKey string) (result keybase1.KVGetResult, err error) { + + opts := kvstoreOptions{ + Team: teamName, + Namespace: &namespace, + EntryKey: &entryKey, + } + args := kvstoreAPIReq{Method: "get", Params: kvstoreParams{Options: opts}} + apiInput, err := json.Marshal(args) + if err != nil { + return result, err + } + cmd := a.runOpts.Command("kvstore", "api") + cmd.Stdin = strings.NewReader(string(apiInput)) + bytes, err := cmd.Output() + if err != nil { + return result, APIError{err} + } + + entry := GetEntryRes{} + err = json.Unmarshal(bytes, &entry) + if err != nil { + return result, UnmarshalError{err} + } + if entry.Error.Message != "" { + return result, entry.Error + } + return entry.Result, nil +} + +func (a *API) ListNamespaces(teamName *string) (result keybase1.KVListNamespaceResult, err error) { + + opts := kvstoreOptions{ + Team: teamName, + } + args := kvstoreAPIReq{Method: "list", Params: kvstoreParams{Options: opts}} + apiInput, err := json.Marshal(args) + if err != nil { + return result, err + } + + cmd := a.runOpts.Command("kvstore", "api") + cmd.Stdin = strings.NewReader(string(apiInput)) + bytes, err := cmd.Output() + if err != nil { + return result, APIError{err} + } + + var namespaces ListNamespacesRes + err = json.Unmarshal(bytes, &namespaces) + if err != nil { + return result, UnmarshalError{err} + } + if namespaces.Error.Message != "" { + return result, namespaces.Error + } + return namespaces.Result, nil +} + +func (a *API) ListEntryKeys(teamName *string, namespace string) (result keybase1.KVListEntryResult, err error) { + + opts := kvstoreOptions{ + Team: teamName, + Namespace: &namespace, + } + args := kvstoreAPIReq{Method: "list", Params: kvstoreParams{Options: opts}} + apiInput, err := json.Marshal(args) + if err != nil { + return result, err + } + + cmd := a.runOpts.Command("kvstore", "api") + cmd.Stdin = strings.NewReader(string(apiInput)) + bytes, err := cmd.Output() + if err != nil { + return result, APIError{err} + } + + entryKeys := ListEntryKeysRes{} + err = json.Unmarshal(bytes, &entryKeys) + if err != nil { + return result, UnmarshalError{err} + } + if entryKeys.Error.Message != "" { + return result, entryKeys.Error + } + return entryKeys.Result, nil +} 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 89c55c4f..0f9d9524 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 @@ -4,22 +4,13 @@ import ( "encoding/json" "fmt" "strings" + + "github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1" ) type ListTeamMembers struct { - Result ListTeamMembersResult `json:"result"` - Error Error `json:"error"` -} - -type ListTeamMembersResult struct { - Members ListTeamMembersResultMembers `json:"members"` -} - -type ListTeamMembersResultMembers struct { - Owners []ListMembersOutputMembersCategory `json:"owners"` - Admins []ListMembersOutputMembersCategory `json:"admins"` - Writers []ListMembersOutputMembersCategory `json:"writers"` - Readers []ListMembersOutputMembersCategory `json:"readers"` + Result keybase1.TeamDetails `json:"result"` + Error Error `json:"error"` } type ListMembersOutputMembersCategory struct { @@ -28,62 +19,46 @@ type ListMembersOutputMembersCategory struct { } type ListUserMemberships struct { - Result ListUserMembershipsResult `json:"result"` - Error Error `json:"error"` + Result keybase1.AnnotatedTeamList `json:"result"` + Error Error `json:"error"` } -type ListUserMembershipsResult struct { - Teams []ListUserMembershipsResultTeam `json:"teams"` -} - -type ListUserMembershipsResultTeam struct { - TeamName string `json:"fq_name"` - IsImplicitTeam bool `json:"is_implicit_team"` - IsOpenTeam bool `json:"is_open_team"` - Role int `json:"role"` - MemberCount int `json:"member_count"` -} - -func (a *API) ListMembersOfTeam(teamName string) (ListTeamMembersResultMembers, error) { - empty := ListTeamMembersResultMembers{} - +func (a *API) ListMembersOfTeam(teamName string) (res keybase1.TeamMembersDetails, err error) { apiInput := fmt.Sprintf(`{"method": "list-team-memberships", "params": {"options": {"team": "%s"}}}`, teamName) cmd := a.runOpts.Command("team", "api") cmd.Stdin = strings.NewReader(apiInput) bytes, err := cmd.CombinedOutput() if err != nil { - return empty, fmt.Errorf("failed to call keybase team api: %v", err) + return res, APIError{err} } members := ListTeamMembers{} err = json.Unmarshal(bytes, &members) if err != nil { - return empty, fmt.Errorf("failed to parse output from keybase team api: %v", err) + return res, UnmarshalError{err} } if members.Error.Message != "" { - return empty, fmt.Errorf("received error from keybase team api: %s", members.Error.Message) + return res, members.Error } return members.Result.Members, nil } -func (a *API) ListUserMemberships(username string) ([]ListUserMembershipsResultTeam, error) { - empty := []ListUserMembershipsResultTeam{} - +func (a *API) ListUserMemberships(username string) ([]keybase1.AnnotatedMemberInfo, error) { apiInput := fmt.Sprintf(`{"method": "list-user-memberships", "params": {"options": {"username": "%s"}}}`, username) cmd := a.runOpts.Command("team", "api") cmd.Stdin = strings.NewReader(apiInput) bytes, err := cmd.CombinedOutput() if err != nil { - return empty, fmt.Errorf("failed to call keybase team api: %v", err) + return nil, APIError{err} } members := ListUserMemberships{} err = json.Unmarshal(bytes, &members) if err != nil { - return empty, fmt.Errorf("failed to parse output from keybase team api: %v", err) + return nil, UnmarshalError{err} } if members.Error.Message != "" { - return empty, fmt.Errorf("received error from keybase team api: %s", members.Error.Message) + return nil, members.Error } return members.Result.Teams, nil } diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/test_config.example.yaml b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/test_config.example.yaml index 87078ed1..1f467962 100644 --- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/test_config.example.yaml +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/test_config.example.yaml @@ -1,16 +1,17 @@ # Rename this file to `test_config.yaml` -config: - bots: - alice: - username: "alice" - paperkey: "foo bar car..." - bob: - username: "bob" - paperkey: "one two three four..." - teams: - acme: - # A real team that you add your alice1 and bob1 into - name: "acme" - # The channel to use - topicname: "mysupercoolchannel" +keybase: "/path/to/keybase" +bots: + # Alice should have an active Stellar account with a little bit of XLM in it + alice: + username: "alice" + paperkey: "foo bar car..." + bob: + username: "bob" + paperkey: "one two three four..." +teams: + acme: + # A real team that you add your alice and bob into + name: "acme" + # The channel to use + topicname: "mysupercoolchannel" diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/test_utils.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/test_utils.go index 1a163951..5d079a1c 100644 --- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/test_utils.go +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/test_utils.go @@ -41,9 +41,7 @@ func copyFile(t *testing.T, source, dest string) { // Creates the working directory and copies over the keybase binary in PATH. // We do this to avoid any version mismatch issues. -func prepWorkingDir(t *testing.T, workingDir string) string { - kbLocation := whichKeybase(t) - +func prepWorkingDir(t *testing.T, workingDir string, kbLocation string) string { err := os.Mkdir(workingDir, 0777) require.NoError(t, err) kbDestination := path.Join(workingDir, "keybase") diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types.go index 74a81646..882e511c 100644 --- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types.go +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types.go @@ -1,159 +1,14 @@ package kbchat -type Sender struct { - Uid string `json:"uid"` - Username string `json:"username"` - DeviceID string `json:"device_id"` - DeviceName string `json:"device_name"` -} - -type Channel struct { - Name string `json:"name"` - Public bool `json:"public"` - TopicType string `json:"topic_type"` - TopicName string `json:"topic_name"` - MembersType string `json:"members_type"` -} - -type Conversation struct { - ID string `json:"id"` - Unread bool `json:"unread"` - Channel Channel `json:"channel"` -} - -type PaymentHolder struct { - Payment Payment `json:"notification"` -} - -type Payment struct { - TxID string `json:"txID"` - StatusDescription string `json:"statusDescription"` - FromAccountID string `json:"fromAccountID"` - FromUsername string `json:"fromUsername"` - ToAccountID string `json:"toAccountID"` - ToUsername string `json:"toUsername"` - AmountDescription string `json:"amountDescription"` - WorthAtSendTime string `json:"worthAtSendTime"` - ExternalTxURL string `json:"externalTxURL"` -} +import ( + "github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1" +) type Result struct { - Convs []Conversation `json:"conversations"` -} - -type Inbox struct { - Result Result `json:"result"` -} - -type ChannelsList struct { - Result Result `json:"result"` -} - -type MsgPaymentDetails struct { - ResultType int `json:"resultTyp"` // 0 good. 1 error - PaymentID string `json:"sent"` -} - -type MsgPayment struct { - Username string `json:"username"` - PaymentText string `json:"paymentText"` - Details MsgPaymentDetails `json:"result"` -} - -type Text struct { - Body string `json:"body"` - Payments []MsgPayment `json:"payments"` - ReplyTo int `json:"replyTo"` -} - -type Content struct { - Type string `json:"type"` - Text Text `json:"text"` -} - -type Message struct { - Content Content `json:"content"` - Sender Sender `json:"sender"` - Channel Channel `json:"channel"` - ConversationID string `json:"conversation_id"` - MsgID int `json:"id"` -} - -type SendResult struct { - MsgID int `json:"id"` + Convs []chat1.ConvSummary `json:"conversations"` } type SendResponse struct { - Result SendResult `json:"result"` -} - -type TypeHolder struct { - Type string `json:"type"` -} - -type MessageHolder struct { - Msg Message `json:"msg"` - Source string `json:"source"` -} - -type ThreadResult struct { - Messages []MessageHolder `json:"messages"` -} - -type Thread struct { - Result ThreadResult `json:"result"` -} - -type CommandExtendedDescription struct { - Title string `json:"title"` - DesktopBody string `json:"desktop_body"` - MobileBody string `json:"mobile_body"` -} - -type Command struct { - Name string `json:"name"` - Description string `json:"description"` - Usage string `json:"usage"` - ExtendedDescription *CommandExtendedDescription `json:"extended_description,omitempty"` -} - -type CommandsAdvertisement struct { - Typ string `json:"type"` - Commands []Command - TeamName string `json:"team_name,omitempty"` -} - -type Advertisement struct { - Alias string `json:"alias,omitempty"` - Advertisements []CommandsAdvertisement -} - -type Error struct { - Code int `json:"code"` - Message string `json:"message"` -} - -type JoinChannel struct { - Error Error `json:"error"` - Result JoinChannelResult `json:"result"` -} - -type JoinChannelResult struct { - RateLimit []RateLimit `json:"ratelimits"` -} - -type LeaveChannel struct { - Error Error `json:"error"` - Result LeaveChannelResult `json:"result"` -} - -type LeaveChannelResult struct { - RateLimit []RateLimit `json:"ratelimits"` -} - -type RateLimit struct { - Tank string `json:"tank"` - Capacity int `json:"capacity"` - Reset int `json:"reset"` - Gas int `json:"gas"` + Result chat1.SendRes `json:"result"` + Error *Error `json:"error,omitempty"` } 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 new file mode 100644 index 00000000..678d2ab3 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/api.go @@ -0,0 +1,933 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/chat1/api.avdl + +package chat1 + +import ( + gregor1 "github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1" + keybase1 "github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1" +) + +type ConvIDStr string + +func (o ConvIDStr) DeepCopy() ConvIDStr { + return o +} + +type TLFIDStr string + +func (o TLFIDStr) DeepCopy() TLFIDStr { + return o +} + +type FlipGameIDStr string + +func (o FlipGameIDStr) DeepCopy() FlipGameIDStr { + return o +} + +type RateLimitRes struct { + Tank string `codec:"tank" json:"tank"` + Capacity int `codec:"capacity" json:"capacity"` + Reset int `codec:"reset" json:"reset"` + Gas int `codec:"gas" json:"gas"` +} + +func (o RateLimitRes) DeepCopy() RateLimitRes { + return RateLimitRes{ + Tank: o.Tank, + Capacity: o.Capacity, + Reset: o.Reset, + Gas: o.Gas, + } +} + +// A Keybase chat channel. This can be a channel in a team, or just an informal channel between two users. +// name: the name of the team or comma-separated list of participants +type ChatChannel struct { + Name string `codec:"name" json:"name"` + Public bool `codec:"public,omitempty" json:"public,omitempty"` + MembersType string `codec:"membersType,omitempty" json:"members_type,omitempty"` + TopicType string `codec:"topicType,omitempty" json:"topic_type,omitempty"` + TopicName string `codec:"topicName,omitempty" json:"topic_name,omitempty"` +} + +func (o ChatChannel) DeepCopy() ChatChannel { + return ChatChannel{ + Name: o.Name, + Public: o.Public, + MembersType: o.MembersType, + TopicType: o.TopicType, + TopicName: o.TopicName, + } +} + +// A chat message. The content goes in the `body` property! +type ChatMessage struct { + Body string `codec:"body" json:"body"` +} + +func (o ChatMessage) DeepCopy() ChatMessage { + return ChatMessage{ + Body: o.Body, + } +} + +type MsgSender struct { + Uid keybase1.UID `codec:"uid" json:"uid"` + Username string `codec:"username,omitempty" json:"username,omitempty"` + DeviceID keybase1.DeviceID `codec:"deviceID" json:"device_id"` + DeviceName string `codec:"deviceName,omitempty" json:"device_name,omitempty"` +} + +func (o MsgSender) DeepCopy() MsgSender { + return MsgSender{ + Uid: o.Uid.DeepCopy(), + Username: o.Username, + DeviceID: o.DeviceID.DeepCopy(), + DeviceName: o.DeviceName, + } +} + +type MsgBotInfo struct { + BotUID keybase1.UID `codec:"botUID" json:"bot_uid"` + BotUsername string `codec:"botUsername,omitempty" json:"bot_username,omitempty"` +} + +func (o MsgBotInfo) DeepCopy() MsgBotInfo { + return MsgBotInfo{ + BotUID: o.BotUID.DeepCopy(), + BotUsername: o.BotUsername, + } +} + +type MsgFlipContent struct { + Text string `codec:"text" json:"text"` + GameID FlipGameIDStr `codec:"gameID" json:"game_id"` + FlipConvID ConvIDStr `codec:"flipConvID" json:"flip_conv_id"` + UserMentions []KnownUserMention `codec:"userMentions" json:"user_mentions"` + TeamMentions []KnownTeamMention `codec:"teamMentions" json:"team_mentions"` +} + +func (o MsgFlipContent) DeepCopy() MsgFlipContent { + return MsgFlipContent{ + Text: o.Text, + GameID: o.GameID.DeepCopy(), + FlipConvID: o.FlipConvID.DeepCopy(), + 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), + } +} + +type MsgContent struct { + TypeName string `codec:"typeName" json:"type"` + Text *MessageText `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"` + Delete *MessageDelete `codec:"delete,omitempty" json:"delete,omitempty"` + Metadata *MessageConversationMetadata `codec:"metadata,omitempty" json:"metadata,omitempty"` + Headline *MessageHeadline `codec:"headline,omitempty" json:"headline,omitempty"` + AttachmentUploaded *MessageAttachmentUploaded `codec:"attachmentUploaded,omitempty" json:"attachment_uploaded,omitempty"` + System *MessageSystem `codec:"system,omitempty" json:"system,omitempty"` + SendPayment *MessageSendPayment `codec:"sendPayment,omitempty" json:"send_payment,omitempty"` + RequestPayment *MessageRequestPayment `codec:"requestPayment,omitempty" json:"request_payment,omitempty"` + Unfurl *MessageUnfurl `codec:"unfurl,omitempty" json:"unfurl,omitempty"` + Flip *MsgFlipContent `codec:"flip,omitempty" json:"flip,omitempty"` +} + +func (o MsgContent) DeepCopy() MsgContent { + return MsgContent{ + TypeName: o.TypeName, + Text: (func(x *MessageText) *MessageText { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Text), + Attachment: (func(x *MessageAttachment) *MessageAttachment { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Attachment), + Edit: (func(x *MessageEdit) *MessageEdit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Edit), + Reaction: (func(x *MessageReaction) *MessageReaction { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Reaction), + Delete: (func(x *MessageDelete) *MessageDelete { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Delete), + Metadata: (func(x *MessageConversationMetadata) *MessageConversationMetadata { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Metadata), + Headline: (func(x *MessageHeadline) *MessageHeadline { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Headline), + AttachmentUploaded: (func(x *MessageAttachmentUploaded) *MessageAttachmentUploaded { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.AttachmentUploaded), + System: (func(x *MessageSystem) *MessageSystem { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.System), + SendPayment: (func(x *MessageSendPayment) *MessageSendPayment { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.SendPayment), + RequestPayment: (func(x *MessageRequestPayment) *MessageRequestPayment { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RequestPayment), + Unfurl: (func(x *MessageUnfurl) *MessageUnfurl { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Unfurl), + Flip: (func(x *MsgFlipContent) *MsgFlipContent { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Flip), + } +} + +type MsgSummary struct { + Id MessageID `codec:"id" json:"id"` + ConvID ConvIDStr `codec:"convID" json:"conversation_id"` + Channel ChatChannel `codec:"channel" json:"channel"` + Sender MsgSender `codec:"sender" json:"sender"` + SentAt int64 `codec:"sentAt" json:"sent_at"` + SentAtMs int64 `codec:"sentAtMs" json:"sent_at_ms"` + Content MsgContent `codec:"content" json:"content"` + Prev []MessagePreviousPointer `codec:"prev" json:"prev"` + Unread bool `codec:"unread" json:"unread"` + RevokedDevice bool `codec:"revokedDevice,omitempty" json:"revoked_device,omitempty"` + Offline bool `codec:"offline,omitempty" json:"offline,omitempty"` + KbfsEncrypted bool `codec:"kbfsEncrypted,omitempty" json:"kbfs_encrypted,omitempty"` + 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"` + 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"` + ChannelNameMentions []UIChannelNameMention `codec:"channelNameMentions,omitempty" json:"channel_name_mentions,omitempty"` + BotInfo *MsgBotInfo `codec:"botInfo,omitempty" json:"bot_info,omitempty"` +} + +func (o MsgSummary) DeepCopy() MsgSummary { + return MsgSummary{ + Id: o.Id.DeepCopy(), + ConvID: o.ConvID.DeepCopy(), + Channel: o.Channel.DeepCopy(), + Sender: o.Sender.DeepCopy(), + SentAt: o.SentAt, + SentAtMs: o.SentAtMs, + Content: o.Content.DeepCopy(), + Prev: (func(x []MessagePreviousPointer) []MessagePreviousPointer { + if x == nil { + return nil + } + ret := make([]MessagePreviousPointer, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Prev), + Unread: o.Unread, + RevokedDevice: o.RevokedDevice, + Offline: o.Offline, + KbfsEncrypted: o.KbfsEncrypted, + IsEphemeral: o.IsEphemeral, + IsEphemeralExpired: o.IsEphemeralExpired, + ETime: o.ETime.DeepCopy(), + Reactions: (func(x *ReactionMap) *ReactionMap { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Reactions), + HasPairwiseMacs: o.HasPairwiseMacs, + AtMentionUsernames: (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.AtMentionUsernames), + ChannelMention: o.ChannelMention, + ChannelNameMentions: (func(x []UIChannelNameMention) []UIChannelNameMention { + if x == nil { + return nil + } + ret := make([]UIChannelNameMention, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.ChannelNameMentions), + BotInfo: (func(x *MsgBotInfo) *MsgBotInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.BotInfo), + } +} + +type Message struct { + Msg *MsgSummary `codec:"msg,omitempty" json:"msg,omitempty"` + Error *string `codec:"error,omitempty" json:"error,omitempty"` +} + +func (o Message) DeepCopy() Message { + return Message{ + Msg: (func(x *MsgSummary) *MsgSummary { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Msg), + Error: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Error), + } +} + +type Thread struct { + Messages []Message `codec:"messages" json:"messages"` + Pagination *Pagination `codec:"pagination,omitempty" json:"pagination,omitempty"` + Offline bool `codec:"offline,omitempty" json:"offline,omitempty"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures,omitempty" json:"identify_failures,omitempty"` + RateLimits []RateLimitRes `codec:"rateLimits,omitempty" json:"ratelimits,omitempty"` +} + +func (o Thread) DeepCopy() Thread { + return Thread{ + Messages: (func(x []Message) []Message { + if x == nil { + return nil + } + ret := make([]Message, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Messages), + Pagination: (func(x *Pagination) *Pagination { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Pagination), + Offline: o.Offline, + 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), + RateLimits: (func(x []RateLimitRes) []RateLimitRes { + if x == nil { + return nil + } + ret := make([]RateLimitRes, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.RateLimits), + } +} + +// A chat conversation. This is essentially a chat channel plus some additional metadata. +type ConvSummary struct { + Id ConvIDStr `codec:"id" json:"id"` + Channel ChatChannel `codec:"channel" json:"channel"` + IsDefaultConv bool `codec:"isDefaultConv" json:"is_default_conv"` + Unread bool `codec:"unread" json:"unread"` + ActiveAt int64 `codec:"activeAt" json:"active_at"` + ActiveAtMs int64 `codec:"activeAtMs" json:"active_at_ms"` + MemberStatus string `codec:"memberStatus" json:"member_status"` + ResetUsers []string `codec:"resetUsers,omitempty" json:"reset_users,omitempty"` + FinalizeInfo *ConversationFinalizeInfo `codec:"finalizeInfo,omitempty" json:"finalize_info,omitempty"` + Supersedes []string `codec:"supersedes,omitempty" json:"supersedes,omitempty"` + SupersededBy []string `codec:"supersededBy,omitempty" json:"superseded_by,omitempty"` + Error string `codec:"error,omitempty" json:"error,omitempty"` + CreatorInfo *ConversationCreatorInfoLocal `codec:"creatorInfo,omitempty" json:"creator_info,omitempty"` +} + +func (o ConvSummary) DeepCopy() ConvSummary { + return ConvSummary{ + Id: o.Id.DeepCopy(), + Channel: o.Channel.DeepCopy(), + IsDefaultConv: o.IsDefaultConv, + Unread: o.Unread, + ActiveAt: o.ActiveAt, + ActiveAtMs: o.ActiveAtMs, + MemberStatus: o.MemberStatus, + ResetUsers: (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.ResetUsers), + FinalizeInfo: (func(x *ConversationFinalizeInfo) *ConversationFinalizeInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.FinalizeInfo), + Supersedes: (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.Supersedes), + SupersededBy: (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.SupersededBy), + Error: o.Error, + CreatorInfo: (func(x *ConversationCreatorInfoLocal) *ConversationCreatorInfoLocal { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.CreatorInfo), + } +} + +type ChatList struct { + Conversations []ConvSummary `codec:"conversations" json:"conversations"` + Offline bool `codec:"offline" json:"offline"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures,omitempty" json:"identify_failures,omitempty"` + RateLimits []RateLimitRes `codec:"rateLimits,omitempty" json:"ratelimits,omitempty"` +} + +func (o ChatList) DeepCopy() ChatList { + return ChatList{ + Conversations: (func(x []ConvSummary) []ConvSummary { + if x == nil { + return nil + } + ret := make([]ConvSummary, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Conversations), + Offline: o.Offline, + 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), + RateLimits: (func(x []RateLimitRes) []RateLimitRes { + if x == nil { + return nil + } + ret := make([]RateLimitRes, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.RateLimits), + } +} + +type SendRes struct { + Message string `codec:"message" json:"message"` + MessageID *MessageID `codec:"messageID,omitempty" json:"id,omitempty"` + OutboxID *OutboxID `codec:"outboxID,omitempty" json:"outbox_id,omitempty"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures,omitempty" json:"identify_failures,omitempty"` + RateLimits []RateLimitRes `codec:"rateLimits,omitempty" json:"ratelimits,omitempty"` +} + +func (o SendRes) DeepCopy() SendRes { + return SendRes{ + Message: o.Message, + MessageID: (func(x *MessageID) *MessageID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.MessageID), + OutboxID: (func(x *OutboxID) *OutboxID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.OutboxID), + 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), + RateLimits: (func(x []RateLimitRes) []RateLimitRes { + if x == nil { + return nil + } + ret := make([]RateLimitRes, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.RateLimits), + } +} + +type SearchInboxResOutput struct { + Results *ChatSearchInboxResults `codec:"results,omitempty" json:"results,omitempty"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures,omitempty" json:"identify_failures,omitempty"` + RateLimits []RateLimitRes `codec:"rateLimits,omitempty" json:"ratelimits,omitempty"` +} + +func (o SearchInboxResOutput) DeepCopy() SearchInboxResOutput { + return SearchInboxResOutput{ + Results: (func(x *ChatSearchInboxResults) *ChatSearchInboxResults { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Results), + 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), + RateLimits: (func(x []RateLimitRes) []RateLimitRes { + if x == nil { + return nil + } + ret := make([]RateLimitRes, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.RateLimits), + } +} + +type RegexpRes struct { + Hits []ChatSearchHit `codec:"hits" json:"hits"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures,omitempty" json:"identify_failures,omitempty"` + RateLimits []RateLimitRes `codec:"rateLimits,omitempty" json:"ratelimits,omitempty"` +} + +func (o RegexpRes) DeepCopy() RegexpRes { + return RegexpRes{ + Hits: (func(x []ChatSearchHit) []ChatSearchHit { + if x == nil { + return nil + } + ret := make([]ChatSearchHit, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Hits), + 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), + RateLimits: (func(x []RateLimitRes) []RateLimitRes { + if x == nil { + return nil + } + ret := make([]RateLimitRes, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.RateLimits), + } +} + +type NewConvRes struct { + Id ConvIDStr `codec:"id" json:"id"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures,omitempty" json:"identify_failures,omitempty"` + RateLimits []RateLimitRes `codec:"rateLimits,omitempty" json:"ratelimits,omitempty"` +} + +func (o NewConvRes) DeepCopy() NewConvRes { + return NewConvRes{ + Id: o.Id.DeepCopy(), + 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), + RateLimits: (func(x []RateLimitRes) []RateLimitRes { + if x == nil { + return nil + } + ret := make([]RateLimitRes, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.RateLimits), + } +} + +type ListCommandsRes struct { + Commands []UserBotCommandOutput `codec:"commands" json:"commands"` + RateLimits []RateLimitRes `codec:"rateLimits,omitempty" json:"ratelimits,omitempty"` +} + +func (o ListCommandsRes) DeepCopy() ListCommandsRes { + return ListCommandsRes{ + Commands: (func(x []UserBotCommandOutput) []UserBotCommandOutput { + if x == nil { + return nil + } + ret := make([]UserBotCommandOutput, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Commands), + RateLimits: (func(x []RateLimitRes) []RateLimitRes { + if x == nil { + return nil + } + ret := make([]RateLimitRes, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.RateLimits), + } +} + +type EmptyRes struct { + RateLimits []RateLimitRes `codec:"rateLimits,omitempty" json:"ratelimits,omitempty"` +} + +func (o EmptyRes) DeepCopy() EmptyRes { + return EmptyRes{ + RateLimits: (func(x []RateLimitRes) []RateLimitRes { + if x == nil { + return nil + } + ret := make([]RateLimitRes, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.RateLimits), + } +} + +type MsgNotification struct { + Type string `codec:"type" json:"type"` + Source string `codec:"source" json:"source"` + Msg *MsgSummary `codec:"msg,omitempty" json:"msg,omitempty"` + Error *string `codec:"error,omitempty" json:"error,omitempty"` + Pagination *UIPagination `codec:"pagination,omitempty" json:"pagination,omitempty"` +} + +func (o MsgNotification) DeepCopy() MsgNotification { + return MsgNotification{ + Type: o.Type, + Source: o.Source, + Msg: (func(x *MsgSummary) *MsgSummary { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Msg), + Error: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Error), + Pagination: (func(x *UIPagination) *UIPagination { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Pagination), + } +} + +type ConvNotification struct { + Type string `codec:"type" json:"type"` + Conv *ConvSummary `codec:"conv,omitempty" json:"conv,omitempty"` + Error *string `codec:"error,omitempty" json:"error,omitempty"` +} + +func (o ConvNotification) DeepCopy() ConvNotification { + return ConvNotification{ + Type: o.Type, + Conv: (func(x *ConvSummary) *ConvSummary { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Conv), + Error: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Error), + } +} + +type AdvertiseCommandAPIParam struct { + Typ string `codec:"typ" json:"type"` + Commands []UserBotCommandInput `codec:"commands" json:"commands"` + TeamName string `codec:"teamName,omitempty" json:"team_name,omitempty"` +} + +func (o AdvertiseCommandAPIParam) DeepCopy() AdvertiseCommandAPIParam { + return AdvertiseCommandAPIParam{ + Typ: o.Typ, + Commands: (func(x []UserBotCommandInput) []UserBotCommandInput { + if x == nil { + return nil + } + ret := make([]UserBotCommandInput, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Commands), + TeamName: o.TeamName, + } +} + +type ResetConvMemberAPI struct { + ConversationID ConvIDStr `codec:"conversationID" json:"conversationID"` + Username string `codec:"username" json:"username"` +} + +func (o ResetConvMemberAPI) DeepCopy() ResetConvMemberAPI { + return ResetConvMemberAPI{ + ConversationID: o.ConversationID.DeepCopy(), + Username: o.Username, + } +} + +type GetResetConvMembersRes struct { + Members []ResetConvMemberAPI `codec:"members" json:"members"` + RateLimits []RateLimitRes `codec:"rateLimits" json:"rateLimits"` +} + +func (o GetResetConvMembersRes) DeepCopy() GetResetConvMembersRes { + return GetResetConvMembersRes{ + Members: (func(x []ResetConvMemberAPI) []ResetConvMemberAPI { + if x == nil { + return nil + } + ret := make([]ResetConvMemberAPI, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Members), + RateLimits: (func(x []RateLimitRes) []RateLimitRes { + if x == nil { + return nil + } + ret := make([]RateLimitRes, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.RateLimits), + } +} + +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"` +} + +func (o DeviceInfo) DeepCopy() DeviceInfo { + return DeviceInfo{ + DeviceID: o.DeviceID.DeepCopy(), + DeviceDescription: o.DeviceDescription, + DeviceType: o.DeviceType, + DeviceCtime: o.DeviceCtime, + } +} + +type GetDeviceInfoRes struct { + Devices []DeviceInfo `codec:"devices" json:"devices"` +} + +func (o GetDeviceInfoRes) DeepCopy() GetDeviceInfoRes { + return GetDeviceInfoRes{ + Devices: (func(x []DeviceInfo) []DeviceInfo { + if x == nil { + return nil + } + ret := make([]DeviceInfo, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Devices), + } +} 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 new file mode 100644 index 00000000..37c5c78a --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/blocking.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..1a908099 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/chat_ui.go @@ -0,0 +1,2874 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/chat1/chat_ui.avdl + +package chat1 + +import ( + "errors" + "fmt" + + 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 UIPagination struct { + Next string `codec:"next" json:"next"` + Previous string `codec:"previous" json:"previous"` + Num int `codec:"num" json:"num"` + Last bool `codec:"last" json:"last"` +} + +func (o UIPagination) DeepCopy() UIPagination { + return UIPagination{ + Next: o.Next, + Previous: o.Previous, + Num: o.Num, + Last: o.Last, + } +} + +type UIInboxSmallTeamRow struct { + ConvID ConvIDStr `codec:"convID" json:"convID"` + Name string `codec:"name" json:"name"` + Time gregor1.Time `codec:"time" json:"time"` + Snippet *string `codec:"snippet,omitempty" json:"snippet,omitempty"` + SnippetDecoration SnippetDecoration `codec:"snippetDecoration" json:"snippetDecoration"` + Draft *string `codec:"draft,omitempty" json:"draft,omitempty"` + IsMuted bool `codec:"isMuted" json:"isMuted"` + IsTeam bool `codec:"isTeam" json:"isTeam"` +} + +func (o UIInboxSmallTeamRow) DeepCopy() UIInboxSmallTeamRow { + return UIInboxSmallTeamRow{ + ConvID: o.ConvID.DeepCopy(), + Name: o.Name, + Time: o.Time.DeepCopy(), + Snippet: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Snippet), + SnippetDecoration: o.SnippetDecoration.DeepCopy(), + Draft: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Draft), + IsMuted: o.IsMuted, + IsTeam: o.IsTeam, + } +} + +type UIInboxBigTeamRowTyp int + +const ( + UIInboxBigTeamRowTyp_LABEL UIInboxBigTeamRowTyp = 1 + UIInboxBigTeamRowTyp_CHANNEL UIInboxBigTeamRowTyp = 2 +) + +func (o UIInboxBigTeamRowTyp) DeepCopy() UIInboxBigTeamRowTyp { return o } + +var UIInboxBigTeamRowTypMap = map[string]UIInboxBigTeamRowTyp{ + "LABEL": 1, + "CHANNEL": 2, +} + +var UIInboxBigTeamRowTypRevMap = map[UIInboxBigTeamRowTyp]string{ + 1: "LABEL", + 2: "CHANNEL", +} + +func (e UIInboxBigTeamRowTyp) String() string { + if v, ok := UIInboxBigTeamRowTypRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type UIInboxBigTeamChannelRow struct { + ConvID ConvIDStr `codec:"convID" json:"convID"` + Teamname string `codec:"teamname" json:"teamname"` + Channelname string `codec:"channelname" json:"channelname"` + Draft *string `codec:"draft,omitempty" json:"draft,omitempty"` + IsMuted bool `codec:"isMuted" json:"isMuted"` +} + +func (o UIInboxBigTeamChannelRow) DeepCopy() UIInboxBigTeamChannelRow { + return UIInboxBigTeamChannelRow{ + ConvID: o.ConvID.DeepCopy(), + Teamname: o.Teamname, + Channelname: o.Channelname, + Draft: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Draft), + IsMuted: o.IsMuted, + } +} + +type UIInboxBigTeamLabelRow struct { + Name string `codec:"name" json:"name"` + Id TLFIDStr `codec:"id" json:"id"` +} + +func (o UIInboxBigTeamLabelRow) DeepCopy() UIInboxBigTeamLabelRow { + return UIInboxBigTeamLabelRow{ + Name: o.Name, + Id: o.Id.DeepCopy(), + } +} + +type UIInboxBigTeamRow struct { + State__ UIInboxBigTeamRowTyp `codec:"state" json:"state"` + Label__ *UIInboxBigTeamLabelRow `codec:"label,omitempty" json:"label,omitempty"` + Channel__ *UIInboxBigTeamChannelRow `codec:"channel,omitempty" json:"channel,omitempty"` +} + +func (o *UIInboxBigTeamRow) State() (ret UIInboxBigTeamRowTyp, err error) { + switch o.State__ { + case UIInboxBigTeamRowTyp_LABEL: + if o.Label__ == nil { + err = errors.New("unexpected nil value for Label__") + return ret, err + } + case UIInboxBigTeamRowTyp_CHANNEL: + if o.Channel__ == nil { + err = errors.New("unexpected nil value for Channel__") + return ret, err + } + } + return o.State__, nil +} + +func (o UIInboxBigTeamRow) Label() (res UIInboxBigTeamLabelRow) { + if o.State__ != UIInboxBigTeamRowTyp_LABEL { + panic("wrong case accessed") + } + if o.Label__ == nil { + return + } + return *o.Label__ +} + +func (o UIInboxBigTeamRow) Channel() (res UIInboxBigTeamChannelRow) { + if o.State__ != UIInboxBigTeamRowTyp_CHANNEL { + panic("wrong case accessed") + } + if o.Channel__ == nil { + return + } + return *o.Channel__ +} + +func NewUIInboxBigTeamRowWithLabel(v UIInboxBigTeamLabelRow) UIInboxBigTeamRow { + return UIInboxBigTeamRow{ + State__: UIInboxBigTeamRowTyp_LABEL, + Label__: &v, + } +} + +func NewUIInboxBigTeamRowWithChannel(v UIInboxBigTeamChannelRow) UIInboxBigTeamRow { + return UIInboxBigTeamRow{ + State__: UIInboxBigTeamRowTyp_CHANNEL, + Channel__: &v, + } +} + +func (o UIInboxBigTeamRow) DeepCopy() UIInboxBigTeamRow { + return UIInboxBigTeamRow{ + State__: o.State__.DeepCopy(), + Label__: (func(x *UIInboxBigTeamLabelRow) *UIInboxBigTeamLabelRow { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Label__), + Channel__: (func(x *UIInboxBigTeamChannelRow) *UIInboxBigTeamChannelRow { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Channel__), + } +} + +type UIInboxReselectInfo struct { + OldConvID ConvIDStr `codec:"oldConvID" json:"oldConvID"` + NewConvID *ConvIDStr `codec:"newConvID,omitempty" json:"newConvID,omitempty"` +} + +func (o UIInboxReselectInfo) DeepCopy() UIInboxReselectInfo { + return UIInboxReselectInfo{ + OldConvID: o.OldConvID.DeepCopy(), + NewConvID: (func(x *ConvIDStr) *ConvIDStr { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.NewConvID), + } +} + +type UIInboxLayout struct { + TotalSmallTeams int `codec:"totalSmallTeams" json:"totalSmallTeams"` + SmallTeams []UIInboxSmallTeamRow `codec:"smallTeams" json:"smallTeams"` + BigTeams []UIInboxBigTeamRow `codec:"bigTeams" json:"bigTeams"` + ReselectInfo *UIInboxReselectInfo `codec:"reselectInfo,omitempty" json:"reselectInfo,omitempty"` + WidgetList []UIInboxSmallTeamRow `codec:"widgetList" json:"widgetList"` +} + +func (o UIInboxLayout) DeepCopy() UIInboxLayout { + return UIInboxLayout{ + TotalSmallTeams: o.TotalSmallTeams, + SmallTeams: (func(x []UIInboxSmallTeamRow) []UIInboxSmallTeamRow { + if x == nil { + return nil + } + ret := make([]UIInboxSmallTeamRow, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.SmallTeams), + BigTeams: (func(x []UIInboxBigTeamRow) []UIInboxBigTeamRow { + if x == nil { + return nil + } + ret := make([]UIInboxBigTeamRow, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.BigTeams), + ReselectInfo: (func(x *UIInboxReselectInfo) *UIInboxReselectInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ReselectInfo), + WidgetList: (func(x []UIInboxSmallTeamRow) []UIInboxSmallTeamRow { + if x == nil { + return nil + } + ret := make([]UIInboxSmallTeamRow, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.WidgetList), + } +} + +type UnverifiedInboxUIItemMetadata struct { + ChannelName string `codec:"channelName" json:"channelName"` + Headline string `codec:"headline" json:"headline"` + HeadlineDecorated string `codec:"headlineDecorated" json:"headlineDecorated"` + Snippet string `codec:"snippet" json:"snippet"` + SnippetDecoration SnippetDecoration `codec:"snippetDecoration" json:"snippetDecoration"` + WriterNames []string `codec:"writerNames" json:"writerNames"` + ResetParticipants []string `codec:"resetParticipants" json:"resetParticipants"` +} + +func (o UnverifiedInboxUIItemMetadata) DeepCopy() UnverifiedInboxUIItemMetadata { + return UnverifiedInboxUIItemMetadata{ + ChannelName: o.ChannelName, + Headline: o.Headline, + HeadlineDecorated: o.HeadlineDecorated, + Snippet: o.Snippet, + SnippetDecoration: o.SnippetDecoration.DeepCopy(), + WriterNames: (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.WriterNames), + ResetParticipants: (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.ResetParticipants), + } +} + +type UnverifiedInboxUIItem struct { + ConvID ConvIDStr `codec:"convID" json:"convID"` + TlfID TLFIDStr `codec:"tlfID" json:"tlfID"` + TopicType TopicType `codec:"topicType" json:"topicType"` + IsPublic bool `codec:"isPublic" json:"isPublic"` + IsDefaultConv bool `codec:"isDefaultConv" json:"isDefaultConv"` + Name string `codec:"name" json:"name"` + Visibility keybase1.TLFVisibility `codec:"visibility" json:"visibility"` + Status ConversationStatus `codec:"status" json:"status"` + MembersType ConversationMembersType `codec:"membersType" json:"membersType"` + MemberStatus ConversationMemberStatus `codec:"memberStatus" json:"memberStatus"` + TeamType TeamType `codec:"teamType" json:"teamType"` + Notifications *ConversationNotificationInfo `codec:"notifications,omitempty" json:"notifications,omitempty"` + Time gregor1.Time `codec:"time" json:"time"` + Version ConversationVers `codec:"version" json:"version"` + LocalVersion LocalConversationVers `codec:"localVersion" json:"localVersion"` + ConvRetention *RetentionPolicy `codec:"convRetention,omitempty" json:"convRetention,omitempty"` + TeamRetention *RetentionPolicy `codec:"teamRetention,omitempty" json:"teamRetention,omitempty"` + MaxMsgID MessageID `codec:"maxMsgID" json:"maxMsgID"` + MaxVisibleMsgID MessageID `codec:"maxVisibleMsgID" json:"maxVisibleMsgID"` + ReadMsgID MessageID `codec:"readMsgID" json:"readMsgID"` + LocalMetadata *UnverifiedInboxUIItemMetadata `codec:"localMetadata,omitempty" json:"localMetadata,omitempty"` + Draft *string `codec:"draft,omitempty" json:"draft,omitempty"` + FinalizeInfo *ConversationFinalizeInfo `codec:"finalizeInfo,omitempty" json:"finalizeInfo,omitempty"` + Supersedes []ConversationMetadata `codec:"supersedes" json:"supersedes"` + SupersededBy []ConversationMetadata `codec:"supersededBy" json:"supersededBy"` + Commands ConversationCommandGroups `codec:"commands" json:"commands"` +} + +func (o UnverifiedInboxUIItem) DeepCopy() UnverifiedInboxUIItem { + return UnverifiedInboxUIItem{ + ConvID: o.ConvID.DeepCopy(), + TlfID: o.TlfID.DeepCopy(), + TopicType: o.TopicType.DeepCopy(), + IsPublic: o.IsPublic, + IsDefaultConv: o.IsDefaultConv, + Name: o.Name, + Visibility: o.Visibility.DeepCopy(), + Status: o.Status.DeepCopy(), + MembersType: o.MembersType.DeepCopy(), + MemberStatus: o.MemberStatus.DeepCopy(), + TeamType: o.TeamType.DeepCopy(), + Notifications: (func(x *ConversationNotificationInfo) *ConversationNotificationInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Notifications), + Time: o.Time.DeepCopy(), + Version: o.Version.DeepCopy(), + LocalVersion: o.LocalVersion.DeepCopy(), + ConvRetention: (func(x *RetentionPolicy) *RetentionPolicy { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ConvRetention), + TeamRetention: (func(x *RetentionPolicy) *RetentionPolicy { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.TeamRetention), + MaxMsgID: o.MaxMsgID.DeepCopy(), + MaxVisibleMsgID: o.MaxVisibleMsgID.DeepCopy(), + ReadMsgID: o.ReadMsgID.DeepCopy(), + LocalMetadata: (func(x *UnverifiedInboxUIItemMetadata) *UnverifiedInboxUIItemMetadata { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.LocalMetadata), + Draft: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Draft), + FinalizeInfo: (func(x *ConversationFinalizeInfo) *ConversationFinalizeInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.FinalizeInfo), + Supersedes: (func(x []ConversationMetadata) []ConversationMetadata { + if x == nil { + return nil + } + ret := make([]ConversationMetadata, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Supersedes), + SupersededBy: (func(x []ConversationMetadata) []ConversationMetadata { + if x == nil { + return nil + } + ret := make([]ConversationMetadata, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.SupersededBy), + Commands: o.Commands.DeepCopy(), + } +} + +type UnverifiedInboxUIItems struct { + Items []UnverifiedInboxUIItem `codec:"items" json:"items"` + Offline bool `codec:"offline" json:"offline"` +} + +func (o UnverifiedInboxUIItems) DeepCopy() UnverifiedInboxUIItems { + return UnverifiedInboxUIItems{ + Items: (func(x []UnverifiedInboxUIItem) []UnverifiedInboxUIItem { + if x == nil { + return nil + } + ret := make([]UnverifiedInboxUIItem, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Items), + Offline: o.Offline, + } +} + +type UIParticipantType int + +const ( + UIParticipantType_NONE UIParticipantType = 0 + UIParticipantType_USER UIParticipantType = 1 + UIParticipantType_PHONENO UIParticipantType = 2 + UIParticipantType_EMAIL UIParticipantType = 3 +) + +func (o UIParticipantType) DeepCopy() UIParticipantType { return o } + +var UIParticipantTypeMap = map[string]UIParticipantType{ + "NONE": 0, + "USER": 1, + "PHONENO": 2, + "EMAIL": 3, +} + +var UIParticipantTypeRevMap = map[UIParticipantType]string{ + 0: "NONE", + 1: "USER", + 2: "PHONENO", + 3: "EMAIL", +} + +func (e UIParticipantType) String() string { + if v, ok := UIParticipantTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type UIParticipant struct { + Type UIParticipantType `codec:"type" json:"type"` + Assertion string `codec:"assertion" json:"assertion"` + InConvName bool `codec:"inConvName" json:"inConvName"` + FullName *string `codec:"fullName,omitempty" json:"fullName,omitempty"` + ContactName *string `codec:"contactName,omitempty" json:"contactName,omitempty"` +} + +func (o UIParticipant) DeepCopy() UIParticipant { + return UIParticipant{ + Type: o.Type.DeepCopy(), + Assertion: o.Assertion, + InConvName: o.InConvName, + FullName: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.FullName), + ContactName: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.ContactName), + } +} + +type UIPinnedMessage struct { + Message UIMessage `codec:"message" json:"message"` + PinnerUsername string `codec:"pinnerUsername" json:"pinnerUsername"` +} + +func (o UIPinnedMessage) DeepCopy() UIPinnedMessage { + return UIPinnedMessage{ + Message: o.Message.DeepCopy(), + PinnerUsername: o.PinnerUsername, + } +} + +type InboxUIItem struct { + ConvID ConvIDStr `codec:"convID" json:"convID"` + TlfID TLFIDStr `codec:"tlfID" json:"tlfID"` + TopicType TopicType `codec:"topicType" json:"topicType"` + IsPublic bool `codec:"isPublic" json:"isPublic"` + IsEmpty bool `codec:"isEmpty" json:"isEmpty"` + IsDefaultConv bool `codec:"isDefaultConv" json:"isDefaultConv"` + Name string `codec:"name" json:"name"` + Snippet string `codec:"snippet" json:"snippet"` + SnippetDecoration SnippetDecoration `codec:"snippetDecoration" json:"snippetDecoration"` + Channel string `codec:"channel" json:"channel"` + Headline string `codec:"headline" json:"headline"` + HeadlineDecorated string `codec:"headlineDecorated" json:"headlineDecorated"` + Draft *string `codec:"draft,omitempty" json:"draft,omitempty"` + Visibility keybase1.TLFVisibility `codec:"visibility" json:"visibility"` + Participants []UIParticipant `codec:"participants" json:"participants"` + ResetParticipants []string `codec:"resetParticipants" json:"resetParticipants"` + Status ConversationStatus `codec:"status" json:"status"` + MembersType ConversationMembersType `codec:"membersType" json:"membersType"` + MemberStatus ConversationMemberStatus `codec:"memberStatus" json:"memberStatus"` + TeamType TeamType `codec:"teamType" json:"teamType"` + Time gregor1.Time `codec:"time" json:"time"` + Notifications *ConversationNotificationInfo `codec:"notifications,omitempty" json:"notifications,omitempty"` + CreatorInfo *ConversationCreatorInfoLocal `codec:"creatorInfo,omitempty" json:"creatorInfo,omitempty"` + Version ConversationVers `codec:"version" json:"version"` + LocalVersion LocalConversationVers `codec:"localVersion" json:"localVersion"` + MaxMsgID MessageID `codec:"maxMsgID" json:"maxMsgID"` + MaxVisibleMsgID MessageID `codec:"maxVisibleMsgID" json:"maxVisibleMsgID"` + ReadMsgID MessageID `codec:"readMsgID" json:"readMsgID"` + ConvRetention *RetentionPolicy `codec:"convRetention,omitempty" json:"convRetention,omitempty"` + TeamRetention *RetentionPolicy `codec:"teamRetention,omitempty" json:"teamRetention,omitempty"` + ConvSettings *ConversationSettingsLocal `codec:"convSettings,omitempty" json:"convSettings,omitempty"` + FinalizeInfo *ConversationFinalizeInfo `codec:"finalizeInfo,omitempty" json:"finalizeInfo,omitempty"` + Supersedes []ConversationMetadata `codec:"supersedes" json:"supersedes"` + SupersededBy []ConversationMetadata `codec:"supersededBy" json:"supersededBy"` + Commands ConversationCommandGroups `codec:"commands" json:"commands"` + BotCommands ConversationCommandGroups `codec:"botCommands" json:"botCommands"` + BotAliases map[string]string `codec:"botAliases" json:"botAliases"` + PinnedMsg *UIPinnedMessage `codec:"pinnedMsg,omitempty" json:"pinnedMsg,omitempty"` +} + +func (o InboxUIItem) DeepCopy() InboxUIItem { + return InboxUIItem{ + ConvID: o.ConvID.DeepCopy(), + TlfID: o.TlfID.DeepCopy(), + TopicType: o.TopicType.DeepCopy(), + IsPublic: o.IsPublic, + IsEmpty: o.IsEmpty, + IsDefaultConv: o.IsDefaultConv, + Name: o.Name, + Snippet: o.Snippet, + SnippetDecoration: o.SnippetDecoration.DeepCopy(), + Channel: o.Channel, + Headline: o.Headline, + HeadlineDecorated: o.HeadlineDecorated, + Draft: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Draft), + Visibility: o.Visibility.DeepCopy(), + Participants: (func(x []UIParticipant) []UIParticipant { + if x == nil { + return nil + } + ret := make([]UIParticipant, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Participants), + ResetParticipants: (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.ResetParticipants), + Status: o.Status.DeepCopy(), + MembersType: o.MembersType.DeepCopy(), + MemberStatus: o.MemberStatus.DeepCopy(), + TeamType: o.TeamType.DeepCopy(), + Time: o.Time.DeepCopy(), + Notifications: (func(x *ConversationNotificationInfo) *ConversationNotificationInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Notifications), + CreatorInfo: (func(x *ConversationCreatorInfoLocal) *ConversationCreatorInfoLocal { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.CreatorInfo), + Version: o.Version.DeepCopy(), + LocalVersion: o.LocalVersion.DeepCopy(), + MaxMsgID: o.MaxMsgID.DeepCopy(), + MaxVisibleMsgID: o.MaxVisibleMsgID.DeepCopy(), + ReadMsgID: o.ReadMsgID.DeepCopy(), + ConvRetention: (func(x *RetentionPolicy) *RetentionPolicy { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ConvRetention), + TeamRetention: (func(x *RetentionPolicy) *RetentionPolicy { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.TeamRetention), + ConvSettings: (func(x *ConversationSettingsLocal) *ConversationSettingsLocal { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ConvSettings), + FinalizeInfo: (func(x *ConversationFinalizeInfo) *ConversationFinalizeInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.FinalizeInfo), + Supersedes: (func(x []ConversationMetadata) []ConversationMetadata { + if x == nil { + return nil + } + ret := make([]ConversationMetadata, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Supersedes), + SupersededBy: (func(x []ConversationMetadata) []ConversationMetadata { + if x == nil { + return nil + } + ret := make([]ConversationMetadata, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.SupersededBy), + Commands: o.Commands.DeepCopy(), + BotCommands: o.BotCommands.DeepCopy(), + BotAliases: (func(x map[string]string) map[string]string { + if x == nil { + return nil + } + ret := make(map[string]string, len(x)) + for k, v := range x { + kCopy := k + vCopy := v + ret[kCopy] = vCopy + } + return ret + })(o.BotAliases), + PinnedMsg: (func(x *UIPinnedMessage) *UIPinnedMessage { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.PinnedMsg), + } +} + +type InboxUIItemError struct { + Typ ConversationErrorType `codec:"typ" json:"typ"` + Message string `codec:"message" json:"message"` + UnverifiedTLFName string `codec:"unverifiedTLFName" json:"unverifiedTLFName"` + RekeyInfo *ConversationErrorRekey `codec:"rekeyInfo,omitempty" json:"rekeyInfo,omitempty"` + RemoteConv UnverifiedInboxUIItem `codec:"remoteConv" json:"remoteConv"` +} + +func (o InboxUIItemError) DeepCopy() InboxUIItemError { + return InboxUIItemError{ + Typ: o.Typ.DeepCopy(), + Message: o.Message, + UnverifiedTLFName: o.UnverifiedTLFName, + RekeyInfo: (func(x *ConversationErrorRekey) *ConversationErrorRekey { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RekeyInfo), + RemoteConv: o.RemoteConv.DeepCopy(), + } +} + +type InboxUIItems struct { + Items []InboxUIItem `codec:"items" json:"items"` + Offline bool `codec:"offline" json:"offline"` +} + +func (o InboxUIItems) DeepCopy() InboxUIItems { + return InboxUIItems{ + Items: (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.Items), + Offline: o.Offline, + } +} + +type UIChannelNameMention struct { + Name string `codec:"name" json:"name"` + ConvID ConvIDStr `codec:"convID" json:"convID"` +} + +func (o UIChannelNameMention) DeepCopy() UIChannelNameMention { + return UIChannelNameMention{ + Name: o.Name, + ConvID: o.ConvID.DeepCopy(), + } +} + +type UIAssetUrlInfo struct { + PreviewUrl string `codec:"previewUrl" json:"previewUrl"` + FullUrl string `codec:"fullUrl" json:"fullUrl"` + FullUrlCached bool `codec:"fullUrlCached" json:"fullUrlCached"` + MimeType string `codec:"mimeType" json:"mimeType"` + VideoDuration *string `codec:"videoDuration,omitempty" json:"videoDuration,omitempty"` + InlineVideoPlayable bool `codec:"inlineVideoPlayable" json:"inlineVideoPlayable"` +} + +func (o UIAssetUrlInfo) DeepCopy() UIAssetUrlInfo { + return UIAssetUrlInfo{ + PreviewUrl: o.PreviewUrl, + FullUrl: o.FullUrl, + FullUrlCached: o.FullUrlCached, + MimeType: o.MimeType, + VideoDuration: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.VideoDuration), + InlineVideoPlayable: o.InlineVideoPlayable, + } +} + +type UIPaymentInfo struct { + AccountID *stellar1.AccountID `codec:"accountID,omitempty" json:"accountID,omitempty"` + AmountDescription string `codec:"amountDescription" json:"amountDescription"` + Worth string `codec:"worth" json:"worth"` + WorthAtSendTime string `codec:"worthAtSendTime" json:"worthAtSendTime"` + Delta stellar1.BalanceDelta `codec:"delta" json:"delta"` + Note string `codec:"note" json:"note"` + PaymentID stellar1.PaymentID `codec:"paymentID" json:"paymentID"` + Status stellar1.PaymentStatus `codec:"status" json:"status"` + StatusDescription string `codec:"statusDescription" json:"statusDescription"` + StatusDetail string `codec:"statusDetail" json:"statusDetail"` + ShowCancel bool `codec:"showCancel" json:"showCancel"` + FromUsername string `codec:"fromUsername" json:"fromUsername"` + ToUsername string `codec:"toUsername" json:"toUsername"` + SourceAmount string `codec:"sourceAmount" json:"sourceAmount"` + SourceAsset stellar1.Asset `codec:"sourceAsset" json:"sourceAsset"` + IssuerDescription string `codec:"issuerDescription" json:"issuerDescription"` +} + +func (o UIPaymentInfo) DeepCopy() UIPaymentInfo { + return UIPaymentInfo{ + AccountID: (func(x *stellar1.AccountID) *stellar1.AccountID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.AccountID), + AmountDescription: o.AmountDescription, + Worth: o.Worth, + WorthAtSendTime: o.WorthAtSendTime, + Delta: o.Delta.DeepCopy(), + Note: o.Note, + PaymentID: o.PaymentID.DeepCopy(), + Status: o.Status.DeepCopy(), + StatusDescription: o.StatusDescription, + StatusDetail: o.StatusDetail, + ShowCancel: o.ShowCancel, + FromUsername: o.FromUsername, + ToUsername: o.ToUsername, + SourceAmount: o.SourceAmount, + SourceAsset: o.SourceAsset.DeepCopy(), + IssuerDescription: o.IssuerDescription, + } +} + +type UIRequestInfo struct { + Amount string `codec:"amount" json:"amount"` + AmountDescription string `codec:"amountDescription" json:"amountDescription"` + Asset *stellar1.Asset `codec:"asset,omitempty" json:"asset,omitempty"` + Currency *stellar1.OutsideCurrencyCode `codec:"currency,omitempty" json:"currency,omitempty"` + WorthAtRequestTime string `codec:"worthAtRequestTime" json:"worthAtRequestTime"` + Status stellar1.RequestStatus `codec:"status" json:"status"` +} + +func (o UIRequestInfo) DeepCopy() UIRequestInfo { + return UIRequestInfo{ + Amount: o.Amount, + AmountDescription: o.AmountDescription, + Asset: (func(x *stellar1.Asset) *stellar1.Asset { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Asset), + Currency: (func(x *stellar1.OutsideCurrencyCode) *stellar1.OutsideCurrencyCode { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Currency), + WorthAtRequestTime: o.WorthAtRequestTime, + Status: o.Status.DeepCopy(), + } +} + +type UIMessageUnfurlInfo struct { + UnfurlMessageID MessageID `codec:"unfurlMessageID" json:"unfurlMessageID"` + Url string `codec:"url" json:"url"` + Unfurl UnfurlDisplay `codec:"unfurl" json:"unfurl"` + IsCollapsed bool `codec:"isCollapsed" json:"isCollapsed"` +} + +func (o UIMessageUnfurlInfo) DeepCopy() UIMessageUnfurlInfo { + return UIMessageUnfurlInfo{ + UnfurlMessageID: o.UnfurlMessageID.DeepCopy(), + Url: o.Url, + Unfurl: o.Unfurl.DeepCopy(), + IsCollapsed: o.IsCollapsed, + } +} + +type UIMessageValid struct { + MessageID MessageID `codec:"messageID" json:"messageID"` + Ctime gregor1.Time `codec:"ctime" json:"ctime"` + OutboxID *string `codec:"outboxID,omitempty" json:"outboxID,omitempty"` + MessageBody MessageBody `codec:"messageBody" json:"messageBody"` + DecoratedTextBody *string `codec:"decoratedTextBody,omitempty" json:"decoratedTextBody,omitempty"` + BodySummary string `codec:"bodySummary" json:"bodySummary"` + SenderUsername string `codec:"senderUsername" json:"senderUsername"` + SenderDeviceName string `codec:"senderDeviceName" json:"senderDeviceName"` + SenderDeviceType string `codec:"senderDeviceType" json:"senderDeviceType"` + SenderUID gregor1.UID `codec:"senderUID" json:"senderUID"` + SenderDeviceID gregor1.DeviceID `codec:"senderDeviceID" json:"senderDeviceID"` + Superseded bool `codec:"superseded" json:"superseded"` + AssetUrlInfo *UIAssetUrlInfo `codec:"assetUrlInfo,omitempty" json:"assetUrlInfo,omitempty"` + SenderDeviceRevokedAt *gregor1.Time `codec:"senderDeviceRevokedAt,omitempty" json:"senderDeviceRevokedAt,omitempty"` + AtMentions []string `codec:"atMentions" json:"atMentions"` + ChannelMention ChannelMention `codec:"channelMention" json:"channelMention"` + ChannelNameMentions []UIChannelNameMention `codec:"channelNameMentions" json:"channelNameMentions"` + IsEphemeral bool `codec:"isEphemeral" json:"isEphemeral"` + 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"` + HasPairwiseMacs bool `codec:"hasPairwiseMacs" json:"hasPairwiseMacs"` + PaymentInfos []UIPaymentInfo `codec:"paymentInfos" json:"paymentInfos"` + RequestInfo *UIRequestInfo `codec:"requestInfo,omitempty" json:"requestInfo,omitempty"` + Unfurls []UIMessageUnfurlInfo `codec:"unfurls" json:"unfurls"` + IsCollapsed bool `codec:"isCollapsed" json:"isCollapsed"` + FlipGameID *FlipGameIDStr `codec:"flipGameID,omitempty" json:"flipGameID,omitempty"` + IsDeleteable bool `codec:"isDeleteable" json:"isDeleteable"` + IsEditable bool `codec:"isEditable" json:"isEditable"` + ReplyTo *UIMessage `codec:"replyTo,omitempty" json:"replyTo,omitempty"` + PinnedMessageID *MessageID `codec:"pinnedMessageID,omitempty" json:"pinnedMessageID,omitempty"` + BotUsername string `codec:"botUsername" json:"botUsername"` +} + +func (o UIMessageValid) DeepCopy() UIMessageValid { + return UIMessageValid{ + MessageID: o.MessageID.DeepCopy(), + Ctime: o.Ctime.DeepCopy(), + OutboxID: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.OutboxID), + MessageBody: o.MessageBody.DeepCopy(), + DecoratedTextBody: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.DecoratedTextBody), + BodySummary: o.BodySummary, + SenderUsername: o.SenderUsername, + SenderDeviceName: o.SenderDeviceName, + SenderDeviceType: o.SenderDeviceType, + SenderUID: o.SenderUID.DeepCopy(), + SenderDeviceID: o.SenderDeviceID.DeepCopy(), + Superseded: o.Superseded, + AssetUrlInfo: (func(x *UIAssetUrlInfo) *UIAssetUrlInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.AssetUrlInfo), + SenderDeviceRevokedAt: (func(x *gregor1.Time) *gregor1.Time { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.SenderDeviceRevokedAt), + AtMentions: (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.AtMentions), + ChannelMention: o.ChannelMention.DeepCopy(), + ChannelNameMentions: (func(x []UIChannelNameMention) []UIChannelNameMention { + if x == nil { + return nil + } + ret := make([]UIChannelNameMention, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.ChannelNameMentions), + IsEphemeral: o.IsEphemeral, + IsEphemeralExpired: o.IsEphemeralExpired, + ExplodedBy: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.ExplodedBy), + Etime: o.Etime.DeepCopy(), + Reactions: o.Reactions.DeepCopy(), + HasPairwiseMacs: o.HasPairwiseMacs, + PaymentInfos: (func(x []UIPaymentInfo) []UIPaymentInfo { + if x == nil { + return nil + } + ret := make([]UIPaymentInfo, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.PaymentInfos), + RequestInfo: (func(x *UIRequestInfo) *UIRequestInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RequestInfo), + Unfurls: (func(x []UIMessageUnfurlInfo) []UIMessageUnfurlInfo { + if x == nil { + return nil + } + ret := make([]UIMessageUnfurlInfo, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Unfurls), + IsCollapsed: o.IsCollapsed, + FlipGameID: (func(x *FlipGameIDStr) *FlipGameIDStr { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.FlipGameID), + IsDeleteable: o.IsDeleteable, + IsEditable: o.IsEditable, + ReplyTo: (func(x *UIMessage) *UIMessage { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ReplyTo), + PinnedMessageID: (func(x *MessageID) *MessageID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.PinnedMessageID), + BotUsername: o.BotUsername, + } +} + +type UIMessageOutbox struct { + State OutboxState `codec:"state" json:"state"` + OutboxID string `codec:"outboxID" json:"outboxID"` + MessageType MessageType `codec:"messageType" json:"messageType"` + Body string `codec:"body" json:"body"` + DecoratedTextBody *string `codec:"decoratedTextBody,omitempty" json:"decoratedTextBody,omitempty"` + Ctime gregor1.Time `codec:"ctime" json:"ctime"` + Ordinal float64 `codec:"ordinal" json:"ordinal"` + IsEphemeral bool `codec:"isEphemeral" json:"isEphemeral"` + FlipGameID *FlipGameIDStr `codec:"flipGameID,omitempty" json:"flipGameID,omitempty"` + ReplyTo *UIMessage `codec:"replyTo,omitempty" json:"replyTo,omitempty"` + Filename string `codec:"filename" json:"filename"` + Title string `codec:"title" json:"title"` + Preview *MakePreviewRes `codec:"preview,omitempty" json:"preview,omitempty"` +} + +func (o UIMessageOutbox) DeepCopy() UIMessageOutbox { + return UIMessageOutbox{ + State: o.State.DeepCopy(), + OutboxID: o.OutboxID, + MessageType: o.MessageType.DeepCopy(), + Body: o.Body, + DecoratedTextBody: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.DecoratedTextBody), + Ctime: o.Ctime.DeepCopy(), + Ordinal: o.Ordinal, + IsEphemeral: o.IsEphemeral, + FlipGameID: (func(x *FlipGameIDStr) *FlipGameIDStr { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.FlipGameID), + ReplyTo: (func(x *UIMessage) *UIMessage { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ReplyTo), + Filename: o.Filename, + Title: o.Title, + Preview: (func(x *MakePreviewRes) *MakePreviewRes { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Preview), + } +} + +type UIMessageJourneycard struct { + Ordinal float64 `codec:"ordinal" json:"ordinal"` + CardType JourneycardType `codec:"cardType" json:"cardType"` + HighlightMsgID MessageID `codec:"highlightMsgID" json:"highlightMsgID"` + OpenTeam bool `codec:"openTeam" json:"openTeam"` +} + +func (o UIMessageJourneycard) DeepCopy() UIMessageJourneycard { + return UIMessageJourneycard{ + Ordinal: o.Ordinal, + CardType: o.CardType.DeepCopy(), + HighlightMsgID: o.HighlightMsgID.DeepCopy(), + OpenTeam: o.OpenTeam, + } +} + +type MessageUnboxedState int + +const ( + MessageUnboxedState_VALID MessageUnboxedState = 1 + MessageUnboxedState_ERROR MessageUnboxedState = 2 + MessageUnboxedState_OUTBOX MessageUnboxedState = 3 + MessageUnboxedState_PLACEHOLDER MessageUnboxedState = 4 + MessageUnboxedState_JOURNEYCARD MessageUnboxedState = 5 +) + +func (o MessageUnboxedState) DeepCopy() MessageUnboxedState { return o } + +var MessageUnboxedStateMap = map[string]MessageUnboxedState{ + "VALID": 1, + "ERROR": 2, + "OUTBOX": 3, + "PLACEHOLDER": 4, + "JOURNEYCARD": 5, +} + +var MessageUnboxedStateRevMap = map[MessageUnboxedState]string{ + 1: "VALID", + 2: "ERROR", + 3: "OUTBOX", + 4: "PLACEHOLDER", + 5: "JOURNEYCARD", +} + +func (e MessageUnboxedState) String() string { + if v, ok := MessageUnboxedStateRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type UIMessage struct { + State__ MessageUnboxedState `codec:"state" json:"state"` + Valid__ *UIMessageValid `codec:"valid,omitempty" json:"valid,omitempty"` + Error__ *MessageUnboxedError `codec:"error,omitempty" json:"error,omitempty"` + Outbox__ *UIMessageOutbox `codec:"outbox,omitempty" json:"outbox,omitempty"` + Placeholder__ *MessageUnboxedPlaceholder `codec:"placeholder,omitempty" json:"placeholder,omitempty"` + Journeycard__ *UIMessageJourneycard `codec:"journeycard,omitempty" json:"journeycard,omitempty"` +} + +func (o *UIMessage) State() (ret MessageUnboxedState, err error) { + switch o.State__ { + case MessageUnboxedState_VALID: + if o.Valid__ == nil { + err = errors.New("unexpected nil value for Valid__") + return ret, err + } + case MessageUnboxedState_ERROR: + if o.Error__ == nil { + err = errors.New("unexpected nil value for Error__") + return ret, err + } + case MessageUnboxedState_OUTBOX: + if o.Outbox__ == nil { + err = errors.New("unexpected nil value for Outbox__") + return ret, err + } + case MessageUnboxedState_PLACEHOLDER: + if o.Placeholder__ == nil { + err = errors.New("unexpected nil value for Placeholder__") + return ret, err + } + case MessageUnboxedState_JOURNEYCARD: + if o.Journeycard__ == nil { + err = errors.New("unexpected nil value for Journeycard__") + return ret, err + } + } + return o.State__, nil +} + +func (o UIMessage) Valid() (res UIMessageValid) { + if o.State__ != MessageUnboxedState_VALID { + panic("wrong case accessed") + } + if o.Valid__ == nil { + return + } + return *o.Valid__ +} + +func (o UIMessage) Error() (res MessageUnboxedError) { + if o.State__ != MessageUnboxedState_ERROR { + panic("wrong case accessed") + } + if o.Error__ == nil { + return + } + return *o.Error__ +} + +func (o UIMessage) Outbox() (res UIMessageOutbox) { + if o.State__ != MessageUnboxedState_OUTBOX { + panic("wrong case accessed") + } + if o.Outbox__ == nil { + return + } + return *o.Outbox__ +} + +func (o UIMessage) Placeholder() (res MessageUnboxedPlaceholder) { + if o.State__ != MessageUnboxedState_PLACEHOLDER { + panic("wrong case accessed") + } + if o.Placeholder__ == nil { + return + } + return *o.Placeholder__ +} + +func (o UIMessage) Journeycard() (res UIMessageJourneycard) { + if o.State__ != MessageUnboxedState_JOURNEYCARD { + panic("wrong case accessed") + } + if o.Journeycard__ == nil { + return + } + return *o.Journeycard__ +} + +func NewUIMessageWithValid(v UIMessageValid) UIMessage { + return UIMessage{ + State__: MessageUnboxedState_VALID, + Valid__: &v, + } +} + +func NewUIMessageWithError(v MessageUnboxedError) UIMessage { + return UIMessage{ + State__: MessageUnboxedState_ERROR, + Error__: &v, + } +} + +func NewUIMessageWithOutbox(v UIMessageOutbox) UIMessage { + return UIMessage{ + State__: MessageUnboxedState_OUTBOX, + Outbox__: &v, + } +} + +func NewUIMessageWithPlaceholder(v MessageUnboxedPlaceholder) UIMessage { + return UIMessage{ + State__: MessageUnboxedState_PLACEHOLDER, + Placeholder__: &v, + } +} + +func NewUIMessageWithJourneycard(v UIMessageJourneycard) UIMessage { + return UIMessage{ + State__: MessageUnboxedState_JOURNEYCARD, + Journeycard__: &v, + } +} + +func (o UIMessage) DeepCopy() UIMessage { + return UIMessage{ + State__: o.State__.DeepCopy(), + Valid__: (func(x *UIMessageValid) *UIMessageValid { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Valid__), + Error__: (func(x *MessageUnboxedError) *MessageUnboxedError { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Error__), + Outbox__: (func(x *UIMessageOutbox) *UIMessageOutbox { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Outbox__), + Placeholder__: (func(x *MessageUnboxedPlaceholder) *MessageUnboxedPlaceholder { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Placeholder__), + Journeycard__: (func(x *UIMessageJourneycard) *UIMessageJourneycard { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Journeycard__), + } +} + +type UIMessages struct { + Messages []UIMessage `codec:"messages" json:"messages"` + Pagination *UIPagination `codec:"pagination,omitempty" json:"pagination,omitempty"` +} + +func (o UIMessages) DeepCopy() UIMessages { + return UIMessages{ + Messages: (func(x []UIMessage) []UIMessage { + if x == nil { + return nil + } + ret := make([]UIMessage, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Messages), + Pagination: (func(x *UIPagination) *UIPagination { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Pagination), + } +} + +type UITeamMention struct { + InTeam bool `codec:"inTeam" json:"inTeam"` + Open bool `codec:"open" json:"open"` + Description *string `codec:"description,omitempty" json:"description,omitempty"` + NumMembers *int `codec:"numMembers,omitempty" json:"numMembers,omitempty"` + PublicAdmins []string `codec:"publicAdmins" json:"publicAdmins"` + ConvID *ConvIDStr `codec:"convID,omitempty" json:"convID,omitempty"` +} + +func (o UITeamMention) DeepCopy() UITeamMention { + return UITeamMention{ + InTeam: o.InTeam, + Open: o.Open, + Description: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Description), + NumMembers: (func(x *int) *int { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.NumMembers), + 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), + ConvID: (func(x *ConvIDStr) *ConvIDStr { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ConvID), + } +} + +type UITextDecorationTyp int + +const ( + UITextDecorationTyp_PAYMENT UITextDecorationTyp = 0 + UITextDecorationTyp_ATMENTION UITextDecorationTyp = 1 + UITextDecorationTyp_CHANNELNAMEMENTION UITextDecorationTyp = 2 + UITextDecorationTyp_MAYBEMENTION UITextDecorationTyp = 3 + UITextDecorationTyp_LINK UITextDecorationTyp = 4 + UITextDecorationTyp_MAILTO UITextDecorationTyp = 5 + UITextDecorationTyp_KBFSPATH UITextDecorationTyp = 6 +) + +func (o UITextDecorationTyp) DeepCopy() UITextDecorationTyp { return o } + +var UITextDecorationTypMap = map[string]UITextDecorationTyp{ + "PAYMENT": 0, + "ATMENTION": 1, + "CHANNELNAMEMENTION": 2, + "MAYBEMENTION": 3, + "LINK": 4, + "MAILTO": 5, + "KBFSPATH": 6, +} + +var UITextDecorationTypRevMap = map[UITextDecorationTyp]string{ + 0: "PAYMENT", + 1: "ATMENTION", + 2: "CHANNELNAMEMENTION", + 3: "MAYBEMENTION", + 4: "LINK", + 5: "MAILTO", + 6: "KBFSPATH", +} + +func (e UITextDecorationTyp) String() string { + if v, ok := UITextDecorationTypRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type UIMaybeMentionStatus int + +const ( + UIMaybeMentionStatus_UNKNOWN UIMaybeMentionStatus = 0 + UIMaybeMentionStatus_USER UIMaybeMentionStatus = 1 + UIMaybeMentionStatus_TEAM UIMaybeMentionStatus = 2 + UIMaybeMentionStatus_NOTHING UIMaybeMentionStatus = 3 +) + +func (o UIMaybeMentionStatus) DeepCopy() UIMaybeMentionStatus { return o } + +var UIMaybeMentionStatusMap = map[string]UIMaybeMentionStatus{ + "UNKNOWN": 0, + "USER": 1, + "TEAM": 2, + "NOTHING": 3, +} + +var UIMaybeMentionStatusRevMap = map[UIMaybeMentionStatus]string{ + 0: "UNKNOWN", + 1: "USER", + 2: "TEAM", + 3: "NOTHING", +} + +func (e UIMaybeMentionStatus) String() string { + if v, ok := UIMaybeMentionStatusRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type UILinkDecoration struct { + Url string `codec:"url" json:"url"` + Punycode string `codec:"punycode" json:"punycode"` +} + +func (o UILinkDecoration) DeepCopy() UILinkDecoration { + return UILinkDecoration{ + Url: o.Url, + Punycode: o.Punycode, + } +} + +type UIMaybeMentionInfo struct { + Status__ UIMaybeMentionStatus `codec:"status" json:"status"` + Team__ *UITeamMention `codec:"team,omitempty" json:"team,omitempty"` +} + +func (o *UIMaybeMentionInfo) Status() (ret UIMaybeMentionStatus, err error) { + switch o.Status__ { + case UIMaybeMentionStatus_TEAM: + if o.Team__ == nil { + err = errors.New("unexpected nil value for Team__") + return ret, err + } + } + return o.Status__, nil +} + +func (o UIMaybeMentionInfo) Team() (res UITeamMention) { + if o.Status__ != UIMaybeMentionStatus_TEAM { + panic("wrong case accessed") + } + if o.Team__ == nil { + return + } + return *o.Team__ +} + +func NewUIMaybeMentionInfoWithUnknown() UIMaybeMentionInfo { + return UIMaybeMentionInfo{ + Status__: UIMaybeMentionStatus_UNKNOWN, + } +} + +func NewUIMaybeMentionInfoWithUser() UIMaybeMentionInfo { + return UIMaybeMentionInfo{ + Status__: UIMaybeMentionStatus_USER, + } +} + +func NewUIMaybeMentionInfoWithTeam(v UITeamMention) UIMaybeMentionInfo { + return UIMaybeMentionInfo{ + Status__: UIMaybeMentionStatus_TEAM, + Team__: &v, + } +} + +func NewUIMaybeMentionInfoWithNothing() UIMaybeMentionInfo { + return UIMaybeMentionInfo{ + Status__: UIMaybeMentionStatus_NOTHING, + } +} + +func (o UIMaybeMentionInfo) DeepCopy() UIMaybeMentionInfo { + return UIMaybeMentionInfo{ + Status__: o.Status__.DeepCopy(), + Team__: (func(x *UITeamMention) *UITeamMention { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Team__), + } +} + +type UITextDecoration struct { + Typ__ UITextDecorationTyp `codec:"typ" json:"typ"` + Payment__ *TextPayment `codec:"payment,omitempty" json:"payment,omitempty"` + Atmention__ *string `codec:"atmention,omitempty" json:"atmention,omitempty"` + Channelnamemention__ *UIChannelNameMention `codec:"channelnamemention,omitempty" json:"channelnamemention,omitempty"` + Maybemention__ *MaybeMention `codec:"maybemention,omitempty" json:"maybemention,omitempty"` + Link__ *UILinkDecoration `codec:"link,omitempty" json:"link,omitempty"` + Mailto__ *UILinkDecoration `codec:"mailto,omitempty" json:"mailto,omitempty"` + Kbfspath__ *KBFSPath `codec:"kbfspath,omitempty" json:"kbfspath,omitempty"` +} + +func (o *UITextDecoration) Typ() (ret UITextDecorationTyp, err error) { + switch o.Typ__ { + case UITextDecorationTyp_PAYMENT: + if o.Payment__ == nil { + err = errors.New("unexpected nil value for Payment__") + return ret, err + } + case UITextDecorationTyp_ATMENTION: + if o.Atmention__ == nil { + err = errors.New("unexpected nil value for Atmention__") + return ret, err + } + case UITextDecorationTyp_CHANNELNAMEMENTION: + if o.Channelnamemention__ == nil { + err = errors.New("unexpected nil value for Channelnamemention__") + return ret, err + } + case UITextDecorationTyp_MAYBEMENTION: + if o.Maybemention__ == nil { + err = errors.New("unexpected nil value for Maybemention__") + return ret, err + } + case UITextDecorationTyp_LINK: + if o.Link__ == nil { + err = errors.New("unexpected nil value for Link__") + return ret, err + } + case UITextDecorationTyp_MAILTO: + if o.Mailto__ == nil { + err = errors.New("unexpected nil value for Mailto__") + return ret, err + } + case UITextDecorationTyp_KBFSPATH: + if o.Kbfspath__ == nil { + err = errors.New("unexpected nil value for Kbfspath__") + return ret, err + } + } + return o.Typ__, nil +} + +func (o UITextDecoration) Payment() (res TextPayment) { + if o.Typ__ != UITextDecorationTyp_PAYMENT { + panic("wrong case accessed") + } + if o.Payment__ == nil { + return + } + return *o.Payment__ +} + +func (o UITextDecoration) Atmention() (res string) { + if o.Typ__ != UITextDecorationTyp_ATMENTION { + panic("wrong case accessed") + } + if o.Atmention__ == nil { + return + } + return *o.Atmention__ +} + +func (o UITextDecoration) Channelnamemention() (res UIChannelNameMention) { + if o.Typ__ != UITextDecorationTyp_CHANNELNAMEMENTION { + panic("wrong case accessed") + } + if o.Channelnamemention__ == nil { + return + } + return *o.Channelnamemention__ +} + +func (o UITextDecoration) Maybemention() (res MaybeMention) { + if o.Typ__ != UITextDecorationTyp_MAYBEMENTION { + panic("wrong case accessed") + } + if o.Maybemention__ == nil { + return + } + return *o.Maybemention__ +} + +func (o UITextDecoration) Link() (res UILinkDecoration) { + if o.Typ__ != UITextDecorationTyp_LINK { + panic("wrong case accessed") + } + if o.Link__ == nil { + return + } + return *o.Link__ +} + +func (o UITextDecoration) Mailto() (res UILinkDecoration) { + if o.Typ__ != UITextDecorationTyp_MAILTO { + panic("wrong case accessed") + } + if o.Mailto__ == nil { + return + } + return *o.Mailto__ +} + +func (o UITextDecoration) Kbfspath() (res KBFSPath) { + if o.Typ__ != UITextDecorationTyp_KBFSPATH { + panic("wrong case accessed") + } + if o.Kbfspath__ == nil { + return + } + return *o.Kbfspath__ +} + +func NewUITextDecorationWithPayment(v TextPayment) UITextDecoration { + return UITextDecoration{ + Typ__: UITextDecorationTyp_PAYMENT, + Payment__: &v, + } +} + +func NewUITextDecorationWithAtmention(v string) UITextDecoration { + return UITextDecoration{ + Typ__: UITextDecorationTyp_ATMENTION, + Atmention__: &v, + } +} + +func NewUITextDecorationWithChannelnamemention(v UIChannelNameMention) UITextDecoration { + return UITextDecoration{ + Typ__: UITextDecorationTyp_CHANNELNAMEMENTION, + Channelnamemention__: &v, + } +} + +func NewUITextDecorationWithMaybemention(v MaybeMention) UITextDecoration { + return UITextDecoration{ + Typ__: UITextDecorationTyp_MAYBEMENTION, + Maybemention__: &v, + } +} + +func NewUITextDecorationWithLink(v UILinkDecoration) UITextDecoration { + return UITextDecoration{ + Typ__: UITextDecorationTyp_LINK, + Link__: &v, + } +} + +func NewUITextDecorationWithMailto(v UILinkDecoration) UITextDecoration { + return UITextDecoration{ + Typ__: UITextDecorationTyp_MAILTO, + Mailto__: &v, + } +} + +func NewUITextDecorationWithKbfspath(v KBFSPath) UITextDecoration { + return UITextDecoration{ + Typ__: UITextDecorationTyp_KBFSPATH, + Kbfspath__: &v, + } +} + +func (o UITextDecoration) DeepCopy() UITextDecoration { + return UITextDecoration{ + Typ__: o.Typ__.DeepCopy(), + Payment__: (func(x *TextPayment) *TextPayment { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Payment__), + Atmention__: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Atmention__), + Channelnamemention__: (func(x *UIChannelNameMention) *UIChannelNameMention { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Channelnamemention__), + Maybemention__: (func(x *MaybeMention) *MaybeMention { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Maybemention__), + Link__: (func(x *UILinkDecoration) *UILinkDecoration { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Link__), + Mailto__: (func(x *UILinkDecoration) *UILinkDecoration { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Mailto__), + Kbfspath__: (func(x *KBFSPath) *KBFSPath { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Kbfspath__), + } +} + +type UIChatThreadStatusTyp int + +const ( + UIChatThreadStatusTyp_NONE UIChatThreadStatusTyp = 0 + UIChatThreadStatusTyp_SERVER UIChatThreadStatusTyp = 1 + UIChatThreadStatusTyp_VALIDATING UIChatThreadStatusTyp = 2 + UIChatThreadStatusTyp_VALIDATED UIChatThreadStatusTyp = 3 +) + +func (o UIChatThreadStatusTyp) DeepCopy() UIChatThreadStatusTyp { return o } + +var UIChatThreadStatusTypMap = map[string]UIChatThreadStatusTyp{ + "NONE": 0, + "SERVER": 1, + "VALIDATING": 2, + "VALIDATED": 3, +} + +var UIChatThreadStatusTypRevMap = map[UIChatThreadStatusTyp]string{ + 0: "NONE", + 1: "SERVER", + 2: "VALIDATING", + 3: "VALIDATED", +} + +func (e UIChatThreadStatusTyp) String() string { + if v, ok := UIChatThreadStatusTypRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type UIChatThreadStatus struct { + Typ__ UIChatThreadStatusTyp `codec:"typ" json:"typ"` + Validating__ *int `codec:"validating,omitempty" json:"validating,omitempty"` +} + +func (o *UIChatThreadStatus) Typ() (ret UIChatThreadStatusTyp, err error) { + switch o.Typ__ { + case UIChatThreadStatusTyp_VALIDATING: + if o.Validating__ == nil { + err = errors.New("unexpected nil value for Validating__") + return ret, err + } + } + return o.Typ__, nil +} + +func (o UIChatThreadStatus) Validating() (res int) { + if o.Typ__ != UIChatThreadStatusTyp_VALIDATING { + panic("wrong case accessed") + } + if o.Validating__ == nil { + return + } + return *o.Validating__ +} + +func NewUIChatThreadStatusWithNone() UIChatThreadStatus { + return UIChatThreadStatus{ + Typ__: UIChatThreadStatusTyp_NONE, + } +} + +func NewUIChatThreadStatusWithServer() UIChatThreadStatus { + return UIChatThreadStatus{ + Typ__: UIChatThreadStatusTyp_SERVER, + } +} + +func NewUIChatThreadStatusWithValidating(v int) UIChatThreadStatus { + return UIChatThreadStatus{ + Typ__: UIChatThreadStatusTyp_VALIDATING, + Validating__: &v, + } +} + +func NewUIChatThreadStatusWithValidated() UIChatThreadStatus { + return UIChatThreadStatus{ + Typ__: UIChatThreadStatusTyp_VALIDATED, + } +} + +func (o UIChatThreadStatus) DeepCopy() UIChatThreadStatus { + return UIChatThreadStatus{ + Typ__: o.Typ__.DeepCopy(), + Validating__: (func(x *int) *int { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Validating__), + } +} + +type UIChatSearchConvHit struct { + ConvID ConvIDStr `codec:"convID" json:"convID"` + TeamType TeamType `codec:"teamType" json:"teamType"` + Name string `codec:"name" json:"name"` + Mtime gregor1.Time `codec:"mtime" json:"mtime"` +} + +func (o UIChatSearchConvHit) DeepCopy() UIChatSearchConvHit { + return UIChatSearchConvHit{ + ConvID: o.ConvID.DeepCopy(), + TeamType: o.TeamType.DeepCopy(), + Name: o.Name, + Mtime: o.Mtime.DeepCopy(), + } +} + +type UIChatSearchConvHits struct { + Hits []UIChatSearchConvHit `codec:"hits" json:"hits"` + UnreadMatches bool `codec:"unreadMatches" json:"unreadMatches"` +} + +func (o UIChatSearchConvHits) DeepCopy() UIChatSearchConvHits { + return UIChatSearchConvHits{ + Hits: (func(x []UIChatSearchConvHit) []UIChatSearchConvHit { + if x == nil { + return nil + } + ret := make([]UIChatSearchConvHit, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Hits), + UnreadMatches: o.UnreadMatches, + } +} + +type UIChatPayment struct { + Username string `codec:"username" json:"username"` + FullName string `codec:"fullName" json:"fullName"` + XlmAmount string `codec:"xlmAmount" json:"xlmAmount"` + Error *string `codec:"error,omitempty" json:"error,omitempty"` + DisplayAmount *string `codec:"displayAmount,omitempty" json:"displayAmount,omitempty"` +} + +func (o UIChatPayment) DeepCopy() UIChatPayment { + return UIChatPayment{ + Username: o.Username, + FullName: o.FullName, + XlmAmount: o.XlmAmount, + Error: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Error), + DisplayAmount: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.DisplayAmount), + } +} + +type UIChatPaymentSummary struct { + XlmTotal string `codec:"xlmTotal" json:"xlmTotal"` + DisplayTotal string `codec:"displayTotal" json:"displayTotal"` + Payments []UIChatPayment `codec:"payments" json:"payments"` +} + +func (o UIChatPaymentSummary) DeepCopy() UIChatPaymentSummary { + return UIChatPaymentSummary{ + XlmTotal: o.XlmTotal, + DisplayTotal: o.DisplayTotal, + Payments: (func(x []UIChatPayment) []UIChatPayment { + if x == nil { + return nil + } + ret := make([]UIChatPayment, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Payments), + } +} + +type GiphySearchResult struct { + TargetUrl string `codec:"targetUrl" json:"targetUrl"` + PreviewUrl string `codec:"previewUrl" json:"previewUrl"` + PreviewWidth int `codec:"previewWidth" json:"previewWidth"` + PreviewHeight int `codec:"previewHeight" json:"previewHeight"` + PreviewIsVideo bool `codec:"previewIsVideo" json:"previewIsVideo"` +} + +func (o GiphySearchResult) DeepCopy() GiphySearchResult { + return GiphySearchResult{ + TargetUrl: o.TargetUrl, + PreviewUrl: o.PreviewUrl, + PreviewWidth: o.PreviewWidth, + PreviewHeight: o.PreviewHeight, + PreviewIsVideo: o.PreviewIsVideo, + } +} + +type GiphySearchResults struct { + Results []GiphySearchResult `codec:"results" json:"results"` + GalleryUrl string `codec:"galleryUrl" json:"galleryUrl"` +} + +func (o GiphySearchResults) DeepCopy() GiphySearchResults { + return GiphySearchResults{ + Results: (func(x []GiphySearchResult) []GiphySearchResult { + if x == nil { + return nil + } + ret := make([]GiphySearchResult, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Results), + GalleryUrl: o.GalleryUrl, + } +} + +type UICoinFlipPhase int + +const ( + UICoinFlipPhase_COMMITMENT UICoinFlipPhase = 0 + UICoinFlipPhase_REVEALS UICoinFlipPhase = 1 + UICoinFlipPhase_COMPLETE UICoinFlipPhase = 2 + UICoinFlipPhase_ERROR UICoinFlipPhase = 3 +) + +func (o UICoinFlipPhase) DeepCopy() UICoinFlipPhase { return o } + +var UICoinFlipPhaseMap = map[string]UICoinFlipPhase{ + "COMMITMENT": 0, + "REVEALS": 1, + "COMPLETE": 2, + "ERROR": 3, +} + +var UICoinFlipPhaseRevMap = map[UICoinFlipPhase]string{ + 0: "COMMITMENT", + 1: "REVEALS", + 2: "COMPLETE", + 3: "ERROR", +} + +func (e UICoinFlipPhase) String() string { + if v, ok := UICoinFlipPhaseRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type UICoinFlipErrorParticipant struct { + User string `codec:"user" json:"user"` + Device string `codec:"device" json:"device"` +} + +func (o UICoinFlipErrorParticipant) DeepCopy() UICoinFlipErrorParticipant { + return UICoinFlipErrorParticipant{ + User: o.User, + Device: o.Device, + } +} + +type UICoinFlipAbsenteeError struct { + Absentees []UICoinFlipErrorParticipant `codec:"absentees" json:"absentees"` +} + +func (o UICoinFlipAbsenteeError) DeepCopy() UICoinFlipAbsenteeError { + return UICoinFlipAbsenteeError{ + Absentees: (func(x []UICoinFlipErrorParticipant) []UICoinFlipErrorParticipant { + if x == nil { + return nil + } + ret := make([]UICoinFlipErrorParticipant, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Absentees), + } +} + +type UICoinFlipErrorTyp int + +const ( + UICoinFlipErrorTyp_GENERIC UICoinFlipErrorTyp = 0 + UICoinFlipErrorTyp_ABSENTEE UICoinFlipErrorTyp = 1 + UICoinFlipErrorTyp_TIMEOUT UICoinFlipErrorTyp = 2 + UICoinFlipErrorTyp_ABORTED UICoinFlipErrorTyp = 3 + UICoinFlipErrorTyp_DUPREG UICoinFlipErrorTyp = 4 + UICoinFlipErrorTyp_DUPCOMMITCOMPLETE UICoinFlipErrorTyp = 5 + UICoinFlipErrorTyp_DUPREVEAL UICoinFlipErrorTyp = 6 + UICoinFlipErrorTyp_COMMITMISMATCH UICoinFlipErrorTyp = 7 +) + +func (o UICoinFlipErrorTyp) DeepCopy() UICoinFlipErrorTyp { return o } + +var UICoinFlipErrorTypMap = map[string]UICoinFlipErrorTyp{ + "GENERIC": 0, + "ABSENTEE": 1, + "TIMEOUT": 2, + "ABORTED": 3, + "DUPREG": 4, + "DUPCOMMITCOMPLETE": 5, + "DUPREVEAL": 6, + "COMMITMISMATCH": 7, +} + +var UICoinFlipErrorTypRevMap = map[UICoinFlipErrorTyp]string{ + 0: "GENERIC", + 1: "ABSENTEE", + 2: "TIMEOUT", + 3: "ABORTED", + 4: "DUPREG", + 5: "DUPCOMMITCOMPLETE", + 6: "DUPREVEAL", + 7: "COMMITMISMATCH", +} + +func (e UICoinFlipErrorTyp) String() string { + if v, ok := UICoinFlipErrorTypRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type UICoinFlipError struct { + Typ__ UICoinFlipErrorTyp `codec:"typ" json:"typ"` + Generic__ *string `codec:"generic,omitempty" json:"generic,omitempty"` + Absentee__ *UICoinFlipAbsenteeError `codec:"absentee,omitempty" json:"absentee,omitempty"` + Dupreg__ *UICoinFlipErrorParticipant `codec:"dupreg,omitempty" json:"dupreg,omitempty"` + Dupcommitcomplete__ *UICoinFlipErrorParticipant `codec:"dupcommitcomplete,omitempty" json:"dupcommitcomplete,omitempty"` + Dupreveal__ *UICoinFlipErrorParticipant `codec:"dupreveal,omitempty" json:"dupreveal,omitempty"` + Commitmismatch__ *UICoinFlipErrorParticipant `codec:"commitmismatch,omitempty" json:"commitmismatch,omitempty"` +} + +func (o *UICoinFlipError) Typ() (ret UICoinFlipErrorTyp, err error) { + switch o.Typ__ { + case UICoinFlipErrorTyp_GENERIC: + if o.Generic__ == nil { + err = errors.New("unexpected nil value for Generic__") + return ret, err + } + case UICoinFlipErrorTyp_ABSENTEE: + if o.Absentee__ == nil { + err = errors.New("unexpected nil value for Absentee__") + return ret, err + } + case UICoinFlipErrorTyp_DUPREG: + if o.Dupreg__ == nil { + err = errors.New("unexpected nil value for Dupreg__") + return ret, err + } + case UICoinFlipErrorTyp_DUPCOMMITCOMPLETE: + if o.Dupcommitcomplete__ == nil { + err = errors.New("unexpected nil value for Dupcommitcomplete__") + return ret, err + } + case UICoinFlipErrorTyp_DUPREVEAL: + if o.Dupreveal__ == nil { + err = errors.New("unexpected nil value for Dupreveal__") + return ret, err + } + case UICoinFlipErrorTyp_COMMITMISMATCH: + if o.Commitmismatch__ == nil { + err = errors.New("unexpected nil value for Commitmismatch__") + return ret, err + } + } + return o.Typ__, nil +} + +func (o UICoinFlipError) Generic() (res string) { + if o.Typ__ != UICoinFlipErrorTyp_GENERIC { + panic("wrong case accessed") + } + if o.Generic__ == nil { + return + } + return *o.Generic__ +} + +func (o UICoinFlipError) Absentee() (res UICoinFlipAbsenteeError) { + if o.Typ__ != UICoinFlipErrorTyp_ABSENTEE { + panic("wrong case accessed") + } + if o.Absentee__ == nil { + return + } + return *o.Absentee__ +} + +func (o UICoinFlipError) Dupreg() (res UICoinFlipErrorParticipant) { + if o.Typ__ != UICoinFlipErrorTyp_DUPREG { + panic("wrong case accessed") + } + if o.Dupreg__ == nil { + return + } + return *o.Dupreg__ +} + +func (o UICoinFlipError) Dupcommitcomplete() (res UICoinFlipErrorParticipant) { + if o.Typ__ != UICoinFlipErrorTyp_DUPCOMMITCOMPLETE { + panic("wrong case accessed") + } + if o.Dupcommitcomplete__ == nil { + return + } + return *o.Dupcommitcomplete__ +} + +func (o UICoinFlipError) Dupreveal() (res UICoinFlipErrorParticipant) { + if o.Typ__ != UICoinFlipErrorTyp_DUPREVEAL { + panic("wrong case accessed") + } + if o.Dupreveal__ == nil { + return + } + return *o.Dupreveal__ +} + +func (o UICoinFlipError) Commitmismatch() (res UICoinFlipErrorParticipant) { + if o.Typ__ != UICoinFlipErrorTyp_COMMITMISMATCH { + panic("wrong case accessed") + } + if o.Commitmismatch__ == nil { + return + } + return *o.Commitmismatch__ +} + +func NewUICoinFlipErrorWithGeneric(v string) UICoinFlipError { + return UICoinFlipError{ + Typ__: UICoinFlipErrorTyp_GENERIC, + Generic__: &v, + } +} + +func NewUICoinFlipErrorWithAbsentee(v UICoinFlipAbsenteeError) UICoinFlipError { + return UICoinFlipError{ + Typ__: UICoinFlipErrorTyp_ABSENTEE, + Absentee__: &v, + } +} + +func NewUICoinFlipErrorWithTimeout() UICoinFlipError { + return UICoinFlipError{ + Typ__: UICoinFlipErrorTyp_TIMEOUT, + } +} + +func NewUICoinFlipErrorWithAborted() UICoinFlipError { + return UICoinFlipError{ + Typ__: UICoinFlipErrorTyp_ABORTED, + } +} + +func NewUICoinFlipErrorWithDupreg(v UICoinFlipErrorParticipant) UICoinFlipError { + return UICoinFlipError{ + Typ__: UICoinFlipErrorTyp_DUPREG, + Dupreg__: &v, + } +} + +func NewUICoinFlipErrorWithDupcommitcomplete(v UICoinFlipErrorParticipant) UICoinFlipError { + return UICoinFlipError{ + Typ__: UICoinFlipErrorTyp_DUPCOMMITCOMPLETE, + Dupcommitcomplete__: &v, + } +} + +func NewUICoinFlipErrorWithDupreveal(v UICoinFlipErrorParticipant) UICoinFlipError { + return UICoinFlipError{ + Typ__: UICoinFlipErrorTyp_DUPREVEAL, + Dupreveal__: &v, + } +} + +func NewUICoinFlipErrorWithCommitmismatch(v UICoinFlipErrorParticipant) UICoinFlipError { + return UICoinFlipError{ + Typ__: UICoinFlipErrorTyp_COMMITMISMATCH, + Commitmismatch__: &v, + } +} + +func (o UICoinFlipError) DeepCopy() UICoinFlipError { + return UICoinFlipError{ + Typ__: o.Typ__.DeepCopy(), + Generic__: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Generic__), + Absentee__: (func(x *UICoinFlipAbsenteeError) *UICoinFlipAbsenteeError { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Absentee__), + Dupreg__: (func(x *UICoinFlipErrorParticipant) *UICoinFlipErrorParticipant { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Dupreg__), + Dupcommitcomplete__: (func(x *UICoinFlipErrorParticipant) *UICoinFlipErrorParticipant { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Dupcommitcomplete__), + Dupreveal__: (func(x *UICoinFlipErrorParticipant) *UICoinFlipErrorParticipant { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Dupreveal__), + Commitmismatch__: (func(x *UICoinFlipErrorParticipant) *UICoinFlipErrorParticipant { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Commitmismatch__), + } +} + +type UICoinFlipResultTyp int + +const ( + UICoinFlipResultTyp_NUMBER UICoinFlipResultTyp = 0 + UICoinFlipResultTyp_SHUFFLE UICoinFlipResultTyp = 1 + UICoinFlipResultTyp_DECK UICoinFlipResultTyp = 2 + UICoinFlipResultTyp_HANDS UICoinFlipResultTyp = 3 + UICoinFlipResultTyp_COIN UICoinFlipResultTyp = 4 +) + +func (o UICoinFlipResultTyp) DeepCopy() UICoinFlipResultTyp { return o } + +var UICoinFlipResultTypMap = map[string]UICoinFlipResultTyp{ + "NUMBER": 0, + "SHUFFLE": 1, + "DECK": 2, + "HANDS": 3, + "COIN": 4, +} + +var UICoinFlipResultTypRevMap = map[UICoinFlipResultTyp]string{ + 0: "NUMBER", + 1: "SHUFFLE", + 2: "DECK", + 3: "HANDS", + 4: "COIN", +} + +func (e UICoinFlipResultTyp) String() string { + if v, ok := UICoinFlipResultTypRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type UICoinFlipHand struct { + Target string `codec:"target" json:"target"` + Hand []int `codec:"hand" json:"hand"` +} + +func (o UICoinFlipHand) DeepCopy() UICoinFlipHand { + return UICoinFlipHand{ + Target: o.Target, + Hand: (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.Hand), + } +} + +type UICoinFlipResult struct { + Typ__ UICoinFlipResultTyp `codec:"typ" json:"typ"` + Number__ *string `codec:"number,omitempty" json:"number,omitempty"` + Shuffle__ *[]string `codec:"shuffle,omitempty" json:"shuffle,omitempty"` + Deck__ *[]int `codec:"deck,omitempty" json:"deck,omitempty"` + Hands__ *[]UICoinFlipHand `codec:"hands,omitempty" json:"hands,omitempty"` + Coin__ *bool `codec:"coin,omitempty" json:"coin,omitempty"` +} + +func (o *UICoinFlipResult) Typ() (ret UICoinFlipResultTyp, err error) { + switch o.Typ__ { + case UICoinFlipResultTyp_NUMBER: + if o.Number__ == nil { + err = errors.New("unexpected nil value for Number__") + return ret, err + } + case UICoinFlipResultTyp_SHUFFLE: + if o.Shuffle__ == nil { + err = errors.New("unexpected nil value for Shuffle__") + return ret, err + } + case UICoinFlipResultTyp_DECK: + if o.Deck__ == nil { + err = errors.New("unexpected nil value for Deck__") + return ret, err + } + case UICoinFlipResultTyp_HANDS: + if o.Hands__ == nil { + err = errors.New("unexpected nil value for Hands__") + return ret, err + } + case UICoinFlipResultTyp_COIN: + if o.Coin__ == nil { + err = errors.New("unexpected nil value for Coin__") + return ret, err + } + } + return o.Typ__, nil +} + +func (o UICoinFlipResult) Number() (res string) { + if o.Typ__ != UICoinFlipResultTyp_NUMBER { + panic("wrong case accessed") + } + if o.Number__ == nil { + return + } + return *o.Number__ +} + +func (o UICoinFlipResult) Shuffle() (res []string) { + if o.Typ__ != UICoinFlipResultTyp_SHUFFLE { + panic("wrong case accessed") + } + if o.Shuffle__ == nil { + return + } + return *o.Shuffle__ +} + +func (o UICoinFlipResult) Deck() (res []int) { + if o.Typ__ != UICoinFlipResultTyp_DECK { + panic("wrong case accessed") + } + if o.Deck__ == nil { + return + } + return *o.Deck__ +} + +func (o UICoinFlipResult) Hands() (res []UICoinFlipHand) { + if o.Typ__ != UICoinFlipResultTyp_HANDS { + panic("wrong case accessed") + } + if o.Hands__ == nil { + return + } + return *o.Hands__ +} + +func (o UICoinFlipResult) Coin() (res bool) { + if o.Typ__ != UICoinFlipResultTyp_COIN { + panic("wrong case accessed") + } + if o.Coin__ == nil { + return + } + return *o.Coin__ +} + +func NewUICoinFlipResultWithNumber(v string) UICoinFlipResult { + return UICoinFlipResult{ + Typ__: UICoinFlipResultTyp_NUMBER, + Number__: &v, + } +} + +func NewUICoinFlipResultWithShuffle(v []string) UICoinFlipResult { + return UICoinFlipResult{ + Typ__: UICoinFlipResultTyp_SHUFFLE, + Shuffle__: &v, + } +} + +func NewUICoinFlipResultWithDeck(v []int) UICoinFlipResult { + return UICoinFlipResult{ + Typ__: UICoinFlipResultTyp_DECK, + Deck__: &v, + } +} + +func NewUICoinFlipResultWithHands(v []UICoinFlipHand) UICoinFlipResult { + return UICoinFlipResult{ + Typ__: UICoinFlipResultTyp_HANDS, + Hands__: &v, + } +} + +func NewUICoinFlipResultWithCoin(v bool) UICoinFlipResult { + return UICoinFlipResult{ + Typ__: UICoinFlipResultTyp_COIN, + Coin__: &v, + } +} + +func (o UICoinFlipResult) DeepCopy() UICoinFlipResult { + return UICoinFlipResult{ + Typ__: o.Typ__.DeepCopy(), + Number__: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Number__), + Shuffle__: (func(x *[]string) *[]string { + if x == nil { + return nil + } + tmp := (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 + })((*x)) + return &tmp + })(o.Shuffle__), + Deck__: (func(x *[]int) *[]int { + if x == nil { + return nil + } + tmp := (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 + })((*x)) + return &tmp + })(o.Deck__), + Hands__: (func(x *[]UICoinFlipHand) *[]UICoinFlipHand { + if x == nil { + return nil + } + tmp := (func(x []UICoinFlipHand) []UICoinFlipHand { + if x == nil { + return nil + } + ret := make([]UICoinFlipHand, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })((*x)) + return &tmp + })(o.Hands__), + Coin__: (func(x *bool) *bool { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Coin__), + } +} + +type UICoinFlipParticipant struct { + Uid string `codec:"uid" json:"uid"` + DeviceID string `codec:"deviceID" json:"deviceID"` + Username string `codec:"username" json:"username"` + DeviceName string `codec:"deviceName" json:"deviceName"` + Commitment string `codec:"commitment" json:"commitment"` + Reveal *string `codec:"reveal,omitempty" json:"reveal,omitempty"` +} + +func (o UICoinFlipParticipant) DeepCopy() UICoinFlipParticipant { + return UICoinFlipParticipant{ + Uid: o.Uid, + DeviceID: o.DeviceID, + Username: o.Username, + DeviceName: o.DeviceName, + Commitment: o.Commitment, + Reveal: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Reveal), + } +} + +type UICoinFlipStatus struct { + GameID FlipGameIDStr `codec:"gameID" json:"gameID"` + Phase UICoinFlipPhase `codec:"phase" json:"phase"` + ProgressText string `codec:"progressText" json:"progressText"` + ResultText string `codec:"resultText" json:"resultText"` + CommitmentVisualization string `codec:"commitmentVisualization" json:"commitmentVisualization"` + RevealVisualization string `codec:"revealVisualization" json:"revealVisualization"` + Participants []UICoinFlipParticipant `codec:"participants" json:"participants"` + ErrorInfo *UICoinFlipError `codec:"errorInfo,omitempty" json:"errorInfo,omitempty"` + ResultInfo *UICoinFlipResult `codec:"resultInfo,omitempty" json:"resultInfo,omitempty"` +} + +func (o UICoinFlipStatus) DeepCopy() UICoinFlipStatus { + return UICoinFlipStatus{ + GameID: o.GameID.DeepCopy(), + Phase: o.Phase.DeepCopy(), + ProgressText: o.ProgressText, + ResultText: o.ResultText, + CommitmentVisualization: o.CommitmentVisualization, + RevealVisualization: o.RevealVisualization, + Participants: (func(x []UICoinFlipParticipant) []UICoinFlipParticipant { + if x == nil { + return nil + } + ret := make([]UICoinFlipParticipant, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Participants), + ErrorInfo: (func(x *UICoinFlipError) *UICoinFlipError { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ErrorInfo), + ResultInfo: (func(x *UICoinFlipResult) *UICoinFlipResult { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ResultInfo), + } +} + +type UICommandMarkdown struct { + Body string `codec:"body" json:"body"` + Title *string `codec:"title,omitempty" json:"title,omitempty"` +} + +func (o UICommandMarkdown) DeepCopy() UICommandMarkdown { + return UICommandMarkdown{ + Body: o.Body, + Title: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Title), + } +} + +type LocationWatchID uint64 + +func (o LocationWatchID) DeepCopy() LocationWatchID { + return o +} + +type UIWatchPositionPerm int + +const ( + UIWatchPositionPerm_BASE UIWatchPositionPerm = 0 + UIWatchPositionPerm_ALWAYS UIWatchPositionPerm = 1 +) + +func (o UIWatchPositionPerm) DeepCopy() UIWatchPositionPerm { return o } + +var UIWatchPositionPermMap = map[string]UIWatchPositionPerm{ + "BASE": 0, + "ALWAYS": 1, +} + +var UIWatchPositionPermRevMap = map[UIWatchPositionPerm]string{ + 0: "BASE", + 1: "ALWAYS", +} + +func (e UIWatchPositionPerm) String() string { + if v, ok := UIWatchPositionPermRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type UICommandStatusDisplayTyp int + +const ( + UICommandStatusDisplayTyp_STATUS UICommandStatusDisplayTyp = 0 + UICommandStatusDisplayTyp_WARNING UICommandStatusDisplayTyp = 1 + UICommandStatusDisplayTyp_ERROR UICommandStatusDisplayTyp = 2 +) + +func (o UICommandStatusDisplayTyp) DeepCopy() UICommandStatusDisplayTyp { return o } + +var UICommandStatusDisplayTypMap = map[string]UICommandStatusDisplayTyp{ + "STATUS": 0, + "WARNING": 1, + "ERROR": 2, +} + +var UICommandStatusDisplayTypRevMap = map[UICommandStatusDisplayTyp]string{ + 0: "STATUS", + 1: "WARNING", + 2: "ERROR", +} + +func (e UICommandStatusDisplayTyp) String() string { + if v, ok := UICommandStatusDisplayTypRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type UICommandStatusActionTyp int + +const ( + UICommandStatusActionTyp_APPSETTINGS UICommandStatusActionTyp = 0 +) + +func (o UICommandStatusActionTyp) DeepCopy() UICommandStatusActionTyp { return o } + +var UICommandStatusActionTypMap = map[string]UICommandStatusActionTyp{ + "APPSETTINGS": 0, +} + +var UICommandStatusActionTypRevMap = map[UICommandStatusActionTyp]string{ + 0: "APPSETTINGS", +} + +func (e UICommandStatusActionTyp) String() string { + if v, ok := UICommandStatusActionTypRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type UIBotCommandsUpdateStatusTyp int + +const ( + UIBotCommandsUpdateStatusTyp_UPTODATE UIBotCommandsUpdateStatusTyp = 0 + UIBotCommandsUpdateStatusTyp_UPDATING UIBotCommandsUpdateStatusTyp = 1 + UIBotCommandsUpdateStatusTyp_FAILED UIBotCommandsUpdateStatusTyp = 2 + UIBotCommandsUpdateStatusTyp_BLANK UIBotCommandsUpdateStatusTyp = 3 +) + +func (o UIBotCommandsUpdateStatusTyp) DeepCopy() UIBotCommandsUpdateStatusTyp { return o } + +var UIBotCommandsUpdateStatusTypMap = map[string]UIBotCommandsUpdateStatusTyp{ + "UPTODATE": 0, + "UPDATING": 1, + "FAILED": 2, + "BLANK": 3, +} + +var UIBotCommandsUpdateStatusTypRevMap = map[UIBotCommandsUpdateStatusTyp]string{ + 0: "UPTODATE", + 1: "UPDATING", + 2: "FAILED", + 3: "BLANK", +} + +func (e UIBotCommandsUpdateStatusTyp) String() string { + if v, ok := UIBotCommandsUpdateStatusTypRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type UIBotCommandsUpdateSettings struct { + Settings map[string]keybase1.TeamBotSettings `codec:"settings" json:"settings"` +} + +func (o UIBotCommandsUpdateSettings) DeepCopy() UIBotCommandsUpdateSettings { + return UIBotCommandsUpdateSettings{ + Settings: (func(x map[string]keybase1.TeamBotSettings) map[string]keybase1.TeamBotSettings { + if x == nil { + return nil + } + ret := make(map[string]keybase1.TeamBotSettings, len(x)) + for k, v := range x { + kCopy := k + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.Settings), + } +} + +type UIBotCommandsUpdateStatus struct { + Typ__ UIBotCommandsUpdateStatusTyp `codec:"typ" json:"typ"` + Uptodate__ *UIBotCommandsUpdateSettings `codec:"uptodate,omitempty" json:"uptodate,omitempty"` +} + +func (o *UIBotCommandsUpdateStatus) Typ() (ret UIBotCommandsUpdateStatusTyp, err error) { + switch o.Typ__ { + case UIBotCommandsUpdateStatusTyp_UPTODATE: + if o.Uptodate__ == nil { + err = errors.New("unexpected nil value for Uptodate__") + return ret, err + } + } + return o.Typ__, nil +} + +func (o UIBotCommandsUpdateStatus) Uptodate() (res UIBotCommandsUpdateSettings) { + if o.Typ__ != UIBotCommandsUpdateStatusTyp_UPTODATE { + panic("wrong case accessed") + } + if o.Uptodate__ == nil { + return + } + return *o.Uptodate__ +} + +func NewUIBotCommandsUpdateStatusWithUptodate(v UIBotCommandsUpdateSettings) UIBotCommandsUpdateStatus { + return UIBotCommandsUpdateStatus{ + Typ__: UIBotCommandsUpdateStatusTyp_UPTODATE, + Uptodate__: &v, + } +} + +func NewUIBotCommandsUpdateStatusWithUpdating() UIBotCommandsUpdateStatus { + return UIBotCommandsUpdateStatus{ + Typ__: UIBotCommandsUpdateStatusTyp_UPDATING, + } +} + +func NewUIBotCommandsUpdateStatusWithFailed() UIBotCommandsUpdateStatus { + return UIBotCommandsUpdateStatus{ + Typ__: UIBotCommandsUpdateStatusTyp_FAILED, + } +} + +func NewUIBotCommandsUpdateStatusWithBlank() UIBotCommandsUpdateStatus { + return UIBotCommandsUpdateStatus{ + Typ__: UIBotCommandsUpdateStatusTyp_BLANK, + } +} + +func (o UIBotCommandsUpdateStatus) DeepCopy() UIBotCommandsUpdateStatus { + return UIBotCommandsUpdateStatus{ + Typ__: o.Typ__.DeepCopy(), + Uptodate__: (func(x *UIBotCommandsUpdateSettings) *UIBotCommandsUpdateSettings { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Uptodate__), + } +} 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 new file mode 100644 index 00000000..f6d4d556 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/commands.go @@ -0,0 +1,199 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/chat1/commands.avdl + +package chat1 + +import ( + "errors" + "fmt" +) + +type ConversationCommand struct { + Description string `codec:"description" json:"description"` + Name string `codec:"name" json:"name"` + Usage string `codec:"usage" json:"usage"` + HasHelpText bool `codec:"hasHelpText" json:"hasHelpText"` + Username *string `codec:"username,omitempty" json:"username,omitempty"` +} + +func (o ConversationCommand) DeepCopy() ConversationCommand { + return ConversationCommand{ + Description: o.Description, + Name: o.Name, + Usage: o.Usage, + HasHelpText: o.HasHelpText, + Username: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Username), + } +} + +type ConversationCommandGroupsTyp int + +const ( + ConversationCommandGroupsTyp_BUILTIN ConversationCommandGroupsTyp = 0 + ConversationCommandGroupsTyp_CUSTOM ConversationCommandGroupsTyp = 1 + ConversationCommandGroupsTyp_NONE ConversationCommandGroupsTyp = 2 +) + +func (o ConversationCommandGroupsTyp) DeepCopy() ConversationCommandGroupsTyp { return o } + +var ConversationCommandGroupsTypMap = map[string]ConversationCommandGroupsTyp{ + "BUILTIN": 0, + "CUSTOM": 1, + "NONE": 2, +} + +var ConversationCommandGroupsTypRevMap = map[ConversationCommandGroupsTyp]string{ + 0: "BUILTIN", + 1: "CUSTOM", + 2: "NONE", +} + +func (e ConversationCommandGroupsTyp) String() string { + if v, ok := ConversationCommandGroupsTypRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ConversationBuiltinCommandTyp int + +const ( + ConversationBuiltinCommandTyp_NONE ConversationBuiltinCommandTyp = 0 + ConversationBuiltinCommandTyp_ADHOC ConversationBuiltinCommandTyp = 1 + ConversationBuiltinCommandTyp_SMALLTEAM ConversationBuiltinCommandTyp = 2 + ConversationBuiltinCommandTyp_BIGTEAM ConversationBuiltinCommandTyp = 3 + ConversationBuiltinCommandTyp_BIGTEAMGENERAL ConversationBuiltinCommandTyp = 4 +) + +func (o ConversationBuiltinCommandTyp) DeepCopy() ConversationBuiltinCommandTyp { return o } + +var ConversationBuiltinCommandTypMap = map[string]ConversationBuiltinCommandTyp{ + "NONE": 0, + "ADHOC": 1, + "SMALLTEAM": 2, + "BIGTEAM": 3, + "BIGTEAMGENERAL": 4, +} + +var ConversationBuiltinCommandTypRevMap = map[ConversationBuiltinCommandTyp]string{ + 0: "NONE", + 1: "ADHOC", + 2: "SMALLTEAM", + 3: "BIGTEAM", + 4: "BIGTEAMGENERAL", +} + +func (e ConversationBuiltinCommandTyp) String() string { + if v, ok := ConversationBuiltinCommandTypRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ConversationCommandGroupsCustom struct { + Commands []ConversationCommand `codec:"commands" json:"commands"` +} + +func (o ConversationCommandGroupsCustom) DeepCopy() ConversationCommandGroupsCustom { + return ConversationCommandGroupsCustom{ + Commands: (func(x []ConversationCommand) []ConversationCommand { + if x == nil { + return nil + } + ret := make([]ConversationCommand, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Commands), + } +} + +type ConversationCommandGroups struct { + Typ__ ConversationCommandGroupsTyp `codec:"typ" json:"typ"` + Builtin__ *ConversationBuiltinCommandTyp `codec:"builtin,omitempty" json:"builtin,omitempty"` + Custom__ *ConversationCommandGroupsCustom `codec:"custom,omitempty" json:"custom,omitempty"` +} + +func (o *ConversationCommandGroups) Typ() (ret ConversationCommandGroupsTyp, err error) { + switch o.Typ__ { + case ConversationCommandGroupsTyp_BUILTIN: + if o.Builtin__ == nil { + err = errors.New("unexpected nil value for Builtin__") + return ret, err + } + case ConversationCommandGroupsTyp_CUSTOM: + if o.Custom__ == nil { + err = errors.New("unexpected nil value for Custom__") + return ret, err + } + } + return o.Typ__, nil +} + +func (o ConversationCommandGroups) Builtin() (res ConversationBuiltinCommandTyp) { + if o.Typ__ != ConversationCommandGroupsTyp_BUILTIN { + panic("wrong case accessed") + } + if o.Builtin__ == nil { + return + } + return *o.Builtin__ +} + +func (o ConversationCommandGroups) Custom() (res ConversationCommandGroupsCustom) { + if o.Typ__ != ConversationCommandGroupsTyp_CUSTOM { + panic("wrong case accessed") + } + if o.Custom__ == nil { + return + } + return *o.Custom__ +} + +func NewConversationCommandGroupsWithBuiltin(v ConversationBuiltinCommandTyp) ConversationCommandGroups { + return ConversationCommandGroups{ + Typ__: ConversationCommandGroupsTyp_BUILTIN, + Builtin__: &v, + } +} + +func NewConversationCommandGroupsWithCustom(v ConversationCommandGroupsCustom) ConversationCommandGroups { + return ConversationCommandGroups{ + Typ__: ConversationCommandGroupsTyp_CUSTOM, + Custom__: &v, + } +} + +func NewConversationCommandGroupsWithNone() ConversationCommandGroups { + return ConversationCommandGroups{ + Typ__: ConversationCommandGroupsTyp_NONE, + } +} + +func (o ConversationCommandGroups) DeepCopy() ConversationCommandGroups { + return ConversationCommandGroups{ + Typ__: o.Typ__.DeepCopy(), + Builtin__: (func(x *ConversationBuiltinCommandTyp) *ConversationBuiltinCommandTyp { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Builtin__), + Custom__: (func(x *ConversationCommandGroupsCustom) *ConversationCommandGroupsCustom { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Custom__), + } +} 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 new file mode 100644 index 00000000..60eff96d --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/common.go @@ -0,0 +1,2473 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/chat1/common.avdl + +package chat1 + +import ( + "errors" + "fmt" + + gregor1 "github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1" + keybase1 "github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1" +) + +type ThreadID []byte + +func (o ThreadID) DeepCopy() ThreadID { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} + +type MessageID uint + +func (o MessageID) DeepCopy() MessageID { + return o +} + +type TLFConvOrdinal uint + +func (o TLFConvOrdinal) DeepCopy() TLFConvOrdinal { + return o +} + +type TopicID []byte + +func (o TopicID) DeepCopy() TopicID { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} + +type ConversationID []byte + +func (o ConversationID) DeepCopy() ConversationID { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} + +type TLFID []byte + +func (o TLFID) DeepCopy() TLFID { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} + +type Hash []byte + +func (o Hash) DeepCopy() Hash { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} + +type InboxVers uint64 + +func (o InboxVers) DeepCopy() InboxVers { + return o +} + +type LocalConversationVers uint64 + +func (o LocalConversationVers) DeepCopy() LocalConversationVers { + return o +} + +type ConversationVers uint64 + +func (o ConversationVers) DeepCopy() ConversationVers { + return o +} + +type OutboxID []byte + +func (o OutboxID) DeepCopy() OutboxID { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} + +type TopicNameState []byte + +func (o TopicNameState) DeepCopy() TopicNameState { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} + +type FlipGameID []byte + +func (o FlipGameID) DeepCopy() FlipGameID { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} + +type InboxVersInfo struct { + Uid gregor1.UID `codec:"uid" json:"uid"` + Vers InboxVers `codec:"vers" json:"vers"` +} + +func (o InboxVersInfo) DeepCopy() InboxVersInfo { + return InboxVersInfo{ + Uid: o.Uid.DeepCopy(), + Vers: o.Vers.DeepCopy(), + } +} + +type ConversationExistence int + +const ( + ConversationExistence_ACTIVE ConversationExistence = 0 + ConversationExistence_ARCHIVED ConversationExistence = 1 + ConversationExistence_DELETED ConversationExistence = 2 + ConversationExistence_ABANDONED ConversationExistence = 3 +) + +func (o ConversationExistence) DeepCopy() ConversationExistence { return o } + +var ConversationExistenceMap = map[string]ConversationExistence{ + "ACTIVE": 0, + "ARCHIVED": 1, + "DELETED": 2, + "ABANDONED": 3, +} + +var ConversationExistenceRevMap = map[ConversationExistence]string{ + 0: "ACTIVE", + 1: "ARCHIVED", + 2: "DELETED", + 3: "ABANDONED", +} + +func (e ConversationExistence) String() string { + if v, ok := ConversationExistenceRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ConversationMembersType int + +const ( + ConversationMembersType_KBFS ConversationMembersType = 0 + ConversationMembersType_TEAM ConversationMembersType = 1 + ConversationMembersType_IMPTEAMNATIVE ConversationMembersType = 2 + ConversationMembersType_IMPTEAMUPGRADE ConversationMembersType = 3 +) + +func (o ConversationMembersType) DeepCopy() ConversationMembersType { return o } + +var ConversationMembersTypeMap = map[string]ConversationMembersType{ + "KBFS": 0, + "TEAM": 1, + "IMPTEAMNATIVE": 2, + "IMPTEAMUPGRADE": 3, +} + +var ConversationMembersTypeRevMap = map[ConversationMembersType]string{ + 0: "KBFS", + 1: "TEAM", + 2: "IMPTEAMNATIVE", + 3: "IMPTEAMUPGRADE", +} + +func (e ConversationMembersType) String() string { + if v, ok := ConversationMembersTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type SyncInboxResType int + +const ( + SyncInboxResType_CURRENT SyncInboxResType = 0 + SyncInboxResType_INCREMENTAL SyncInboxResType = 1 + SyncInboxResType_CLEAR SyncInboxResType = 2 +) + +func (o SyncInboxResType) DeepCopy() SyncInboxResType { return o } + +var SyncInboxResTypeMap = map[string]SyncInboxResType{ + "CURRENT": 0, + "INCREMENTAL": 1, + "CLEAR": 2, +} + +var SyncInboxResTypeRevMap = map[SyncInboxResType]string{ + 0: "CURRENT", + 1: "INCREMENTAL", + 2: "CLEAR", +} + +func (e SyncInboxResType) String() string { + if v, ok := SyncInboxResTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type MessageType int + +const ( + MessageType_NONE MessageType = 0 + MessageType_TEXT MessageType = 1 + MessageType_ATTACHMENT MessageType = 2 + MessageType_EDIT MessageType = 3 + MessageType_DELETE MessageType = 4 + MessageType_METADATA MessageType = 5 + MessageType_TLFNAME MessageType = 6 + MessageType_HEADLINE MessageType = 7 + MessageType_ATTACHMENTUPLOADED MessageType = 8 + MessageType_JOIN MessageType = 9 + MessageType_LEAVE MessageType = 10 + MessageType_SYSTEM MessageType = 11 + MessageType_DELETEHISTORY MessageType = 12 + MessageType_REACTION MessageType = 13 + MessageType_SENDPAYMENT MessageType = 14 + MessageType_REQUESTPAYMENT MessageType = 15 + MessageType_UNFURL MessageType = 16 + MessageType_FLIP MessageType = 17 + MessageType_PIN MessageType = 18 +) + +func (o MessageType) DeepCopy() MessageType { return o } + +var MessageTypeMap = map[string]MessageType{ + "NONE": 0, + "TEXT": 1, + "ATTACHMENT": 2, + "EDIT": 3, + "DELETE": 4, + "METADATA": 5, + "TLFNAME": 6, + "HEADLINE": 7, + "ATTACHMENTUPLOADED": 8, + "JOIN": 9, + "LEAVE": 10, + "SYSTEM": 11, + "DELETEHISTORY": 12, + "REACTION": 13, + "SENDPAYMENT": 14, + "REQUESTPAYMENT": 15, + "UNFURL": 16, + "FLIP": 17, + "PIN": 18, +} + +var MessageTypeRevMap = map[MessageType]string{ + 0: "NONE", + 1: "TEXT", + 2: "ATTACHMENT", + 3: "EDIT", + 4: "DELETE", + 5: "METADATA", + 6: "TLFNAME", + 7: "HEADLINE", + 8: "ATTACHMENTUPLOADED", + 9: "JOIN", + 10: "LEAVE", + 11: "SYSTEM", + 12: "DELETEHISTORY", + 13: "REACTION", + 14: "SENDPAYMENT", + 15: "REQUESTPAYMENT", + 16: "UNFURL", + 17: "FLIP", + 18: "PIN", +} + +type TopicType int + +const ( + TopicType_NONE TopicType = 0 + TopicType_CHAT TopicType = 1 + TopicType_DEV TopicType = 2 + TopicType_KBFSFILEEDIT TopicType = 3 +) + +func (o TopicType) DeepCopy() TopicType { return o } + +var TopicTypeMap = map[string]TopicType{ + "NONE": 0, + "CHAT": 1, + "DEV": 2, + "KBFSFILEEDIT": 3, +} + +var TopicTypeRevMap = map[TopicType]string{ + 0: "NONE", + 1: "CHAT", + 2: "DEV", + 3: "KBFSFILEEDIT", +} + +type TeamType int + +const ( + TeamType_NONE TeamType = 0 + TeamType_SIMPLE TeamType = 1 + TeamType_COMPLEX TeamType = 2 +) + +func (o TeamType) DeepCopy() TeamType { return o } + +var TeamTypeMap = map[string]TeamType{ + "NONE": 0, + "SIMPLE": 1, + "COMPLEX": 2, +} + +var TeamTypeRevMap = map[TeamType]string{ + 0: "NONE", + 1: "SIMPLE", + 2: "COMPLEX", +} + +func (e TeamType) String() string { + if v, ok := TeamTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type NotificationKind int + +const ( + NotificationKind_GENERIC NotificationKind = 0 + NotificationKind_ATMENTION NotificationKind = 1 +) + +func (o NotificationKind) DeepCopy() NotificationKind { return o } + +var NotificationKindMap = map[string]NotificationKind{ + "GENERIC": 0, + "ATMENTION": 1, +} + +var NotificationKindRevMap = map[NotificationKind]string{ + 0: "GENERIC", + 1: "ATMENTION", +} + +type GlobalAppNotificationSetting int + +const ( + GlobalAppNotificationSetting_NEWMESSAGES GlobalAppNotificationSetting = 0 + GlobalAppNotificationSetting_PLAINTEXTMOBILE GlobalAppNotificationSetting = 1 + GlobalAppNotificationSetting_PLAINTEXTDESKTOP GlobalAppNotificationSetting = 2 + GlobalAppNotificationSetting_DEFAULTSOUNDMOBILE GlobalAppNotificationSetting = 3 + GlobalAppNotificationSetting_DISABLETYPING GlobalAppNotificationSetting = 4 +) + +func (o GlobalAppNotificationSetting) DeepCopy() GlobalAppNotificationSetting { return o } + +var GlobalAppNotificationSettingMap = map[string]GlobalAppNotificationSetting{ + "NEWMESSAGES": 0, + "PLAINTEXTMOBILE": 1, + "PLAINTEXTDESKTOP": 2, + "DEFAULTSOUNDMOBILE": 3, + "DISABLETYPING": 4, +} + +var GlobalAppNotificationSettingRevMap = map[GlobalAppNotificationSetting]string{ + 0: "NEWMESSAGES", + 1: "PLAINTEXTMOBILE", + 2: "PLAINTEXTDESKTOP", + 3: "DEFAULTSOUNDMOBILE", + 4: "DISABLETYPING", +} + +func (e GlobalAppNotificationSetting) String() string { + if v, ok := GlobalAppNotificationSettingRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type GlobalAppNotificationSettings struct { + Settings map[GlobalAppNotificationSetting]bool `codec:"settings" json:"settings"` +} + +func (o GlobalAppNotificationSettings) DeepCopy() GlobalAppNotificationSettings { + return GlobalAppNotificationSettings{ + Settings: (func(x map[GlobalAppNotificationSetting]bool) map[GlobalAppNotificationSetting]bool { + if x == nil { + return nil + } + ret := make(map[GlobalAppNotificationSetting]bool, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v + ret[kCopy] = vCopy + } + return ret + })(o.Settings), + } +} + +type ConversationStatus int + +const ( + ConversationStatus_UNFILED ConversationStatus = 0 + ConversationStatus_FAVORITE ConversationStatus = 1 + ConversationStatus_IGNORED ConversationStatus = 2 + ConversationStatus_BLOCKED ConversationStatus = 3 + ConversationStatus_MUTED ConversationStatus = 4 + ConversationStatus_REPORTED ConversationStatus = 5 +) + +func (o ConversationStatus) DeepCopy() ConversationStatus { return o } + +var ConversationStatusMap = map[string]ConversationStatus{ + "UNFILED": 0, + "FAVORITE": 1, + "IGNORED": 2, + "BLOCKED": 3, + "MUTED": 4, + "REPORTED": 5, +} + +var ConversationStatusRevMap = map[ConversationStatus]string{ + 0: "UNFILED", + 1: "FAVORITE", + 2: "IGNORED", + 3: "BLOCKED", + 4: "MUTED", + 5: "REPORTED", +} + +func (e ConversationStatus) String() string { + if v, ok := ConversationStatusRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ConversationMember struct { + Uid gregor1.UID `codec:"uid" json:"uid"` + ConvID ConversationID `codec:"convID" json:"convID"` + TopicType TopicType `codec:"topicType" json:"topicType"` +} + +func (o ConversationMember) DeepCopy() ConversationMember { + return ConversationMember{ + Uid: o.Uid.DeepCopy(), + ConvID: o.ConvID.DeepCopy(), + TopicType: o.TopicType.DeepCopy(), + } +} + +type ConversationIDMessageIDPair struct { + ConvID ConversationID `codec:"convID" json:"convID"` + MsgID MessageID `codec:"msgID" json:"msgID"` +} + +func (o ConversationIDMessageIDPair) DeepCopy() ConversationIDMessageIDPair { + return ConversationIDMessageIDPair{ + ConvID: o.ConvID.DeepCopy(), + MsgID: o.MsgID.DeepCopy(), + } +} + +type ConversationIDMessageIDPairs struct { + Pairs []ConversationIDMessageIDPair `codec:"pairs" json:"pairs"` +} + +func (o ConversationIDMessageIDPairs) DeepCopy() ConversationIDMessageIDPairs { + return ConversationIDMessageIDPairs{ + Pairs: (func(x []ConversationIDMessageIDPair) []ConversationIDMessageIDPair { + if x == nil { + return nil + } + ret := make([]ConversationIDMessageIDPair, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Pairs), + } +} + +type ChannelNameMention struct { + ConvID ConversationID `codec:"convID" json:"convID"` + TopicName string `codec:"topicName" json:"topicName"` +} + +func (o ChannelNameMention) DeepCopy() ChannelNameMention { + return ChannelNameMention{ + ConvID: o.ConvID.DeepCopy(), + TopicName: o.TopicName, + } +} + +type KBFSPath struct { + StartIndex int `codec:"startIndex" json:"startIndex"` + RawPath string `codec:"rawPath" json:"rawPath"` + StandardPath string `codec:"standardPath" json:"standardPath"` + PathInfo keybase1.KBFSPathInfo `codec:"pathInfo" json:"pathInfo"` +} + +func (o KBFSPath) DeepCopy() KBFSPath { + return KBFSPath{ + StartIndex: o.StartIndex, + RawPath: o.RawPath, + StandardPath: o.StandardPath, + PathInfo: o.PathInfo.DeepCopy(), + } +} + +type ConversationMemberStatus int + +const ( + ConversationMemberStatus_ACTIVE ConversationMemberStatus = 0 + ConversationMemberStatus_REMOVED ConversationMemberStatus = 1 + ConversationMemberStatus_LEFT ConversationMemberStatus = 2 + ConversationMemberStatus_PREVIEW ConversationMemberStatus = 3 + ConversationMemberStatus_RESET ConversationMemberStatus = 4 + ConversationMemberStatus_NEVER_JOINED ConversationMemberStatus = 5 +) + +func (o ConversationMemberStatus) DeepCopy() ConversationMemberStatus { return o } + +var ConversationMemberStatusMap = map[string]ConversationMemberStatus{ + "ACTIVE": 0, + "REMOVED": 1, + "LEFT": 2, + "PREVIEW": 3, + "RESET": 4, + "NEVER_JOINED": 5, +} + +var ConversationMemberStatusRevMap = map[ConversationMemberStatus]string{ + 0: "ACTIVE", + 1: "REMOVED", + 2: "LEFT", + 3: "PREVIEW", + 4: "RESET", + 5: "NEVER_JOINED", +} + +func (e ConversationMemberStatus) String() string { + if v, ok := ConversationMemberStatusRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type Pagination struct { + Next []byte `codec:"next,omitempty" json:"next,omitempty"` + Previous []byte `codec:"previous,omitempty" json:"previous,omitempty"` + Num int `codec:"num" json:"num"` + Last bool `codec:"last,omitempty" json:"last,omitempty"` + ForceFirstPage bool `codec:"forceFirstPage,omitempty" json:"forceFirstPage,omitempty"` +} + +func (o Pagination) DeepCopy() Pagination { + return Pagination{ + Next: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.Next), + Previous: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.Previous), + Num: o.Num, + Last: o.Last, + ForceFirstPage: o.ForceFirstPage, + } +} + +type RateLimit struct { + Name string `codec:"name" json:"name"` + CallsRemaining int `codec:"callsRemaining" json:"callsRemaining"` + WindowReset int `codec:"windowReset" json:"windowReset"` + MaxCalls int `codec:"maxCalls" json:"maxCalls"` +} + +func (o RateLimit) DeepCopy() RateLimit { + return RateLimit{ + Name: o.Name, + CallsRemaining: o.CallsRemaining, + WindowReset: o.WindowReset, + MaxCalls: o.MaxCalls, + } +} + +type GetInboxQuery struct { + ConvID *ConversationID `codec:"convID,omitempty" json:"convID,omitempty"` + TopicType *TopicType `codec:"topicType,omitempty" json:"topicType,omitempty"` + TlfID *TLFID `codec:"tlfID,omitempty" json:"tlfID,omitempty"` + TlfVisibility *keybase1.TLFVisibility `codec:"tlfVisibility,omitempty" json:"tlfVisibility,omitempty"` + Before *gregor1.Time `codec:"before,omitempty" json:"before,omitempty"` + After *gregor1.Time `codec:"after,omitempty" json:"after,omitempty"` + OneChatTypePerTLF *bool `codec:"oneChatTypePerTLF,omitempty" json:"oneChatTypePerTLF,omitempty"` + TopicName *string `codec:"topicName,omitempty" json:"topicName,omitempty"` + Status []ConversationStatus `codec:"status" json:"status"` + MemberStatus []ConversationMemberStatus `codec:"memberStatus" json:"memberStatus"` + Existences []ConversationExistence `codec:"existences" json:"existences"` + MembersTypes []ConversationMembersType `codec:"membersTypes" json:"membersTypes"` + ConvIDs []ConversationID `codec:"convIDs" json:"convIDs"` + UnreadOnly bool `codec:"unreadOnly" json:"unreadOnly"` + ReadOnly bool `codec:"readOnly" json:"readOnly"` + ComputeActiveList bool `codec:"computeActiveList" json:"computeActiveList"` + SummarizeMaxMsgs bool `codec:"summarizeMaxMsgs" json:"summarizeMaxMsgs"` + SkipBgLoads bool `codec:"skipBgLoads" json:"skipBgLoads"` + AllowUnseenQuery bool `codec:"allowUnseenQuery" json:"allowUnseenQuery"` +} + +func (o GetInboxQuery) DeepCopy() GetInboxQuery { + return GetInboxQuery{ + ConvID: (func(x *ConversationID) *ConversationID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ConvID), + TopicType: (func(x *TopicType) *TopicType { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.TopicType), + TlfID: (func(x *TLFID) *TLFID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.TlfID), + TlfVisibility: (func(x *keybase1.TLFVisibility) *keybase1.TLFVisibility { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.TlfVisibility), + Before: (func(x *gregor1.Time) *gregor1.Time { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Before), + After: (func(x *gregor1.Time) *gregor1.Time { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.After), + OneChatTypePerTLF: (func(x *bool) *bool { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.OneChatTypePerTLF), + TopicName: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.TopicName), + Status: (func(x []ConversationStatus) []ConversationStatus { + if x == nil { + return nil + } + ret := make([]ConversationStatus, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Status), + MemberStatus: (func(x []ConversationMemberStatus) []ConversationMemberStatus { + if x == nil { + return nil + } + ret := make([]ConversationMemberStatus, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.MemberStatus), + Existences: (func(x []ConversationExistence) []ConversationExistence { + if x == nil { + return nil + } + ret := make([]ConversationExistence, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Existences), + MembersTypes: (func(x []ConversationMembersType) []ConversationMembersType { + if x == nil { + return nil + } + ret := make([]ConversationMembersType, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.MembersTypes), + 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), + UnreadOnly: o.UnreadOnly, + ReadOnly: o.ReadOnly, + ComputeActiveList: o.ComputeActiveList, + SummarizeMaxMsgs: o.SummarizeMaxMsgs, + SkipBgLoads: o.SkipBgLoads, + AllowUnseenQuery: o.AllowUnseenQuery, + } +} + +type ConversationIDTriple struct { + Tlfid TLFID `codec:"tlfid" json:"tlfid"` + TopicType TopicType `codec:"topicType" json:"topicType"` + TopicID TopicID `codec:"topicID" json:"topicID"` +} + +func (o ConversationIDTriple) DeepCopy() ConversationIDTriple { + return ConversationIDTriple{ + Tlfid: o.Tlfid.DeepCopy(), + TopicType: o.TopicType.DeepCopy(), + TopicID: o.TopicID.DeepCopy(), + } +} + +type ConversationFinalizeInfo struct { + ResetUser string `codec:"resetUser" json:"resetUser"` + ResetDate string `codec:"resetDate" json:"resetDate"` + ResetFull string `codec:"resetFull" json:"resetFull"` + ResetTimestamp gregor1.Time `codec:"resetTimestamp" json:"resetTimestamp"` +} + +func (o ConversationFinalizeInfo) DeepCopy() ConversationFinalizeInfo { + return ConversationFinalizeInfo{ + ResetUser: o.ResetUser, + ResetDate: o.ResetDate, + ResetFull: o.ResetFull, + ResetTimestamp: o.ResetTimestamp.DeepCopy(), + } +} + +type ConversationResolveInfo struct { + NewTLFName string `codec:"newTLFName" json:"newTLFName"` +} + +func (o ConversationResolveInfo) DeepCopy() ConversationResolveInfo { + return ConversationResolveInfo{ + NewTLFName: o.NewTLFName, + } +} + +type Expunge struct { + Upto MessageID `codec:"upto" json:"upto"` + Basis MessageID `codec:"basis" json:"basis"` +} + +func (o Expunge) DeepCopy() Expunge { + return Expunge{ + Upto: o.Upto.DeepCopy(), + Basis: o.Basis.DeepCopy(), + } +} + +type ConversationMetadata struct { + IdTriple ConversationIDTriple `codec:"idTriple" json:"idTriple"` + ConversationID ConversationID `codec:"conversationID" json:"conversationID"` + Visibility keybase1.TLFVisibility `codec:"visibility" json:"visibility"` + Status ConversationStatus `codec:"status" json:"status"` + MembersType ConversationMembersType `codec:"membersType" json:"membersType"` + TeamType TeamType `codec:"teamType" json:"teamType"` + Existence ConversationExistence `codec:"existence" json:"existence"` + Version ConversationVers `codec:"version" json:"version"` + LocalVersion LocalConversationVers `codec:"localVersion" json:"localVersion"` + FinalizeInfo *ConversationFinalizeInfo `codec:"finalizeInfo,omitempty" json:"finalizeInfo,omitempty"` + Supersedes []ConversationMetadata `codec:"supersedes" json:"supersedes"` + SupersededBy []ConversationMetadata `codec:"supersededBy" json:"supersededBy"` + ActiveList []gregor1.UID `codec:"activeList" json:"activeList"` + AllList []gregor1.UID `codec:"allList" json:"allList"` + ResetList []gregor1.UID `codec:"resetList" json:"resetList"` + IsDefaultConv bool `codec:"d" json:"isDefaultConv"` +} + +func (o ConversationMetadata) DeepCopy() ConversationMetadata { + return ConversationMetadata{ + IdTriple: o.IdTriple.DeepCopy(), + ConversationID: o.ConversationID.DeepCopy(), + Visibility: o.Visibility.DeepCopy(), + Status: o.Status.DeepCopy(), + MembersType: o.MembersType.DeepCopy(), + TeamType: o.TeamType.DeepCopy(), + Existence: o.Existence.DeepCopy(), + Version: o.Version.DeepCopy(), + LocalVersion: o.LocalVersion.DeepCopy(), + FinalizeInfo: (func(x *ConversationFinalizeInfo) *ConversationFinalizeInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.FinalizeInfo), + Supersedes: (func(x []ConversationMetadata) []ConversationMetadata { + if x == nil { + return nil + } + ret := make([]ConversationMetadata, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Supersedes), + SupersededBy: (func(x []ConversationMetadata) []ConversationMetadata { + if x == nil { + return nil + } + ret := make([]ConversationMetadata, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.SupersededBy), + ActiveList: (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.ActiveList), + AllList: (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.AllList), + ResetList: (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.ResetList), + IsDefaultConv: o.IsDefaultConv, + } +} + +type ConversationNotificationInfo struct { + ChannelWide bool `codec:"channelWide" json:"channelWide"` + Settings map[keybase1.DeviceType]map[NotificationKind]bool `codec:"settings" json:"settings"` +} + +func (o ConversationNotificationInfo) DeepCopy() ConversationNotificationInfo { + return ConversationNotificationInfo{ + ChannelWide: o.ChannelWide, + Settings: (func(x map[keybase1.DeviceType]map[NotificationKind]bool) map[keybase1.DeviceType]map[NotificationKind]bool { + if x == nil { + return nil + } + ret := make(map[keybase1.DeviceType]map[NotificationKind]bool, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := (func(x map[NotificationKind]bool) map[NotificationKind]bool { + if x == nil { + return nil + } + ret := make(map[NotificationKind]bool, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v + ret[kCopy] = vCopy + } + return ret + })(v) + ret[kCopy] = vCopy + } + return ret + })(o.Settings), + } +} + +type ConversationReaderInfo struct { + Mtime gregor1.Time `codec:"mtime" json:"mtime"` + ReadMsgid MessageID `codec:"readMsgid" json:"readMsgid"` + MaxMsgid MessageID `codec:"maxMsgid" json:"maxMsgid"` + Status ConversationMemberStatus `codec:"status" json:"status"` + UntrustedTeamRole keybase1.TeamRole `codec:"untrustedTeamRole" json:"untrustedTeamRole"` + Journeycard *ConversationJourneycardInfo `codec:"jc,omitempty" json:"jc,omitempty"` +} + +func (o ConversationReaderInfo) DeepCopy() ConversationReaderInfo { + return ConversationReaderInfo{ + Mtime: o.Mtime.DeepCopy(), + ReadMsgid: o.ReadMsgid.DeepCopy(), + MaxMsgid: o.MaxMsgid.DeepCopy(), + Status: o.Status.DeepCopy(), + UntrustedTeamRole: o.UntrustedTeamRole.DeepCopy(), + Journeycard: (func(x *ConversationJourneycardInfo) *ConversationJourneycardInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Journeycard), + } +} + +type ConversationJourneycardInfo struct { + WelcomeEligible bool `codec:"w" json:"w"` +} + +func (o ConversationJourneycardInfo) DeepCopy() ConversationJourneycardInfo { + return ConversationJourneycardInfo{ + WelcomeEligible: o.WelcomeEligible, + } +} + +type ConversationCreatorInfo struct { + Ctime gregor1.Time `codec:"ctime" json:"ctime"` + Uid gregor1.UID `codec:"uid" json:"uid"` +} + +func (o ConversationCreatorInfo) DeepCopy() ConversationCreatorInfo { + return ConversationCreatorInfo{ + Ctime: o.Ctime.DeepCopy(), + Uid: o.Uid.DeepCopy(), + } +} + +type ConversationCreatorInfoLocal struct { + Ctime gregor1.Time `codec:"ctime" json:"ctime"` + Username string `codec:"username" json:"username"` +} + +func (o ConversationCreatorInfoLocal) DeepCopy() ConversationCreatorInfoLocal { + return ConversationCreatorInfoLocal{ + Ctime: o.Ctime.DeepCopy(), + Username: o.Username, + } +} + +type ConversationMinWriterRoleInfo struct { + Uid gregor1.UID `codec:"uid" json:"uid"` + Role keybase1.TeamRole `codec:"role" json:"role"` +} + +func (o ConversationMinWriterRoleInfo) DeepCopy() ConversationMinWriterRoleInfo { + return ConversationMinWriterRoleInfo{ + Uid: o.Uid.DeepCopy(), + Role: o.Role.DeepCopy(), + } +} + +type ConversationSettings struct { + MinWriterRoleInfo *ConversationMinWriterRoleInfo `codec:"mwr,omitempty" json:"mwr,omitempty"` +} + +func (o ConversationSettings) DeepCopy() ConversationSettings { + return ConversationSettings{ + MinWriterRoleInfo: (func(x *ConversationMinWriterRoleInfo) *ConversationMinWriterRoleInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.MinWriterRoleInfo), + } +} + +type Conversation struct { + Metadata ConversationMetadata `codec:"metadata" json:"metadata"` + ReaderInfo *ConversationReaderInfo `codec:"readerInfo,omitempty" json:"readerInfo,omitempty"` + Notifications *ConversationNotificationInfo `codec:"notifications,omitempty" json:"notifications,omitempty"` + MaxMsgs []MessageBoxed `codec:"maxMsgs" json:"maxMsgs"` + MaxMsgSummaries []MessageSummary `codec:"maxMsgSummaries" json:"maxMsgSummaries"` + CreatorInfo *ConversationCreatorInfo `codec:"creatorInfo,omitempty" json:"creatorInfo,omitempty"` + PinnedMsg *MessageID `codec:"pinnedMsg,omitempty" json:"pinnedMsg,omitempty"` + Expunge Expunge `codec:"expunge" json:"expunge"` + ConvRetention *RetentionPolicy `codec:"convRetention,omitempty" json:"convRetention,omitempty"` + TeamRetention *RetentionPolicy `codec:"teamRetention,omitempty" json:"teamRetention,omitempty"` + ConvSettings *ConversationSettings `codec:"cs,omitempty" json:"cs,omitempty"` +} + +func (o Conversation) DeepCopy() Conversation { + return Conversation{ + Metadata: o.Metadata.DeepCopy(), + ReaderInfo: (func(x *ConversationReaderInfo) *ConversationReaderInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ReaderInfo), + Notifications: (func(x *ConversationNotificationInfo) *ConversationNotificationInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Notifications), + MaxMsgs: (func(x []MessageBoxed) []MessageBoxed { + if x == nil { + return nil + } + ret := make([]MessageBoxed, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.MaxMsgs), + MaxMsgSummaries: (func(x []MessageSummary) []MessageSummary { + if x == nil { + return nil + } + ret := make([]MessageSummary, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.MaxMsgSummaries), + CreatorInfo: (func(x *ConversationCreatorInfo) *ConversationCreatorInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.CreatorInfo), + PinnedMsg: (func(x *MessageID) *MessageID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.PinnedMsg), + Expunge: o.Expunge.DeepCopy(), + ConvRetention: (func(x *RetentionPolicy) *RetentionPolicy { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ConvRetention), + TeamRetention: (func(x *RetentionPolicy) *RetentionPolicy { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.TeamRetention), + ConvSettings: (func(x *ConversationSettings) *ConversationSettings { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ConvSettings), + } +} + +type MessageSummary struct { + MsgID MessageID `codec:"msgID" json:"msgID"` + MessageType MessageType `codec:"messageType" json:"messageType"` + TlfName string `codec:"tlfName" json:"tlfName"` + TlfPublic bool `codec:"tlfPublic" json:"tlfPublic"` + Ctime gregor1.Time `codec:"ctime" json:"ctime"` +} + +func (o MessageSummary) DeepCopy() MessageSummary { + return MessageSummary{ + MsgID: o.MsgID.DeepCopy(), + MessageType: o.MessageType.DeepCopy(), + TlfName: o.TlfName, + TlfPublic: o.TlfPublic, + Ctime: o.Ctime.DeepCopy(), + } +} + +type Reaction struct { + Ctime gregor1.Time `codec:"ctime" json:"ctime"` + ReactionMsgID MessageID `codec:"reactionMsgID" json:"reactionMsgID"` +} + +func (o Reaction) DeepCopy() Reaction { + return Reaction{ + Ctime: o.Ctime.DeepCopy(), + ReactionMsgID: o.ReactionMsgID.DeepCopy(), + } +} + +type ReactionMap struct { + Reactions map[string]map[string]Reaction `codec:"reactions" json:"reactions"` +} + +func (o ReactionMap) DeepCopy() ReactionMap { + return ReactionMap{ + Reactions: (func(x map[string]map[string]Reaction) map[string]map[string]Reaction { + if x == nil { + return nil + } + ret := make(map[string]map[string]Reaction, len(x)) + for k, v := range x { + kCopy := k + vCopy := (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 + })(v) + ret[kCopy] = vCopy + } + return ret + })(o.Reactions), + } +} + +type MessageServerHeader struct { + MessageID MessageID `codec:"messageID" json:"messageID"` + SupersededBy MessageID `codec:"supersededBy" json:"supersededBy"` + ReactionIDs []MessageID `codec:"r" json:"r"` + UnfurlIDs []MessageID `codec:"u" json:"u"` + Replies []MessageID `codec:"replies" json:"replies"` + Ctime gregor1.Time `codec:"ctime" json:"ctime"` + Now gregor1.Time `codec:"n" json:"n"` + Rtime *gregor1.Time `codec:"rt,omitempty" json:"rt,omitempty"` +} + +func (o MessageServerHeader) DeepCopy() MessageServerHeader { + return MessageServerHeader{ + MessageID: o.MessageID.DeepCopy(), + SupersededBy: o.SupersededBy.DeepCopy(), + ReactionIDs: (func(x []MessageID) []MessageID { + if x == nil { + return nil + } + ret := make([]MessageID, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.ReactionIDs), + UnfurlIDs: (func(x []MessageID) []MessageID { + if x == nil { + return nil + } + ret := make([]MessageID, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.UnfurlIDs), + Replies: (func(x []MessageID) []MessageID { + if x == nil { + return nil + } + ret := make([]MessageID, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Replies), + Ctime: o.Ctime.DeepCopy(), + Now: o.Now.DeepCopy(), + Rtime: (func(x *gregor1.Time) *gregor1.Time { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Rtime), + } +} + +type MessagePreviousPointer struct { + Id MessageID `codec:"id" json:"id"` + Hash Hash `codec:"hash" json:"hash"` +} + +func (o MessagePreviousPointer) DeepCopy() MessagePreviousPointer { + return MessagePreviousPointer{ + Id: o.Id.DeepCopy(), + Hash: o.Hash.DeepCopy(), + } +} + +type OutboxInfo struct { + Prev MessageID `codec:"prev" json:"prev"` + ComposeTime gregor1.Time `codec:"composeTime" json:"composeTime"` +} + +func (o OutboxInfo) DeepCopy() OutboxInfo { + return OutboxInfo{ + Prev: o.Prev.DeepCopy(), + ComposeTime: o.ComposeTime.DeepCopy(), + } +} + +type MsgEphemeralMetadata struct { + Lifetime gregor1.DurationSec `codec:"l" json:"l"` + Generation keybase1.EkGeneration `codec:"g" json:"g"` + ExplodedBy *string `codec:"u,omitempty" json:"u,omitempty"` +} + +func (o MsgEphemeralMetadata) DeepCopy() MsgEphemeralMetadata { + return MsgEphemeralMetadata{ + Lifetime: o.Lifetime.DeepCopy(), + Generation: o.Generation.DeepCopy(), + ExplodedBy: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.ExplodedBy), + } +} + +type EphemeralPurgeInfo struct { + ConvID ConversationID `codec:"c" json:"c"` + IsActive bool `codec:"a" json:"a"` + NextPurgeTime gregor1.Time `codec:"n" json:"n"` + MinUnexplodedID MessageID `codec:"e" json:"e"` +} + +func (o EphemeralPurgeInfo) DeepCopy() EphemeralPurgeInfo { + return EphemeralPurgeInfo{ + ConvID: o.ConvID.DeepCopy(), + IsActive: o.IsActive, + NextPurgeTime: o.NextPurgeTime.DeepCopy(), + MinUnexplodedID: o.MinUnexplodedID.DeepCopy(), + } +} + +type MessageClientHeader struct { + Conv ConversationIDTriple `codec:"conv" json:"conv"` + TlfName string `codec:"tlfName" json:"tlfName"` + TlfPublic bool `codec:"tlfPublic" json:"tlfPublic"` + MessageType MessageType `codec:"messageType" json:"messageType"` + Supersedes MessageID `codec:"supersedes" json:"supersedes"` + KbfsCryptKeysUsed *bool `codec:"kbfsCryptKeysUsed,omitempty" json:"kbfsCryptKeysUsed,omitempty"` + Deletes []MessageID `codec:"deletes" json:"deletes"` + Prev []MessagePreviousPointer `codec:"prev" json:"prev"` + DeleteHistory *MessageDeleteHistory `codec:"deleteHistory,omitempty" json:"deleteHistory,omitempty"` + Sender gregor1.UID `codec:"sender" json:"sender"` + SenderDevice gregor1.DeviceID `codec:"senderDevice" json:"senderDevice"` + MerkleRoot *MerkleRoot `codec:"merkleRoot,omitempty" json:"merkleRoot,omitempty"` + OutboxID *OutboxID `codec:"outboxID,omitempty" json:"outboxID,omitempty"` + OutboxInfo *OutboxInfo `codec:"outboxInfo,omitempty" json:"outboxInfo,omitempty"` + 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"` +} + +func (o MessageClientHeader) DeepCopy() MessageClientHeader { + return MessageClientHeader{ + Conv: o.Conv.DeepCopy(), + TlfName: o.TlfName, + TlfPublic: o.TlfPublic, + MessageType: o.MessageType.DeepCopy(), + Supersedes: o.Supersedes.DeepCopy(), + KbfsCryptKeysUsed: (func(x *bool) *bool { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.KbfsCryptKeysUsed), + Deletes: (func(x []MessageID) []MessageID { + if x == nil { + return nil + } + ret := make([]MessageID, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Deletes), + Prev: (func(x []MessagePreviousPointer) []MessagePreviousPointer { + if x == nil { + return nil + } + ret := make([]MessagePreviousPointer, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Prev), + DeleteHistory: (func(x *MessageDeleteHistory) *MessageDeleteHistory { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.DeleteHistory), + Sender: o.Sender.DeepCopy(), + SenderDevice: o.SenderDevice.DeepCopy(), + MerkleRoot: (func(x *MerkleRoot) *MerkleRoot { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.MerkleRoot), + OutboxID: (func(x *OutboxID) *OutboxID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.OutboxID), + OutboxInfo: (func(x *OutboxInfo) *OutboxInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.OutboxInfo), + EphemeralMetadata: (func(x *MsgEphemeralMetadata) *MsgEphemeralMetadata { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.EphemeralMetadata), + PairwiseMacs: (func(x map[keybase1.KID][]byte) map[keybase1.KID][]byte { + if x == nil { + return nil + } + ret := make(map[keybase1.KID][]byte, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(v) + ret[kCopy] = vCopy + } + return ret + })(o.PairwiseMacs), + BotUID: (func(x *gregor1.UID) *gregor1.UID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.BotUID), + } +} + +type MessageClientHeaderVerified struct { + Conv ConversationIDTriple `codec:"conv" json:"conv"` + TlfName string `codec:"tlfName" json:"tlfName"` + TlfPublic bool `codec:"tlfPublic" json:"tlfPublic"` + MessageType MessageType `codec:"messageType" json:"messageType"` + Prev []MessagePreviousPointer `codec:"prev" json:"prev"` + Sender gregor1.UID `codec:"sender" json:"sender"` + SenderDevice gregor1.DeviceID `codec:"senderDevice" json:"senderDevice"` + KbfsCryptKeysUsed *bool `codec:"kbfsCryptKeysUsed,omitempty" json:"kbfsCryptKeysUsed,omitempty"` + MerkleRoot *MerkleRoot `codec:"merkleRoot,omitempty" json:"merkleRoot,omitempty"` + OutboxID *OutboxID `codec:"outboxID,omitempty" json:"outboxID,omitempty"` + OutboxInfo *OutboxInfo `codec:"outboxInfo,omitempty" json:"outboxInfo,omitempty"` + EphemeralMetadata *MsgEphemeralMetadata `codec:"em,omitempty" json:"em,omitempty"` + Rtime gregor1.Time `codec:"rt" json:"rt"` + HasPairwiseMacs bool `codec:"pm" json:"pm"` + BotUID *gregor1.UID `codec:"b,omitempty" json:"b,omitempty"` +} + +func (o MessageClientHeaderVerified) DeepCopy() MessageClientHeaderVerified { + return MessageClientHeaderVerified{ + Conv: o.Conv.DeepCopy(), + TlfName: o.TlfName, + TlfPublic: o.TlfPublic, + MessageType: o.MessageType.DeepCopy(), + Prev: (func(x []MessagePreviousPointer) []MessagePreviousPointer { + if x == nil { + return nil + } + ret := make([]MessagePreviousPointer, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Prev), + Sender: o.Sender.DeepCopy(), + SenderDevice: o.SenderDevice.DeepCopy(), + KbfsCryptKeysUsed: (func(x *bool) *bool { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.KbfsCryptKeysUsed), + MerkleRoot: (func(x *MerkleRoot) *MerkleRoot { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.MerkleRoot), + OutboxID: (func(x *OutboxID) *OutboxID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.OutboxID), + OutboxInfo: (func(x *OutboxInfo) *OutboxInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.OutboxInfo), + EphemeralMetadata: (func(x *MsgEphemeralMetadata) *MsgEphemeralMetadata { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.EphemeralMetadata), + Rtime: o.Rtime.DeepCopy(), + HasPairwiseMacs: o.HasPairwiseMacs, + BotUID: (func(x *gregor1.UID) *gregor1.UID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.BotUID), + } +} + +type EncryptedData struct { + V int `codec:"v" json:"v"` + E []byte `codec:"e" json:"e"` + N []byte `codec:"n" json:"n"` +} + +func (o EncryptedData) DeepCopy() EncryptedData { + return EncryptedData{ + V: o.V, + E: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.E), + N: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.N), + } +} + +type SignEncryptedData struct { + V int `codec:"v" json:"v"` + E []byte `codec:"e" json:"e"` + N []byte `codec:"n" json:"n"` +} + +func (o SignEncryptedData) DeepCopy() SignEncryptedData { + return SignEncryptedData{ + V: o.V, + E: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.E), + N: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.N), + } +} + +type SealedData struct { + V int `codec:"v" json:"v"` + E []byte `codec:"e" json:"e"` + N []byte `codec:"n" json:"n"` +} + +func (o SealedData) DeepCopy() SealedData { + return SealedData{ + V: o.V, + E: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.E), + N: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.N), + } +} + +type SignatureInfo struct { + V int `codec:"v" json:"v"` + S []byte `codec:"s" json:"s"` + K []byte `codec:"k" json:"k"` +} + +func (o SignatureInfo) DeepCopy() SignatureInfo { + return SignatureInfo{ + V: o.V, + S: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.S), + K: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.K), + } +} + +type MerkleRoot struct { + Seqno int64 `codec:"seqno" json:"seqno"` + Hash []byte `codec:"hash" json:"hash"` +} + +func (o MerkleRoot) DeepCopy() MerkleRoot { + return MerkleRoot{ + Seqno: o.Seqno, + Hash: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.Hash), + } +} + +type InboxResType int + +const ( + InboxResType_VERSIONHIT InboxResType = 0 + InboxResType_FULL InboxResType = 1 +) + +func (o InboxResType) DeepCopy() InboxResType { return o } + +var InboxResTypeMap = map[string]InboxResType{ + "VERSIONHIT": 0, + "FULL": 1, +} + +var InboxResTypeRevMap = map[InboxResType]string{ + 0: "VERSIONHIT", + 1: "FULL", +} + +func (e InboxResType) String() string { + if v, ok := InboxResTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type InboxViewFull struct { + Vers InboxVers `codec:"vers" json:"vers"` + Conversations []Conversation `codec:"conversations" json:"conversations"` + Pagination *Pagination `codec:"pagination,omitempty" json:"pagination,omitempty"` +} + +func (o InboxViewFull) DeepCopy() InboxViewFull { + return InboxViewFull{ + Vers: o.Vers.DeepCopy(), + Conversations: (func(x []Conversation) []Conversation { + if x == nil { + return nil + } + ret := make([]Conversation, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Conversations), + Pagination: (func(x *Pagination) *Pagination { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Pagination), + } +} + +type InboxView struct { + Rtype__ InboxResType `codec:"rtype" json:"rtype"` + Full__ *InboxViewFull `codec:"full,omitempty" json:"full,omitempty"` +} + +func (o *InboxView) Rtype() (ret InboxResType, err error) { + switch o.Rtype__ { + case InboxResType_FULL: + if o.Full__ == nil { + err = errors.New("unexpected nil value for Full__") + return ret, err + } + } + return o.Rtype__, nil +} + +func (o InboxView) Full() (res InboxViewFull) { + if o.Rtype__ != InboxResType_FULL { + panic("wrong case accessed") + } + if o.Full__ == nil { + return + } + return *o.Full__ +} + +func NewInboxViewWithVersionhit() InboxView { + return InboxView{ + Rtype__: InboxResType_VERSIONHIT, + } +} + +func NewInboxViewWithFull(v InboxViewFull) InboxView { + return InboxView{ + Rtype__: InboxResType_FULL, + Full__: &v, + } +} + +func (o InboxView) DeepCopy() InboxView { + return InboxView{ + Rtype__: o.Rtype__.DeepCopy(), + Full__: (func(x *InboxViewFull) *InboxViewFull { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Full__), + } +} + +type RetentionPolicyType int + +const ( + RetentionPolicyType_NONE RetentionPolicyType = 0 + RetentionPolicyType_RETAIN RetentionPolicyType = 1 + RetentionPolicyType_EXPIRE RetentionPolicyType = 2 + RetentionPolicyType_INHERIT RetentionPolicyType = 3 + RetentionPolicyType_EPHEMERAL RetentionPolicyType = 4 +) + +func (o RetentionPolicyType) DeepCopy() RetentionPolicyType { return o } + +var RetentionPolicyTypeMap = map[string]RetentionPolicyType{ + "NONE": 0, + "RETAIN": 1, + "EXPIRE": 2, + "INHERIT": 3, + "EPHEMERAL": 4, +} + +var RetentionPolicyTypeRevMap = map[RetentionPolicyType]string{ + 0: "NONE", + 1: "RETAIN", + 2: "EXPIRE", + 3: "INHERIT", + 4: "EPHEMERAL", +} + +func (e RetentionPolicyType) String() string { + if v, ok := RetentionPolicyTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type RetentionPolicy struct { + Typ__ RetentionPolicyType `codec:"typ" json:"typ"` + Retain__ *RpRetain `codec:"retain,omitempty" json:"retain,omitempty"` + Expire__ *RpExpire `codec:"expire,omitempty" json:"expire,omitempty"` + Inherit__ *RpInherit `codec:"inherit,omitempty" json:"inherit,omitempty"` + Ephemeral__ *RpEphemeral `codec:"ephemeral,omitempty" json:"ephemeral,omitempty"` +} + +func (o *RetentionPolicy) Typ() (ret RetentionPolicyType, err error) { + switch o.Typ__ { + case RetentionPolicyType_RETAIN: + if o.Retain__ == nil { + err = errors.New("unexpected nil value for Retain__") + return ret, err + } + case RetentionPolicyType_EXPIRE: + if o.Expire__ == nil { + err = errors.New("unexpected nil value for Expire__") + return ret, err + } + case RetentionPolicyType_INHERIT: + if o.Inherit__ == nil { + err = errors.New("unexpected nil value for Inherit__") + return ret, err + } + case RetentionPolicyType_EPHEMERAL: + if o.Ephemeral__ == nil { + err = errors.New("unexpected nil value for Ephemeral__") + return ret, err + } + } + return o.Typ__, nil +} + +func (o RetentionPolicy) Retain() (res RpRetain) { + if o.Typ__ != RetentionPolicyType_RETAIN { + panic("wrong case accessed") + } + if o.Retain__ == nil { + return + } + return *o.Retain__ +} + +func (o RetentionPolicy) Expire() (res RpExpire) { + if o.Typ__ != RetentionPolicyType_EXPIRE { + panic("wrong case accessed") + } + if o.Expire__ == nil { + return + } + return *o.Expire__ +} + +func (o RetentionPolicy) Inherit() (res RpInherit) { + if o.Typ__ != RetentionPolicyType_INHERIT { + panic("wrong case accessed") + } + if o.Inherit__ == nil { + return + } + return *o.Inherit__ +} + +func (o RetentionPolicy) Ephemeral() (res RpEphemeral) { + if o.Typ__ != RetentionPolicyType_EPHEMERAL { + panic("wrong case accessed") + } + if o.Ephemeral__ == nil { + return + } + return *o.Ephemeral__ +} + +func NewRetentionPolicyWithRetain(v RpRetain) RetentionPolicy { + return RetentionPolicy{ + Typ__: RetentionPolicyType_RETAIN, + Retain__: &v, + } +} + +func NewRetentionPolicyWithExpire(v RpExpire) RetentionPolicy { + return RetentionPolicy{ + Typ__: RetentionPolicyType_EXPIRE, + Expire__: &v, + } +} + +func NewRetentionPolicyWithInherit(v RpInherit) RetentionPolicy { + return RetentionPolicy{ + Typ__: RetentionPolicyType_INHERIT, + Inherit__: &v, + } +} + +func NewRetentionPolicyWithEphemeral(v RpEphemeral) RetentionPolicy { + return RetentionPolicy{ + Typ__: RetentionPolicyType_EPHEMERAL, + Ephemeral__: &v, + } +} + +func (o RetentionPolicy) DeepCopy() RetentionPolicy { + return RetentionPolicy{ + Typ__: o.Typ__.DeepCopy(), + Retain__: (func(x *RpRetain) *RpRetain { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Retain__), + Expire__: (func(x *RpExpire) *RpExpire { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Expire__), + Inherit__: (func(x *RpInherit) *RpInherit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Inherit__), + Ephemeral__: (func(x *RpEphemeral) *RpEphemeral { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Ephemeral__), + } +} + +type RpRetain struct { +} + +func (o RpRetain) DeepCopy() RpRetain { + return RpRetain{} +} + +type RpExpire struct { + Age gregor1.DurationSec `codec:"age" json:"age"` +} + +func (o RpExpire) DeepCopy() RpExpire { + return RpExpire{ + Age: o.Age.DeepCopy(), + } +} + +type RpInherit struct { +} + +func (o RpInherit) DeepCopy() RpInherit { + return RpInherit{} +} + +type RpEphemeral struct { + Age gregor1.DurationSec `codec:"age" json:"age"` +} + +func (o RpEphemeral) DeepCopy() RpEphemeral { + return RpEphemeral{ + Age: o.Age.DeepCopy(), + } +} + +type GetThreadReason int + +const ( + GetThreadReason_GENERAL GetThreadReason = 0 + GetThreadReason_PUSH GetThreadReason = 1 + GetThreadReason_FOREGROUND GetThreadReason = 2 + GetThreadReason_BACKGROUNDCONVLOAD GetThreadReason = 3 + GetThreadReason_FIXRETRY GetThreadReason = 4 + GetThreadReason_PREPARE GetThreadReason = 5 + GetThreadReason_SEARCHER GetThreadReason = 6 + GetThreadReason_INDEXED_SEARCH GetThreadReason = 7 + GetThreadReason_KBFSFILEACTIVITY GetThreadReason = 8 + GetThreadReason_COINFLIP GetThreadReason = 9 + GetThreadReason_BOTCOMMANDS GetThreadReason = 10 +) + +func (o GetThreadReason) DeepCopy() GetThreadReason { return o } + +var GetThreadReasonMap = map[string]GetThreadReason{ + "GENERAL": 0, + "PUSH": 1, + "FOREGROUND": 2, + "BACKGROUNDCONVLOAD": 3, + "FIXRETRY": 4, + "PREPARE": 5, + "SEARCHER": 6, + "INDEXED_SEARCH": 7, + "KBFSFILEACTIVITY": 8, + "COINFLIP": 9, + "BOTCOMMANDS": 10, +} + +var GetThreadReasonRevMap = map[GetThreadReason]string{ + 0: "GENERAL", + 1: "PUSH", + 2: "FOREGROUND", + 3: "BACKGROUNDCONVLOAD", + 4: "FIXRETRY", + 5: "PREPARE", + 6: "SEARCHER", + 7: "INDEXED_SEARCH", + 8: "KBFSFILEACTIVITY", + 9: "COINFLIP", + 10: "BOTCOMMANDS", +} + +func (e GetThreadReason) String() string { + if v, ok := GetThreadReasonRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ReIndexingMode int + +const ( + ReIndexingMode_NONE ReIndexingMode = 0 + ReIndexingMode_PRESEARCH_SYNC ReIndexingMode = 1 + ReIndexingMode_POSTSEARCH_SYNC ReIndexingMode = 2 +) + +func (o ReIndexingMode) DeepCopy() ReIndexingMode { return o } + +var ReIndexingModeMap = map[string]ReIndexingMode{ + "NONE": 0, + "PRESEARCH_SYNC": 1, + "POSTSEARCH_SYNC": 2, +} + +var ReIndexingModeRevMap = map[ReIndexingMode]string{ + 0: "NONE", + 1: "PRESEARCH_SYNC", + 2: "POSTSEARCH_SYNC", +} + +func (e ReIndexingMode) String() string { + if v, ok := ReIndexingModeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type SearchOpts struct { + IsRegex bool `codec:"isRegex" json:"isRegex"` + SentBy string `codec:"sentBy" json:"sentBy"` + SentTo string `codec:"sentTo" json:"sentTo"` + MatchMentions bool `codec:"matchMentions" json:"matchMentions"` + SentBefore gregor1.Time `codec:"sentBefore" json:"sentBefore"` + SentAfter gregor1.Time `codec:"sentAfter" json:"sentAfter"` + MaxHits int `codec:"maxHits" json:"maxHits"` + MaxMessages int `codec:"maxMessages" json:"maxMessages"` + BeforeContext int `codec:"beforeContext" json:"beforeContext"` + AfterContext int `codec:"afterContext" json:"afterContext"` + InitialPagination *Pagination `codec:"initialPagination,omitempty" json:"initialPagination,omitempty"` + ReindexMode ReIndexingMode `codec:"reindexMode" json:"reindexMode"` + MaxConvsSearched int `codec:"maxConvsSearched" json:"maxConvsSearched"` + MaxConvsHit int `codec:"maxConvsHit" json:"maxConvsHit"` + ConvID *ConversationID `codec:"convID,omitempty" json:"convID,omitempty"` + MaxNameConvs int `codec:"maxNameConvs" json:"maxNameConvs"` +} + +func (o SearchOpts) DeepCopy() SearchOpts { + return SearchOpts{ + IsRegex: o.IsRegex, + SentBy: o.SentBy, + SentTo: o.SentTo, + MatchMentions: o.MatchMentions, + SentBefore: o.SentBefore.DeepCopy(), + SentAfter: o.SentAfter.DeepCopy(), + MaxHits: o.MaxHits, + MaxMessages: o.MaxMessages, + BeforeContext: o.BeforeContext, + AfterContext: o.AfterContext, + InitialPagination: (func(x *Pagination) *Pagination { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.InitialPagination), + ReindexMode: o.ReindexMode.DeepCopy(), + MaxConvsSearched: o.MaxConvsSearched, + MaxConvsHit: o.MaxConvsHit, + ConvID: (func(x *ConversationID) *ConversationID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ConvID), + MaxNameConvs: o.MaxNameConvs, + } +} + +type EmptyStruct struct { +} + +func (o EmptyStruct) DeepCopy() EmptyStruct { + return EmptyStruct{} +} + +type ChatSearchMatch struct { + StartIndex int `codec:"startIndex" json:"startIndex"` + EndIndex int `codec:"endIndex" json:"endIndex"` + Match string `codec:"match" json:"match"` +} + +func (o ChatSearchMatch) DeepCopy() ChatSearchMatch { + return ChatSearchMatch{ + StartIndex: o.StartIndex, + EndIndex: o.EndIndex, + Match: o.Match, + } +} + +type ChatSearchHit struct { + BeforeMessages []UIMessage `codec:"beforeMessages" json:"beforeMessages"` + HitMessage UIMessage `codec:"hitMessage" json:"hitMessage"` + AfterMessages []UIMessage `codec:"afterMessages" json:"afterMessages"` + Matches []ChatSearchMatch `codec:"matches" json:"matches"` +} + +func (o ChatSearchHit) DeepCopy() ChatSearchHit { + return ChatSearchHit{ + BeforeMessages: (func(x []UIMessage) []UIMessage { + if x == nil { + return nil + } + ret := make([]UIMessage, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.BeforeMessages), + HitMessage: o.HitMessage.DeepCopy(), + AfterMessages: (func(x []UIMessage) []UIMessage { + if x == nil { + return nil + } + ret := make([]UIMessage, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.AfterMessages), + Matches: (func(x []ChatSearchMatch) []ChatSearchMatch { + if x == nil { + return nil + } + ret := make([]ChatSearchMatch, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Matches), + } +} + +type ChatSearchInboxHit struct { + ConvID ConversationID `codec:"convID" json:"convID"` + TeamType TeamType `codec:"teamType" json:"teamType"` + ConvName string `codec:"convName" json:"convName"` + Query string `codec:"query" json:"query"` + Time gregor1.Time `codec:"time" json:"time"` + Hits []ChatSearchHit `codec:"hits" json:"hits"` +} + +func (o ChatSearchInboxHit) DeepCopy() ChatSearchInboxHit { + return ChatSearchInboxHit{ + ConvID: o.ConvID.DeepCopy(), + TeamType: o.TeamType.DeepCopy(), + ConvName: o.ConvName, + Query: o.Query, + Time: o.Time.DeepCopy(), + Hits: (func(x []ChatSearchHit) []ChatSearchHit { + if x == nil { + return nil + } + ret := make([]ChatSearchHit, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Hits), + } +} + +type ChatSearchInboxResults struct { + Hits []ChatSearchInboxHit `codec:"hits" json:"hits"` + PercentIndexed int `codec:"percentIndexed" json:"percentIndexed"` +} + +func (o ChatSearchInboxResults) DeepCopy() ChatSearchInboxResults { + return ChatSearchInboxResults{ + Hits: (func(x []ChatSearchInboxHit) []ChatSearchInboxHit { + if x == nil { + return nil + } + ret := make([]ChatSearchInboxHit, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Hits), + PercentIndexed: o.PercentIndexed, + } +} + +type ChatSearchInboxDone struct { + NumHits int `codec:"numHits" json:"numHits"` + NumConvs int `codec:"numConvs" json:"numConvs"` + PercentIndexed int `codec:"percentIndexed" json:"percentIndexed"` + Delegated bool `codec:"delegated" json:"delegated"` +} + +func (o ChatSearchInboxDone) DeepCopy() ChatSearchInboxDone { + return ChatSearchInboxDone{ + NumHits: o.NumHits, + NumConvs: o.NumConvs, + PercentIndexed: o.PercentIndexed, + Delegated: o.Delegated, + } +} + +type ChatSearchIndexStatus struct { + PercentIndexed int `codec:"percentIndexed" json:"percentIndexed"` +} + +func (o ChatSearchIndexStatus) DeepCopy() ChatSearchIndexStatus { + return ChatSearchIndexStatus{ + PercentIndexed: o.PercentIndexed, + } +} + +type AssetMetadataImage struct { + Width int `codec:"width" json:"width"` + Height int `codec:"height" json:"height"` + AudioAmps []float64 `codec:"audioAmps" json:"audioAmps"` +} + +func (o AssetMetadataImage) DeepCopy() AssetMetadataImage { + return AssetMetadataImage{ + Width: o.Width, + Height: o.Height, + AudioAmps: (func(x []float64) []float64 { + if x == nil { + return nil + } + ret := make([]float64, len(x)) + for i, v := range x { + vCopy := v + ret[i] = vCopy + } + return ret + })(o.AudioAmps), + } +} + +type AssetMetadataVideo struct { + Width int `codec:"width" json:"width"` + Height int `codec:"height" json:"height"` + DurationMs int `codec:"durationMs" json:"durationMs"` + IsAudio bool `codec:"isAudio" json:"isAudio"` +} + +func (o AssetMetadataVideo) DeepCopy() AssetMetadataVideo { + return AssetMetadataVideo{ + Width: o.Width, + Height: o.Height, + DurationMs: o.DurationMs, + IsAudio: o.IsAudio, + } +} + +type AssetMetadataType int + +const ( + AssetMetadataType_NONE AssetMetadataType = 0 + AssetMetadataType_IMAGE AssetMetadataType = 1 + AssetMetadataType_VIDEO AssetMetadataType = 2 +) + +func (o AssetMetadataType) DeepCopy() AssetMetadataType { return o } + +var AssetMetadataTypeMap = map[string]AssetMetadataType{ + "NONE": 0, + "IMAGE": 1, + "VIDEO": 2, +} + +var AssetMetadataTypeRevMap = map[AssetMetadataType]string{ + 0: "NONE", + 1: "IMAGE", + 2: "VIDEO", +} + +type AssetMetadata struct { + AssetType__ AssetMetadataType `codec:"assetType" json:"assetType"` + Image__ *AssetMetadataImage `codec:"image,omitempty" json:"image,omitempty"` + Video__ *AssetMetadataVideo `codec:"video,omitempty" json:"video,omitempty"` +} + +func (o *AssetMetadata) AssetType() (ret AssetMetadataType, err error) { + switch o.AssetType__ { + case AssetMetadataType_IMAGE: + if o.Image__ == nil { + err = errors.New("unexpected nil value for Image__") + return ret, err + } + case AssetMetadataType_VIDEO: + if o.Video__ == nil { + err = errors.New("unexpected nil value for Video__") + return ret, err + } + } + return o.AssetType__, nil +} + +func (o AssetMetadata) Image() (res AssetMetadataImage) { + if o.AssetType__ != AssetMetadataType_IMAGE { + panic("wrong case accessed") + } + if o.Image__ == nil { + return + } + return *o.Image__ +} + +func (o AssetMetadata) Video() (res AssetMetadataVideo) { + if o.AssetType__ != AssetMetadataType_VIDEO { + panic("wrong case accessed") + } + if o.Video__ == nil { + return + } + return *o.Video__ +} + +func NewAssetMetadataWithImage(v AssetMetadataImage) AssetMetadata { + return AssetMetadata{ + AssetType__: AssetMetadataType_IMAGE, + Image__: &v, + } +} + +func NewAssetMetadataWithVideo(v AssetMetadataVideo) AssetMetadata { + return AssetMetadata{ + AssetType__: AssetMetadataType_VIDEO, + Video__: &v, + } +} + +func (o AssetMetadata) DeepCopy() AssetMetadata { + return AssetMetadata{ + AssetType__: o.AssetType__.DeepCopy(), + Image__: (func(x *AssetMetadataImage) *AssetMetadataImage { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Image__), + Video__: (func(x *AssetMetadataVideo) *AssetMetadataVideo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Video__), + } +} + +type AssetTag int + +const ( + AssetTag_PRIMARY AssetTag = 0 +) + +func (o AssetTag) DeepCopy() AssetTag { return o } + +var AssetTagMap = map[string]AssetTag{ + "PRIMARY": 0, +} + +var AssetTagRevMap = map[AssetTag]string{ + 0: "PRIMARY", +} + +type Asset struct { + Filename string `codec:"filename" json:"filename"` + Region string `codec:"region" json:"region"` + Endpoint string `codec:"endpoint" json:"endpoint"` + Bucket string `codec:"bucket" json:"bucket"` + Path string `codec:"path" json:"path"` + Size int64 `codec:"size" json:"size"` + MimeType string `codec:"mimeType" json:"mimeType"` + EncHash Hash `codec:"encHash" json:"encHash"` + Key []byte `codec:"key" json:"key"` + VerifyKey []byte `codec:"verifyKey" json:"verifyKey"` + Title string `codec:"title" json:"title"` + Nonce []byte `codec:"nonce" json:"nonce"` + Metadata AssetMetadata `codec:"metadata" json:"metadata"` + Tag AssetTag `codec:"tag" json:"tag"` +} + +func (o Asset) DeepCopy() Asset { + return Asset{ + Filename: o.Filename, + Region: o.Region, + Endpoint: o.Endpoint, + Bucket: o.Bucket, + Path: o.Path, + Size: o.Size, + MimeType: o.MimeType, + EncHash: o.EncHash.DeepCopy(), + Key: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.Key), + VerifyKey: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.VerifyKey), + Title: o.Title, + Nonce: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.Nonce), + Metadata: o.Metadata.DeepCopy(), + Tag: o.Tag.DeepCopy(), + } +} + +type BotCommandsAdvertisementTyp int + +const ( + BotCommandsAdvertisementTyp_PUBLIC BotCommandsAdvertisementTyp = 0 + BotCommandsAdvertisementTyp_TLFID_MEMBERS BotCommandsAdvertisementTyp = 1 + BotCommandsAdvertisementTyp_TLFID_CONVS BotCommandsAdvertisementTyp = 2 +) + +func (o BotCommandsAdvertisementTyp) DeepCopy() BotCommandsAdvertisementTyp { return o } + +var BotCommandsAdvertisementTypMap = map[string]BotCommandsAdvertisementTyp{ + "PUBLIC": 0, + "TLFID_MEMBERS": 1, + "TLFID_CONVS": 2, +} + +var BotCommandsAdvertisementTypRevMap = map[BotCommandsAdvertisementTyp]string{ + 0: "PUBLIC", + 1: "TLFID_MEMBERS", + 2: "TLFID_CONVS", +} + +func (e BotCommandsAdvertisementTyp) String() string { + if v, ok := BotCommandsAdvertisementTypRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type TeamMember struct { + Uid gregor1.UID `codec:"uid" json:"uid"` + Role keybase1.TeamRole `codec:"role" json:"role"` + Status keybase1.TeamMemberStatus `codec:"status" json:"status"` +} + +func (o TeamMember) DeepCopy() TeamMember { + return TeamMember{ + Uid: o.Uid.DeepCopy(), + Role: o.Role.DeepCopy(), + Status: o.Status.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..30e78484 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/gregor.go @@ -0,0 +1,548 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/chat1/gregor.avdl + +package chat1 + +import ( + gregor1 "github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1" + keybase1 "github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1" +) + +type GenericPayload struct { + Action string `codec:"Action" json:"Action"` + InboxVers InboxVers `codec:"inboxVers" json:"inboxVers"` + ConvID ConversationID `codec:"convID" json:"convID"` + TopicType TopicType `codec:"topicType" json:"topicType"` + UnreadUpdate *UnreadUpdate `codec:"unreadUpdate,omitempty" json:"unreadUpdate,omitempty"` +} + +func (o GenericPayload) DeepCopy() GenericPayload { + return GenericPayload{ + Action: o.Action, + InboxVers: o.InboxVers.DeepCopy(), + ConvID: o.ConvID.DeepCopy(), + TopicType: o.TopicType.DeepCopy(), + UnreadUpdate: (func(x *UnreadUpdate) *UnreadUpdate { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.UnreadUpdate), + } +} + +type NewConversationPayload struct { + Action string `codec:"Action" json:"Action"` + ConvID ConversationID `codec:"convID" json:"convID"` + InboxVers InboxVers `codec:"inboxVers" json:"inboxVers"` + TopicType TopicType `codec:"topicType" json:"topicType"` + UnreadUpdate *UnreadUpdate `codec:"unreadUpdate,omitempty" json:"unreadUpdate,omitempty"` +} + +func (o NewConversationPayload) DeepCopy() NewConversationPayload { + return NewConversationPayload{ + Action: o.Action, + ConvID: o.ConvID.DeepCopy(), + InboxVers: o.InboxVers.DeepCopy(), + TopicType: o.TopicType.DeepCopy(), + UnreadUpdate: (func(x *UnreadUpdate) *UnreadUpdate { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.UnreadUpdate), + } +} + +type NewMessagePayload struct { + Action string `codec:"Action" json:"Action"` + ConvID ConversationID `codec:"convID" json:"convID"` + Message MessageBoxed `codec:"message" json:"message"` + InboxVers InboxVers `codec:"inboxVers" json:"inboxVers"` + TopicType TopicType `codec:"topicType" json:"topicType"` + UnreadUpdate *UnreadUpdate `codec:"unreadUpdate,omitempty" json:"unreadUpdate,omitempty"` + UntrustedTeamRole keybase1.TeamRole `codec:"untrustedTeamRole" json:"untrustedTeamRole"` + MaxMsgs []MessageSummary `codec:"maxMsgs" json:"maxMsgs"` +} + +func (o NewMessagePayload) DeepCopy() NewMessagePayload { + return NewMessagePayload{ + Action: o.Action, + ConvID: o.ConvID.DeepCopy(), + Message: o.Message.DeepCopy(), + InboxVers: o.InboxVers.DeepCopy(), + TopicType: o.TopicType.DeepCopy(), + UnreadUpdate: (func(x *UnreadUpdate) *UnreadUpdate { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.UnreadUpdate), + UntrustedTeamRole: o.UntrustedTeamRole.DeepCopy(), + MaxMsgs: (func(x []MessageSummary) []MessageSummary { + if x == nil { + return nil + } + ret := make([]MessageSummary, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.MaxMsgs), + } +} + +type ReadMessagePayload struct { + Action string `codec:"Action" json:"Action"` + ConvID ConversationID `codec:"convID" json:"convID"` + MsgID MessageID `codec:"msgID" json:"msgID"` + InboxVers InboxVers `codec:"inboxVers" json:"inboxVers"` + TopicType TopicType `codec:"topicType" json:"topicType"` + UnreadUpdate *UnreadUpdate `codec:"unreadUpdate,omitempty" json:"unreadUpdate,omitempty"` +} + +func (o ReadMessagePayload) DeepCopy() ReadMessagePayload { + return ReadMessagePayload{ + Action: o.Action, + ConvID: o.ConvID.DeepCopy(), + MsgID: o.MsgID.DeepCopy(), + InboxVers: o.InboxVers.DeepCopy(), + TopicType: o.TopicType.DeepCopy(), + UnreadUpdate: (func(x *UnreadUpdate) *UnreadUpdate { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.UnreadUpdate), + } +} + +type SetStatusPayload struct { + Action string `codec:"Action" json:"Action"` + ConvID ConversationID `codec:"convID" json:"convID"` + Status ConversationStatus `codec:"status" json:"status"` + InboxVers InboxVers `codec:"inboxVers" json:"inboxVers"` + TopicType TopicType `codec:"topicType" json:"topicType"` + UnreadUpdate *UnreadUpdate `codec:"unreadUpdate,omitempty" json:"unreadUpdate,omitempty"` +} + +func (o SetStatusPayload) DeepCopy() SetStatusPayload { + return SetStatusPayload{ + Action: o.Action, + ConvID: o.ConvID.DeepCopy(), + Status: o.Status.DeepCopy(), + InboxVers: o.InboxVers.DeepCopy(), + TopicType: o.TopicType.DeepCopy(), + UnreadUpdate: (func(x *UnreadUpdate) *UnreadUpdate { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.UnreadUpdate), + } +} + +type TeamTypePayload struct { + Action string `codec:"Action" json:"Action"` + ConvID ConversationID `codec:"convID" json:"convID"` + TeamType TeamType `codec:"teamType" json:"teamType"` + InboxVers InboxVers `codec:"inboxVers" json:"inboxVers"` + TopicType TopicType `codec:"topicType" json:"topicType"` + UnreadUpdate *UnreadUpdate `codec:"unreadUpdate,omitempty" json:"unreadUpdate,omitempty"` +} + +func (o TeamTypePayload) DeepCopy() TeamTypePayload { + return TeamTypePayload{ + Action: o.Action, + ConvID: o.ConvID.DeepCopy(), + TeamType: o.TeamType.DeepCopy(), + InboxVers: o.InboxVers.DeepCopy(), + TopicType: o.TopicType.DeepCopy(), + UnreadUpdate: (func(x *UnreadUpdate) *UnreadUpdate { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.UnreadUpdate), + } +} + +type SetAppNotificationSettingsPayload struct { + Action string `codec:"Action" json:"Action"` + ConvID ConversationID `codec:"convID" json:"convID"` + InboxVers InboxVers `codec:"inboxVers" json:"inboxVers"` + Settings ConversationNotificationInfo `codec:"settings" json:"settings"` + TopicType TopicType `codec:"topicType" json:"topicType"` + UnreadUpdate *UnreadUpdate `codec:"unreadUpdate,omitempty" json:"unreadUpdate,omitempty"` +} + +func (o SetAppNotificationSettingsPayload) DeepCopy() SetAppNotificationSettingsPayload { + return SetAppNotificationSettingsPayload{ + Action: o.Action, + ConvID: o.ConvID.DeepCopy(), + InboxVers: o.InboxVers.DeepCopy(), + Settings: o.Settings.DeepCopy(), + TopicType: o.TopicType.DeepCopy(), + UnreadUpdate: (func(x *UnreadUpdate) *UnreadUpdate { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.UnreadUpdate), + } +} + +type ExpungePayload struct { + Action string `codec:"Action" json:"Action"` + ConvID ConversationID `codec:"convID" json:"convID"` + InboxVers InboxVers `codec:"inboxVers" json:"inboxVers"` + Expunge Expunge `codec:"expunge" json:"expunge"` + MaxMsgs []MessageSummary `codec:"maxMsgs" json:"maxMsgs"` + TopicType TopicType `codec:"topicType" json:"topicType"` + UnreadUpdate *UnreadUpdate `codec:"unreadUpdate,omitempty" json:"unreadUpdate,omitempty"` +} + +func (o ExpungePayload) DeepCopy() ExpungePayload { + return ExpungePayload{ + Action: o.Action, + ConvID: o.ConvID.DeepCopy(), + InboxVers: o.InboxVers.DeepCopy(), + Expunge: o.Expunge.DeepCopy(), + MaxMsgs: (func(x []MessageSummary) []MessageSummary { + if x == nil { + return nil + } + ret := make([]MessageSummary, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.MaxMsgs), + TopicType: o.TopicType.DeepCopy(), + UnreadUpdate: (func(x *UnreadUpdate) *UnreadUpdate { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.UnreadUpdate), + } +} + +type UnreadUpdate struct { + ConvID ConversationID `codec:"convID" json:"convID"` + UnreadMessages int `codec:"unreadMessages" json:"unreadMessages"` + UnreadNotifyingMessages map[keybase1.DeviceType]int `codec:"unreadNotifyingMessages" json:"unreadNotifyingMessages"` + CompatUnreadMessages int `codec:"UnreadMessages" json:"UnreadMessages"` + Diff bool `codec:"diff" json:"diff"` +} + +func (o UnreadUpdate) DeepCopy() UnreadUpdate { + return UnreadUpdate{ + ConvID: o.ConvID.DeepCopy(), + UnreadMessages: o.UnreadMessages, + UnreadNotifyingMessages: (func(x map[keybase1.DeviceType]int) map[keybase1.DeviceType]int { + if x == nil { + return nil + } + ret := make(map[keybase1.DeviceType]int, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v + ret[kCopy] = vCopy + } + return ret + })(o.UnreadNotifyingMessages), + CompatUnreadMessages: o.CompatUnreadMessages, + Diff: o.Diff, + } +} + +type TLFFinalizeUpdate struct { + FinalizeInfo ConversationFinalizeInfo `codec:"finalizeInfo" json:"finalizeInfo"` + ConvIDs []ConversationID `codec:"convIDs" json:"convIDs"` + InboxVers InboxVers `codec:"inboxVers" json:"inboxVers"` +} + +func (o TLFFinalizeUpdate) DeepCopy() TLFFinalizeUpdate { + return TLFFinalizeUpdate{ + FinalizeInfo: o.FinalizeInfo.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), + InboxVers: o.InboxVers.DeepCopy(), + } +} + +type TLFResolveUpdate struct { + ConvID ConversationID `codec:"convID" json:"convID"` + InboxVers InboxVers `codec:"inboxVers" json:"inboxVers"` +} + +func (o TLFResolveUpdate) DeepCopy() TLFResolveUpdate { + return TLFResolveUpdate{ + ConvID: o.ConvID.DeepCopy(), + InboxVers: o.InboxVers.DeepCopy(), + } +} + +type RemoteUserTypingUpdate struct { + Uid gregor1.UID `codec:"uid" json:"uid"` + DeviceID gregor1.DeviceID `codec:"deviceID" json:"deviceID"` + ConvID ConversationID `codec:"convID" json:"convID"` + Typing bool `codec:"typing" json:"typing"` + TeamType TeamType `codec:"t" json:"teamType"` +} + +func (o RemoteUserTypingUpdate) DeepCopy() RemoteUserTypingUpdate { + return RemoteUserTypingUpdate{ + Uid: o.Uid.DeepCopy(), + DeviceID: o.DeviceID.DeepCopy(), + ConvID: o.ConvID.DeepCopy(), + Typing: o.Typing, + TeamType: o.TeamType.DeepCopy(), + } +} + +type TeamMemberRoleUpdate struct { + TlfID TLFID `codec:"tlfID" json:"tlfID"` + Role keybase1.TeamRole `codec:"role" json:"role"` +} + +func (o TeamMemberRoleUpdate) DeepCopy() TeamMemberRoleUpdate { + return TeamMemberRoleUpdate{ + TlfID: o.TlfID.DeepCopy(), + Role: o.Role.DeepCopy(), + } +} + +type UpdateConversationMembership struct { + InboxVers InboxVers `codec:"inboxVers" json:"inboxVers"` + TeamMemberRoleUpdate *TeamMemberRoleUpdate `codec:"teamMemberRoleUpdate,omitempty" json:"teamMemberRoleUpdate,omitempty"` + Joined []ConversationMember `codec:"joined" json:"joined"` + Removed []ConversationMember `codec:"removed" json:"removed"` + Reset []ConversationMember `codec:"reset" json:"reset"` + Previewed []ConversationID `codec:"previewed" json:"previewed"` + UnreadUpdate *UnreadUpdate `codec:"unreadUpdate,omitempty" json:"unreadUpdate,omitempty"` + UnreadUpdates []UnreadUpdate `codec:"unreadUpdates" json:"unreadUpdates"` +} + +func (o UpdateConversationMembership) DeepCopy() UpdateConversationMembership { + return UpdateConversationMembership{ + InboxVers: o.InboxVers.DeepCopy(), + TeamMemberRoleUpdate: (func(x *TeamMemberRoleUpdate) *TeamMemberRoleUpdate { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.TeamMemberRoleUpdate), + Joined: (func(x []ConversationMember) []ConversationMember { + if x == nil { + return nil + } + ret := make([]ConversationMember, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Joined), + Removed: (func(x []ConversationMember) []ConversationMember { + if x == nil { + return nil + } + ret := make([]ConversationMember, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Removed), + Reset: (func(x []ConversationMember) []ConversationMember { + if x == nil { + return nil + } + ret := make([]ConversationMember, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Reset), + Previewed: (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.Previewed), + UnreadUpdate: (func(x *UnreadUpdate) *UnreadUpdate { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.UnreadUpdate), + UnreadUpdates: (func(x []UnreadUpdate) []UnreadUpdate { + if x == nil { + return nil + } + ret := make([]UnreadUpdate, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.UnreadUpdates), + } +} + +type ConversationUpdate struct { + ConvID ConversationID `codec:"convID" json:"convID"` + Existence ConversationExistence `codec:"existence" json:"existence"` +} + +func (o ConversationUpdate) DeepCopy() ConversationUpdate { + return ConversationUpdate{ + ConvID: o.ConvID.DeepCopy(), + Existence: o.Existence.DeepCopy(), + } +} + +type UpdateConversations struct { + InboxVers InboxVers `codec:"inboxVers" json:"inboxVers"` + ConvUpdates []ConversationUpdate `codec:"convUpdates" json:"convUpdates"` +} + +func (o UpdateConversations) DeepCopy() UpdateConversations { + return UpdateConversations{ + InboxVers: o.InboxVers.DeepCopy(), + ConvUpdates: (func(x []ConversationUpdate) []ConversationUpdate { + if x == nil { + return nil + } + ret := make([]ConversationUpdate, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.ConvUpdates), + } +} + +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"` + Policy RetentionPolicy `codec:"policy" json:"policy"` +} + +func (o SetConvRetentionUpdate) DeepCopy() SetConvRetentionUpdate { + return SetConvRetentionUpdate{ + InboxVers: o.InboxVers.DeepCopy(), + ConvID: o.ConvID.DeepCopy(), + Policy: o.Policy.DeepCopy(), + } +} + +type SetTeamRetentionUpdate struct { + InboxVers InboxVers `codec:"inboxVers" json:"inboxVers"` + TeamID keybase1.TeamID `codec:"teamID" json:"teamID"` + Policy RetentionPolicy `codec:"policy" json:"policy"` +} + +func (o SetTeamRetentionUpdate) DeepCopy() SetTeamRetentionUpdate { + return SetTeamRetentionUpdate{ + InboxVers: o.InboxVers.DeepCopy(), + TeamID: o.TeamID.DeepCopy(), + Policy: o.Policy.DeepCopy(), + } +} + +type SetConvSettingsUpdate struct { + InboxVers InboxVers `codec:"inboxVers" json:"inboxVers"` + ConvID ConversationID `codec:"convID" json:"convID"` + ConvSettings *ConversationSettings `codec:"convSettings,omitempty" json:"convSettings,omitempty"` +} + +func (o SetConvSettingsUpdate) DeepCopy() SetConvSettingsUpdate { + return SetConvSettingsUpdate{ + InboxVers: o.InboxVers.DeepCopy(), + ConvID: o.ConvID.DeepCopy(), + ConvSettings: (func(x *ConversationSettings) *ConversationSettings { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ConvSettings), + } +} + +type KBFSImpteamUpgradeUpdate struct { + ConvID ConversationID `codec:"convID" json:"convID"` + InboxVers InboxVers `codec:"inboxVers" json:"inboxVers"` + TopicType TopicType `codec:"topicType" json:"topicType"` +} + +func (o KBFSImpteamUpgradeUpdate) DeepCopy() KBFSImpteamUpgradeUpdate { + return KBFSImpteamUpgradeUpdate{ + ConvID: o.ConvID.DeepCopy(), + InboxVers: o.InboxVers.DeepCopy(), + TopicType: o.TopicType.DeepCopy(), + } +} + +type SubteamRenameUpdate struct { + ConvIDs []ConversationID `codec:"convIDs" json:"convIDs"` + InboxVers InboxVers `codec:"inboxVers" json:"inboxVers"` +} + +func (o SubteamRenameUpdate) DeepCopy() SubteamRenameUpdate { + return SubteamRenameUpdate{ + 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), + InboxVers: o.InboxVers.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..d9ae8815 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/local.go @@ -0,0 +1,5865 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/chat1/local.avdl + +package chat1 + +import ( + "errors" + "fmt" + + 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 VersionKind string + +func (o VersionKind) DeepCopy() VersionKind { + return o +} + +type TextPaymentResultTyp int + +const ( + TextPaymentResultTyp_SENT TextPaymentResultTyp = 0 + TextPaymentResultTyp_ERROR TextPaymentResultTyp = 1 +) + +func (o TextPaymentResultTyp) DeepCopy() TextPaymentResultTyp { return o } + +var TextPaymentResultTypMap = map[string]TextPaymentResultTyp{ + "SENT": 0, + "ERROR": 1, +} + +var TextPaymentResultTypRevMap = map[TextPaymentResultTyp]string{ + 0: "SENT", + 1: "ERROR", +} + +func (e TextPaymentResultTyp) String() string { + if v, ok := TextPaymentResultTypRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type TextPaymentResult struct { + ResultTyp__ TextPaymentResultTyp `codec:"resultTyp" json:"resultTyp"` + Error__ *string `codec:"error,omitempty" json:"error,omitempty"` + Sent__ *stellar1.PaymentID `codec:"sent,omitempty" json:"sent,omitempty"` +} + +func (o *TextPaymentResult) ResultTyp() (ret TextPaymentResultTyp, err error) { + switch o.ResultTyp__ { + case TextPaymentResultTyp_ERROR: + if o.Error__ == nil { + err = errors.New("unexpected nil value for Error__") + return ret, err + } + case TextPaymentResultTyp_SENT: + if o.Sent__ == nil { + err = errors.New("unexpected nil value for Sent__") + return ret, err + } + } + return o.ResultTyp__, nil +} + +func (o TextPaymentResult) Error() (res string) { + if o.ResultTyp__ != TextPaymentResultTyp_ERROR { + panic("wrong case accessed") + } + if o.Error__ == nil { + return + } + return *o.Error__ +} + +func (o TextPaymentResult) Sent() (res stellar1.PaymentID) { + if o.ResultTyp__ != TextPaymentResultTyp_SENT { + panic("wrong case accessed") + } + if o.Sent__ == nil { + return + } + return *o.Sent__ +} + +func NewTextPaymentResultWithError(v string) TextPaymentResult { + return TextPaymentResult{ + ResultTyp__: TextPaymentResultTyp_ERROR, + Error__: &v, + } +} + +func NewTextPaymentResultWithSent(v stellar1.PaymentID) TextPaymentResult { + return TextPaymentResult{ + ResultTyp__: TextPaymentResultTyp_SENT, + Sent__: &v, + } +} + +func (o TextPaymentResult) DeepCopy() TextPaymentResult { + return TextPaymentResult{ + ResultTyp__: o.ResultTyp__.DeepCopy(), + Error__: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Error__), + Sent__: (func(x *stellar1.PaymentID) *stellar1.PaymentID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Sent__), + } +} + +type TextPayment struct { + Username string `codec:"username" json:"username"` + PaymentText string `codec:"paymentText" json:"paymentText"` + Result TextPaymentResult `codec:"result" json:"result"` +} + +func (o TextPayment) DeepCopy() TextPayment { + return TextPayment{ + Username: o.Username, + PaymentText: o.PaymentText, + Result: o.Result.DeepCopy(), + } +} + +type KnownUserMention struct { + Text string `codec:"text" json:"text"` + Uid gregor1.UID `codec:"uid" json:"uid"` +} + +func (o KnownUserMention) DeepCopy() KnownUserMention { + return KnownUserMention{ + Text: o.Text, + Uid: o.Uid.DeepCopy(), + } +} + +type KnownTeamMention struct { + Name string `codec:"name" json:"name"` + Channel string `codec:"channel" json:"channel"` +} + +func (o KnownTeamMention) DeepCopy() KnownTeamMention { + return KnownTeamMention{ + Name: o.Name, + Channel: o.Channel, + } +} + +type MaybeMention struct { + Name string `codec:"name" json:"name"` + Channel string `codec:"channel" json:"channel"` +} + +func (o MaybeMention) DeepCopy() MaybeMention { + return MaybeMention{ + Name: o.Name, + Channel: o.Channel, + } +} + +type Coordinate struct { + Lat float64 `codec:"lat" json:"lat"` + Lon float64 `codec:"lon" json:"lon"` + Accuracy float64 `codec:"accuracy" json:"accuracy"` +} + +func (o Coordinate) DeepCopy() Coordinate { + return Coordinate{ + Lat: o.Lat, + Lon: o.Lon, + Accuracy: o.Accuracy, + } +} + +type LiveLocation struct { + EndTime gregor1.Time `codec:"endTime" json:"endTime"` +} + +func (o LiveLocation) DeepCopy() LiveLocation { + return LiveLocation{ + EndTime: o.EndTime.DeepCopy(), + } +} + +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"` +} + +func (o MessageText) DeepCopy() MessageText { + return MessageText{ + 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 *gregor1.UID) *gregor1.UID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + 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), + } +} + +type MessageConversationMetadata struct { + ConversationTitle string `codec:"conversationTitle" json:"conversationTitle"` +} + +func (o MessageConversationMetadata) DeepCopy() MessageConversationMetadata { + return MessageConversationMetadata{ + ConversationTitle: o.ConversationTitle, + } +} + +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"` +} + +func (o MessageEdit) DeepCopy() MessageEdit { + return MessageEdit{ + MessageID: o.MessageID.DeepCopy(), + Body: o.Body, + 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), + } +} + +type MessageDelete struct { + MessageIDs []MessageID `codec:"messageIDs" json:"messageIDs"` +} + +func (o MessageDelete) DeepCopy() MessageDelete { + return MessageDelete{ + MessageIDs: (func(x []MessageID) []MessageID { + if x == nil { + return nil + } + ret := make([]MessageID, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.MessageIDs), + } +} + +type MessageHeadline struct { + Headline string `codec:"headline" json:"headline"` +} + +func (o MessageHeadline) DeepCopy() MessageHeadline { + return MessageHeadline{ + Headline: o.Headline, + } +} + +type MessageFlip struct { + Text string `codec:"text" json:"text"` + GameID FlipGameID `codec:"gameID" json:"gameID"` + FlipConvID ConversationID `codec:"flipConvID" json:"flipConvID"` + UserMentions []KnownUserMention `codec:"userMentions" json:"userMentions"` + TeamMentions []KnownTeamMention `codec:"teamMentions" json:"teamMentions"` +} + +func (o MessageFlip) DeepCopy() MessageFlip { + return MessageFlip{ + Text: o.Text, + GameID: o.GameID.DeepCopy(), + FlipConvID: o.FlipConvID.DeepCopy(), + 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), + } +} + +type MessagePin struct { + MsgID MessageID `codec:"msgID" json:"msgID"` +} + +func (o MessagePin) DeepCopy() MessagePin { + return MessagePin{ + MsgID: o.MsgID.DeepCopy(), + } +} + +type MessageSystemType int + +const ( + MessageSystemType_ADDEDTOTEAM MessageSystemType = 0 + MessageSystemType_INVITEADDEDTOTEAM MessageSystemType = 1 + MessageSystemType_COMPLEXTEAM MessageSystemType = 2 + MessageSystemType_CREATETEAM MessageSystemType = 3 + MessageSystemType_GITPUSH MessageSystemType = 4 + MessageSystemType_CHANGEAVATAR MessageSystemType = 5 + MessageSystemType_CHANGERETENTION MessageSystemType = 6 + MessageSystemType_BULKADDTOCONV MessageSystemType = 7 + MessageSystemType_SBSRESOLVE MessageSystemType = 8 +) + +func (o MessageSystemType) DeepCopy() MessageSystemType { return o } + +var MessageSystemTypeMap = map[string]MessageSystemType{ + "ADDEDTOTEAM": 0, + "INVITEADDEDTOTEAM": 1, + "COMPLEXTEAM": 2, + "CREATETEAM": 3, + "GITPUSH": 4, + "CHANGEAVATAR": 5, + "CHANGERETENTION": 6, + "BULKADDTOCONV": 7, + "SBSRESOLVE": 8, +} + +var MessageSystemTypeRevMap = map[MessageSystemType]string{ + 0: "ADDEDTOTEAM", + 1: "INVITEADDEDTOTEAM", + 2: "COMPLEXTEAM", + 3: "CREATETEAM", + 4: "GITPUSH", + 5: "CHANGEAVATAR", + 6: "CHANGERETENTION", + 7: "BULKADDTOCONV", + 8: "SBSRESOLVE", +} + +func (e MessageSystemType) String() string { + if v, ok := MessageSystemTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +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"` +} + +func (o MessageSystemAddedToTeam) DeepCopy() MessageSystemAddedToTeam { + return MessageSystemAddedToTeam{ + Team: o.Team, + Adder: o.Adder, + Addee: o.Addee, + Role: o.Role.DeepCopy(), + BulkAdds: (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.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), + } +} + +type MessageSystemInviteAddedToTeam struct { + Team string `codec:"team" json:"team"` + Inviter string `codec:"inviter" json:"inviter"` + Invitee string `codec:"invitee" json:"invitee"` + Adder string `codec:"adder" json:"adder"` + InviteType keybase1.TeamInviteCategory `codec:"inviteType" json:"inviteType"` + Role keybase1.TeamRole `codec:"role" json:"role"` +} + +func (o MessageSystemInviteAddedToTeam) DeepCopy() MessageSystemInviteAddedToTeam { + return MessageSystemInviteAddedToTeam{ + Team: o.Team, + Inviter: o.Inviter, + Invitee: o.Invitee, + Adder: o.Adder, + InviteType: o.InviteType.DeepCopy(), + Role: o.Role.DeepCopy(), + } +} + +type MessageSystemComplexTeam struct { + Team string `codec:"team" json:"team"` +} + +func (o MessageSystemComplexTeam) DeepCopy() MessageSystemComplexTeam { + return MessageSystemComplexTeam{ + Team: o.Team, + } +} + +type MessageSystemCreateTeam struct { + Team string `codec:"team" json:"team"` + Creator string `codec:"creator" json:"creator"` +} + +func (o MessageSystemCreateTeam) DeepCopy() MessageSystemCreateTeam { + return MessageSystemCreateTeam{ + Team: o.Team, + Creator: o.Creator, + } +} + +type MessageSystemGitPush struct { + Team string `codec:"team" json:"team"` + Pusher string `codec:"pusher" json:"pusher"` + RepoName string `codec:"repoName" json:"repoName"` + RepoID keybase1.RepoID `codec:"repoID" json:"repoID"` + Refs []keybase1.GitRefMetadata `codec:"refs" json:"refs"` + PushType keybase1.GitPushType `codec:"pushType" json:"pushType"` + PreviousRepoName string `codec:"previousRepoName" json:"previousRepoName"` +} + +func (o MessageSystemGitPush) DeepCopy() MessageSystemGitPush { + return MessageSystemGitPush{ + Team: o.Team, + Pusher: o.Pusher, + RepoName: o.RepoName, + RepoID: o.RepoID.DeepCopy(), + Refs: (func(x []keybase1.GitRefMetadata) []keybase1.GitRefMetadata { + if x == nil { + return nil + } + ret := make([]keybase1.GitRefMetadata, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Refs), + PushType: o.PushType.DeepCopy(), + PreviousRepoName: o.PreviousRepoName, + } +} + +type MessageSystemChangeAvatar struct { + Team string `codec:"team" json:"team"` + User string `codec:"user" json:"user"` +} + +func (o MessageSystemChangeAvatar) DeepCopy() MessageSystemChangeAvatar { + return MessageSystemChangeAvatar{ + Team: o.Team, + User: o.User, + } +} + +type MessageSystemChangeRetention struct { + IsTeam bool `codec:"isTeam" json:"isTeam"` + IsInherit bool `codec:"isInherit" json:"isInherit"` + MembersType ConversationMembersType `codec:"membersType" json:"membersType"` + Policy RetentionPolicy `codec:"policy" json:"policy"` + User string `codec:"user" json:"user"` +} + +func (o MessageSystemChangeRetention) DeepCopy() MessageSystemChangeRetention { + return MessageSystemChangeRetention{ + IsTeam: o.IsTeam, + IsInherit: o.IsInherit, + MembersType: o.MembersType.DeepCopy(), + Policy: o.Policy.DeepCopy(), + User: o.User, + } +} + +type MessageSystemBulkAddToConv struct { + Usernames []string `codec:"usernames" json:"usernames"` +} + +func (o MessageSystemBulkAddToConv) DeepCopy() MessageSystemBulkAddToConv { + return MessageSystemBulkAddToConv{ + Usernames: (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.Usernames), + } +} + +type MessageSystemSbsResolve struct { + AssertionService string `codec:"assertionService" json:"assertionService"` + AssertionUsername string `codec:"assertionUsername" json:"assertionUsername"` + Prover string `codec:"prover" json:"prover"` +} + +func (o MessageSystemSbsResolve) DeepCopy() MessageSystemSbsResolve { + return MessageSystemSbsResolve{ + AssertionService: o.AssertionService, + AssertionUsername: o.AssertionUsername, + Prover: o.Prover, + } +} + +type MessageSystem struct { + SystemType__ MessageSystemType `codec:"systemType" json:"systemType"` + Addedtoteam__ *MessageSystemAddedToTeam `codec:"addedtoteam,omitempty" json:"addedtoteam,omitempty"` + Inviteaddedtoteam__ *MessageSystemInviteAddedToTeam `codec:"inviteaddedtoteam,omitempty" json:"inviteaddedtoteam,omitempty"` + Complexteam__ *MessageSystemComplexTeam `codec:"complexteam,omitempty" json:"complexteam,omitempty"` + Createteam__ *MessageSystemCreateTeam `codec:"createteam,omitempty" json:"createteam,omitempty"` + Gitpush__ *MessageSystemGitPush `codec:"gitpush,omitempty" json:"gitpush,omitempty"` + Changeavatar__ *MessageSystemChangeAvatar `codec:"changeavatar,omitempty" json:"changeavatar,omitempty"` + Changeretention__ *MessageSystemChangeRetention `codec:"changeretention,omitempty" json:"changeretention,omitempty"` + Bulkaddtoconv__ *MessageSystemBulkAddToConv `codec:"bulkaddtoconv,omitempty" json:"bulkaddtoconv,omitempty"` + Sbsresolve__ *MessageSystemSbsResolve `codec:"sbsresolve,omitempty" json:"sbsresolve,omitempty"` +} + +func (o *MessageSystem) SystemType() (ret MessageSystemType, err error) { + switch o.SystemType__ { + case MessageSystemType_ADDEDTOTEAM: + if o.Addedtoteam__ == nil { + err = errors.New("unexpected nil value for Addedtoteam__") + return ret, err + } + case MessageSystemType_INVITEADDEDTOTEAM: + if o.Inviteaddedtoteam__ == nil { + err = errors.New("unexpected nil value for Inviteaddedtoteam__") + return ret, err + } + case MessageSystemType_COMPLEXTEAM: + if o.Complexteam__ == nil { + err = errors.New("unexpected nil value for Complexteam__") + return ret, err + } + case MessageSystemType_CREATETEAM: + if o.Createteam__ == nil { + err = errors.New("unexpected nil value for Createteam__") + return ret, err + } + case MessageSystemType_GITPUSH: + if o.Gitpush__ == nil { + err = errors.New("unexpected nil value for Gitpush__") + return ret, err + } + case MessageSystemType_CHANGEAVATAR: + if o.Changeavatar__ == nil { + err = errors.New("unexpected nil value for Changeavatar__") + return ret, err + } + case MessageSystemType_CHANGERETENTION: + if o.Changeretention__ == nil { + err = errors.New("unexpected nil value for Changeretention__") + return ret, err + } + case MessageSystemType_BULKADDTOCONV: + if o.Bulkaddtoconv__ == nil { + err = errors.New("unexpected nil value for Bulkaddtoconv__") + return ret, err + } + case MessageSystemType_SBSRESOLVE: + if o.Sbsresolve__ == nil { + err = errors.New("unexpected nil value for Sbsresolve__") + return ret, err + } + } + return o.SystemType__, nil +} + +func (o MessageSystem) Addedtoteam() (res MessageSystemAddedToTeam) { + if o.SystemType__ != MessageSystemType_ADDEDTOTEAM { + panic("wrong case accessed") + } + if o.Addedtoteam__ == nil { + return + } + return *o.Addedtoteam__ +} + +func (o MessageSystem) Inviteaddedtoteam() (res MessageSystemInviteAddedToTeam) { + if o.SystemType__ != MessageSystemType_INVITEADDEDTOTEAM { + panic("wrong case accessed") + } + if o.Inviteaddedtoteam__ == nil { + return + } + return *o.Inviteaddedtoteam__ +} + +func (o MessageSystem) Complexteam() (res MessageSystemComplexTeam) { + if o.SystemType__ != MessageSystemType_COMPLEXTEAM { + panic("wrong case accessed") + } + if o.Complexteam__ == nil { + return + } + return *o.Complexteam__ +} + +func (o MessageSystem) Createteam() (res MessageSystemCreateTeam) { + if o.SystemType__ != MessageSystemType_CREATETEAM { + panic("wrong case accessed") + } + if o.Createteam__ == nil { + return + } + return *o.Createteam__ +} + +func (o MessageSystem) Gitpush() (res MessageSystemGitPush) { + if o.SystemType__ != MessageSystemType_GITPUSH { + panic("wrong case accessed") + } + if o.Gitpush__ == nil { + return + } + return *o.Gitpush__ +} + +func (o MessageSystem) Changeavatar() (res MessageSystemChangeAvatar) { + if o.SystemType__ != MessageSystemType_CHANGEAVATAR { + panic("wrong case accessed") + } + if o.Changeavatar__ == nil { + return + } + return *o.Changeavatar__ +} + +func (o MessageSystem) Changeretention() (res MessageSystemChangeRetention) { + if o.SystemType__ != MessageSystemType_CHANGERETENTION { + panic("wrong case accessed") + } + if o.Changeretention__ == nil { + return + } + return *o.Changeretention__ +} + +func (o MessageSystem) Bulkaddtoconv() (res MessageSystemBulkAddToConv) { + if o.SystemType__ != MessageSystemType_BULKADDTOCONV { + panic("wrong case accessed") + } + if o.Bulkaddtoconv__ == nil { + return + } + return *o.Bulkaddtoconv__ +} + +func (o MessageSystem) Sbsresolve() (res MessageSystemSbsResolve) { + if o.SystemType__ != MessageSystemType_SBSRESOLVE { + panic("wrong case accessed") + } + if o.Sbsresolve__ == nil { + return + } + return *o.Sbsresolve__ +} + +func NewMessageSystemWithAddedtoteam(v MessageSystemAddedToTeam) MessageSystem { + return MessageSystem{ + SystemType__: MessageSystemType_ADDEDTOTEAM, + Addedtoteam__: &v, + } +} + +func NewMessageSystemWithInviteaddedtoteam(v MessageSystemInviteAddedToTeam) MessageSystem { + return MessageSystem{ + SystemType__: MessageSystemType_INVITEADDEDTOTEAM, + Inviteaddedtoteam__: &v, + } +} + +func NewMessageSystemWithComplexteam(v MessageSystemComplexTeam) MessageSystem { + return MessageSystem{ + SystemType__: MessageSystemType_COMPLEXTEAM, + Complexteam__: &v, + } +} + +func NewMessageSystemWithCreateteam(v MessageSystemCreateTeam) MessageSystem { + return MessageSystem{ + SystemType__: MessageSystemType_CREATETEAM, + Createteam__: &v, + } +} + +func NewMessageSystemWithGitpush(v MessageSystemGitPush) MessageSystem { + return MessageSystem{ + SystemType__: MessageSystemType_GITPUSH, + Gitpush__: &v, + } +} + +func NewMessageSystemWithChangeavatar(v MessageSystemChangeAvatar) MessageSystem { + return MessageSystem{ + SystemType__: MessageSystemType_CHANGEAVATAR, + Changeavatar__: &v, + } +} + +func NewMessageSystemWithChangeretention(v MessageSystemChangeRetention) MessageSystem { + return MessageSystem{ + SystemType__: MessageSystemType_CHANGERETENTION, + Changeretention__: &v, + } +} + +func NewMessageSystemWithBulkaddtoconv(v MessageSystemBulkAddToConv) MessageSystem { + return MessageSystem{ + SystemType__: MessageSystemType_BULKADDTOCONV, + Bulkaddtoconv__: &v, + } +} + +func NewMessageSystemWithSbsresolve(v MessageSystemSbsResolve) MessageSystem { + return MessageSystem{ + SystemType__: MessageSystemType_SBSRESOLVE, + Sbsresolve__: &v, + } +} + +func (o MessageSystem) DeepCopy() MessageSystem { + return MessageSystem{ + SystemType__: o.SystemType__.DeepCopy(), + Addedtoteam__: (func(x *MessageSystemAddedToTeam) *MessageSystemAddedToTeam { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Addedtoteam__), + Inviteaddedtoteam__: (func(x *MessageSystemInviteAddedToTeam) *MessageSystemInviteAddedToTeam { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Inviteaddedtoteam__), + Complexteam__: (func(x *MessageSystemComplexTeam) *MessageSystemComplexTeam { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Complexteam__), + Createteam__: (func(x *MessageSystemCreateTeam) *MessageSystemCreateTeam { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Createteam__), + Gitpush__: (func(x *MessageSystemGitPush) *MessageSystemGitPush { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Gitpush__), + Changeavatar__: (func(x *MessageSystemChangeAvatar) *MessageSystemChangeAvatar { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Changeavatar__), + Changeretention__: (func(x *MessageSystemChangeRetention) *MessageSystemChangeRetention { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Changeretention__), + Bulkaddtoconv__: (func(x *MessageSystemBulkAddToConv) *MessageSystemBulkAddToConv { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Bulkaddtoconv__), + Sbsresolve__: (func(x *MessageSystemSbsResolve) *MessageSystemSbsResolve { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Sbsresolve__), + } +} + +type MessageDeleteHistory struct { + Upto MessageID `codec:"upto" json:"upto"` +} + +func (o MessageDeleteHistory) DeepCopy() MessageDeleteHistory { + return MessageDeleteHistory{ + Upto: o.Upto.DeepCopy(), + } +} + +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"` +} + +func (o MessageAttachment) DeepCopy() MessageAttachment { + return MessageAttachment{ + Object: o.Object.DeepCopy(), + Preview: (func(x *Asset) *Asset { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Preview), + Previews: (func(x []Asset) []Asset { + if x == nil { + return nil + } + ret := make([]Asset, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Previews), + Metadata: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.Metadata), + Uploaded: o.Uploaded, + } +} + +type MessageAttachmentUploaded struct { + MessageID MessageID `codec:"messageID" json:"messageID"` + Object Asset `codec:"object" json:"object"` + Previews []Asset `codec:"previews" json:"previews"` + Metadata []byte `codec:"metadata" json:"metadata"` +} + +func (o MessageAttachmentUploaded) DeepCopy() MessageAttachmentUploaded { + return MessageAttachmentUploaded{ + MessageID: o.MessageID.DeepCopy(), + Object: o.Object.DeepCopy(), + Previews: (func(x []Asset) []Asset { + if x == nil { + return nil + } + ret := make([]Asset, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Previews), + Metadata: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.Metadata), + } +} + +type MessageJoin struct { + Joiners []string `codec:"joiners" json:"joiners"` + Leavers []string `codec:"leavers" json:"leavers"` +} + +func (o MessageJoin) DeepCopy() MessageJoin { + return MessageJoin{ + Joiners: (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.Joiners), + Leavers: (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.Leavers), + } +} + +type MessageLeave struct { +} + +func (o MessageLeave) DeepCopy() MessageLeave { + return MessageLeave{} +} + +type MessageReaction struct { + MessageID MessageID `codec:"m" json:"m"` + Body string `codec:"b" json:"b"` +} + +func (o MessageReaction) DeepCopy() MessageReaction { + return MessageReaction{ + MessageID: o.MessageID.DeepCopy(), + Body: o.Body, + } +} + +type MessageSendPayment struct { + PaymentID stellar1.PaymentID `codec:"paymentID" json:"paymentID"` +} + +func (o MessageSendPayment) DeepCopy() MessageSendPayment { + return MessageSendPayment{ + PaymentID: o.PaymentID.DeepCopy(), + } +} + +type MessageRequestPayment struct { + RequestID stellar1.KeybaseRequestID `codec:"requestID" json:"requestID"` + Note string `codec:"note" json:"note"` +} + +func (o MessageRequestPayment) DeepCopy() MessageRequestPayment { + return MessageRequestPayment{ + RequestID: o.RequestID.DeepCopy(), + Note: o.Note, + } +} + +type MessageUnfurl struct { + Unfurl UnfurlResult `codec:"unfurl" json:"unfurl"` + MessageID MessageID `codec:"messageID" json:"messageID"` +} + +func (o MessageUnfurl) DeepCopy() MessageUnfurl { + return MessageUnfurl{ + Unfurl: o.Unfurl.DeepCopy(), + MessageID: o.MessageID.DeepCopy(), + } +} + +type MessageBody struct { + MessageType__ MessageType `codec:"messageType" json:"messageType"` + Text__ *MessageText `codec:"text,omitempty" json:"text,omitempty"` + Attachment__ *MessageAttachment `codec:"attachment,omitempty" json:"attachment,omitempty"` + Edit__ *MessageEdit `codec:"edit,omitempty" json:"edit,omitempty"` + Delete__ *MessageDelete `codec:"delete,omitempty" json:"delete,omitempty"` + Metadata__ *MessageConversationMetadata `codec:"metadata,omitempty" json:"metadata,omitempty"` + Headline__ *MessageHeadline `codec:"headline,omitempty" json:"headline,omitempty"` + Attachmentuploaded__ *MessageAttachmentUploaded `codec:"attachmentuploaded,omitempty" json:"attachmentuploaded,omitempty"` + Join__ *MessageJoin `codec:"join,omitempty" json:"join,omitempty"` + Leave__ *MessageLeave `codec:"leave,omitempty" json:"leave,omitempty"` + System__ *MessageSystem `codec:"system,omitempty" json:"system,omitempty"` + Deletehistory__ *MessageDeleteHistory `codec:"deletehistory,omitempty" json:"deletehistory,omitempty"` + Reaction__ *MessageReaction `codec:"reaction,omitempty" json:"reaction,omitempty"` + Sendpayment__ *MessageSendPayment `codec:"sendpayment,omitempty" json:"sendpayment,omitempty"` + Requestpayment__ *MessageRequestPayment `codec:"requestpayment,omitempty" json:"requestpayment,omitempty"` + Unfurl__ *MessageUnfurl `codec:"unfurl,omitempty" json:"unfurl,omitempty"` + Flip__ *MessageFlip `codec:"flip,omitempty" json:"flip,omitempty"` + Pin__ *MessagePin `codec:"pin,omitempty" json:"pin,omitempty"` +} + +func (o *MessageBody) MessageType() (ret MessageType, err error) { + switch o.MessageType__ { + case MessageType_TEXT: + if o.Text__ == nil { + err = errors.New("unexpected nil value for Text__") + return ret, err + } + case MessageType_ATTACHMENT: + if o.Attachment__ == nil { + err = errors.New("unexpected nil value for Attachment__") + return ret, err + } + case MessageType_EDIT: + if o.Edit__ == nil { + err = errors.New("unexpected nil value for Edit__") + return ret, err + } + case MessageType_DELETE: + if o.Delete__ == nil { + err = errors.New("unexpected nil value for Delete__") + return ret, err + } + case MessageType_METADATA: + if o.Metadata__ == nil { + err = errors.New("unexpected nil value for Metadata__") + return ret, err + } + case MessageType_HEADLINE: + if o.Headline__ == nil { + err = errors.New("unexpected nil value for Headline__") + return ret, err + } + case MessageType_ATTACHMENTUPLOADED: + if o.Attachmentuploaded__ == nil { + err = errors.New("unexpected nil value for Attachmentuploaded__") + return ret, err + } + case MessageType_JOIN: + if o.Join__ == nil { + err = errors.New("unexpected nil value for Join__") + return ret, err + } + case MessageType_LEAVE: + if o.Leave__ == nil { + err = errors.New("unexpected nil value for Leave__") + return ret, err + } + case MessageType_SYSTEM: + if o.System__ == nil { + err = errors.New("unexpected nil value for System__") + return ret, err + } + case MessageType_DELETEHISTORY: + if o.Deletehistory__ == nil { + err = errors.New("unexpected nil value for Deletehistory__") + return ret, err + } + case MessageType_REACTION: + if o.Reaction__ == nil { + err = errors.New("unexpected nil value for Reaction__") + return ret, err + } + case MessageType_SENDPAYMENT: + if o.Sendpayment__ == nil { + err = errors.New("unexpected nil value for Sendpayment__") + return ret, err + } + case MessageType_REQUESTPAYMENT: + if o.Requestpayment__ == nil { + err = errors.New("unexpected nil value for Requestpayment__") + return ret, err + } + case MessageType_UNFURL: + if o.Unfurl__ == nil { + err = errors.New("unexpected nil value for Unfurl__") + return ret, err + } + case MessageType_FLIP: + if o.Flip__ == nil { + err = errors.New("unexpected nil value for Flip__") + return ret, err + } + case MessageType_PIN: + if o.Pin__ == nil { + err = errors.New("unexpected nil value for Pin__") + return ret, err + } + } + return o.MessageType__, nil +} + +func (o MessageBody) Text() (res MessageText) { + if o.MessageType__ != MessageType_TEXT { + panic("wrong case accessed") + } + if o.Text__ == nil { + return + } + return *o.Text__ +} + +func (o MessageBody) Attachment() (res MessageAttachment) { + if o.MessageType__ != MessageType_ATTACHMENT { + panic("wrong case accessed") + } + if o.Attachment__ == nil { + return + } + return *o.Attachment__ +} + +func (o MessageBody) Edit() (res MessageEdit) { + if o.MessageType__ != MessageType_EDIT { + panic("wrong case accessed") + } + if o.Edit__ == nil { + return + } + return *o.Edit__ +} + +func (o MessageBody) Delete() (res MessageDelete) { + if o.MessageType__ != MessageType_DELETE { + panic("wrong case accessed") + } + if o.Delete__ == nil { + return + } + return *o.Delete__ +} + +func (o MessageBody) Metadata() (res MessageConversationMetadata) { + if o.MessageType__ != MessageType_METADATA { + panic("wrong case accessed") + } + if o.Metadata__ == nil { + return + } + return *o.Metadata__ +} + +func (o MessageBody) Headline() (res MessageHeadline) { + if o.MessageType__ != MessageType_HEADLINE { + panic("wrong case accessed") + } + if o.Headline__ == nil { + return + } + return *o.Headline__ +} + +func (o MessageBody) Attachmentuploaded() (res MessageAttachmentUploaded) { + if o.MessageType__ != MessageType_ATTACHMENTUPLOADED { + panic("wrong case accessed") + } + if o.Attachmentuploaded__ == nil { + return + } + return *o.Attachmentuploaded__ +} + +func (o MessageBody) Join() (res MessageJoin) { + if o.MessageType__ != MessageType_JOIN { + panic("wrong case accessed") + } + if o.Join__ == nil { + return + } + return *o.Join__ +} + +func (o MessageBody) Leave() (res MessageLeave) { + if o.MessageType__ != MessageType_LEAVE { + panic("wrong case accessed") + } + if o.Leave__ == nil { + return + } + return *o.Leave__ +} + +func (o MessageBody) System() (res MessageSystem) { + if o.MessageType__ != MessageType_SYSTEM { + panic("wrong case accessed") + } + if o.System__ == nil { + return + } + return *o.System__ +} + +func (o MessageBody) Deletehistory() (res MessageDeleteHistory) { + if o.MessageType__ != MessageType_DELETEHISTORY { + panic("wrong case accessed") + } + if o.Deletehistory__ == nil { + return + } + return *o.Deletehistory__ +} + +func (o MessageBody) Reaction() (res MessageReaction) { + if o.MessageType__ != MessageType_REACTION { + panic("wrong case accessed") + } + if o.Reaction__ == nil { + return + } + return *o.Reaction__ +} + +func (o MessageBody) Sendpayment() (res MessageSendPayment) { + if o.MessageType__ != MessageType_SENDPAYMENT { + panic("wrong case accessed") + } + if o.Sendpayment__ == nil { + return + } + return *o.Sendpayment__ +} + +func (o MessageBody) Requestpayment() (res MessageRequestPayment) { + if o.MessageType__ != MessageType_REQUESTPAYMENT { + panic("wrong case accessed") + } + if o.Requestpayment__ == nil { + return + } + return *o.Requestpayment__ +} + +func (o MessageBody) Unfurl() (res MessageUnfurl) { + if o.MessageType__ != MessageType_UNFURL { + panic("wrong case accessed") + } + if o.Unfurl__ == nil { + return + } + return *o.Unfurl__ +} + +func (o MessageBody) Flip() (res MessageFlip) { + if o.MessageType__ != MessageType_FLIP { + panic("wrong case accessed") + } + if o.Flip__ == nil { + return + } + return *o.Flip__ +} + +func (o MessageBody) Pin() (res MessagePin) { + if o.MessageType__ != MessageType_PIN { + panic("wrong case accessed") + } + if o.Pin__ == nil { + return + } + return *o.Pin__ +} + +func NewMessageBodyWithText(v MessageText) MessageBody { + return MessageBody{ + MessageType__: MessageType_TEXT, + Text__: &v, + } +} + +func NewMessageBodyWithAttachment(v MessageAttachment) MessageBody { + return MessageBody{ + MessageType__: MessageType_ATTACHMENT, + Attachment__: &v, + } +} + +func NewMessageBodyWithEdit(v MessageEdit) MessageBody { + return MessageBody{ + MessageType__: MessageType_EDIT, + Edit__: &v, + } +} + +func NewMessageBodyWithDelete(v MessageDelete) MessageBody { + return MessageBody{ + MessageType__: MessageType_DELETE, + Delete__: &v, + } +} + +func NewMessageBodyWithMetadata(v MessageConversationMetadata) MessageBody { + return MessageBody{ + MessageType__: MessageType_METADATA, + Metadata__: &v, + } +} + +func NewMessageBodyWithHeadline(v MessageHeadline) MessageBody { + return MessageBody{ + MessageType__: MessageType_HEADLINE, + Headline__: &v, + } +} + +func NewMessageBodyWithAttachmentuploaded(v MessageAttachmentUploaded) MessageBody { + return MessageBody{ + MessageType__: MessageType_ATTACHMENTUPLOADED, + Attachmentuploaded__: &v, + } +} + +func NewMessageBodyWithJoin(v MessageJoin) MessageBody { + return MessageBody{ + MessageType__: MessageType_JOIN, + Join__: &v, + } +} + +func NewMessageBodyWithLeave(v MessageLeave) MessageBody { + return MessageBody{ + MessageType__: MessageType_LEAVE, + Leave__: &v, + } +} + +func NewMessageBodyWithSystem(v MessageSystem) MessageBody { + return MessageBody{ + MessageType__: MessageType_SYSTEM, + System__: &v, + } +} + +func NewMessageBodyWithDeletehistory(v MessageDeleteHistory) MessageBody { + return MessageBody{ + MessageType__: MessageType_DELETEHISTORY, + Deletehistory__: &v, + } +} + +func NewMessageBodyWithReaction(v MessageReaction) MessageBody { + return MessageBody{ + MessageType__: MessageType_REACTION, + Reaction__: &v, + } +} + +func NewMessageBodyWithSendpayment(v MessageSendPayment) MessageBody { + return MessageBody{ + MessageType__: MessageType_SENDPAYMENT, + Sendpayment__: &v, + } +} + +func NewMessageBodyWithRequestpayment(v MessageRequestPayment) MessageBody { + return MessageBody{ + MessageType__: MessageType_REQUESTPAYMENT, + Requestpayment__: &v, + } +} + +func NewMessageBodyWithUnfurl(v MessageUnfurl) MessageBody { + return MessageBody{ + MessageType__: MessageType_UNFURL, + Unfurl__: &v, + } +} + +func NewMessageBodyWithFlip(v MessageFlip) MessageBody { + return MessageBody{ + MessageType__: MessageType_FLIP, + Flip__: &v, + } +} + +func NewMessageBodyWithPin(v MessagePin) MessageBody { + return MessageBody{ + MessageType__: MessageType_PIN, + Pin__: &v, + } +} + +func (o MessageBody) DeepCopy() MessageBody { + return MessageBody{ + MessageType__: o.MessageType__.DeepCopy(), + Text__: (func(x *MessageText) *MessageText { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Text__), + Attachment__: (func(x *MessageAttachment) *MessageAttachment { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Attachment__), + Edit__: (func(x *MessageEdit) *MessageEdit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Edit__), + Delete__: (func(x *MessageDelete) *MessageDelete { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Delete__), + Metadata__: (func(x *MessageConversationMetadata) *MessageConversationMetadata { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Metadata__), + Headline__: (func(x *MessageHeadline) *MessageHeadline { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Headline__), + Attachmentuploaded__: (func(x *MessageAttachmentUploaded) *MessageAttachmentUploaded { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Attachmentuploaded__), + Join__: (func(x *MessageJoin) *MessageJoin { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Join__), + Leave__: (func(x *MessageLeave) *MessageLeave { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Leave__), + System__: (func(x *MessageSystem) *MessageSystem { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.System__), + Deletehistory__: (func(x *MessageDeleteHistory) *MessageDeleteHistory { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Deletehistory__), + Reaction__: (func(x *MessageReaction) *MessageReaction { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Reaction__), + Sendpayment__: (func(x *MessageSendPayment) *MessageSendPayment { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Sendpayment__), + Requestpayment__: (func(x *MessageRequestPayment) *MessageRequestPayment { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Requestpayment__), + Unfurl__: (func(x *MessageUnfurl) *MessageUnfurl { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Unfurl__), + Flip__: (func(x *MessageFlip) *MessageFlip { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Flip__), + Pin__: (func(x *MessagePin) *MessagePin { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Pin__), + } +} + +type SenderPrepareOptions struct { + SkipTopicNameState bool `codec:"skipTopicNameState" json:"skipTopicNameState"` + ReplyTo *MessageID `codec:"replyTo,omitempty" json:"replyTo,omitempty"` +} + +func (o SenderPrepareOptions) DeepCopy() SenderPrepareOptions { + return SenderPrepareOptions{ + SkipTopicNameState: o.SkipTopicNameState, + ReplyTo: (func(x *MessageID) *MessageID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ReplyTo), + } +} + +type SenderSendOptions struct { + JoinMentionsAs *ConversationMemberStatus `codec:"joinMentionsAs,omitempty" json:"joinMentionsAs,omitempty"` +} + +func (o SenderSendOptions) DeepCopy() SenderSendOptions { + return SenderSendOptions{ + JoinMentionsAs: (func(x *ConversationMemberStatus) *ConversationMemberStatus { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.JoinMentionsAs), + } +} + +type OutboxStateType int + +const ( + OutboxStateType_SENDING OutboxStateType = 0 + OutboxStateType_ERROR OutboxStateType = 1 +) + +func (o OutboxStateType) DeepCopy() OutboxStateType { return o } + +var OutboxStateTypeMap = map[string]OutboxStateType{ + "SENDING": 0, + "ERROR": 1, +} + +var OutboxStateTypeRevMap = map[OutboxStateType]string{ + 0: "SENDING", + 1: "ERROR", +} + +func (e OutboxStateType) String() string { + if v, ok := OutboxStateTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type OutboxErrorType int + +const ( + OutboxErrorType_MISC OutboxErrorType = 0 + OutboxErrorType_OFFLINE OutboxErrorType = 1 + OutboxErrorType_IDENTIFY OutboxErrorType = 2 + OutboxErrorType_TOOLONG OutboxErrorType = 3 + OutboxErrorType_DUPLICATE OutboxErrorType = 4 + OutboxErrorType_EXPIRED OutboxErrorType = 5 + OutboxErrorType_TOOMANYATTEMPTS OutboxErrorType = 6 + OutboxErrorType_ALREADY_DELETED OutboxErrorType = 7 + OutboxErrorType_UPLOADFAILED OutboxErrorType = 8 + OutboxErrorType_RESTRICTEDBOT OutboxErrorType = 9 + OutboxErrorType_MINWRITER OutboxErrorType = 10 +) + +func (o OutboxErrorType) DeepCopy() OutboxErrorType { return o } + +var OutboxErrorTypeMap = map[string]OutboxErrorType{ + "MISC": 0, + "OFFLINE": 1, + "IDENTIFY": 2, + "TOOLONG": 3, + "DUPLICATE": 4, + "EXPIRED": 5, + "TOOMANYATTEMPTS": 6, + "ALREADY_DELETED": 7, + "UPLOADFAILED": 8, + "RESTRICTEDBOT": 9, + "MINWRITER": 10, +} + +var OutboxErrorTypeRevMap = map[OutboxErrorType]string{ + 0: "MISC", + 1: "OFFLINE", + 2: "IDENTIFY", + 3: "TOOLONG", + 4: "DUPLICATE", + 5: "EXPIRED", + 6: "TOOMANYATTEMPTS", + 7: "ALREADY_DELETED", + 8: "UPLOADFAILED", + 9: "RESTRICTEDBOT", + 10: "MINWRITER", +} + +func (e OutboxErrorType) String() string { + if v, ok := OutboxErrorTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type OutboxStateError struct { + Message string `codec:"message" json:"message"` + Typ OutboxErrorType `codec:"typ" json:"typ"` +} + +func (o OutboxStateError) DeepCopy() OutboxStateError { + return OutboxStateError{ + Message: o.Message, + Typ: o.Typ.DeepCopy(), + } +} + +type OutboxState struct { + State__ OutboxStateType `codec:"state" json:"state"` + Sending__ *int `codec:"sending,omitempty" json:"sending,omitempty"` + Error__ *OutboxStateError `codec:"error,omitempty" json:"error,omitempty"` +} + +func (o *OutboxState) State() (ret OutboxStateType, err error) { + switch o.State__ { + case OutboxStateType_SENDING: + if o.Sending__ == nil { + err = errors.New("unexpected nil value for Sending__") + return ret, err + } + case OutboxStateType_ERROR: + if o.Error__ == nil { + err = errors.New("unexpected nil value for Error__") + return ret, err + } + } + return o.State__, nil +} + +func (o OutboxState) Sending() (res int) { + if o.State__ != OutboxStateType_SENDING { + panic("wrong case accessed") + } + if o.Sending__ == nil { + return + } + return *o.Sending__ +} + +func (o OutboxState) Error() (res OutboxStateError) { + if o.State__ != OutboxStateType_ERROR { + panic("wrong case accessed") + } + if o.Error__ == nil { + return + } + return *o.Error__ +} + +func NewOutboxStateWithSending(v int) OutboxState { + return OutboxState{ + State__: OutboxStateType_SENDING, + Sending__: &v, + } +} + +func NewOutboxStateWithError(v OutboxStateError) OutboxState { + return OutboxState{ + State__: OutboxStateType_ERROR, + Error__: &v, + } +} + +func (o OutboxState) DeepCopy() OutboxState { + return OutboxState{ + State__: o.State__.DeepCopy(), + Sending__: (func(x *int) *int { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Sending__), + Error__: (func(x *OutboxStateError) *OutboxStateError { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Error__), + } +} + +type OutboxRecord struct { + State OutboxState `codec:"state" json:"state"` + OutboxID OutboxID `codec:"outboxID" json:"outboxID"` + ConvID ConversationID `codec:"convID" json:"convID"` + Ctime gregor1.Time `codec:"ctime" json:"ctime"` + Msg MessagePlaintext `codec:"Msg" json:"Msg"` + IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` + PrepareOpts *SenderPrepareOptions `codec:"prepareOpts,omitempty" json:"prepareOpts,omitempty"` + SendOpts *SenderSendOptions `codec:"sendOpts,omitempty" json:"sendOpts,omitempty"` + Ordinal int `codec:"ordinal" json:"ordinal"` + Preview *MakePreviewRes `codec:"preview,omitempty" json:"preview,omitempty"` + ReplyTo *MessageUnboxed `codec:"replyTo,omitempty" json:"replyTo,omitempty"` +} + +func (o OutboxRecord) DeepCopy() OutboxRecord { + return OutboxRecord{ + State: o.State.DeepCopy(), + OutboxID: o.OutboxID.DeepCopy(), + ConvID: o.ConvID.DeepCopy(), + Ctime: o.Ctime.DeepCopy(), + Msg: o.Msg.DeepCopy(), + IdentifyBehavior: o.IdentifyBehavior.DeepCopy(), + PrepareOpts: (func(x *SenderPrepareOptions) *SenderPrepareOptions { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.PrepareOpts), + SendOpts: (func(x *SenderSendOptions) *SenderSendOptions { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.SendOpts), + Ordinal: o.Ordinal, + Preview: (func(x *MakePreviewRes) *MakePreviewRes { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Preview), + ReplyTo: (func(x *MessageUnboxed) *MessageUnboxed { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ReplyTo), + } +} + +type HeaderPlaintextVersion int + +const ( + HeaderPlaintextVersion_V1 HeaderPlaintextVersion = 1 + HeaderPlaintextVersion_V2 HeaderPlaintextVersion = 2 + HeaderPlaintextVersion_V3 HeaderPlaintextVersion = 3 + HeaderPlaintextVersion_V4 HeaderPlaintextVersion = 4 + HeaderPlaintextVersion_V5 HeaderPlaintextVersion = 5 + HeaderPlaintextVersion_V6 HeaderPlaintextVersion = 6 + HeaderPlaintextVersion_V7 HeaderPlaintextVersion = 7 + HeaderPlaintextVersion_V8 HeaderPlaintextVersion = 8 + HeaderPlaintextVersion_V9 HeaderPlaintextVersion = 9 + HeaderPlaintextVersion_V10 HeaderPlaintextVersion = 10 +) + +func (o HeaderPlaintextVersion) DeepCopy() HeaderPlaintextVersion { return o } + +var HeaderPlaintextVersionMap = map[string]HeaderPlaintextVersion{ + "V1": 1, + "V2": 2, + "V3": 3, + "V4": 4, + "V5": 5, + "V6": 6, + "V7": 7, + "V8": 8, + "V9": 9, + "V10": 10, +} + +var HeaderPlaintextVersionRevMap = map[HeaderPlaintextVersion]string{ + 1: "V1", + 2: "V2", + 3: "V3", + 4: "V4", + 5: "V5", + 6: "V6", + 7: "V7", + 8: "V8", + 9: "V9", + 10: "V10", +} + +func (e HeaderPlaintextVersion) String() string { + if v, ok := HeaderPlaintextVersionRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type HeaderPlaintextMetaInfo struct { + Crit bool `codec:"crit" json:"crit"` +} + +func (o HeaderPlaintextMetaInfo) DeepCopy() HeaderPlaintextMetaInfo { + return HeaderPlaintextMetaInfo{ + Crit: o.Crit, + } +} + +type HeaderPlaintextUnsupported struct { + Mi HeaderPlaintextMetaInfo `codec:"mi" json:"mi"` +} + +func (o HeaderPlaintextUnsupported) DeepCopy() HeaderPlaintextUnsupported { + return HeaderPlaintextUnsupported{ + Mi: o.Mi.DeepCopy(), + } +} + +type HeaderPlaintextV1 struct { + Conv ConversationIDTriple `codec:"conv" json:"conv"` + TlfName string `codec:"tlfName" json:"tlfName"` + TlfPublic bool `codec:"tlfPublic" json:"tlfPublic"` + MessageType MessageType `codec:"messageType" json:"messageType"` + Prev []MessagePreviousPointer `codec:"prev" json:"prev"` + Sender gregor1.UID `codec:"sender" json:"sender"` + SenderDevice gregor1.DeviceID `codec:"senderDevice" json:"senderDevice"` + KbfsCryptKeysUsed *bool `codec:"kbfsCryptKeysUsed,omitempty" json:"kbfsCryptKeysUsed,omitempty"` + BodyHash Hash `codec:"bodyHash" json:"bodyHash"` + OutboxInfo *OutboxInfo `codec:"outboxInfo,omitempty" json:"outboxInfo,omitempty"` + OutboxID *OutboxID `codec:"outboxID,omitempty" json:"outboxID,omitempty"` + HeaderSignature *SignatureInfo `codec:"headerSignature,omitempty" json:"headerSignature,omitempty"` + MerkleRoot *MerkleRoot `codec:"merkleRoot,omitempty" json:"merkleRoot,omitempty"` + EphemeralMetadata *MsgEphemeralMetadata `codec:"em,omitempty" json:"em,omitempty"` + BotUID *gregor1.UID `codec:"b,omitempty" json:"b,omitempty"` +} + +func (o HeaderPlaintextV1) DeepCopy() HeaderPlaintextV1 { + return HeaderPlaintextV1{ + Conv: o.Conv.DeepCopy(), + TlfName: o.TlfName, + TlfPublic: o.TlfPublic, + MessageType: o.MessageType.DeepCopy(), + Prev: (func(x []MessagePreviousPointer) []MessagePreviousPointer { + if x == nil { + return nil + } + ret := make([]MessagePreviousPointer, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Prev), + Sender: o.Sender.DeepCopy(), + SenderDevice: o.SenderDevice.DeepCopy(), + KbfsCryptKeysUsed: (func(x *bool) *bool { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.KbfsCryptKeysUsed), + BodyHash: o.BodyHash.DeepCopy(), + OutboxInfo: (func(x *OutboxInfo) *OutboxInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.OutboxInfo), + OutboxID: (func(x *OutboxID) *OutboxID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.OutboxID), + HeaderSignature: (func(x *SignatureInfo) *SignatureInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.HeaderSignature), + MerkleRoot: (func(x *MerkleRoot) *MerkleRoot { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.MerkleRoot), + EphemeralMetadata: (func(x *MsgEphemeralMetadata) *MsgEphemeralMetadata { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.EphemeralMetadata), + BotUID: (func(x *gregor1.UID) *gregor1.UID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.BotUID), + } +} + +type HeaderPlaintext struct { + Version__ HeaderPlaintextVersion `codec:"version" json:"version"` + V1__ *HeaderPlaintextV1 `codec:"v1,omitempty" json:"v1,omitempty"` + V2__ *HeaderPlaintextUnsupported `codec:"v2,omitempty" json:"v2,omitempty"` + V3__ *HeaderPlaintextUnsupported `codec:"v3,omitempty" json:"v3,omitempty"` + V4__ *HeaderPlaintextUnsupported `codec:"v4,omitempty" json:"v4,omitempty"` + V5__ *HeaderPlaintextUnsupported `codec:"v5,omitempty" json:"v5,omitempty"` + V6__ *HeaderPlaintextUnsupported `codec:"v6,omitempty" json:"v6,omitempty"` + V7__ *HeaderPlaintextUnsupported `codec:"v7,omitempty" json:"v7,omitempty"` + V8__ *HeaderPlaintextUnsupported `codec:"v8,omitempty" json:"v8,omitempty"` + V9__ *HeaderPlaintextUnsupported `codec:"v9,omitempty" json:"v9,omitempty"` + V10__ *HeaderPlaintextUnsupported `codec:"v10,omitempty" json:"v10,omitempty"` +} + +func (o *HeaderPlaintext) Version() (ret HeaderPlaintextVersion, err error) { + switch o.Version__ { + case HeaderPlaintextVersion_V1: + if o.V1__ == nil { + err = errors.New("unexpected nil value for V1__") + return ret, err + } + case HeaderPlaintextVersion_V2: + if o.V2__ == nil { + err = errors.New("unexpected nil value for V2__") + return ret, err + } + case HeaderPlaintextVersion_V3: + if o.V3__ == nil { + err = errors.New("unexpected nil value for V3__") + return ret, err + } + case HeaderPlaintextVersion_V4: + if o.V4__ == nil { + err = errors.New("unexpected nil value for V4__") + return ret, err + } + case HeaderPlaintextVersion_V5: + if o.V5__ == nil { + err = errors.New("unexpected nil value for V5__") + return ret, err + } + case HeaderPlaintextVersion_V6: + if o.V6__ == nil { + err = errors.New("unexpected nil value for V6__") + return ret, err + } + case HeaderPlaintextVersion_V7: + if o.V7__ == nil { + err = errors.New("unexpected nil value for V7__") + return ret, err + } + case HeaderPlaintextVersion_V8: + if o.V8__ == nil { + err = errors.New("unexpected nil value for V8__") + return ret, err + } + case HeaderPlaintextVersion_V9: + if o.V9__ == nil { + err = errors.New("unexpected nil value for V9__") + return ret, err + } + case HeaderPlaintextVersion_V10: + if o.V10__ == nil { + err = errors.New("unexpected nil value for V10__") + return ret, err + } + } + return o.Version__, nil +} + +func (o HeaderPlaintext) V1() (res HeaderPlaintextV1) { + if o.Version__ != HeaderPlaintextVersion_V1 { + panic("wrong case accessed") + } + if o.V1__ == nil { + return + } + return *o.V1__ +} + +func (o HeaderPlaintext) V2() (res HeaderPlaintextUnsupported) { + if o.Version__ != HeaderPlaintextVersion_V2 { + panic("wrong case accessed") + } + if o.V2__ == nil { + return + } + return *o.V2__ +} + +func (o HeaderPlaintext) V3() (res HeaderPlaintextUnsupported) { + if o.Version__ != HeaderPlaintextVersion_V3 { + panic("wrong case accessed") + } + if o.V3__ == nil { + return + } + return *o.V3__ +} + +func (o HeaderPlaintext) V4() (res HeaderPlaintextUnsupported) { + if o.Version__ != HeaderPlaintextVersion_V4 { + panic("wrong case accessed") + } + if o.V4__ == nil { + return + } + return *o.V4__ +} + +func (o HeaderPlaintext) V5() (res HeaderPlaintextUnsupported) { + if o.Version__ != HeaderPlaintextVersion_V5 { + panic("wrong case accessed") + } + if o.V5__ == nil { + return + } + return *o.V5__ +} + +func (o HeaderPlaintext) V6() (res HeaderPlaintextUnsupported) { + if o.Version__ != HeaderPlaintextVersion_V6 { + panic("wrong case accessed") + } + if o.V6__ == nil { + return + } + return *o.V6__ +} + +func (o HeaderPlaintext) V7() (res HeaderPlaintextUnsupported) { + if o.Version__ != HeaderPlaintextVersion_V7 { + panic("wrong case accessed") + } + if o.V7__ == nil { + return + } + return *o.V7__ +} + +func (o HeaderPlaintext) V8() (res HeaderPlaintextUnsupported) { + if o.Version__ != HeaderPlaintextVersion_V8 { + panic("wrong case accessed") + } + if o.V8__ == nil { + return + } + return *o.V8__ +} + +func (o HeaderPlaintext) V9() (res HeaderPlaintextUnsupported) { + if o.Version__ != HeaderPlaintextVersion_V9 { + panic("wrong case accessed") + } + if o.V9__ == nil { + return + } + return *o.V9__ +} + +func (o HeaderPlaintext) V10() (res HeaderPlaintextUnsupported) { + if o.Version__ != HeaderPlaintextVersion_V10 { + panic("wrong case accessed") + } + if o.V10__ == nil { + return + } + return *o.V10__ +} + +func NewHeaderPlaintextWithV1(v HeaderPlaintextV1) HeaderPlaintext { + return HeaderPlaintext{ + Version__: HeaderPlaintextVersion_V1, + V1__: &v, + } +} + +func NewHeaderPlaintextWithV2(v HeaderPlaintextUnsupported) HeaderPlaintext { + return HeaderPlaintext{ + Version__: HeaderPlaintextVersion_V2, + V2__: &v, + } +} + +func NewHeaderPlaintextWithV3(v HeaderPlaintextUnsupported) HeaderPlaintext { + return HeaderPlaintext{ + Version__: HeaderPlaintextVersion_V3, + V3__: &v, + } +} + +func NewHeaderPlaintextWithV4(v HeaderPlaintextUnsupported) HeaderPlaintext { + return HeaderPlaintext{ + Version__: HeaderPlaintextVersion_V4, + V4__: &v, + } +} + +func NewHeaderPlaintextWithV5(v HeaderPlaintextUnsupported) HeaderPlaintext { + return HeaderPlaintext{ + Version__: HeaderPlaintextVersion_V5, + V5__: &v, + } +} + +func NewHeaderPlaintextWithV6(v HeaderPlaintextUnsupported) HeaderPlaintext { + return HeaderPlaintext{ + Version__: HeaderPlaintextVersion_V6, + V6__: &v, + } +} + +func NewHeaderPlaintextWithV7(v HeaderPlaintextUnsupported) HeaderPlaintext { + return HeaderPlaintext{ + Version__: HeaderPlaintextVersion_V7, + V7__: &v, + } +} + +func NewHeaderPlaintextWithV8(v HeaderPlaintextUnsupported) HeaderPlaintext { + return HeaderPlaintext{ + Version__: HeaderPlaintextVersion_V8, + V8__: &v, + } +} + +func NewHeaderPlaintextWithV9(v HeaderPlaintextUnsupported) HeaderPlaintext { + return HeaderPlaintext{ + Version__: HeaderPlaintextVersion_V9, + V9__: &v, + } +} + +func NewHeaderPlaintextWithV10(v HeaderPlaintextUnsupported) HeaderPlaintext { + return HeaderPlaintext{ + Version__: HeaderPlaintextVersion_V10, + V10__: &v, + } +} + +func (o HeaderPlaintext) DeepCopy() HeaderPlaintext { + return HeaderPlaintext{ + Version__: o.Version__.DeepCopy(), + V1__: (func(x *HeaderPlaintextV1) *HeaderPlaintextV1 { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V1__), + V2__: (func(x *HeaderPlaintextUnsupported) *HeaderPlaintextUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V2__), + V3__: (func(x *HeaderPlaintextUnsupported) *HeaderPlaintextUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V3__), + V4__: (func(x *HeaderPlaintextUnsupported) *HeaderPlaintextUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V4__), + V5__: (func(x *HeaderPlaintextUnsupported) *HeaderPlaintextUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V5__), + V6__: (func(x *HeaderPlaintextUnsupported) *HeaderPlaintextUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V6__), + V7__: (func(x *HeaderPlaintextUnsupported) *HeaderPlaintextUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V7__), + V8__: (func(x *HeaderPlaintextUnsupported) *HeaderPlaintextUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V8__), + V9__: (func(x *HeaderPlaintextUnsupported) *HeaderPlaintextUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V9__), + V10__: (func(x *HeaderPlaintextUnsupported) *HeaderPlaintextUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V10__), + } +} + +type BodyPlaintextVersion int + +const ( + BodyPlaintextVersion_V1 BodyPlaintextVersion = 1 + BodyPlaintextVersion_V2 BodyPlaintextVersion = 2 + BodyPlaintextVersion_V3 BodyPlaintextVersion = 3 + BodyPlaintextVersion_V4 BodyPlaintextVersion = 4 + BodyPlaintextVersion_V5 BodyPlaintextVersion = 5 + BodyPlaintextVersion_V6 BodyPlaintextVersion = 6 + BodyPlaintextVersion_V7 BodyPlaintextVersion = 7 + BodyPlaintextVersion_V8 BodyPlaintextVersion = 8 + BodyPlaintextVersion_V9 BodyPlaintextVersion = 9 + BodyPlaintextVersion_V10 BodyPlaintextVersion = 10 +) + +func (o BodyPlaintextVersion) DeepCopy() BodyPlaintextVersion { return o } + +var BodyPlaintextVersionMap = map[string]BodyPlaintextVersion{ + "V1": 1, + "V2": 2, + "V3": 3, + "V4": 4, + "V5": 5, + "V6": 6, + "V7": 7, + "V8": 8, + "V9": 9, + "V10": 10, +} + +var BodyPlaintextVersionRevMap = map[BodyPlaintextVersion]string{ + 1: "V1", + 2: "V2", + 3: "V3", + 4: "V4", + 5: "V5", + 6: "V6", + 7: "V7", + 8: "V8", + 9: "V9", + 10: "V10", +} + +func (e BodyPlaintextVersion) String() string { + if v, ok := BodyPlaintextVersionRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type BodyPlaintextMetaInfo struct { + Crit bool `codec:"crit" json:"crit"` +} + +func (o BodyPlaintextMetaInfo) DeepCopy() BodyPlaintextMetaInfo { + return BodyPlaintextMetaInfo{ + Crit: o.Crit, + } +} + +type BodyPlaintextUnsupported struct { + Mi BodyPlaintextMetaInfo `codec:"mi" json:"mi"` +} + +func (o BodyPlaintextUnsupported) DeepCopy() BodyPlaintextUnsupported { + return BodyPlaintextUnsupported{ + Mi: o.Mi.DeepCopy(), + } +} + +type BodyPlaintextV1 struct { + MessageBody MessageBody `codec:"messageBody" json:"messageBody"` +} + +func (o BodyPlaintextV1) DeepCopy() BodyPlaintextV1 { + return BodyPlaintextV1{ + MessageBody: o.MessageBody.DeepCopy(), + } +} + +type BodyPlaintextV2 struct { + MessageBody MessageBody `codec:"messageBody" json:"messageBody"` + Mi BodyPlaintextMetaInfo `codec:"mi" json:"mi"` +} + +func (o BodyPlaintextV2) DeepCopy() BodyPlaintextV2 { + return BodyPlaintextV2{ + MessageBody: o.MessageBody.DeepCopy(), + Mi: o.Mi.DeepCopy(), + } +} + +type BodyPlaintext struct { + Version__ BodyPlaintextVersion `codec:"version" json:"version"` + V1__ *BodyPlaintextV1 `codec:"v1,omitempty" json:"v1,omitempty"` + V2__ *BodyPlaintextV2 `codec:"v2,omitempty" json:"v2,omitempty"` + V3__ *BodyPlaintextUnsupported `codec:"v3,omitempty" json:"v3,omitempty"` + V4__ *BodyPlaintextUnsupported `codec:"v4,omitempty" json:"v4,omitempty"` + V5__ *BodyPlaintextUnsupported `codec:"v5,omitempty" json:"v5,omitempty"` + V6__ *BodyPlaintextUnsupported `codec:"v6,omitempty" json:"v6,omitempty"` + V7__ *BodyPlaintextUnsupported `codec:"v7,omitempty" json:"v7,omitempty"` + V8__ *BodyPlaintextUnsupported `codec:"v8,omitempty" json:"v8,omitempty"` + V9__ *BodyPlaintextUnsupported `codec:"v9,omitempty" json:"v9,omitempty"` + V10__ *BodyPlaintextUnsupported `codec:"v10,omitempty" json:"v10,omitempty"` +} + +func (o *BodyPlaintext) Version() (ret BodyPlaintextVersion, err error) { + switch o.Version__ { + case BodyPlaintextVersion_V1: + if o.V1__ == nil { + err = errors.New("unexpected nil value for V1__") + return ret, err + } + case BodyPlaintextVersion_V2: + if o.V2__ == nil { + err = errors.New("unexpected nil value for V2__") + return ret, err + } + case BodyPlaintextVersion_V3: + if o.V3__ == nil { + err = errors.New("unexpected nil value for V3__") + return ret, err + } + case BodyPlaintextVersion_V4: + if o.V4__ == nil { + err = errors.New("unexpected nil value for V4__") + return ret, err + } + case BodyPlaintextVersion_V5: + if o.V5__ == nil { + err = errors.New("unexpected nil value for V5__") + return ret, err + } + case BodyPlaintextVersion_V6: + if o.V6__ == nil { + err = errors.New("unexpected nil value for V6__") + return ret, err + } + case BodyPlaintextVersion_V7: + if o.V7__ == nil { + err = errors.New("unexpected nil value for V7__") + return ret, err + } + case BodyPlaintextVersion_V8: + if o.V8__ == nil { + err = errors.New("unexpected nil value for V8__") + return ret, err + } + case BodyPlaintextVersion_V9: + if o.V9__ == nil { + err = errors.New("unexpected nil value for V9__") + return ret, err + } + case BodyPlaintextVersion_V10: + if o.V10__ == nil { + err = errors.New("unexpected nil value for V10__") + return ret, err + } + } + return o.Version__, nil +} + +func (o BodyPlaintext) V1() (res BodyPlaintextV1) { + if o.Version__ != BodyPlaintextVersion_V1 { + panic("wrong case accessed") + } + if o.V1__ == nil { + return + } + return *o.V1__ +} + +func (o BodyPlaintext) V2() (res BodyPlaintextV2) { + if o.Version__ != BodyPlaintextVersion_V2 { + panic("wrong case accessed") + } + if o.V2__ == nil { + return + } + return *o.V2__ +} + +func (o BodyPlaintext) V3() (res BodyPlaintextUnsupported) { + if o.Version__ != BodyPlaintextVersion_V3 { + panic("wrong case accessed") + } + if o.V3__ == nil { + return + } + return *o.V3__ +} + +func (o BodyPlaintext) V4() (res BodyPlaintextUnsupported) { + if o.Version__ != BodyPlaintextVersion_V4 { + panic("wrong case accessed") + } + if o.V4__ == nil { + return + } + return *o.V4__ +} + +func (o BodyPlaintext) V5() (res BodyPlaintextUnsupported) { + if o.Version__ != BodyPlaintextVersion_V5 { + panic("wrong case accessed") + } + if o.V5__ == nil { + return + } + return *o.V5__ +} + +func (o BodyPlaintext) V6() (res BodyPlaintextUnsupported) { + if o.Version__ != BodyPlaintextVersion_V6 { + panic("wrong case accessed") + } + if o.V6__ == nil { + return + } + return *o.V6__ +} + +func (o BodyPlaintext) V7() (res BodyPlaintextUnsupported) { + if o.Version__ != BodyPlaintextVersion_V7 { + panic("wrong case accessed") + } + if o.V7__ == nil { + return + } + return *o.V7__ +} + +func (o BodyPlaintext) V8() (res BodyPlaintextUnsupported) { + if o.Version__ != BodyPlaintextVersion_V8 { + panic("wrong case accessed") + } + if o.V8__ == nil { + return + } + return *o.V8__ +} + +func (o BodyPlaintext) V9() (res BodyPlaintextUnsupported) { + if o.Version__ != BodyPlaintextVersion_V9 { + panic("wrong case accessed") + } + if o.V9__ == nil { + return + } + return *o.V9__ +} + +func (o BodyPlaintext) V10() (res BodyPlaintextUnsupported) { + if o.Version__ != BodyPlaintextVersion_V10 { + panic("wrong case accessed") + } + if o.V10__ == nil { + return + } + return *o.V10__ +} + +func NewBodyPlaintextWithV1(v BodyPlaintextV1) BodyPlaintext { + return BodyPlaintext{ + Version__: BodyPlaintextVersion_V1, + V1__: &v, + } +} + +func NewBodyPlaintextWithV2(v BodyPlaintextV2) BodyPlaintext { + return BodyPlaintext{ + Version__: BodyPlaintextVersion_V2, + V2__: &v, + } +} + +func NewBodyPlaintextWithV3(v BodyPlaintextUnsupported) BodyPlaintext { + return BodyPlaintext{ + Version__: BodyPlaintextVersion_V3, + V3__: &v, + } +} + +func NewBodyPlaintextWithV4(v BodyPlaintextUnsupported) BodyPlaintext { + return BodyPlaintext{ + Version__: BodyPlaintextVersion_V4, + V4__: &v, + } +} + +func NewBodyPlaintextWithV5(v BodyPlaintextUnsupported) BodyPlaintext { + return BodyPlaintext{ + Version__: BodyPlaintextVersion_V5, + V5__: &v, + } +} + +func NewBodyPlaintextWithV6(v BodyPlaintextUnsupported) BodyPlaintext { + return BodyPlaintext{ + Version__: BodyPlaintextVersion_V6, + V6__: &v, + } +} + +func NewBodyPlaintextWithV7(v BodyPlaintextUnsupported) BodyPlaintext { + return BodyPlaintext{ + Version__: BodyPlaintextVersion_V7, + V7__: &v, + } +} + +func NewBodyPlaintextWithV8(v BodyPlaintextUnsupported) BodyPlaintext { + return BodyPlaintext{ + Version__: BodyPlaintextVersion_V8, + V8__: &v, + } +} + +func NewBodyPlaintextWithV9(v BodyPlaintextUnsupported) BodyPlaintext { + return BodyPlaintext{ + Version__: BodyPlaintextVersion_V9, + V9__: &v, + } +} + +func NewBodyPlaintextWithV10(v BodyPlaintextUnsupported) BodyPlaintext { + return BodyPlaintext{ + Version__: BodyPlaintextVersion_V10, + V10__: &v, + } +} + +func (o BodyPlaintext) DeepCopy() BodyPlaintext { + return BodyPlaintext{ + Version__: o.Version__.DeepCopy(), + V1__: (func(x *BodyPlaintextV1) *BodyPlaintextV1 { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V1__), + V2__: (func(x *BodyPlaintextV2) *BodyPlaintextV2 { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V2__), + V3__: (func(x *BodyPlaintextUnsupported) *BodyPlaintextUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V3__), + V4__: (func(x *BodyPlaintextUnsupported) *BodyPlaintextUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V4__), + V5__: (func(x *BodyPlaintextUnsupported) *BodyPlaintextUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V5__), + V6__: (func(x *BodyPlaintextUnsupported) *BodyPlaintextUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V6__), + V7__: (func(x *BodyPlaintextUnsupported) *BodyPlaintextUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V7__), + V8__: (func(x *BodyPlaintextUnsupported) *BodyPlaintextUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V8__), + V9__: (func(x *BodyPlaintextUnsupported) *BodyPlaintextUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V9__), + V10__: (func(x *BodyPlaintextUnsupported) *BodyPlaintextUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V10__), + } +} + +type MessagePlaintext struct { + ClientHeader MessageClientHeader `codec:"clientHeader" json:"clientHeader"` + MessageBody MessageBody `codec:"messageBody" json:"messageBody"` + SupersedesOutboxID *OutboxID `codec:"supersedesOutboxID,omitempty" json:"supersedesOutboxID,omitempty"` +} + +func (o MessagePlaintext) DeepCopy() MessagePlaintext { + return MessagePlaintext{ + ClientHeader: o.ClientHeader.DeepCopy(), + MessageBody: o.MessageBody.DeepCopy(), + SupersedesOutboxID: (func(x *OutboxID) *OutboxID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.SupersedesOutboxID), + } +} + +type MessageUnboxedValid struct { + ClientHeader MessageClientHeaderVerified `codec:"clientHeader" json:"clientHeader"` + ServerHeader MessageServerHeader `codec:"serverHeader" json:"serverHeader"` + MessageBody MessageBody `codec:"messageBody" json:"messageBody"` + SenderUsername string `codec:"senderUsername" json:"senderUsername"` + SenderDeviceName string `codec:"senderDeviceName" json:"senderDeviceName"` + SenderDeviceType string `codec:"senderDeviceType" json:"senderDeviceType"` + BodyHash Hash `codec:"bodyHash" json:"bodyHash"` + HeaderHash Hash `codec:"headerHash" json:"headerHash"` + HeaderSignature *SignatureInfo `codec:"headerSignature,omitempty" json:"headerSignature,omitempty"` + VerificationKey *[]byte `codec:"verificationKey,omitempty" json:"verificationKey,omitempty"` + SenderDeviceRevokedAt *gregor1.Time `codec:"senderDeviceRevokedAt,omitempty" json:"senderDeviceRevokedAt,omitempty"` + AtMentionUsernames []string `codec:"atMentionUsernames" json:"atMentionUsernames"` + AtMentions []gregor1.UID `codec:"atMentions" json:"atMentions"` + ChannelMention ChannelMention `codec:"channelMention" json:"channelMention"` + MaybeMentions []MaybeMention `codec:"maybeMentions" json:"maybeMentions"` + ChannelNameMentions []ChannelNameMention `codec:"channelNameMentions" json:"channelNameMentions"` + Reactions ReactionMap `codec:"reactions" json:"reactions"` + Unfurls map[MessageID]UnfurlResult `codec:"unfurls" json:"unfurls"` + ReplyTo *MessageUnboxed `codec:"replyTo,omitempty" json:"replyTo,omitempty"` + BotUsername string `codec:"botUsername" json:"botUsername"` +} + +func (o MessageUnboxedValid) DeepCopy() MessageUnboxedValid { + return MessageUnboxedValid{ + ClientHeader: o.ClientHeader.DeepCopy(), + ServerHeader: o.ServerHeader.DeepCopy(), + MessageBody: o.MessageBody.DeepCopy(), + SenderUsername: o.SenderUsername, + SenderDeviceName: o.SenderDeviceName, + SenderDeviceType: o.SenderDeviceType, + BodyHash: o.BodyHash.DeepCopy(), + HeaderHash: o.HeaderHash.DeepCopy(), + HeaderSignature: (func(x *SignatureInfo) *SignatureInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.HeaderSignature), + VerificationKey: (func(x *[]byte) *[]byte { + if x == nil { + return nil + } + tmp := (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })((*x)) + return &tmp + })(o.VerificationKey), + SenderDeviceRevokedAt: (func(x *gregor1.Time) *gregor1.Time { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.SenderDeviceRevokedAt), + AtMentionUsernames: (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.AtMentionUsernames), + AtMentions: (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.AtMentions), + ChannelMention: o.ChannelMention.DeepCopy(), + MaybeMentions: (func(x []MaybeMention) []MaybeMention { + if x == nil { + return nil + } + ret := make([]MaybeMention, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.MaybeMentions), + ChannelNameMentions: (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.ChannelNameMentions), + Reactions: o.Reactions.DeepCopy(), + Unfurls: (func(x map[MessageID]UnfurlResult) map[MessageID]UnfurlResult { + if x == nil { + return nil + } + ret := make(map[MessageID]UnfurlResult, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.Unfurls), + ReplyTo: (func(x *MessageUnboxed) *MessageUnboxed { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ReplyTo), + BotUsername: o.BotUsername, + } +} + +type MessageUnboxedErrorType int + +const ( + MessageUnboxedErrorType_MISC MessageUnboxedErrorType = 0 + MessageUnboxedErrorType_BADVERSION_CRITICAL MessageUnboxedErrorType = 1 + MessageUnboxedErrorType_BADVERSION MessageUnboxedErrorType = 2 + MessageUnboxedErrorType_IDENTIFY MessageUnboxedErrorType = 3 + MessageUnboxedErrorType_EPHEMERAL MessageUnboxedErrorType = 4 + MessageUnboxedErrorType_PAIRWISE_MISSING MessageUnboxedErrorType = 5 +) + +func (o MessageUnboxedErrorType) DeepCopy() MessageUnboxedErrorType { return o } + +var MessageUnboxedErrorTypeMap = map[string]MessageUnboxedErrorType{ + "MISC": 0, + "BADVERSION_CRITICAL": 1, + "BADVERSION": 2, + "IDENTIFY": 3, + "EPHEMERAL": 4, + "PAIRWISE_MISSING": 5, +} + +var MessageUnboxedErrorTypeRevMap = map[MessageUnboxedErrorType]string{ + 0: "MISC", + 1: "BADVERSION_CRITICAL", + 2: "BADVERSION", + 3: "IDENTIFY", + 4: "EPHEMERAL", + 5: "PAIRWISE_MISSING", +} + +func (e MessageUnboxedErrorType) String() string { + if v, ok := MessageUnboxedErrorTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type MessageUnboxedError struct { + ErrType MessageUnboxedErrorType `codec:"errType" json:"errType"` + ErrMsg string `codec:"errMsg" json:"errMsg"` + InternalErrMsg string `codec:"internalErrMsg" json:"internalErrMsg"` + VersionKind VersionKind `codec:"versionKind" json:"versionKind"` + VersionNumber int `codec:"versionNumber" json:"versionNumber"` + IsCritical bool `codec:"isCritical" json:"isCritical"` + SenderUsername string `codec:"senderUsername" json:"senderUsername"` + SenderDeviceName string `codec:"senderDeviceName" json:"senderDeviceName"` + SenderDeviceType string `codec:"senderDeviceType" json:"senderDeviceType"` + MessageID MessageID `codec:"messageID" json:"messageID"` + MessageType MessageType `codec:"messageType" json:"messageType"` + Ctime gregor1.Time `codec:"ctime" json:"ctime"` + IsEphemeral bool `codec:"isEphemeral" json:"isEphemeral"` + ExplodedBy *string `codec:"explodedBy,omitempty" json:"explodedBy,omitempty"` + Etime gregor1.Time `codec:"etime" json:"etime"` + BotUsername string `codec:"botUsername" json:"botUsername"` +} + +func (o MessageUnboxedError) DeepCopy() MessageUnboxedError { + return MessageUnboxedError{ + ErrType: o.ErrType.DeepCopy(), + ErrMsg: o.ErrMsg, + InternalErrMsg: o.InternalErrMsg, + VersionKind: o.VersionKind.DeepCopy(), + VersionNumber: o.VersionNumber, + IsCritical: o.IsCritical, + SenderUsername: o.SenderUsername, + SenderDeviceName: o.SenderDeviceName, + SenderDeviceType: o.SenderDeviceType, + MessageID: o.MessageID.DeepCopy(), + MessageType: o.MessageType.DeepCopy(), + Ctime: o.Ctime.DeepCopy(), + IsEphemeral: o.IsEphemeral, + ExplodedBy: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.ExplodedBy), + Etime: o.Etime.DeepCopy(), + BotUsername: o.BotUsername, + } +} + +type MessageUnboxedPlaceholder struct { + MessageID MessageID `codec:"messageID" json:"messageID"` + Hidden bool `codec:"hidden" json:"hidden"` +} + +func (o MessageUnboxedPlaceholder) DeepCopy() MessageUnboxedPlaceholder { + return MessageUnboxedPlaceholder{ + MessageID: o.MessageID.DeepCopy(), + Hidden: o.Hidden, + } +} + +type JourneycardType int + +const ( + JourneycardType_WELCOME JourneycardType = 0 + JourneycardType_POPULAR_CHANNELS JourneycardType = 1 + JourneycardType_ADD_PEOPLE JourneycardType = 2 + JourneycardType_CREATE_CHANNELS JourneycardType = 3 + JourneycardType_MSG_ATTENTION JourneycardType = 4 + JourneycardType_UNUSED JourneycardType = 5 + JourneycardType_CHANNEL_INACTIVE JourneycardType = 6 + JourneycardType_MSG_NO_ANSWER JourneycardType = 7 +) + +func (o JourneycardType) DeepCopy() JourneycardType { return o } + +var JourneycardTypeMap = map[string]JourneycardType{ + "WELCOME": 0, + "POPULAR_CHANNELS": 1, + "ADD_PEOPLE": 2, + "CREATE_CHANNELS": 3, + "MSG_ATTENTION": 4, + "UNUSED": 5, + "CHANNEL_INACTIVE": 6, + "MSG_NO_ANSWER": 7, +} + +var JourneycardTypeRevMap = map[JourneycardType]string{ + 0: "WELCOME", + 1: "POPULAR_CHANNELS", + 2: "ADD_PEOPLE", + 3: "CREATE_CHANNELS", + 4: "MSG_ATTENTION", + 5: "UNUSED", + 6: "CHANNEL_INACTIVE", + 7: "MSG_NO_ANSWER", +} + +func (e JourneycardType) String() string { + if v, ok := JourneycardTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type MessageUnboxedJourneycard struct { + PrevID MessageID `codec:"prevID" json:"prevID"` + Ordinal int `codec:"ordinal" json:"ordinal"` + CardType JourneycardType `codec:"cardType" json:"cardType"` + HighlightMsgID MessageID `codec:"highlightMsgID" json:"highlightMsgID"` + OpenTeam bool `codec:"openTeam" json:"openTeam"` +} + +func (o MessageUnboxedJourneycard) DeepCopy() MessageUnboxedJourneycard { + return MessageUnboxedJourneycard{ + PrevID: o.PrevID.DeepCopy(), + Ordinal: o.Ordinal, + CardType: o.CardType.DeepCopy(), + HighlightMsgID: o.HighlightMsgID.DeepCopy(), + OpenTeam: o.OpenTeam, + } +} + +type MessageUnboxed struct { + State__ MessageUnboxedState `codec:"state" json:"state"` + Valid__ *MessageUnboxedValid `codec:"valid,omitempty" json:"valid,omitempty"` + Error__ *MessageUnboxedError `codec:"error,omitempty" json:"error,omitempty"` + Outbox__ *OutboxRecord `codec:"outbox,omitempty" json:"outbox,omitempty"` + Placeholder__ *MessageUnboxedPlaceholder `codec:"placeholder,omitempty" json:"placeholder,omitempty"` + Journeycard__ *MessageUnboxedJourneycard `codec:"journeycard,omitempty" json:"journeycard,omitempty"` +} + +func (o *MessageUnboxed) State() (ret MessageUnboxedState, err error) { + switch o.State__ { + case MessageUnboxedState_VALID: + if o.Valid__ == nil { + err = errors.New("unexpected nil value for Valid__") + return ret, err + } + case MessageUnboxedState_ERROR: + if o.Error__ == nil { + err = errors.New("unexpected nil value for Error__") + return ret, err + } + case MessageUnboxedState_OUTBOX: + if o.Outbox__ == nil { + err = errors.New("unexpected nil value for Outbox__") + return ret, err + } + case MessageUnboxedState_PLACEHOLDER: + if o.Placeholder__ == nil { + err = errors.New("unexpected nil value for Placeholder__") + return ret, err + } + case MessageUnboxedState_JOURNEYCARD: + if o.Journeycard__ == nil { + err = errors.New("unexpected nil value for Journeycard__") + return ret, err + } + } + return o.State__, nil +} + +func (o MessageUnboxed) Valid() (res MessageUnboxedValid) { + if o.State__ != MessageUnboxedState_VALID { + panic("wrong case accessed") + } + if o.Valid__ == nil { + return + } + return *o.Valid__ +} + +func (o MessageUnboxed) Error() (res MessageUnboxedError) { + if o.State__ != MessageUnboxedState_ERROR { + panic("wrong case accessed") + } + if o.Error__ == nil { + return + } + return *o.Error__ +} + +func (o MessageUnboxed) Outbox() (res OutboxRecord) { + if o.State__ != MessageUnboxedState_OUTBOX { + panic("wrong case accessed") + } + if o.Outbox__ == nil { + return + } + return *o.Outbox__ +} + +func (o MessageUnboxed) Placeholder() (res MessageUnboxedPlaceholder) { + if o.State__ != MessageUnboxedState_PLACEHOLDER { + panic("wrong case accessed") + } + if o.Placeholder__ == nil { + return + } + return *o.Placeholder__ +} + +func (o MessageUnboxed) Journeycard() (res MessageUnboxedJourneycard) { + if o.State__ != MessageUnboxedState_JOURNEYCARD { + panic("wrong case accessed") + } + if o.Journeycard__ == nil { + return + } + return *o.Journeycard__ +} + +func NewMessageUnboxedWithValid(v MessageUnboxedValid) MessageUnboxed { + return MessageUnboxed{ + State__: MessageUnboxedState_VALID, + Valid__: &v, + } +} + +func NewMessageUnboxedWithError(v MessageUnboxedError) MessageUnboxed { + return MessageUnboxed{ + State__: MessageUnboxedState_ERROR, + Error__: &v, + } +} + +func NewMessageUnboxedWithOutbox(v OutboxRecord) MessageUnboxed { + return MessageUnboxed{ + State__: MessageUnboxedState_OUTBOX, + Outbox__: &v, + } +} + +func NewMessageUnboxedWithPlaceholder(v MessageUnboxedPlaceholder) MessageUnboxed { + return MessageUnboxed{ + State__: MessageUnboxedState_PLACEHOLDER, + Placeholder__: &v, + } +} + +func NewMessageUnboxedWithJourneycard(v MessageUnboxedJourneycard) MessageUnboxed { + return MessageUnboxed{ + State__: MessageUnboxedState_JOURNEYCARD, + Journeycard__: &v, + } +} + +func (o MessageUnboxed) DeepCopy() MessageUnboxed { + return MessageUnboxed{ + State__: o.State__.DeepCopy(), + Valid__: (func(x *MessageUnboxedValid) *MessageUnboxedValid { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Valid__), + Error__: (func(x *MessageUnboxedError) *MessageUnboxedError { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Error__), + Outbox__: (func(x *OutboxRecord) *OutboxRecord { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Outbox__), + Placeholder__: (func(x *MessageUnboxedPlaceholder) *MessageUnboxedPlaceholder { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Placeholder__), + Journeycard__: (func(x *MessageUnboxedJourneycard) *MessageUnboxedJourneycard { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Journeycard__), + } +} + +type UnreadFirstNumLimit struct { + NumRead int `codec:"NumRead" json:"NumRead"` + AtLeast int `codec:"AtLeast" json:"AtLeast"` + AtMost int `codec:"AtMost" json:"AtMost"` +} + +func (o UnreadFirstNumLimit) DeepCopy() UnreadFirstNumLimit { + return UnreadFirstNumLimit{ + NumRead: o.NumRead, + AtLeast: o.AtLeast, + AtMost: o.AtMost, + } +} + +type ConversationLocalParticipant struct { + Username string `codec:"username" json:"username"` + InConvName bool `codec:"inConvName" json:"inConvName"` + Fullname *string `codec:"fullname,omitempty" json:"fullname,omitempty"` + ContactName *string `codec:"contactName,omitempty" json:"contactName,omitempty"` +} + +func (o ConversationLocalParticipant) DeepCopy() ConversationLocalParticipant { + return ConversationLocalParticipant{ + Username: o.Username, + InConvName: o.InConvName, + Fullname: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Fullname), + ContactName: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.ContactName), + } +} + +type ConversationPinnedMessage struct { + Message MessageUnboxed `codec:"message" json:"message"` + PinnerUsername string `codec:"pinnerUsername" json:"pinnerUsername"` +} + +func (o ConversationPinnedMessage) DeepCopy() ConversationPinnedMessage { + return ConversationPinnedMessage{ + Message: o.Message.DeepCopy(), + PinnerUsername: o.PinnerUsername, + } +} + +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"` +} + +func (o ConversationInfoLocal) DeepCopy() ConversationInfoLocal { + return ConversationInfoLocal{ + Id: o.Id.DeepCopy(), + Triple: o.Triple.DeepCopy(), + TlfName: o.TlfName, + TopicName: o.TopicName, + Headline: o.Headline, + SnippetMsg: (func(x *MessageUnboxed) *MessageUnboxed { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.SnippetMsg), + PinnedMsg: (func(x *ConversationPinnedMessage) *ConversationPinnedMessage { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.PinnedMsg), + Draft: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Draft), + Visibility: o.Visibility.DeepCopy(), + IsDefaultConv: o.IsDefaultConv, + Status: o.Status.DeepCopy(), + MembersType: o.MembersType.DeepCopy(), + MemberStatus: o.MemberStatus.DeepCopy(), + TeamType: o.TeamType.DeepCopy(), + Existence: o.Existence.DeepCopy(), + Version: o.Version.DeepCopy(), + LocalVersion: o.LocalVersion.DeepCopy(), + Participants: (func(x []ConversationLocalParticipant) []ConversationLocalParticipant { + if x == nil { + return nil + } + ret := make([]ConversationLocalParticipant, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Participants), + FinalizeInfo: (func(x *ConversationFinalizeInfo) *ConversationFinalizeInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.FinalizeInfo), + ResetNames: (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.ResetNames), + } +} + +type ConversationErrorType int + +const ( + ConversationErrorType_PERMANENT ConversationErrorType = 0 + ConversationErrorType_MISSINGINFO ConversationErrorType = 1 + ConversationErrorType_SELFREKEYNEEDED ConversationErrorType = 2 + ConversationErrorType_OTHERREKEYNEEDED ConversationErrorType = 3 + ConversationErrorType_IDENTIFY ConversationErrorType = 4 + ConversationErrorType_TRANSIENT ConversationErrorType = 5 + ConversationErrorType_NONE ConversationErrorType = 6 +) + +func (o ConversationErrorType) DeepCopy() ConversationErrorType { return o } + +var ConversationErrorTypeMap = map[string]ConversationErrorType{ + "PERMANENT": 0, + "MISSINGINFO": 1, + "SELFREKEYNEEDED": 2, + "OTHERREKEYNEEDED": 3, + "IDENTIFY": 4, + "TRANSIENT": 5, + "NONE": 6, +} + +var ConversationErrorTypeRevMap = map[ConversationErrorType]string{ + 0: "PERMANENT", + 1: "MISSINGINFO", + 2: "SELFREKEYNEEDED", + 3: "OTHERREKEYNEEDED", + 4: "IDENTIFY", + 5: "TRANSIENT", + 6: "NONE", +} + +func (e ConversationErrorType) String() string { + if v, ok := ConversationErrorTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ConversationErrorLocal struct { + Typ ConversationErrorType `codec:"typ" json:"typ"` + Message string `codec:"message" json:"message"` + RemoteConv Conversation `codec:"remoteConv" json:"remoteConv"` + UnverifiedTLFName string `codec:"unverifiedTLFName" json:"unverifiedTLFName"` + RekeyInfo *ConversationErrorRekey `codec:"rekeyInfo,omitempty" json:"rekeyInfo,omitempty"` +} + +func (o ConversationErrorLocal) DeepCopy() ConversationErrorLocal { + return ConversationErrorLocal{ + Typ: o.Typ.DeepCopy(), + Message: o.Message, + RemoteConv: o.RemoteConv.DeepCopy(), + UnverifiedTLFName: o.UnverifiedTLFName, + RekeyInfo: (func(x *ConversationErrorRekey) *ConversationErrorRekey { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RekeyInfo), + } +} + +type ConversationErrorRekey struct { + TlfName string `codec:"tlfName" json:"tlfName"` + TlfPublic bool `codec:"tlfPublic" json:"tlfPublic"` + Rekeyers []string `codec:"rekeyers" json:"rekeyers"` + WriterNames []string `codec:"writerNames" json:"writerNames"` + ReaderNames []string `codec:"readerNames" json:"readerNames"` +} + +func (o ConversationErrorRekey) DeepCopy() ConversationErrorRekey { + return ConversationErrorRekey{ + TlfName: o.TlfName, + TlfPublic: o.TlfPublic, + Rekeyers: (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.Rekeyers), + WriterNames: (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.WriterNames), + ReaderNames: (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.ReaderNames), + } +} + +type ConversationMinWriterRoleInfoLocal struct { + ChangedBy string `codec:"changedBy" json:"changedBy"` + CannotWrite bool `codec:"cannotWrite" json:"cannotWrite"` + Role keybase1.TeamRole `codec:"role" json:"role"` +} + +func (o ConversationMinWriterRoleInfoLocal) DeepCopy() ConversationMinWriterRoleInfoLocal { + return ConversationMinWriterRoleInfoLocal{ + ChangedBy: o.ChangedBy, + CannotWrite: o.CannotWrite, + Role: o.Role.DeepCopy(), + } +} + +type ConversationSettingsLocal struct { + MinWriterRoleInfo *ConversationMinWriterRoleInfoLocal `codec:"minWriterRoleInfo,omitempty" json:"minWriterRoleInfo,omitempty"` +} + +func (o ConversationSettingsLocal) DeepCopy() ConversationSettingsLocal { + return ConversationSettingsLocal{ + MinWriterRoleInfo: (func(x *ConversationMinWriterRoleInfoLocal) *ConversationMinWriterRoleInfoLocal { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.MinWriterRoleInfo), + } +} + +type ConversationLocal struct { + Error *ConversationErrorLocal `codec:"error,omitempty" json:"error,omitempty"` + Info ConversationInfoLocal `codec:"info" json:"info"` + ReaderInfo ConversationReaderInfo `codec:"readerInfo" json:"readerInfo"` + CreatorInfo *ConversationCreatorInfoLocal `codec:"creatorInfo,omitempty" json:"creatorInfo,omitempty"` + Notifications *ConversationNotificationInfo `codec:"notifications,omitempty" json:"notifications,omitempty"` + Supersedes []ConversationMetadata `codec:"supersedes" json:"supersedes"` + SupersededBy []ConversationMetadata `codec:"supersededBy" json:"supersededBy"` + MaxMessages []MessageSummary `codec:"maxMessages" json:"maxMessages"` + IsEmpty bool `codec:"isEmpty" json:"isEmpty"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` + Expunge Expunge `codec:"expunge" json:"expunge"` + ConvRetention *RetentionPolicy `codec:"convRetention,omitempty" json:"convRetention,omitempty"` + TeamRetention *RetentionPolicy `codec:"teamRetention,omitempty" json:"teamRetention,omitempty"` + ConvSettings *ConversationSettingsLocal `codec:"convSettings,omitempty" json:"convSettings,omitempty"` + Commands ConversationCommandGroups `codec:"commands" json:"commands"` + BotCommands ConversationCommandGroups `codec:"botCommands" json:"botCommands"` + BotAliases map[string]string `codec:"botAliases" json:"botAliases"` +} + +func (o ConversationLocal) DeepCopy() ConversationLocal { + return ConversationLocal{ + Error: (func(x *ConversationErrorLocal) *ConversationErrorLocal { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Error), + Info: o.Info.DeepCopy(), + ReaderInfo: o.ReaderInfo.DeepCopy(), + CreatorInfo: (func(x *ConversationCreatorInfoLocal) *ConversationCreatorInfoLocal { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.CreatorInfo), + Notifications: (func(x *ConversationNotificationInfo) *ConversationNotificationInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Notifications), + Supersedes: (func(x []ConversationMetadata) []ConversationMetadata { + if x == nil { + return nil + } + ret := make([]ConversationMetadata, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Supersedes), + SupersededBy: (func(x []ConversationMetadata) []ConversationMetadata { + if x == nil { + return nil + } + ret := make([]ConversationMetadata, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.SupersededBy), + MaxMessages: (func(x []MessageSummary) []MessageSummary { + if x == nil { + return nil + } + ret := make([]MessageSummary, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.MaxMessages), + IsEmpty: o.IsEmpty, + 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), + Expunge: o.Expunge.DeepCopy(), + ConvRetention: (func(x *RetentionPolicy) *RetentionPolicy { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ConvRetention), + TeamRetention: (func(x *RetentionPolicy) *RetentionPolicy { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.TeamRetention), + ConvSettings: (func(x *ConversationSettingsLocal) *ConversationSettingsLocal { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ConvSettings), + Commands: o.Commands.DeepCopy(), + BotCommands: o.BotCommands.DeepCopy(), + BotAliases: (func(x map[string]string) map[string]string { + if x == nil { + return nil + } + ret := make(map[string]string, len(x)) + for k, v := range x { + kCopy := k + vCopy := v + ret[kCopy] = vCopy + } + return ret + })(o.BotAliases), + } +} + +type NonblockFetchRes struct { + Offline bool `codec:"offline" json:"offline"` + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` +} + +func (o NonblockFetchRes) DeepCopy() NonblockFetchRes { + return NonblockFetchRes{ + 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), + 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 ThreadView struct { + Messages []MessageUnboxed `codec:"messages" json:"messages"` + Pagination *Pagination `codec:"pagination,omitempty" json:"pagination,omitempty"` +} + +func (o ThreadView) DeepCopy() ThreadView { + return ThreadView{ + Messages: (func(x []MessageUnboxed) []MessageUnboxed { + if x == nil { + return nil + } + ret := make([]MessageUnboxed, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Messages), + Pagination: (func(x *Pagination) *Pagination { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Pagination), + } +} + +type MessageIDControlMode int + +const ( + MessageIDControlMode_OLDERMESSAGES MessageIDControlMode = 0 + MessageIDControlMode_NEWERMESSAGES MessageIDControlMode = 1 + MessageIDControlMode_CENTERED MessageIDControlMode = 2 + MessageIDControlMode_UNREADLINE MessageIDControlMode = 3 +) + +func (o MessageIDControlMode) DeepCopy() MessageIDControlMode { return o } + +var MessageIDControlModeMap = map[string]MessageIDControlMode{ + "OLDERMESSAGES": 0, + "NEWERMESSAGES": 1, + "CENTERED": 2, + "UNREADLINE": 3, +} + +var MessageIDControlModeRevMap = map[MessageIDControlMode]string{ + 0: "OLDERMESSAGES", + 1: "NEWERMESSAGES", + 2: "CENTERED", + 3: "UNREADLINE", +} + +func (e MessageIDControlMode) String() string { + if v, ok := MessageIDControlModeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type MessageIDControl struct { + Pivot *MessageID `codec:"pivot,omitempty" json:"pivot,omitempty"` + Mode MessageIDControlMode `codec:"mode" json:"mode"` + Num int `codec:"num" json:"num"` +} + +func (o MessageIDControl) DeepCopy() MessageIDControl { + return MessageIDControl{ + Pivot: (func(x *MessageID) *MessageID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Pivot), + Mode: o.Mode.DeepCopy(), + Num: o.Num, + } +} + +type GetThreadQuery struct { + MarkAsRead bool `codec:"markAsRead" json:"markAsRead"` + MessageTypes []MessageType `codec:"messageTypes" json:"messageTypes"` + DisableResolveSupersedes bool `codec:"disableResolveSupersedes" json:"disableResolveSupersedes"` + EnableDeletePlaceholders bool `codec:"enableDeletePlaceholders" json:"enableDeletePlaceholders"` + DisablePostProcessThread bool `codec:"disablePostProcessThread" json:"disablePostProcessThread"` + Before *gregor1.Time `codec:"before,omitempty" json:"before,omitempty"` + After *gregor1.Time `codec:"after,omitempty" json:"after,omitempty"` + MessageIDControl *MessageIDControl `codec:"messageIDControl,omitempty" json:"messageIDControl,omitempty"` +} + +func (o GetThreadQuery) DeepCopy() GetThreadQuery { + return GetThreadQuery{ + MarkAsRead: o.MarkAsRead, + MessageTypes: (func(x []MessageType) []MessageType { + if x == nil { + return nil + } + ret := make([]MessageType, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.MessageTypes), + DisableResolveSupersedes: o.DisableResolveSupersedes, + EnableDeletePlaceholders: o.EnableDeletePlaceholders, + DisablePostProcessThread: o.DisablePostProcessThread, + Before: (func(x *gregor1.Time) *gregor1.Time { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Before), + After: (func(x *gregor1.Time) *gregor1.Time { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.After), + MessageIDControl: (func(x *MessageIDControl) *MessageIDControl { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.MessageIDControl), + } +} + +type GetThreadLocalRes struct { + Thread ThreadView `codec:"thread" json:"thread"` + Offline bool `codec:"offline" json:"offline"` + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` +} + +func (o GetThreadLocalRes) DeepCopy() GetThreadLocalRes { + return GetThreadLocalRes{ + Thread: o.Thread.DeepCopy(), + 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), + 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 GetThreadNonblockCbMode int + +const ( + GetThreadNonblockCbMode_FULL GetThreadNonblockCbMode = 0 + GetThreadNonblockCbMode_INCREMENTAL GetThreadNonblockCbMode = 1 +) + +func (o GetThreadNonblockCbMode) DeepCopy() GetThreadNonblockCbMode { return o } + +var GetThreadNonblockCbModeMap = map[string]GetThreadNonblockCbMode{ + "FULL": 0, + "INCREMENTAL": 1, +} + +var GetThreadNonblockCbModeRevMap = map[GetThreadNonblockCbMode]string{ + 0: "FULL", + 1: "INCREMENTAL", +} + +func (e GetThreadNonblockCbMode) String() string { + if v, ok := GetThreadNonblockCbModeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type GetThreadNonblockPgMode int + +const ( + GetThreadNonblockPgMode_DEFAULT GetThreadNonblockPgMode = 0 + GetThreadNonblockPgMode_SERVER GetThreadNonblockPgMode = 1 +) + +func (o GetThreadNonblockPgMode) DeepCopy() GetThreadNonblockPgMode { return o } + +var GetThreadNonblockPgModeMap = map[string]GetThreadNonblockPgMode{ + "DEFAULT": 0, + "SERVER": 1, +} + +var GetThreadNonblockPgModeRevMap = map[GetThreadNonblockPgMode]string{ + 0: "DEFAULT", + 1: "SERVER", +} + +func (e GetThreadNonblockPgMode) String() string { + if v, ok := GetThreadNonblockPgModeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type UnreadlineRes struct { + Offline bool `codec:"offline" json:"offline"` + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` + UnreadlineID *MessageID `codec:"unreadlineID,omitempty" json:"unreadlineID,omitempty"` +} + +func (o UnreadlineRes) DeepCopy() UnreadlineRes { + return UnreadlineRes{ + 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), + 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), + UnreadlineID: (func(x *MessageID) *MessageID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.UnreadlineID), + } +} + +type NameQuery struct { + Name string `codec:"name" json:"name"` + TlfID *TLFID `codec:"tlfID,omitempty" json:"tlfID,omitempty"` + MembersType ConversationMembersType `codec:"membersType" json:"membersType"` +} + +func (o NameQuery) DeepCopy() NameQuery { + return NameQuery{ + Name: o.Name, + TlfID: (func(x *TLFID) *TLFID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.TlfID), + MembersType: o.MembersType.DeepCopy(), + } +} + +type GetInboxLocalQuery struct { + Name *NameQuery `codec:"name,omitempty" json:"name,omitempty"` + TopicName *string `codec:"topicName,omitempty" json:"topicName,omitempty"` + ConvIDs []ConversationID `codec:"convIDs" json:"convIDs"` + TopicType *TopicType `codec:"topicType,omitempty" json:"topicType,omitempty"` + TlfVisibility *keybase1.TLFVisibility `codec:"tlfVisibility,omitempty" json:"tlfVisibility,omitempty"` + Before *gregor1.Time `codec:"before,omitempty" json:"before,omitempty"` + After *gregor1.Time `codec:"after,omitempty" json:"after,omitempty"` + OneChatTypePerTLF *bool `codec:"oneChatTypePerTLF,omitempty" json:"oneChatTypePerTLF,omitempty"` + Status []ConversationStatus `codec:"status" json:"status"` + MemberStatus []ConversationMemberStatus `codec:"memberStatus" json:"memberStatus"` + UnreadOnly bool `codec:"unreadOnly" json:"unreadOnly"` + ReadOnly bool `codec:"readOnly" json:"readOnly"` + ComputeActiveList bool `codec:"computeActiveList" json:"computeActiveList"` +} + +func (o GetInboxLocalQuery) DeepCopy() GetInboxLocalQuery { + return GetInboxLocalQuery{ + Name: (func(x *NameQuery) *NameQuery { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Name), + TopicName: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.TopicName), + 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), + TopicType: (func(x *TopicType) *TopicType { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.TopicType), + TlfVisibility: (func(x *keybase1.TLFVisibility) *keybase1.TLFVisibility { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.TlfVisibility), + Before: (func(x *gregor1.Time) *gregor1.Time { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Before), + After: (func(x *gregor1.Time) *gregor1.Time { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.After), + OneChatTypePerTLF: (func(x *bool) *bool { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.OneChatTypePerTLF), + Status: (func(x []ConversationStatus) []ConversationStatus { + if x == nil { + return nil + } + ret := make([]ConversationStatus, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Status), + MemberStatus: (func(x []ConversationMemberStatus) []ConversationMemberStatus { + if x == nil { + return nil + } + ret := make([]ConversationMemberStatus, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.MemberStatus), + UnreadOnly: o.UnreadOnly, + ReadOnly: o.ReadOnly, + ComputeActiveList: o.ComputeActiveList, + } +} + +type GetInboxAndUnboxLocalRes struct { + Conversations []ConversationLocal `codec:"conversations" json:"conversations"` + Offline bool `codec:"offline" json:"offline"` + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` +} + +func (o GetInboxAndUnboxLocalRes) DeepCopy() GetInboxAndUnboxLocalRes { + return GetInboxAndUnboxLocalRes{ + Conversations: (func(x []ConversationLocal) []ConversationLocal { + if x == nil { + return nil + } + ret := make([]ConversationLocal, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Conversations), + 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), + 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 GetInboxAndUnboxUILocalRes struct { + Conversations []InboxUIItem `codec:"conversations" json:"conversations"` + Offline bool `codec:"offline" json:"offline"` + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` +} + +func (o GetInboxAndUnboxUILocalRes) DeepCopy() GetInboxAndUnboxUILocalRes { + return GetInboxAndUnboxUILocalRes{ + Conversations: (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.Conversations), + 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), + 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 InboxLayoutReselectMode int + +const ( + InboxLayoutReselectMode_DEFAULT InboxLayoutReselectMode = 0 + InboxLayoutReselectMode_FORCE InboxLayoutReselectMode = 1 +) + +func (o InboxLayoutReselectMode) DeepCopy() InboxLayoutReselectMode { return o } + +var InboxLayoutReselectModeMap = map[string]InboxLayoutReselectMode{ + "DEFAULT": 0, + "FORCE": 1, +} + +var InboxLayoutReselectModeRevMap = map[InboxLayoutReselectMode]string{ + 0: "DEFAULT", + 1: "FORCE", +} + +func (e InboxLayoutReselectMode) String() string { + if v, ok := InboxLayoutReselectModeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type PostLocalRes struct { + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` + MessageID MessageID `codec:"messageID" json:"messageID"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` +} + +func (o PostLocalRes) DeepCopy() PostLocalRes { + return PostLocalRes{ + 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), + MessageID: o.MessageID.DeepCopy(), + 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 PostLocalNonblockRes struct { + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` + OutboxID OutboxID `codec:"outboxID" json:"outboxID"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` +} + +func (o PostLocalNonblockRes) DeepCopy() PostLocalNonblockRes { + return PostLocalNonblockRes{ + 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), + OutboxID: o.OutboxID.DeepCopy(), + 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 EditTarget struct { + MessageID *MessageID `codec:"messageID,omitempty" json:"messageID,omitempty"` + OutboxID *OutboxID `codec:"outboxID,omitempty" json:"outboxID,omitempty"` +} + +func (o EditTarget) DeepCopy() EditTarget { + return EditTarget{ + MessageID: (func(x *MessageID) *MessageID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.MessageID), + OutboxID: (func(x *OutboxID) *OutboxID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.OutboxID), + } +} + +type SetConversationStatusLocalRes struct { + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` +} + +func (o SetConversationStatusLocalRes) DeepCopy() SetConversationStatusLocalRes { + return SetConversationStatusLocalRes{ + 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 NewConversationLocalRes struct { + Conv ConversationLocal `codec:"conv" json:"conv"` + UiConv InboxUIItem `codec:"uiConv" json:"uiConv"` + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` +} + +func (o NewConversationLocalRes) DeepCopy() NewConversationLocalRes { + return NewConversationLocalRes{ + Conv: o.Conv.DeepCopy(), + UiConv: o.UiConv.DeepCopy(), + 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 GetInboxSummaryForCLILocalQuery struct { + TopicType TopicType `codec:"topicType" json:"topicType"` + After string `codec:"after" json:"after"` + Before string `codec:"before" json:"before"` + Visibility keybase1.TLFVisibility `codec:"visibility" json:"visibility"` + Status []ConversationStatus `codec:"status" json:"status"` + ConvIDs []ConversationID `codec:"convIDs" json:"convIDs"` + UnreadFirst bool `codec:"unreadFirst" json:"unreadFirst"` + UnreadFirstLimit UnreadFirstNumLimit `codec:"unreadFirstLimit" json:"unreadFirstLimit"` + ActivitySortedLimit int `codec:"activitySortedLimit" json:"activitySortedLimit"` +} + +func (o GetInboxSummaryForCLILocalQuery) DeepCopy() GetInboxSummaryForCLILocalQuery { + return GetInboxSummaryForCLILocalQuery{ + TopicType: o.TopicType.DeepCopy(), + After: o.After, + Before: o.Before, + Visibility: o.Visibility.DeepCopy(), + Status: (func(x []ConversationStatus) []ConversationStatus { + if x == nil { + return nil + } + ret := make([]ConversationStatus, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Status), + 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), + UnreadFirst: o.UnreadFirst, + UnreadFirstLimit: o.UnreadFirstLimit.DeepCopy(), + ActivitySortedLimit: o.ActivitySortedLimit, + } +} + +type GetInboxSummaryForCLILocalRes struct { + Conversations []ConversationLocal `codec:"conversations" json:"conversations"` + Offline bool `codec:"offline" json:"offline"` + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` +} + +func (o GetInboxSummaryForCLILocalRes) DeepCopy() GetInboxSummaryForCLILocalRes { + return GetInboxSummaryForCLILocalRes{ + Conversations: (func(x []ConversationLocal) []ConversationLocal { + if x == nil { + return nil + } + ret := make([]ConversationLocal, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Conversations), + 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 GetConversationForCLILocalQuery struct { + MarkAsRead bool `codec:"markAsRead" json:"markAsRead"` + MessageTypes []MessageType `codec:"MessageTypes" json:"MessageTypes"` + Since *string `codec:"Since,omitempty" json:"Since,omitempty"` + Limit UnreadFirstNumLimit `codec:"limit" json:"limit"` + Conv ConversationLocal `codec:"conv" json:"conv"` +} + +func (o GetConversationForCLILocalQuery) DeepCopy() GetConversationForCLILocalQuery { + return GetConversationForCLILocalQuery{ + MarkAsRead: o.MarkAsRead, + MessageTypes: (func(x []MessageType) []MessageType { + if x == nil { + return nil + } + ret := make([]MessageType, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.MessageTypes), + Since: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Since), + Limit: o.Limit.DeepCopy(), + Conv: o.Conv.DeepCopy(), + } +} + +type GetConversationForCLILocalRes struct { + Conversation ConversationLocal `codec:"conversation" json:"conversation"` + Messages []MessageUnboxed `codec:"messages" json:"messages"` + Offline bool `codec:"offline" json:"offline"` + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` +} + +func (o GetConversationForCLILocalRes) DeepCopy() GetConversationForCLILocalRes { + return GetConversationForCLILocalRes{ + Conversation: o.Conversation.DeepCopy(), + Messages: (func(x []MessageUnboxed) []MessageUnboxed { + if x == nil { + return nil + } + ret := make([]MessageUnboxed, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Messages), + 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 GetMessagesLocalRes struct { + Messages []MessageUnboxed `codec:"messages" json:"messages"` + Offline bool `codec:"offline" json:"offline"` + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` +} + +func (o GetMessagesLocalRes) DeepCopy() GetMessagesLocalRes { + return GetMessagesLocalRes{ + Messages: (func(x []MessageUnboxed) []MessageUnboxed { + if x == nil { + return nil + } + ret := make([]MessageUnboxed, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Messages), + 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), + 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 PostFileAttachmentArg struct { + ConversationID ConversationID `codec:"conversationID" json:"conversationID"` + TlfName string `codec:"tlfName" json:"tlfName"` + Visibility keybase1.TLFVisibility `codec:"visibility" json:"visibility"` + Filename string `codec:"filename" json:"filename"` + Title string `codec:"title" json:"title"` + Metadata []byte `codec:"metadata" json:"metadata"` + IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` + CallerPreview *MakePreviewRes `codec:"callerPreview,omitempty" json:"callerPreview,omitempty"` + OutboxID *OutboxID `codec:"outboxID,omitempty" json:"outboxID,omitempty"` + EphemeralLifetime *gregor1.DurationSec `codec:"ephemeralLifetime,omitempty" json:"ephemeralLifetime,omitempty"` +} + +func (o PostFileAttachmentArg) DeepCopy() PostFileAttachmentArg { + return PostFileAttachmentArg{ + ConversationID: o.ConversationID.DeepCopy(), + TlfName: o.TlfName, + Visibility: o.Visibility.DeepCopy(), + Filename: o.Filename, + Title: o.Title, + Metadata: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.Metadata), + IdentifyBehavior: o.IdentifyBehavior.DeepCopy(), + CallerPreview: (func(x *MakePreviewRes) *MakePreviewRes { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.CallerPreview), + OutboxID: (func(x *OutboxID) *OutboxID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.OutboxID), + EphemeralLifetime: (func(x *gregor1.DurationSec) *gregor1.DurationSec { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.EphemeralLifetime), + } +} + +type GetNextAttachmentMessageLocalRes struct { + Message *UIMessage `codec:"message,omitempty" json:"message,omitempty"` + Offline bool `codec:"offline" json:"offline"` + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` +} + +func (o GetNextAttachmentMessageLocalRes) DeepCopy() GetNextAttachmentMessageLocalRes { + return GetNextAttachmentMessageLocalRes{ + Message: (func(x *UIMessage) *UIMessage { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Message), + 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), + 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 DownloadAttachmentLocalRes struct { + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` +} + +func (o DownloadAttachmentLocalRes) DeepCopy() DownloadAttachmentLocalRes { + return DownloadAttachmentLocalRes{ + 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 DownloadFileAttachmentLocalRes struct { + FilePath string `codec:"filePath" json:"filePath"` + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` +} + +func (o DownloadFileAttachmentLocalRes) DeepCopy() DownloadFileAttachmentLocalRes { + return DownloadFileAttachmentLocalRes{ + FilePath: o.FilePath, + 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 PreviewLocationTyp int + +const ( + PreviewLocationTyp_URL PreviewLocationTyp = 0 + PreviewLocationTyp_FILE PreviewLocationTyp = 1 + PreviewLocationTyp_BYTES PreviewLocationTyp = 2 +) + +func (o PreviewLocationTyp) DeepCopy() PreviewLocationTyp { return o } + +var PreviewLocationTypMap = map[string]PreviewLocationTyp{ + "URL": 0, + "FILE": 1, + "BYTES": 2, +} + +var PreviewLocationTypRevMap = map[PreviewLocationTyp]string{ + 0: "URL", + 1: "FILE", + 2: "BYTES", +} + +func (e PreviewLocationTyp) String() string { + if v, ok := PreviewLocationTypRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type PreviewLocation struct { + Ltyp__ PreviewLocationTyp `codec:"ltyp" json:"ltyp"` + Url__ *string `codec:"url,omitempty" json:"url,omitempty"` + File__ *string `codec:"file,omitempty" json:"file,omitempty"` + Bytes__ *[]byte `codec:"bytes,omitempty" json:"bytes,omitempty"` +} + +func (o *PreviewLocation) Ltyp() (ret PreviewLocationTyp, err error) { + switch o.Ltyp__ { + case PreviewLocationTyp_URL: + if o.Url__ == nil { + err = errors.New("unexpected nil value for Url__") + return ret, err + } + case PreviewLocationTyp_FILE: + if o.File__ == nil { + err = errors.New("unexpected nil value for File__") + return ret, err + } + case PreviewLocationTyp_BYTES: + if o.Bytes__ == nil { + err = errors.New("unexpected nil value for Bytes__") + return ret, err + } + } + return o.Ltyp__, nil +} + +func (o PreviewLocation) Url() (res string) { + if o.Ltyp__ != PreviewLocationTyp_URL { + panic("wrong case accessed") + } + if o.Url__ == nil { + return + } + return *o.Url__ +} + +func (o PreviewLocation) File() (res string) { + if o.Ltyp__ != PreviewLocationTyp_FILE { + panic("wrong case accessed") + } + if o.File__ == nil { + return + } + return *o.File__ +} + +func (o PreviewLocation) Bytes() (res []byte) { + if o.Ltyp__ != PreviewLocationTyp_BYTES { + panic("wrong case accessed") + } + if o.Bytes__ == nil { + return + } + return *o.Bytes__ +} + +func NewPreviewLocationWithUrl(v string) PreviewLocation { + return PreviewLocation{ + Ltyp__: PreviewLocationTyp_URL, + Url__: &v, + } +} + +func NewPreviewLocationWithFile(v string) PreviewLocation { + return PreviewLocation{ + Ltyp__: PreviewLocationTyp_FILE, + File__: &v, + } +} + +func NewPreviewLocationWithBytes(v []byte) PreviewLocation { + return PreviewLocation{ + Ltyp__: PreviewLocationTyp_BYTES, + Bytes__: &v, + } +} + +func (o PreviewLocation) DeepCopy() PreviewLocation { + return PreviewLocation{ + Ltyp__: o.Ltyp__.DeepCopy(), + Url__: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Url__), + File__: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.File__), + Bytes__: (func(x *[]byte) *[]byte { + if x == nil { + return nil + } + tmp := (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })((*x)) + return &tmp + })(o.Bytes__), + } +} + +type MakePreviewRes struct { + MimeType string `codec:"mimeType" json:"mimeType"` + PreviewMimeType *string `codec:"previewMimeType,omitempty" json:"previewMimeType,omitempty"` + Location *PreviewLocation `codec:"location,omitempty" json:"location,omitempty"` + Metadata *AssetMetadata `codec:"metadata,omitempty" json:"metadata,omitempty"` + BaseMetadata *AssetMetadata `codec:"baseMetadata,omitempty" json:"baseMetadata,omitempty"` +} + +func (o MakePreviewRes) DeepCopy() MakePreviewRes { + return MakePreviewRes{ + MimeType: o.MimeType, + PreviewMimeType: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.PreviewMimeType), + Location: (func(x *PreviewLocation) *PreviewLocation { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Location), + Metadata: (func(x *AssetMetadata) *AssetMetadata { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Metadata), + BaseMetadata: (func(x *AssetMetadata) *AssetMetadata { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.BaseMetadata), + } +} + +type MarkAsReadLocalRes struct { + Offline bool `codec:"offline" json:"offline"` + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` +} + +func (o MarkAsReadLocalRes) DeepCopy() MarkAsReadLocalRes { + return MarkAsReadLocalRes{ + 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 FindConversationsLocalRes struct { + Conversations []ConversationLocal `codec:"conversations" json:"conversations"` + UiConversations []InboxUIItem `codec:"uiConversations" json:"uiConversations"` + Offline bool `codec:"offline" json:"offline"` + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` +} + +func (o FindConversationsLocalRes) DeepCopy() FindConversationsLocalRes { + return FindConversationsLocalRes{ + Conversations: (func(x []ConversationLocal) []ConversationLocal { + if x == nil { + return nil + } + ret := make([]ConversationLocal, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Conversations), + UiConversations: (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.UiConversations), + 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), + 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 JoinLeaveConversationLocalRes struct { + Offline bool `codec:"offline" json:"offline"` + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` +} + +func (o JoinLeaveConversationLocalRes) DeepCopy() JoinLeaveConversationLocalRes { + return JoinLeaveConversationLocalRes{ + 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 PreviewConversationLocalRes struct { + Conv InboxUIItem `codec:"conv" json:"conv"` + Offline bool `codec:"offline" json:"offline"` + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` +} + +func (o PreviewConversationLocalRes) DeepCopy() PreviewConversationLocalRes { + return PreviewConversationLocalRes{ + Conv: o.Conv.DeepCopy(), + 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 DeleteConversationLocalRes struct { + Offline bool `codec:"offline" json:"offline"` + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` +} + +func (o DeleteConversationLocalRes) DeepCopy() DeleteConversationLocalRes { + return DeleteConversationLocalRes{ + 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 GetTLFConversationsLocalRes struct { + Convs []InboxUIItem `codec:"convs" json:"convs"` + Offline bool `codec:"offline" json:"offline"` + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` +} + +func (o GetTLFConversationsLocalRes) DeepCopy() GetTLFConversationsLocalRes { + return GetTLFConversationsLocalRes{ + 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), + 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"` +} + +func (o SetAppNotificationSettingsLocalRes) DeepCopy() SetAppNotificationSettingsLocalRes { + return SetAppNotificationSettingsLocalRes{ + 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 AppNotificationSettingLocal struct { + DeviceType keybase1.DeviceType `codec:"deviceType" json:"deviceType"` + Kind NotificationKind `codec:"kind" json:"kind"` + Enabled bool `codec:"enabled" json:"enabled"` +} + +func (o AppNotificationSettingLocal) DeepCopy() AppNotificationSettingLocal { + return AppNotificationSettingLocal{ + DeviceType: o.DeviceType.DeepCopy(), + Kind: o.Kind.DeepCopy(), + Enabled: o.Enabled, + } +} + +type ResetConvMember struct { + Username string `codec:"username" json:"username"` + Uid gregor1.UID `codec:"uid" json:"uid"` + Conv ConversationID `codec:"conv" json:"conv"` +} + +func (o ResetConvMember) DeepCopy() ResetConvMember { + return ResetConvMember{ + Username: o.Username, + Uid: o.Uid.DeepCopy(), + Conv: o.Conv.DeepCopy(), + } +} + +type GetAllResetConvMembersRes struct { + Members []ResetConvMember `codec:"members" json:"members"` + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` +} + +func (o GetAllResetConvMembersRes) DeepCopy() GetAllResetConvMembersRes { + return GetAllResetConvMembersRes{ + Members: (func(x []ResetConvMember) []ResetConvMember { + if x == nil { + return nil + } + ret := make([]ResetConvMember, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Members), + 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 SearchRegexpRes struct { + Offline bool `codec:"offline" json:"offline"` + Hits []ChatSearchHit `codec:"hits" json:"hits"` + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` +} + +func (o SearchRegexpRes) DeepCopy() SearchRegexpRes { + return SearchRegexpRes{ + Offline: o.Offline, + Hits: (func(x []ChatSearchHit) []ChatSearchHit { + if x == nil { + return nil + } + ret := make([]ChatSearchHit, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Hits), + 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 SearchInboxRes struct { + Offline bool `codec:"offline" json:"offline"` + Res *ChatSearchInboxResults `codec:"res,omitempty" json:"res,omitempty"` + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` +} + +func (o SearchInboxRes) DeepCopy() SearchInboxRes { + return SearchInboxRes{ + Offline: o.Offline, + Res: (func(x *ChatSearchInboxResults) *ChatSearchInboxResults { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Res), + 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 ProfileSearchConvStats struct { + Err string `codec:"err" json:"err"` + ConvName string `codec:"convName" json:"convName"` + MinConvID MessageID `codec:"minConvID" json:"minConvID"` + MaxConvID MessageID `codec:"maxConvID" json:"maxConvID"` + NumMissing int `codec:"numMissing" json:"numMissing"` + NumMessages int `codec:"numMessages" json:"numMessages"` + IndexSizeDisk int `codec:"indexSizeDisk" json:"indexSizeDisk"` + IndexSizeMem int64 `codec:"indexSizeMem" json:"indexSizeMem"` + DurationMsec gregor1.DurationMsec `codec:"durationMsec" json:"durationMsec"` + PercentIndexed int `codec:"percentIndexed" json:"percentIndexed"` +} + +func (o ProfileSearchConvStats) DeepCopy() ProfileSearchConvStats { + return ProfileSearchConvStats{ + Err: o.Err, + ConvName: o.ConvName, + MinConvID: o.MinConvID.DeepCopy(), + MaxConvID: o.MaxConvID.DeepCopy(), + NumMissing: o.NumMissing, + NumMessages: o.NumMessages, + IndexSizeDisk: o.IndexSizeDisk, + IndexSizeMem: o.IndexSizeMem, + DurationMsec: o.DurationMsec.DeepCopy(), + PercentIndexed: o.PercentIndexed, + } +} + +type BuiltinCommandGroup struct { + Typ ConversationBuiltinCommandTyp `codec:"typ" json:"typ"` + Commands []ConversationCommand `codec:"commands" json:"commands"` +} + +func (o BuiltinCommandGroup) DeepCopy() BuiltinCommandGroup { + return BuiltinCommandGroup{ + Typ: o.Typ.DeepCopy(), + Commands: (func(x []ConversationCommand) []ConversationCommand { + if x == nil { + return nil + } + ret := make([]ConversationCommand, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Commands), + } +} + +type StaticConfig struct { + DeletableByDeleteHistory []MessageType `codec:"deletableByDeleteHistory" json:"deletableByDeleteHistory"` + BuiltinCommands []BuiltinCommandGroup `codec:"builtinCommands" json:"builtinCommands"` +} + +func (o StaticConfig) DeepCopy() StaticConfig { + return StaticConfig{ + DeletableByDeleteHistory: (func(x []MessageType) []MessageType { + if x == nil { + return nil + } + ret := make([]MessageType, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.DeletableByDeleteHistory), + BuiltinCommands: (func(x []BuiltinCommandGroup) []BuiltinCommandGroup { + if x == nil { + return nil + } + ret := make([]BuiltinCommandGroup, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.BuiltinCommands), + } +} + +type UnfurlPromptAction int + +const ( + UnfurlPromptAction_ALWAYS UnfurlPromptAction = 0 + UnfurlPromptAction_NEVER UnfurlPromptAction = 1 + UnfurlPromptAction_ACCEPT UnfurlPromptAction = 2 + UnfurlPromptAction_NOTNOW UnfurlPromptAction = 3 + UnfurlPromptAction_ONETIME UnfurlPromptAction = 4 +) + +func (o UnfurlPromptAction) DeepCopy() UnfurlPromptAction { return o } + +var UnfurlPromptActionMap = map[string]UnfurlPromptAction{ + "ALWAYS": 0, + "NEVER": 1, + "ACCEPT": 2, + "NOTNOW": 3, + "ONETIME": 4, +} + +var UnfurlPromptActionRevMap = map[UnfurlPromptAction]string{ + 0: "ALWAYS", + 1: "NEVER", + 2: "ACCEPT", + 3: "NOTNOW", + 4: "ONETIME", +} + +func (e UnfurlPromptAction) String() string { + if v, ok := UnfurlPromptActionRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type UnfurlPromptResult struct { + ActionType__ UnfurlPromptAction `codec:"actionType" json:"actionType"` + Accept__ *string `codec:"accept,omitempty" json:"accept,omitempty"` + Onetime__ *string `codec:"onetime,omitempty" json:"onetime,omitempty"` +} + +func (o *UnfurlPromptResult) ActionType() (ret UnfurlPromptAction, err error) { + switch o.ActionType__ { + case UnfurlPromptAction_ACCEPT: + if o.Accept__ == nil { + err = errors.New("unexpected nil value for Accept__") + return ret, err + } + case UnfurlPromptAction_ONETIME: + if o.Onetime__ == nil { + err = errors.New("unexpected nil value for Onetime__") + return ret, err + } + } + return o.ActionType__, nil +} + +func (o UnfurlPromptResult) Accept() (res string) { + if o.ActionType__ != UnfurlPromptAction_ACCEPT { + panic("wrong case accessed") + } + if o.Accept__ == nil { + return + } + return *o.Accept__ +} + +func (o UnfurlPromptResult) Onetime() (res string) { + if o.ActionType__ != UnfurlPromptAction_ONETIME { + panic("wrong case accessed") + } + if o.Onetime__ == nil { + return + } + return *o.Onetime__ +} + +func NewUnfurlPromptResultWithAlways() UnfurlPromptResult { + return UnfurlPromptResult{ + ActionType__: UnfurlPromptAction_ALWAYS, + } +} + +func NewUnfurlPromptResultWithNever() UnfurlPromptResult { + return UnfurlPromptResult{ + ActionType__: UnfurlPromptAction_NEVER, + } +} + +func NewUnfurlPromptResultWithNotnow() UnfurlPromptResult { + return UnfurlPromptResult{ + ActionType__: UnfurlPromptAction_NOTNOW, + } +} + +func NewUnfurlPromptResultWithAccept(v string) UnfurlPromptResult { + return UnfurlPromptResult{ + ActionType__: UnfurlPromptAction_ACCEPT, + Accept__: &v, + } +} + +func NewUnfurlPromptResultWithOnetime(v string) UnfurlPromptResult { + return UnfurlPromptResult{ + ActionType__: UnfurlPromptAction_ONETIME, + Onetime__: &v, + } +} + +func (o UnfurlPromptResult) DeepCopy() UnfurlPromptResult { + return UnfurlPromptResult{ + ActionType__: o.ActionType__.DeepCopy(), + Accept__: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Accept__), + Onetime__: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Onetime__), + } +} + +type GalleryItemTyp int + +const ( + GalleryItemTyp_MEDIA GalleryItemTyp = 0 + GalleryItemTyp_LINK GalleryItemTyp = 1 + GalleryItemTyp_DOC GalleryItemTyp = 2 +) + +func (o GalleryItemTyp) DeepCopy() GalleryItemTyp { return o } + +var GalleryItemTypMap = map[string]GalleryItemTyp{ + "MEDIA": 0, + "LINK": 1, + "DOC": 2, +} + +var GalleryItemTypRevMap = map[GalleryItemTyp]string{ + 0: "MEDIA", + 1: "LINK", + 2: "DOC", +} + +func (e GalleryItemTyp) String() string { + if v, ok := GalleryItemTypRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type LoadGalleryRes struct { + Messages []UIMessage `codec:"messages" json:"messages"` + Last bool `codec:"last" json:"last"` + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` +} + +func (o LoadGalleryRes) DeepCopy() LoadGalleryRes { + return LoadGalleryRes{ + Messages: (func(x []UIMessage) []UIMessage { + if x == nil { + return nil + } + ret := make([]UIMessage, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Messages), + Last: o.Last, + 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 LoadFlipRes struct { + Status UICoinFlipStatus `codec:"status" json:"status"` + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` + IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` +} + +func (o LoadFlipRes) DeepCopy() LoadFlipRes { + return LoadFlipRes{ + Status: o.Status.DeepCopy(), + 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 UserBotExtendedDescription struct { + Title string `codec:"title" json:"title"` + DesktopBody string `codec:"desktopBody" json:"desktop_body"` + MobileBody string `codec:"mobileBody" json:"mobile_body"` +} + +func (o UserBotExtendedDescription) DeepCopy() UserBotExtendedDescription { + return UserBotExtendedDescription{ + Title: o.Title, + DesktopBody: o.DesktopBody, + MobileBody: o.MobileBody, + } +} + +type UserBotCommandOutput struct { + Name string `codec:"name" json:"name"` + Description string `codec:"description" json:"description"` + Usage string `codec:"usage" json:"usage"` + ExtendedDescription *UserBotExtendedDescription `codec:"extendedDescription,omitempty" json:"extended_description,omitempty"` + Username string `codec:"username" json:"username"` +} + +func (o UserBotCommandOutput) DeepCopy() UserBotCommandOutput { + return UserBotCommandOutput{ + Name: o.Name, + Description: o.Description, + Usage: o.Usage, + ExtendedDescription: (func(x *UserBotExtendedDescription) *UserBotExtendedDescription { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ExtendedDescription), + Username: o.Username, + } +} + +type UserBotCommandInput struct { + Name string `codec:"name" json:"name"` + Description string `codec:"description" json:"description"` + Usage string `codec:"usage" json:"usage"` + ExtendedDescription *UserBotExtendedDescription `codec:"extendedDescription,omitempty" json:"extended_description,omitempty"` +} + +func (o UserBotCommandInput) DeepCopy() UserBotCommandInput { + return UserBotCommandInput{ + Name: o.Name, + Description: o.Description, + Usage: o.Usage, + ExtendedDescription: (func(x *UserBotExtendedDescription) *UserBotExtendedDescription { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ExtendedDescription), + } +} + +type AdvertiseCommandsParam struct { + Typ BotCommandsAdvertisementTyp `codec:"typ" json:"typ"` + Commands []UserBotCommandInput `codec:"commands" json:"commands"` + TeamName *string `codec:"teamName,omitempty" json:"teamName,omitempty"` +} + +func (o AdvertiseCommandsParam) DeepCopy() AdvertiseCommandsParam { + return AdvertiseCommandsParam{ + Typ: o.Typ.DeepCopy(), + Commands: (func(x []UserBotCommandInput) []UserBotCommandInput { + if x == nil { + return nil + } + ret := make([]UserBotCommandInput, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Commands), + TeamName: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.TeamName), + } +} + +type AdvertiseBotCommandsLocalRes struct { + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` +} + +func (o AdvertiseBotCommandsLocalRes) DeepCopy() AdvertiseBotCommandsLocalRes { + return AdvertiseBotCommandsLocalRes{ + 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 ListBotCommandsLocalRes struct { + Commands []UserBotCommandOutput `codec:"commands" json:"commands"` + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` +} + +func (o ListBotCommandsLocalRes) DeepCopy() ListBotCommandsLocalRes { + return ListBotCommandsLocalRes{ + Commands: (func(x []UserBotCommandOutput) []UserBotCommandOutput { + if x == nil { + return nil + } + ret := make([]UserBotCommandOutput, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Commands), + 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 ClearBotCommandsLocalRes struct { + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` +} + +func (o ClearBotCommandsLocalRes) DeepCopy() ClearBotCommandsLocalRes { + return ClearBotCommandsLocalRes{ + 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 PinMessageRes struct { + RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` +} + +func (o PinMessageRes) DeepCopy() PinMessageRes { + return PinMessageRes{ + 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 AddBotConvSearchHit 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"` +} + +func (o AddBotConvSearchHit) DeepCopy() AddBotConvSearchHit { + return AddBotConvSearchHit{ + 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), + } +} + +type LocalMtimeUpdate struct { + ConvID ConversationID `codec:"convID" json:"convID"` + Mtime gregor1.Time `codec:"mtime" json:"mtime"` +} + +func (o LocalMtimeUpdate) DeepCopy() LocalMtimeUpdate { + return LocalMtimeUpdate{ + ConvID: o.ConvID.DeepCopy(), + Mtime: o.Mtime.DeepCopy(), + } +} + +type SnippetDecoration int + +const ( + SnippetDecoration_NONE SnippetDecoration = 0 + SnippetDecoration_PENDING_MESSAGE SnippetDecoration = 1 + SnippetDecoration_FAILED_PENDING_MESSAGE SnippetDecoration = 2 + SnippetDecoration_EXPLODING_MESSAGE SnippetDecoration = 3 + SnippetDecoration_EXPLODED_MESSAGE SnippetDecoration = 4 + SnippetDecoration_AUDIO_ATTACHMENT SnippetDecoration = 5 + SnippetDecoration_VIDEO_ATTACHMENT SnippetDecoration = 6 + SnippetDecoration_PHOTO_ATTACHMENT SnippetDecoration = 7 + SnippetDecoration_FILE_ATTACHMENT SnippetDecoration = 8 + SnippetDecoration_STELLAR_RECEIVED SnippetDecoration = 9 + SnippetDecoration_STELLAR_SENT SnippetDecoration = 10 + SnippetDecoration_PINNED_MESSAGE SnippetDecoration = 11 +) + +func (o SnippetDecoration) DeepCopy() SnippetDecoration { return o } + +var SnippetDecorationMap = map[string]SnippetDecoration{ + "NONE": 0, + "PENDING_MESSAGE": 1, + "FAILED_PENDING_MESSAGE": 2, + "EXPLODING_MESSAGE": 3, + "EXPLODED_MESSAGE": 4, + "AUDIO_ATTACHMENT": 5, + "VIDEO_ATTACHMENT": 6, + "PHOTO_ATTACHMENT": 7, + "FILE_ATTACHMENT": 8, + "STELLAR_RECEIVED": 9, + "STELLAR_SENT": 10, + "PINNED_MESSAGE": 11, +} + +var SnippetDecorationRevMap = map[SnippetDecoration]string{ + 0: "NONE", + 1: "PENDING_MESSAGE", + 2: "FAILED_PENDING_MESSAGE", + 3: "EXPLODING_MESSAGE", + 4: "EXPLODED_MESSAGE", + 5: "AUDIO_ATTACHMENT", + 6: "VIDEO_ATTACHMENT", + 7: "PHOTO_ATTACHMENT", + 8: "FILE_ATTACHMENT", + 9: "STELLAR_RECEIVED", + 10: "STELLAR_SENT", + 11: "PINNED_MESSAGE", +} + +func (e SnippetDecoration) String() string { + if v, ok := SnippetDecorationRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} 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 new file mode 100644 index 00000000..ebc5c2a2 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/notify.go @@ -0,0 +1,938 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/chat1/notify.avdl + +package chat1 + +import ( + "errors" + "fmt" + + keybase1 "github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1" +) + +type ChatActivitySource int + +const ( + ChatActivitySource_LOCAL ChatActivitySource = 0 + ChatActivitySource_REMOTE ChatActivitySource = 1 +) + +func (o ChatActivitySource) DeepCopy() ChatActivitySource { return o } + +var ChatActivitySourceMap = map[string]ChatActivitySource{ + "LOCAL": 0, + "REMOTE": 1, +} + +var ChatActivitySourceRevMap = map[ChatActivitySource]string{ + 0: "LOCAL", + 1: "REMOTE", +} + +func (e ChatActivitySource) String() string { + if v, ok := ChatActivitySourceRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ChatActivityType int + +const ( + ChatActivityType_RESERVED ChatActivityType = 0 + ChatActivityType_INCOMING_MESSAGE ChatActivityType = 1 + ChatActivityType_READ_MESSAGE ChatActivityType = 2 + ChatActivityType_NEW_CONVERSATION ChatActivityType = 3 + ChatActivityType_SET_STATUS ChatActivityType = 4 + ChatActivityType_FAILED_MESSAGE ChatActivityType = 5 + ChatActivityType_MEMBERS_UPDATE ChatActivityType = 6 + ChatActivityType_SET_APP_NOTIFICATION_SETTINGS ChatActivityType = 7 + ChatActivityType_TEAMTYPE ChatActivityType = 8 + ChatActivityType_EXPUNGE ChatActivityType = 9 + ChatActivityType_EPHEMERAL_PURGE ChatActivityType = 10 + ChatActivityType_REACTION_UPDATE ChatActivityType = 11 + ChatActivityType_MESSAGES_UPDATED ChatActivityType = 12 +) + +func (o ChatActivityType) DeepCopy() ChatActivityType { return o } + +var ChatActivityTypeMap = map[string]ChatActivityType{ + "RESERVED": 0, + "INCOMING_MESSAGE": 1, + "READ_MESSAGE": 2, + "NEW_CONVERSATION": 3, + "SET_STATUS": 4, + "FAILED_MESSAGE": 5, + "MEMBERS_UPDATE": 6, + "SET_APP_NOTIFICATION_SETTINGS": 7, + "TEAMTYPE": 8, + "EXPUNGE": 9, + "EPHEMERAL_PURGE": 10, + "REACTION_UPDATE": 11, + "MESSAGES_UPDATED": 12, +} + +var ChatActivityTypeRevMap = map[ChatActivityType]string{ + 0: "RESERVED", + 1: "INCOMING_MESSAGE", + 2: "READ_MESSAGE", + 3: "NEW_CONVERSATION", + 4: "SET_STATUS", + 5: "FAILED_MESSAGE", + 6: "MEMBERS_UPDATE", + 7: "SET_APP_NOTIFICATION_SETTINGS", + 8: "TEAMTYPE", + 9: "EXPUNGE", + 10: "EPHEMERAL_PURGE", + 11: "REACTION_UPDATE", + 12: "MESSAGES_UPDATED", +} + +func (e ChatActivityType) String() string { + if v, ok := ChatActivityTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type IncomingMessage struct { + Message UIMessage `codec:"message" json:"message"` + ModifiedMessage *UIMessage `codec:"modifiedMessage,omitempty" json:"modifiedMessage,omitempty"` + ConvID ConversationID `codec:"convID" json:"convID"` + DisplayDesktopNotification bool `codec:"displayDesktopNotification" json:"displayDesktopNotification"` + DesktopNotificationSnippet string `codec:"desktopNotificationSnippet" json:"desktopNotificationSnippet"` + Conv *InboxUIItem `codec:"conv,omitempty" json:"conv,omitempty"` + Pagination *UIPagination `codec:"pagination,omitempty" json:"pagination,omitempty"` +} + +func (o IncomingMessage) DeepCopy() IncomingMessage { + return IncomingMessage{ + Message: o.Message.DeepCopy(), + ModifiedMessage: (func(x *UIMessage) *UIMessage { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ModifiedMessage), + ConvID: o.ConvID.DeepCopy(), + DisplayDesktopNotification: o.DisplayDesktopNotification, + DesktopNotificationSnippet: o.DesktopNotificationSnippet, + Conv: (func(x *InboxUIItem) *InboxUIItem { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Conv), + Pagination: (func(x *UIPagination) *UIPagination { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Pagination), + } +} + +type ReadMessageInfo struct { + ConvID ConversationID `codec:"convID" json:"convID"` + MsgID MessageID `codec:"msgID" json:"msgID"` + Conv *InboxUIItem `codec:"conv,omitempty" json:"conv,omitempty"` +} + +func (o ReadMessageInfo) DeepCopy() ReadMessageInfo { + return ReadMessageInfo{ + ConvID: o.ConvID.DeepCopy(), + MsgID: o.MsgID.DeepCopy(), + Conv: (func(x *InboxUIItem) *InboxUIItem { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Conv), + } +} + +type NewConversationInfo struct { + ConvID ConversationID `codec:"convID" json:"convID"` + Conv *InboxUIItem `codec:"conv,omitempty" json:"conv,omitempty"` +} + +func (o NewConversationInfo) DeepCopy() NewConversationInfo { + return NewConversationInfo{ + ConvID: o.ConvID.DeepCopy(), + Conv: (func(x *InboxUIItem) *InboxUIItem { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Conv), + } +} + +type SetStatusInfo struct { + ConvID ConversationID `codec:"convID" json:"convID"` + Status ConversationStatus `codec:"status" json:"status"` + Conv *InboxUIItem `codec:"conv,omitempty" json:"conv,omitempty"` +} + +func (o SetStatusInfo) DeepCopy() SetStatusInfo { + return SetStatusInfo{ + ConvID: o.ConvID.DeepCopy(), + Status: o.Status.DeepCopy(), + Conv: (func(x *InboxUIItem) *InboxUIItem { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Conv), + } +} + +type SetAppNotificationSettingsInfo struct { + ConvID ConversationID `codec:"convID" json:"convID"` + Settings ConversationNotificationInfo `codec:"settings" json:"settings"` +} + +func (o SetAppNotificationSettingsInfo) DeepCopy() SetAppNotificationSettingsInfo { + return SetAppNotificationSettingsInfo{ + ConvID: o.ConvID.DeepCopy(), + Settings: o.Settings.DeepCopy(), + } +} + +type FailedMessageInfo struct { + OutboxRecords []OutboxRecord `codec:"outboxRecords" json:"outboxRecords"` + IsEphemeralPurge bool `codec:"isEphemeralPurge" json:"isEphemeralPurge"` + Conv *InboxUIItem `codec:"conv,omitempty" json:"conv,omitempty"` +} + +func (o FailedMessageInfo) DeepCopy() FailedMessageInfo { + return FailedMessageInfo{ + OutboxRecords: (func(x []OutboxRecord) []OutboxRecord { + if x == nil { + return nil + } + ret := make([]OutboxRecord, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.OutboxRecords), + IsEphemeralPurge: o.IsEphemeralPurge, + Conv: (func(x *InboxUIItem) *InboxUIItem { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Conv), + } +} + +type MemberInfo struct { + Member string `codec:"member" json:"member"` + Status ConversationMemberStatus `codec:"status" json:"status"` +} + +func (o MemberInfo) DeepCopy() MemberInfo { + return MemberInfo{ + Member: o.Member, + Status: o.Status.DeepCopy(), + } +} + +type MembersUpdateInfo struct { + ConvID ConversationID `codec:"convID" json:"convID"` + Members []MemberInfo `codec:"members" json:"members"` +} + +func (o MembersUpdateInfo) DeepCopy() MembersUpdateInfo { + return MembersUpdateInfo{ + ConvID: o.ConvID.DeepCopy(), + Members: (func(x []MemberInfo) []MemberInfo { + if x == nil { + return nil + } + ret := make([]MemberInfo, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Members), + } +} + +type TeamTypeInfo struct { + ConvID ConversationID `codec:"convID" json:"convID"` + TeamType TeamType `codec:"teamType" json:"teamType"` + Conv *InboxUIItem `codec:"conv,omitempty" json:"conv,omitempty"` +} + +func (o TeamTypeInfo) DeepCopy() TeamTypeInfo { + return TeamTypeInfo{ + ConvID: o.ConvID.DeepCopy(), + TeamType: o.TeamType.DeepCopy(), + Conv: (func(x *InboxUIItem) *InboxUIItem { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Conv), + } +} + +type ExpungeInfo struct { + ConvID ConversationID `codec:"convID" json:"convID"` + Expunge Expunge `codec:"expunge" json:"expunge"` +} + +func (o ExpungeInfo) DeepCopy() ExpungeInfo { + return ExpungeInfo{ + ConvID: o.ConvID.DeepCopy(), + Expunge: o.Expunge.DeepCopy(), + } +} + +type EphemeralPurgeNotifInfo struct { + ConvID ConversationID `codec:"convID" json:"convID"` + Msgs []UIMessage `codec:"msgs" json:"msgs"` +} + +func (o EphemeralPurgeNotifInfo) DeepCopy() EphemeralPurgeNotifInfo { + return EphemeralPurgeNotifInfo{ + ConvID: o.ConvID.DeepCopy(), + Msgs: (func(x []UIMessage) []UIMessage { + if x == nil { + return nil + } + ret := make([]UIMessage, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Msgs), + } +} + +type ReactionUpdate struct { + Reactions ReactionMap `codec:"reactions" json:"reactions"` + TargetMsgID MessageID `codec:"targetMsgID" json:"targetMsgID"` +} + +func (o ReactionUpdate) DeepCopy() ReactionUpdate { + return ReactionUpdate{ + Reactions: o.Reactions.DeepCopy(), + TargetMsgID: o.TargetMsgID.DeepCopy(), + } +} + +type ReactionUpdateNotif struct { + ConvID ConversationID `codec:"convID" json:"convID"` + UserReacjis keybase1.UserReacjis `codec:"userReacjis" json:"userReacjis"` + ReactionUpdates []ReactionUpdate `codec:"reactionUpdates" json:"reactionUpdates"` +} + +func (o ReactionUpdateNotif) DeepCopy() ReactionUpdateNotif { + return ReactionUpdateNotif{ + ConvID: o.ConvID.DeepCopy(), + UserReacjis: o.UserReacjis.DeepCopy(), + ReactionUpdates: (func(x []ReactionUpdate) []ReactionUpdate { + if x == nil { + return nil + } + ret := make([]ReactionUpdate, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.ReactionUpdates), + } +} + +type MessagesUpdated struct { + ConvID ConversationID `codec:"convID" json:"convID"` + Updates []UIMessage `codec:"updates" json:"updates"` +} + +func (o MessagesUpdated) DeepCopy() MessagesUpdated { + return MessagesUpdated{ + ConvID: o.ConvID.DeepCopy(), + Updates: (func(x []UIMessage) []UIMessage { + if x == nil { + return nil + } + ret := make([]UIMessage, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Updates), + } +} + +type ChatActivity struct { + ActivityType__ ChatActivityType `codec:"activityType" json:"activityType"` + IncomingMessage__ *IncomingMessage `codec:"incomingMessage,omitempty" json:"incomingMessage,omitempty"` + ReadMessage__ *ReadMessageInfo `codec:"readMessage,omitempty" json:"readMessage,omitempty"` + NewConversation__ *NewConversationInfo `codec:"newConversation,omitempty" json:"newConversation,omitempty"` + SetStatus__ *SetStatusInfo `codec:"setStatus,omitempty" json:"setStatus,omitempty"` + FailedMessage__ *FailedMessageInfo `codec:"failedMessage,omitempty" json:"failedMessage,omitempty"` + MembersUpdate__ *MembersUpdateInfo `codec:"membersUpdate,omitempty" json:"membersUpdate,omitempty"` + SetAppNotificationSettings__ *SetAppNotificationSettingsInfo `codec:"setAppNotificationSettings,omitempty" json:"setAppNotificationSettings,omitempty"` + Teamtype__ *TeamTypeInfo `codec:"teamtype,omitempty" json:"teamtype,omitempty"` + Expunge__ *ExpungeInfo `codec:"expunge,omitempty" json:"expunge,omitempty"` + EphemeralPurge__ *EphemeralPurgeNotifInfo `codec:"ephemeralPurge,omitempty" json:"ephemeralPurge,omitempty"` + ReactionUpdate__ *ReactionUpdateNotif `codec:"reactionUpdate,omitempty" json:"reactionUpdate,omitempty"` + MessagesUpdated__ *MessagesUpdated `codec:"messagesUpdated,omitempty" json:"messagesUpdated,omitempty"` +} + +func (o *ChatActivity) ActivityType() (ret ChatActivityType, err error) { + switch o.ActivityType__ { + case ChatActivityType_INCOMING_MESSAGE: + if o.IncomingMessage__ == nil { + err = errors.New("unexpected nil value for IncomingMessage__") + return ret, err + } + case ChatActivityType_READ_MESSAGE: + if o.ReadMessage__ == nil { + err = errors.New("unexpected nil value for ReadMessage__") + return ret, err + } + case ChatActivityType_NEW_CONVERSATION: + if o.NewConversation__ == nil { + err = errors.New("unexpected nil value for NewConversation__") + return ret, err + } + case ChatActivityType_SET_STATUS: + if o.SetStatus__ == nil { + err = errors.New("unexpected nil value for SetStatus__") + return ret, err + } + case ChatActivityType_FAILED_MESSAGE: + if o.FailedMessage__ == nil { + err = errors.New("unexpected nil value for FailedMessage__") + return ret, err + } + case ChatActivityType_MEMBERS_UPDATE: + if o.MembersUpdate__ == nil { + err = errors.New("unexpected nil value for MembersUpdate__") + return ret, err + } + case ChatActivityType_SET_APP_NOTIFICATION_SETTINGS: + if o.SetAppNotificationSettings__ == nil { + err = errors.New("unexpected nil value for SetAppNotificationSettings__") + return ret, err + } + case ChatActivityType_TEAMTYPE: + if o.Teamtype__ == nil { + err = errors.New("unexpected nil value for Teamtype__") + return ret, err + } + case ChatActivityType_EXPUNGE: + if o.Expunge__ == nil { + err = errors.New("unexpected nil value for Expunge__") + return ret, err + } + case ChatActivityType_EPHEMERAL_PURGE: + if o.EphemeralPurge__ == nil { + err = errors.New("unexpected nil value for EphemeralPurge__") + return ret, err + } + case ChatActivityType_REACTION_UPDATE: + if o.ReactionUpdate__ == nil { + err = errors.New("unexpected nil value for ReactionUpdate__") + return ret, err + } + case ChatActivityType_MESSAGES_UPDATED: + if o.MessagesUpdated__ == nil { + err = errors.New("unexpected nil value for MessagesUpdated__") + return ret, err + } + } + return o.ActivityType__, nil +} + +func (o ChatActivity) IncomingMessage() (res IncomingMessage) { + if o.ActivityType__ != ChatActivityType_INCOMING_MESSAGE { + panic("wrong case accessed") + } + if o.IncomingMessage__ == nil { + return + } + return *o.IncomingMessage__ +} + +func (o ChatActivity) ReadMessage() (res ReadMessageInfo) { + if o.ActivityType__ != ChatActivityType_READ_MESSAGE { + panic("wrong case accessed") + } + if o.ReadMessage__ == nil { + return + } + return *o.ReadMessage__ +} + +func (o ChatActivity) NewConversation() (res NewConversationInfo) { + if o.ActivityType__ != ChatActivityType_NEW_CONVERSATION { + panic("wrong case accessed") + } + if o.NewConversation__ == nil { + return + } + return *o.NewConversation__ +} + +func (o ChatActivity) SetStatus() (res SetStatusInfo) { + if o.ActivityType__ != ChatActivityType_SET_STATUS { + panic("wrong case accessed") + } + if o.SetStatus__ == nil { + return + } + return *o.SetStatus__ +} + +func (o ChatActivity) FailedMessage() (res FailedMessageInfo) { + if o.ActivityType__ != ChatActivityType_FAILED_MESSAGE { + panic("wrong case accessed") + } + if o.FailedMessage__ == nil { + return + } + return *o.FailedMessage__ +} + +func (o ChatActivity) MembersUpdate() (res MembersUpdateInfo) { + if o.ActivityType__ != ChatActivityType_MEMBERS_UPDATE { + panic("wrong case accessed") + } + if o.MembersUpdate__ == nil { + return + } + return *o.MembersUpdate__ +} + +func (o ChatActivity) SetAppNotificationSettings() (res SetAppNotificationSettingsInfo) { + if o.ActivityType__ != ChatActivityType_SET_APP_NOTIFICATION_SETTINGS { + panic("wrong case accessed") + } + if o.SetAppNotificationSettings__ == nil { + return + } + return *o.SetAppNotificationSettings__ +} + +func (o ChatActivity) Teamtype() (res TeamTypeInfo) { + if o.ActivityType__ != ChatActivityType_TEAMTYPE { + panic("wrong case accessed") + } + if o.Teamtype__ == nil { + return + } + return *o.Teamtype__ +} + +func (o ChatActivity) Expunge() (res ExpungeInfo) { + if o.ActivityType__ != ChatActivityType_EXPUNGE { + panic("wrong case accessed") + } + if o.Expunge__ == nil { + return + } + return *o.Expunge__ +} + +func (o ChatActivity) EphemeralPurge() (res EphemeralPurgeNotifInfo) { + if o.ActivityType__ != ChatActivityType_EPHEMERAL_PURGE { + panic("wrong case accessed") + } + if o.EphemeralPurge__ == nil { + return + } + return *o.EphemeralPurge__ +} + +func (o ChatActivity) ReactionUpdate() (res ReactionUpdateNotif) { + if o.ActivityType__ != ChatActivityType_REACTION_UPDATE { + panic("wrong case accessed") + } + if o.ReactionUpdate__ == nil { + return + } + return *o.ReactionUpdate__ +} + +func (o ChatActivity) MessagesUpdated() (res MessagesUpdated) { + if o.ActivityType__ != ChatActivityType_MESSAGES_UPDATED { + panic("wrong case accessed") + } + if o.MessagesUpdated__ == nil { + return + } + return *o.MessagesUpdated__ +} + +func NewChatActivityWithIncomingMessage(v IncomingMessage) ChatActivity { + return ChatActivity{ + ActivityType__: ChatActivityType_INCOMING_MESSAGE, + IncomingMessage__: &v, + } +} + +func NewChatActivityWithReadMessage(v ReadMessageInfo) ChatActivity { + return ChatActivity{ + ActivityType__: ChatActivityType_READ_MESSAGE, + ReadMessage__: &v, + } +} + +func NewChatActivityWithNewConversation(v NewConversationInfo) ChatActivity { + return ChatActivity{ + ActivityType__: ChatActivityType_NEW_CONVERSATION, + NewConversation__: &v, + } +} + +func NewChatActivityWithSetStatus(v SetStatusInfo) ChatActivity { + return ChatActivity{ + ActivityType__: ChatActivityType_SET_STATUS, + SetStatus__: &v, + } +} + +func NewChatActivityWithFailedMessage(v FailedMessageInfo) ChatActivity { + return ChatActivity{ + ActivityType__: ChatActivityType_FAILED_MESSAGE, + FailedMessage__: &v, + } +} + +func NewChatActivityWithMembersUpdate(v MembersUpdateInfo) ChatActivity { + return ChatActivity{ + ActivityType__: ChatActivityType_MEMBERS_UPDATE, + MembersUpdate__: &v, + } +} + +func NewChatActivityWithSetAppNotificationSettings(v SetAppNotificationSettingsInfo) ChatActivity { + return ChatActivity{ + ActivityType__: ChatActivityType_SET_APP_NOTIFICATION_SETTINGS, + SetAppNotificationSettings__: &v, + } +} + +func NewChatActivityWithTeamtype(v TeamTypeInfo) ChatActivity { + return ChatActivity{ + ActivityType__: ChatActivityType_TEAMTYPE, + Teamtype__: &v, + } +} + +func NewChatActivityWithExpunge(v ExpungeInfo) ChatActivity { + return ChatActivity{ + ActivityType__: ChatActivityType_EXPUNGE, + Expunge__: &v, + } +} + +func NewChatActivityWithEphemeralPurge(v EphemeralPurgeNotifInfo) ChatActivity { + return ChatActivity{ + ActivityType__: ChatActivityType_EPHEMERAL_PURGE, + EphemeralPurge__: &v, + } +} + +func NewChatActivityWithReactionUpdate(v ReactionUpdateNotif) ChatActivity { + return ChatActivity{ + ActivityType__: ChatActivityType_REACTION_UPDATE, + ReactionUpdate__: &v, + } +} + +func NewChatActivityWithMessagesUpdated(v MessagesUpdated) ChatActivity { + return ChatActivity{ + ActivityType__: ChatActivityType_MESSAGES_UPDATED, + MessagesUpdated__: &v, + } +} + +func (o ChatActivity) DeepCopy() ChatActivity { + return ChatActivity{ + ActivityType__: o.ActivityType__.DeepCopy(), + IncomingMessage__: (func(x *IncomingMessage) *IncomingMessage { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.IncomingMessage__), + ReadMessage__: (func(x *ReadMessageInfo) *ReadMessageInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ReadMessage__), + NewConversation__: (func(x *NewConversationInfo) *NewConversationInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.NewConversation__), + SetStatus__: (func(x *SetStatusInfo) *SetStatusInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.SetStatus__), + FailedMessage__: (func(x *FailedMessageInfo) *FailedMessageInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.FailedMessage__), + MembersUpdate__: (func(x *MembersUpdateInfo) *MembersUpdateInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.MembersUpdate__), + SetAppNotificationSettings__: (func(x *SetAppNotificationSettingsInfo) *SetAppNotificationSettingsInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.SetAppNotificationSettings__), + Teamtype__: (func(x *TeamTypeInfo) *TeamTypeInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Teamtype__), + Expunge__: (func(x *ExpungeInfo) *ExpungeInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Expunge__), + EphemeralPurge__: (func(x *EphemeralPurgeNotifInfo) *EphemeralPurgeNotifInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.EphemeralPurge__), + ReactionUpdate__: (func(x *ReactionUpdateNotif) *ReactionUpdateNotif { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ReactionUpdate__), + MessagesUpdated__: (func(x *MessagesUpdated) *MessagesUpdated { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.MessagesUpdated__), + } +} + +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"` +} + +func (o TyperInfo) DeepCopy() TyperInfo { + return TyperInfo{ + Uid: o.Uid.DeepCopy(), + Username: o.Username, + DeviceID: o.DeviceID.DeepCopy(), + DeviceName: o.DeviceName, + DeviceType: o.DeviceType, + } +} + +type ConvTypingUpdate struct { + ConvID ConversationID `codec:"convID" json:"convID"` + Typers []TyperInfo `codec:"typers" json:"typers"` +} + +func (o ConvTypingUpdate) DeepCopy() ConvTypingUpdate { + return ConvTypingUpdate{ + ConvID: o.ConvID.DeepCopy(), + Typers: (func(x []TyperInfo) []TyperInfo { + if x == nil { + return nil + } + ret := make([]TyperInfo, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Typers), + } +} + +type StaleUpdateType int + +const ( + StaleUpdateType_CLEAR StaleUpdateType = 0 + StaleUpdateType_NEWACTIVITY StaleUpdateType = 1 +) + +func (o StaleUpdateType) DeepCopy() StaleUpdateType { return o } + +var StaleUpdateTypeMap = map[string]StaleUpdateType{ + "CLEAR": 0, + "NEWACTIVITY": 1, +} + +var StaleUpdateTypeRevMap = map[StaleUpdateType]string{ + 0: "CLEAR", + 1: "NEWACTIVITY", +} + +func (e StaleUpdateType) String() string { + if v, ok := StaleUpdateTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ConversationStaleUpdate struct { + ConvID ConversationID `codec:"convID" json:"convID"` + UpdateType StaleUpdateType `codec:"updateType" json:"updateType"` +} + +func (o ConversationStaleUpdate) DeepCopy() ConversationStaleUpdate { + return ConversationStaleUpdate{ + ConvID: o.ConvID.DeepCopy(), + UpdateType: o.UpdateType.DeepCopy(), + } +} + +type ChatSyncIncrementalConv struct { + Conv UnverifiedInboxUIItem `codec:"conv" json:"conv"` + ShouldUnbox bool `codec:"shouldUnbox" json:"shouldUnbox"` +} + +func (o ChatSyncIncrementalConv) DeepCopy() ChatSyncIncrementalConv { + return ChatSyncIncrementalConv{ + Conv: o.Conv.DeepCopy(), + ShouldUnbox: o.ShouldUnbox, + } +} + +type ChatSyncIncrementalInfo struct { + Items []ChatSyncIncrementalConv `codec:"items" json:"items"` + Removals []string `codec:"removals" json:"removals"` +} + +func (o ChatSyncIncrementalInfo) DeepCopy() ChatSyncIncrementalInfo { + return ChatSyncIncrementalInfo{ + Items: (func(x []ChatSyncIncrementalConv) []ChatSyncIncrementalConv { + if x == nil { + return nil + } + ret := make([]ChatSyncIncrementalConv, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Items), + Removals: (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.Removals), + } +} + +type ChatSyncResult struct { + SyncType__ SyncInboxResType `codec:"syncType" json:"syncType"` + Incremental__ *ChatSyncIncrementalInfo `codec:"incremental,omitempty" json:"incremental,omitempty"` +} + +func (o *ChatSyncResult) SyncType() (ret SyncInboxResType, err error) { + switch o.SyncType__ { + case SyncInboxResType_INCREMENTAL: + if o.Incremental__ == nil { + err = errors.New("unexpected nil value for Incremental__") + return ret, err + } + } + return o.SyncType__, nil +} + +func (o ChatSyncResult) Incremental() (res ChatSyncIncrementalInfo) { + if o.SyncType__ != SyncInboxResType_INCREMENTAL { + panic("wrong case accessed") + } + if o.Incremental__ == nil { + return + } + return *o.Incremental__ +} + +func NewChatSyncResultWithCurrent() ChatSyncResult { + return ChatSyncResult{ + SyncType__: SyncInboxResType_CURRENT, + } +} + +func NewChatSyncResultWithClear() ChatSyncResult { + return ChatSyncResult{ + SyncType__: SyncInboxResType_CLEAR, + } +} + +func NewChatSyncResultWithIncremental(v ChatSyncIncrementalInfo) ChatSyncResult { + return ChatSyncResult{ + SyncType__: SyncInboxResType_INCREMENTAL, + Incremental__: &v, + } +} + +func (o ChatSyncResult) DeepCopy() ChatSyncResult { + return ChatSyncResult{ + SyncType__: o.SyncType__.DeepCopy(), + Incremental__: (func(x *ChatSyncIncrementalInfo) *ChatSyncIncrementalInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Incremental__), + } +} 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 new file mode 100644 index 00000000..bc4c3020 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/remote.go @@ -0,0 +1,1250 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/chat1/remote.avdl + +package chat1 + +import ( + "errors" + "fmt" + + gregor1 "github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1" + keybase1 "github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1" +) + +type MessageBoxed struct { + Version MessageBoxedVersion `codec:"version" json:"version"` + ServerHeader *MessageServerHeader `codec:"serverHeader,omitempty" json:"serverHeader,omitempty"` + ClientHeader MessageClientHeader `codec:"clientHeader" json:"clientHeader"` + HeaderCiphertext SealedData `codec:"headerCiphertext" json:"headerCiphertext"` + BodyCiphertext EncryptedData `codec:"bodyCiphertext" json:"bodyCiphertext"` + VerifyKey []byte `codec:"verifyKey" json:"verifyKey"` + KeyGeneration int `codec:"keyGeneration" json:"keyGeneration"` +} + +func (o MessageBoxed) DeepCopy() MessageBoxed { + return MessageBoxed{ + Version: o.Version.DeepCopy(), + ServerHeader: (func(x *MessageServerHeader) *MessageServerHeader { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ServerHeader), + ClientHeader: o.ClientHeader.DeepCopy(), + HeaderCiphertext: o.HeaderCiphertext.DeepCopy(), + BodyCiphertext: o.BodyCiphertext.DeepCopy(), + VerifyKey: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.VerifyKey), + KeyGeneration: o.KeyGeneration, + } +} + +type MessageBoxedVersion int + +const ( + MessageBoxedVersion_VNONE MessageBoxedVersion = 0 + MessageBoxedVersion_V1 MessageBoxedVersion = 1 + MessageBoxedVersion_V2 MessageBoxedVersion = 2 + MessageBoxedVersion_V3 MessageBoxedVersion = 3 + MessageBoxedVersion_V4 MessageBoxedVersion = 4 +) + +func (o MessageBoxedVersion) DeepCopy() MessageBoxedVersion { return o } + +var MessageBoxedVersionMap = map[string]MessageBoxedVersion{ + "VNONE": 0, + "V1": 1, + "V2": 2, + "V3": 3, + "V4": 4, +} + +var MessageBoxedVersionRevMap = map[MessageBoxedVersion]string{ + 0: "VNONE", + 1: "V1", + 2: "V2", + 3: "V3", + 4: "V4", +} + +func (e MessageBoxedVersion) String() string { + if v, ok := MessageBoxedVersionRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ThreadViewBoxed struct { + Messages []MessageBoxed `codec:"messages" json:"messages"` + Pagination *Pagination `codec:"pagination,omitempty" json:"pagination,omitempty"` +} + +func (o ThreadViewBoxed) DeepCopy() ThreadViewBoxed { + return ThreadViewBoxed{ + Messages: (func(x []MessageBoxed) []MessageBoxed { + if x == nil { + return nil + } + ret := make([]MessageBoxed, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Messages), + Pagination: (func(x *Pagination) *Pagination { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Pagination), + } +} + +type GetInboxRemoteRes struct { + Inbox InboxView `codec:"inbox" json:"inbox"` + RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` +} + +func (o GetInboxRemoteRes) DeepCopy() GetInboxRemoteRes { + return GetInboxRemoteRes{ + Inbox: o.Inbox.DeepCopy(), + RateLimit: (func(x *RateLimit) *RateLimit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RateLimit), + } +} + +type GetInboxByTLFIDRemoteRes struct { + Convs []Conversation `codec:"convs" json:"convs"` + RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` +} + +func (o GetInboxByTLFIDRemoteRes) DeepCopy() GetInboxByTLFIDRemoteRes { + return GetInboxByTLFIDRemoteRes{ + Convs: (func(x []Conversation) []Conversation { + if x == nil { + return nil + } + ret := make([]Conversation, 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 GetThreadRemoteRes struct { + Thread ThreadViewBoxed `codec:"thread" json:"thread"` + MembersType ConversationMembersType `codec:"membersType" json:"membersType"` + Visibility keybase1.TLFVisibility `codec:"visibility" json:"visibility"` + RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` +} + +func (o GetThreadRemoteRes) DeepCopy() GetThreadRemoteRes { + return GetThreadRemoteRes{ + Thread: o.Thread.DeepCopy(), + MembersType: o.MembersType.DeepCopy(), + Visibility: o.Visibility.DeepCopy(), + RateLimit: (func(x *RateLimit) *RateLimit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RateLimit), + } +} + +type GetConversationMetadataRemoteRes struct { + Conv Conversation `codec:"conv" json:"conv"` + RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` +} + +func (o GetConversationMetadataRemoteRes) DeepCopy() GetConversationMetadataRemoteRes { + return GetConversationMetadataRemoteRes{ + Conv: o.Conv.DeepCopy(), + RateLimit: (func(x *RateLimit) *RateLimit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RateLimit), + } +} + +type PostRemoteRes struct { + MsgHeader MessageServerHeader `codec:"msgHeader" json:"msgHeader"` + RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` +} + +func (o PostRemoteRes) DeepCopy() PostRemoteRes { + return PostRemoteRes{ + MsgHeader: o.MsgHeader.DeepCopy(), + RateLimit: (func(x *RateLimit) *RateLimit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RateLimit), + } +} + +type NewConversationRemoteRes struct { + ConvID ConversationID `codec:"convID" json:"convID"` + CreatedComplexTeam bool `codec:"createdComplexTeam" json:"createdComplexTeam"` + RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` +} + +func (o NewConversationRemoteRes) DeepCopy() NewConversationRemoteRes { + return NewConversationRemoteRes{ + ConvID: o.ConvID.DeepCopy(), + CreatedComplexTeam: o.CreatedComplexTeam, + RateLimit: (func(x *RateLimit) *RateLimit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RateLimit), + } +} + +type GetMessagesRemoteRes struct { + Msgs []MessageBoxed `codec:"msgs" json:"msgs"` + RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` +} + +func (o GetMessagesRemoteRes) DeepCopy() GetMessagesRemoteRes { + return GetMessagesRemoteRes{ + Msgs: (func(x []MessageBoxed) []MessageBoxed { + if x == nil { + return nil + } + ret := make([]MessageBoxed, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Msgs), + RateLimit: (func(x *RateLimit) *RateLimit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RateLimit), + } +} + +type MarkAsReadRes struct { + RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` +} + +func (o MarkAsReadRes) DeepCopy() MarkAsReadRes { + return MarkAsReadRes{ + RateLimit: (func(x *RateLimit) *RateLimit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RateLimit), + } +} + +type SetConversationStatusRes struct { + RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` +} + +func (o SetConversationStatusRes) DeepCopy() SetConversationStatusRes { + return SetConversationStatusRes{ + RateLimit: (func(x *RateLimit) *RateLimit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RateLimit), + } +} + +type GetPublicConversationsRes struct { + Conversations []Conversation `codec:"conversations" json:"conversations"` + RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` +} + +func (o GetPublicConversationsRes) DeepCopy() GetPublicConversationsRes { + return GetPublicConversationsRes{ + Conversations: (func(x []Conversation) []Conversation { + if x == nil { + return nil + } + ret := make([]Conversation, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Conversations), + RateLimit: (func(x *RateLimit) *RateLimit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RateLimit), + } +} + +type GetUnreadlineRemoteRes struct { + UnreadlineID *MessageID `codec:"unreadlineID,omitempty" json:"unreadlineID,omitempty"` + RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` +} + +func (o GetUnreadlineRemoteRes) DeepCopy() GetUnreadlineRemoteRes { + return GetUnreadlineRemoteRes{ + UnreadlineID: (func(x *MessageID) *MessageID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.UnreadlineID), + RateLimit: (func(x *RateLimit) *RateLimit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RateLimit), + } +} + +type ChannelMention int + +const ( + ChannelMention_NONE ChannelMention = 0 + ChannelMention_ALL ChannelMention = 1 + ChannelMention_HERE ChannelMention = 2 +) + +func (o ChannelMention) DeepCopy() ChannelMention { return o } + +var ChannelMentionMap = map[string]ChannelMention{ + "NONE": 0, + "ALL": 1, + "HERE": 2, +} + +var ChannelMentionRevMap = map[ChannelMention]string{ + 0: "NONE", + 1: "ALL", + 2: "HERE", +} + +func (e ChannelMention) String() string { + if v, ok := ChannelMentionRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type UnreadUpdateFull struct { + Ignore bool `codec:"ignore" json:"ignore"` + InboxVers InboxVers `codec:"inboxVers" json:"inboxVers"` + InboxSyncStatus SyncInboxResType `codec:"inboxSyncStatus" json:"inboxSyncStatus"` + Updates []UnreadUpdate `codec:"updates" json:"updates"` +} + +func (o UnreadUpdateFull) DeepCopy() UnreadUpdateFull { + return UnreadUpdateFull{ + Ignore: o.Ignore, + InboxVers: o.InboxVers.DeepCopy(), + InboxSyncStatus: o.InboxSyncStatus.DeepCopy(), + Updates: (func(x []UnreadUpdate) []UnreadUpdate { + if x == nil { + return nil + } + ret := make([]UnreadUpdate, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Updates), + } +} + +type S3Params struct { + Bucket string `codec:"bucket" json:"bucket"` + ObjectKey string `codec:"objectKey" json:"objectKey"` + AccessKey string `codec:"accessKey" json:"accessKey"` + Acl string `codec:"acl" json:"acl"` + RegionName string `codec:"regionName" json:"regionName"` + RegionEndpoint string `codec:"regionEndpoint" json:"regionEndpoint"` + RegionBucketEndpoint string `codec:"regionBucketEndpoint" json:"regionBucketEndpoint"` +} + +func (o S3Params) DeepCopy() S3Params { + return S3Params{ + Bucket: o.Bucket, + ObjectKey: o.ObjectKey, + AccessKey: o.AccessKey, + Acl: o.Acl, + RegionName: o.RegionName, + RegionEndpoint: o.RegionEndpoint, + RegionBucketEndpoint: o.RegionBucketEndpoint, + } +} + +type SyncIncrementalRes struct { + Vers InboxVers `codec:"vers" json:"vers"` + Convs []Conversation `codec:"convs" json:"convs"` +} + +func (o SyncIncrementalRes) DeepCopy() SyncIncrementalRes { + return SyncIncrementalRes{ + Vers: o.Vers.DeepCopy(), + Convs: (func(x []Conversation) []Conversation { + if x == nil { + return nil + } + ret := make([]Conversation, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Convs), + } +} + +type ServerCacheVers struct { + InboxVers int `codec:"inboxVers" json:"inboxVers"` + BodiesVers int `codec:"bodiesVers" json:"bodiesVers"` +} + +func (o ServerCacheVers) DeepCopy() ServerCacheVers { + return ServerCacheVers{ + InboxVers: o.InboxVers, + BodiesVers: o.BodiesVers, + } +} + +type SyncInboxRes struct { + Typ__ SyncInboxResType `codec:"typ" json:"typ"` + Incremental__ *SyncIncrementalRes `codec:"incremental,omitempty" json:"incremental,omitempty"` +} + +func (o *SyncInboxRes) Typ() (ret SyncInboxResType, err error) { + switch o.Typ__ { + case SyncInboxResType_INCREMENTAL: + if o.Incremental__ == nil { + err = errors.New("unexpected nil value for Incremental__") + return ret, err + } + } + return o.Typ__, nil +} + +func (o SyncInboxRes) Incremental() (res SyncIncrementalRes) { + if o.Typ__ != SyncInboxResType_INCREMENTAL { + panic("wrong case accessed") + } + if o.Incremental__ == nil { + return + } + return *o.Incremental__ +} + +func NewSyncInboxResWithCurrent() SyncInboxRes { + return SyncInboxRes{ + Typ__: SyncInboxResType_CURRENT, + } +} + +func NewSyncInboxResWithIncremental(v SyncIncrementalRes) SyncInboxRes { + return SyncInboxRes{ + Typ__: SyncInboxResType_INCREMENTAL, + Incremental__: &v, + } +} + +func NewSyncInboxResWithClear() SyncInboxRes { + return SyncInboxRes{ + Typ__: SyncInboxResType_CLEAR, + } +} + +func (o SyncInboxRes) DeepCopy() SyncInboxRes { + return SyncInboxRes{ + Typ__: o.Typ__.DeepCopy(), + Incremental__: (func(x *SyncIncrementalRes) *SyncIncrementalRes { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Incremental__), + } +} + +type SyncChatRes struct { + CacheVers ServerCacheVers `codec:"cacheVers" json:"cacheVers"` + InboxRes SyncInboxRes `codec:"inboxRes" json:"inboxRes"` +} + +func (o SyncChatRes) DeepCopy() SyncChatRes { + return SyncChatRes{ + CacheVers: o.CacheVers.DeepCopy(), + InboxRes: o.InboxRes.DeepCopy(), + } +} + +type SyncAllProtVers int + +const ( + SyncAllProtVers_V0 SyncAllProtVers = 0 + SyncAllProtVers_V1 SyncAllProtVers = 1 +) + +func (o SyncAllProtVers) DeepCopy() SyncAllProtVers { return o } + +var SyncAllProtVersMap = map[string]SyncAllProtVers{ + "V0": 0, + "V1": 1, +} + +var SyncAllProtVersRevMap = map[SyncAllProtVers]string{ + 0: "V0", + 1: "V1", +} + +func (e SyncAllProtVers) String() string { + if v, ok := SyncAllProtVersRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type SyncAllNotificationType int + +const ( + SyncAllNotificationType_STATE SyncAllNotificationType = 0 + SyncAllNotificationType_INCREMENTAL SyncAllNotificationType = 1 +) + +func (o SyncAllNotificationType) DeepCopy() SyncAllNotificationType { return o } + +var SyncAllNotificationTypeMap = map[string]SyncAllNotificationType{ + "STATE": 0, + "INCREMENTAL": 1, +} + +var SyncAllNotificationTypeRevMap = map[SyncAllNotificationType]string{ + 0: "STATE", + 1: "INCREMENTAL", +} + +func (e SyncAllNotificationType) String() string { + if v, ok := SyncAllNotificationTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type SyncAllNotificationRes struct { + Typ__ SyncAllNotificationType `codec:"typ" json:"typ"` + State__ *gregor1.State `codec:"state,omitempty" json:"state,omitempty"` + Incremental__ *gregor1.SyncResult `codec:"incremental,omitempty" json:"incremental,omitempty"` +} + +func (o *SyncAllNotificationRes) Typ() (ret SyncAllNotificationType, err error) { + switch o.Typ__ { + case SyncAllNotificationType_STATE: + if o.State__ == nil { + err = errors.New("unexpected nil value for State__") + return ret, err + } + case SyncAllNotificationType_INCREMENTAL: + if o.Incremental__ == nil { + err = errors.New("unexpected nil value for Incremental__") + return ret, err + } + } + return o.Typ__, nil +} + +func (o SyncAllNotificationRes) State() (res gregor1.State) { + if o.Typ__ != SyncAllNotificationType_STATE { + panic("wrong case accessed") + } + if o.State__ == nil { + return + } + return *o.State__ +} + +func (o SyncAllNotificationRes) Incremental() (res gregor1.SyncResult) { + if o.Typ__ != SyncAllNotificationType_INCREMENTAL { + panic("wrong case accessed") + } + if o.Incremental__ == nil { + return + } + return *o.Incremental__ +} + +func NewSyncAllNotificationResWithState(v gregor1.State) SyncAllNotificationRes { + return SyncAllNotificationRes{ + Typ__: SyncAllNotificationType_STATE, + State__: &v, + } +} + +func NewSyncAllNotificationResWithIncremental(v gregor1.SyncResult) SyncAllNotificationRes { + return SyncAllNotificationRes{ + Typ__: SyncAllNotificationType_INCREMENTAL, + Incremental__: &v, + } +} + +func (o SyncAllNotificationRes) DeepCopy() SyncAllNotificationRes { + return SyncAllNotificationRes{ + Typ__: o.Typ__.DeepCopy(), + State__: (func(x *gregor1.State) *gregor1.State { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.State__), + Incremental__: (func(x *gregor1.SyncResult) *gregor1.SyncResult { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Incremental__), + } +} + +type SyncAllResult struct { + Auth gregor1.AuthResult `codec:"auth" json:"auth"` + Chat SyncChatRes `codec:"chat" json:"chat"` + Notification SyncAllNotificationRes `codec:"notification" json:"notification"` + Badge UnreadUpdateFull `codec:"badge" json:"badge"` +} + +func (o SyncAllResult) DeepCopy() SyncAllResult { + return SyncAllResult{ + Auth: o.Auth.DeepCopy(), + Chat: o.Chat.DeepCopy(), + Notification: o.Notification.DeepCopy(), + Badge: o.Badge.DeepCopy(), + } +} + +type JoinLeaveConversationRemoteRes struct { + RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` +} + +func (o JoinLeaveConversationRemoteRes) DeepCopy() JoinLeaveConversationRemoteRes { + return JoinLeaveConversationRemoteRes{ + RateLimit: (func(x *RateLimit) *RateLimit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RateLimit), + } +} + +type DeleteConversationRemoteRes struct { + RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` +} + +func (o DeleteConversationRemoteRes) DeepCopy() DeleteConversationRemoteRes { + return DeleteConversationRemoteRes{ + RateLimit: (func(x *RateLimit) *RateLimit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RateLimit), + } +} + +type GetMessageBeforeRes struct { + MsgID MessageID `codec:"msgID" json:"msgID"` + RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` +} + +func (o GetMessageBeforeRes) DeepCopy() GetMessageBeforeRes { + return GetMessageBeforeRes{ + MsgID: o.MsgID.DeepCopy(), + RateLimit: (func(x *RateLimit) *RateLimit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RateLimit), + } +} + +type GetTLFConversationsRes struct { + Conversations []Conversation `codec:"conversations" json:"conversations"` + RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` +} + +func (o GetTLFConversationsRes) DeepCopy() GetTLFConversationsRes { + return GetTLFConversationsRes{ + Conversations: (func(x []Conversation) []Conversation { + if x == nil { + return nil + } + ret := make([]Conversation, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Conversations), + RateLimit: (func(x *RateLimit) *RateLimit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RateLimit), + } +} + +type SetAppNotificationSettingsRes struct { + RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` +} + +func (o SetAppNotificationSettingsRes) DeepCopy() SetAppNotificationSettingsRes { + return SetAppNotificationSettingsRes{ + RateLimit: (func(x *RateLimit) *RateLimit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RateLimit), + } +} + +type SetRetentionRes struct { + RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` +} + +func (o SetRetentionRes) DeepCopy() SetRetentionRes { + return SetRetentionRes{ + RateLimit: (func(x *RateLimit) *RateLimit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RateLimit), + } +} + +type SetConvMinWriterRoleRes struct { + RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` +} + +func (o SetConvMinWriterRoleRes) DeepCopy() SetConvMinWriterRoleRes { + return SetConvMinWriterRoleRes{ + RateLimit: (func(x *RateLimit) *RateLimit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RateLimit), + } +} + +type SweepRes struct { + FoundTask bool `codec:"foundTask" json:"foundTask"` + DeletedMessages bool `codec:"deletedMessages" json:"deletedMessages"` + Expunge Expunge `codec:"expunge" json:"expunge"` +} + +func (o SweepRes) DeepCopy() SweepRes { + return SweepRes{ + FoundTask: o.FoundTask, + DeletedMessages: o.DeletedMessages, + Expunge: o.Expunge.DeepCopy(), + } +} + +type ServerNowRes struct { + RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` + Now gregor1.Time `codec:"now" json:"now"` +} + +func (o ServerNowRes) DeepCopy() ServerNowRes { + return ServerNowRes{ + RateLimit: (func(x *RateLimit) *RateLimit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RateLimit), + Now: o.Now.DeepCopy(), + } +} + +type ExternalAPIKeyTyp int + +const ( + ExternalAPIKeyTyp_GOOGLEMAPS ExternalAPIKeyTyp = 0 + ExternalAPIKeyTyp_GIPHY ExternalAPIKeyTyp = 1 +) + +func (o ExternalAPIKeyTyp) DeepCopy() ExternalAPIKeyTyp { return o } + +var ExternalAPIKeyTypMap = map[string]ExternalAPIKeyTyp{ + "GOOGLEMAPS": 0, + "GIPHY": 1, +} + +var ExternalAPIKeyTypRevMap = map[ExternalAPIKeyTyp]string{ + 0: "GOOGLEMAPS", + 1: "GIPHY", +} + +func (e ExternalAPIKeyTyp) String() string { + if v, ok := ExternalAPIKeyTypRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ExternalAPIKey struct { + Typ__ ExternalAPIKeyTyp `codec:"typ" json:"typ"` + Googlemaps__ *string `codec:"googlemaps,omitempty" json:"googlemaps,omitempty"` + Giphy__ *string `codec:"giphy,omitempty" json:"giphy,omitempty"` +} + +func (o *ExternalAPIKey) Typ() (ret ExternalAPIKeyTyp, err error) { + switch o.Typ__ { + case ExternalAPIKeyTyp_GOOGLEMAPS: + if o.Googlemaps__ == nil { + err = errors.New("unexpected nil value for Googlemaps__") + return ret, err + } + case ExternalAPIKeyTyp_GIPHY: + if o.Giphy__ == nil { + err = errors.New("unexpected nil value for Giphy__") + return ret, err + } + } + return o.Typ__, nil +} + +func (o ExternalAPIKey) Googlemaps() (res string) { + if o.Typ__ != ExternalAPIKeyTyp_GOOGLEMAPS { + panic("wrong case accessed") + } + if o.Googlemaps__ == nil { + return + } + return *o.Googlemaps__ +} + +func (o ExternalAPIKey) Giphy() (res string) { + if o.Typ__ != ExternalAPIKeyTyp_GIPHY { + panic("wrong case accessed") + } + if o.Giphy__ == nil { + return + } + return *o.Giphy__ +} + +func NewExternalAPIKeyWithGooglemaps(v string) ExternalAPIKey { + return ExternalAPIKey{ + Typ__: ExternalAPIKeyTyp_GOOGLEMAPS, + Googlemaps__: &v, + } +} + +func NewExternalAPIKeyWithGiphy(v string) ExternalAPIKey { + return ExternalAPIKey{ + Typ__: ExternalAPIKeyTyp_GIPHY, + Giphy__: &v, + } +} + +func (o ExternalAPIKey) DeepCopy() ExternalAPIKey { + return ExternalAPIKey{ + Typ__: o.Typ__.DeepCopy(), + Googlemaps__: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Googlemaps__), + Giphy__: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Giphy__), + } +} + +type BotInfoHashVers uint64 + +func (o BotInfoHashVers) DeepCopy() BotInfoHashVers { + return o +} + +type CommandConvVers uint64 + +func (o CommandConvVers) DeepCopy() CommandConvVers { + return o +} + +type RemoteBotCommandsAdvertisementPublic struct { + ConvID ConversationID `codec:"convID" json:"convID"` +} + +func (o RemoteBotCommandsAdvertisementPublic) DeepCopy() RemoteBotCommandsAdvertisementPublic { + return RemoteBotCommandsAdvertisementPublic{ + ConvID: o.ConvID.DeepCopy(), + } +} + +type RemoteBotCommandsAdvertisementTLFID struct { + ConvID ConversationID `codec:"convID" json:"convID"` + TlfID TLFID `codec:"tlfID" json:"tlfID"` +} + +func (o RemoteBotCommandsAdvertisementTLFID) DeepCopy() RemoteBotCommandsAdvertisementTLFID { + return RemoteBotCommandsAdvertisementTLFID{ + ConvID: o.ConvID.DeepCopy(), + TlfID: o.TlfID.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"` +} + +func (o *RemoteBotCommandsAdvertisement) 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 + } + } + return o.Typ__, nil +} + +func (o RemoteBotCommandsAdvertisement) Public() (res RemoteBotCommandsAdvertisementPublic) { + if o.Typ__ != BotCommandsAdvertisementTyp_PUBLIC { + panic("wrong case accessed") + } + if o.Public__ == nil { + return + } + return *o.Public__ +} + +func (o RemoteBotCommandsAdvertisement) TlfidMembers() (res RemoteBotCommandsAdvertisementTLFID) { + if o.Typ__ != BotCommandsAdvertisementTyp_TLFID_MEMBERS { + panic("wrong case accessed") + } + if o.TlfidMembers__ == nil { + return + } + return *o.TlfidMembers__ +} + +func (o RemoteBotCommandsAdvertisement) TlfidConvs() (res RemoteBotCommandsAdvertisementTLFID) { + if o.Typ__ != BotCommandsAdvertisementTyp_TLFID_CONVS { + panic("wrong case accessed") + } + if o.TlfidConvs__ == nil { + return + } + return *o.TlfidConvs__ +} + +func NewRemoteBotCommandsAdvertisementWithPublic(v RemoteBotCommandsAdvertisementPublic) RemoteBotCommandsAdvertisement { + return RemoteBotCommandsAdvertisement{ + Typ__: BotCommandsAdvertisementTyp_PUBLIC, + Public__: &v, + } +} + +func NewRemoteBotCommandsAdvertisementWithTlfidMembers(v RemoteBotCommandsAdvertisementTLFID) RemoteBotCommandsAdvertisement { + return RemoteBotCommandsAdvertisement{ + Typ__: BotCommandsAdvertisementTyp_TLFID_MEMBERS, + TlfidMembers__: &v, + } +} + +func NewRemoteBotCommandsAdvertisementWithTlfidConvs(v RemoteBotCommandsAdvertisementTLFID) RemoteBotCommandsAdvertisement { + return RemoteBotCommandsAdvertisement{ + Typ__: BotCommandsAdvertisementTyp_TLFID_CONVS, + TlfidConvs__: &v, + } +} + +func (o RemoteBotCommandsAdvertisement) DeepCopy() RemoteBotCommandsAdvertisement { + return RemoteBotCommandsAdvertisement{ + Typ__: o.Typ__.DeepCopy(), + Public__: (func(x *RemoteBotCommandsAdvertisementPublic) *RemoteBotCommandsAdvertisementPublic { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Public__), + TlfidMembers__: (func(x *RemoteBotCommandsAdvertisementTLFID) *RemoteBotCommandsAdvertisementTLFID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.TlfidMembers__), + TlfidConvs__: (func(x *RemoteBotCommandsAdvertisementTLFID) *RemoteBotCommandsAdvertisementTLFID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.TlfidConvs__), + } +} + +type BotCommandConv struct { + Uid gregor1.UID `codec:"uid" json:"uid"` + UntrustedTeamRole keybase1.TeamRole `codec:"untrustedTeamRole" json:"untrustedTeamRole"` + ConvID ConversationID `codec:"convID" json:"convID"` + Vers CommandConvVers `codec:"vers" json:"vers"` + Mtime gregor1.Time `codec:"mtime" json:"mtime"` +} + +func (o BotCommandConv) DeepCopy() BotCommandConv { + return BotCommandConv{ + Uid: o.Uid.DeepCopy(), + UntrustedTeamRole: o.UntrustedTeamRole.DeepCopy(), + ConvID: o.ConvID.DeepCopy(), + Vers: o.Vers.DeepCopy(), + Mtime: o.Mtime.DeepCopy(), + } +} + +type BotInfo struct { + ServerHashVers BotInfoHashVers `codec:"serverHashVers" json:"serverHashVers"` + ClientHashVers BotInfoHashVers `codec:"clientHashVers" json:"clientHashVers"` + CommandConvs []BotCommandConv `codec:"commandConvs" json:"commandConvs"` +} + +func (o BotInfo) DeepCopy() BotInfo { + return BotInfo{ + ServerHashVers: o.ServerHashVers.DeepCopy(), + ClientHashVers: o.ClientHashVers.DeepCopy(), + CommandConvs: (func(x []BotCommandConv) []BotCommandConv { + if x == nil { + return nil + } + ret := make([]BotCommandConv, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.CommandConvs), + } +} + +type AdvertiseBotCommandsRes struct { + RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` +} + +func (o AdvertiseBotCommandsRes) DeepCopy() AdvertiseBotCommandsRes { + return AdvertiseBotCommandsRes{ + RateLimit: (func(x *RateLimit) *RateLimit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RateLimit), + } +} + +type ClearBotCommandsRes struct { + RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` +} + +func (o ClearBotCommandsRes) DeepCopy() ClearBotCommandsRes { + return ClearBotCommandsRes{ + RateLimit: (func(x *RateLimit) *RateLimit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RateLimit), + } +} + +type BotInfoResponseTyp int + +const ( + BotInfoResponseTyp_UPTODATE BotInfoResponseTyp = 0 + BotInfoResponseTyp_INFO BotInfoResponseTyp = 1 +) + +func (o BotInfoResponseTyp) DeepCopy() BotInfoResponseTyp { return o } + +var BotInfoResponseTypMap = map[string]BotInfoResponseTyp{ + "UPTODATE": 0, + "INFO": 1, +} + +var BotInfoResponseTypRevMap = map[BotInfoResponseTyp]string{ + 0: "UPTODATE", + 1: "INFO", +} + +func (e BotInfoResponseTyp) String() string { + if v, ok := BotInfoResponseTypRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type BotInfoResponse struct { + Typ__ BotInfoResponseTyp `codec:"typ" json:"typ"` + Info__ *BotInfo `codec:"info,omitempty" json:"info,omitempty"` +} + +func (o *BotInfoResponse) Typ() (ret BotInfoResponseTyp, err error) { + switch o.Typ__ { + case BotInfoResponseTyp_INFO: + if o.Info__ == nil { + err = errors.New("unexpected nil value for Info__") + return ret, err + } + } + return o.Typ__, nil +} + +func (o BotInfoResponse) Info() (res BotInfo) { + if o.Typ__ != BotInfoResponseTyp_INFO { + panic("wrong case accessed") + } + if o.Info__ == nil { + return + } + return *o.Info__ +} + +func NewBotInfoResponseWithUptodate() BotInfoResponse { + return BotInfoResponse{ + Typ__: BotInfoResponseTyp_UPTODATE, + } +} + +func NewBotInfoResponseWithInfo(v BotInfo) BotInfoResponse { + return BotInfoResponse{ + Typ__: BotInfoResponseTyp_INFO, + Info__: &v, + } +} + +func (o BotInfoResponse) DeepCopy() BotInfoResponse { + return BotInfoResponse{ + Typ__: o.Typ__.DeepCopy(), + Info__: (func(x *BotInfo) *BotInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Info__), + } +} + +type GetBotInfoRes struct { + Response BotInfoResponse `codec:"response" json:"response"` + RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` +} + +func (o GetBotInfoRes) DeepCopy() GetBotInfoRes { + return GetBotInfoRes{ + Response: o.Response.DeepCopy(), + RateLimit: (func(x *RateLimit) *RateLimit { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RateLimit), + } +} + +type BotInfoHash []byte + +func (o BotInfoHash) DeepCopy() BotInfoHash { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} 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 new file mode 100644 index 00000000..7b99d35d --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/unfurl.go @@ -0,0 +1,850 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/chat1/unfurl.avdl + +package chat1 + +import ( + "errors" + "fmt" + + gregor1 "github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1" +) + +type UnfurlType int + +const ( + UnfurlType_GENERIC UnfurlType = 0 + UnfurlType_YOUTUBE UnfurlType = 1 + UnfurlType_GIPHY UnfurlType = 2 + UnfurlType_MAPS UnfurlType = 3 +) + +func (o UnfurlType) DeepCopy() UnfurlType { return o } + +var UnfurlTypeMap = map[string]UnfurlType{ + "GENERIC": 0, + "YOUTUBE": 1, + "GIPHY": 2, + "MAPS": 3, +} + +var UnfurlTypeRevMap = map[UnfurlType]string{ + 0: "GENERIC", + 1: "YOUTUBE", + 2: "GIPHY", + 3: "MAPS", +} + +func (e UnfurlType) String() string { + if v, ok := UnfurlTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type UnfurlVideo struct { + Url string `codec:"url" json:"url"` + MimeType string `codec:"mimeType" json:"mimeType"` + Height int `codec:"height" json:"height"` + Width int `codec:"width" json:"width"` +} + +func (o UnfurlVideo) DeepCopy() UnfurlVideo { + return UnfurlVideo{ + Url: o.Url, + MimeType: o.MimeType, + Height: o.Height, + Width: o.Width, + } +} + +type UnfurlGenericRaw struct { + Title string `codec:"title" json:"title"` + Url string `codec:"url" json:"url"` + SiteName string `codec:"siteName" json:"siteName"` + FaviconUrl *string `codec:"faviconUrl,omitempty" json:"faviconUrl,omitempty"` + ImageUrl *string `codec:"imageUrl,omitempty" json:"imageUrl,omitempty"` + Video *UnfurlVideo `codec:"video,omitempty" json:"video,omitempty"` + PublishTime *int `codec:"publishTime,omitempty" json:"publishTime,omitempty"` + Description *string `codec:"description,omitempty" json:"description,omitempty"` +} + +func (o UnfurlGenericRaw) DeepCopy() UnfurlGenericRaw { + return UnfurlGenericRaw{ + Title: o.Title, + Url: o.Url, + SiteName: o.SiteName, + FaviconUrl: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.FaviconUrl), + ImageUrl: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.ImageUrl), + Video: (func(x *UnfurlVideo) *UnfurlVideo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Video), + PublishTime: (func(x *int) *int { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.PublishTime), + Description: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Description), + } +} + +type UnfurlYoutubeRaw struct { +} + +func (o UnfurlYoutubeRaw) DeepCopy() UnfurlYoutubeRaw { + return UnfurlYoutubeRaw{} +} + +type UnfurlGiphyRaw struct { + ImageUrl *string `codec:"imageUrl,omitempty" json:"imageUrl,omitempty"` + Video *UnfurlVideo `codec:"video,omitempty" json:"video,omitempty"` + FaviconUrl *string `codec:"faviconUrl,omitempty" json:"faviconUrl,omitempty"` +} + +func (o UnfurlGiphyRaw) DeepCopy() UnfurlGiphyRaw { + return UnfurlGiphyRaw{ + ImageUrl: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.ImageUrl), + Video: (func(x *UnfurlVideo) *UnfurlVideo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Video), + FaviconUrl: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.FaviconUrl), + } +} + +type UnfurlMapsRaw struct { + Title string `codec:"title" json:"title"` + Url string `codec:"url" json:"url"` + SiteName string `codec:"siteName" json:"siteName"` + ImageUrl string `codec:"imageUrl" json:"imageUrl"` + HistoryImageUrl *string `codec:"historyImageUrl,omitempty" json:"historyImageUrl,omitempty"` + Description string `codec:"description" json:"description"` + Coord Coordinate `codec:"coord" json:"coord"` + Time gregor1.Time `codec:"time" json:"time"` + LiveLocationEndTime *gregor1.Time `codec:"liveLocationEndTime,omitempty" json:"liveLocationEndTime,omitempty"` + LiveLocationDone bool `codec:"liveLocationDone" json:"liveLocationDone"` +} + +func (o UnfurlMapsRaw) DeepCopy() UnfurlMapsRaw { + return UnfurlMapsRaw{ + Title: o.Title, + Url: o.Url, + SiteName: o.SiteName, + ImageUrl: o.ImageUrl, + HistoryImageUrl: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.HistoryImageUrl), + Description: o.Description, + Coord: o.Coord.DeepCopy(), + Time: o.Time.DeepCopy(), + LiveLocationEndTime: (func(x *gregor1.Time) *gregor1.Time { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.LiveLocationEndTime), + LiveLocationDone: o.LiveLocationDone, + } +} + +type UnfurlRaw struct { + UnfurlType__ UnfurlType `codec:"unfurlType" json:"unfurlType"` + Generic__ *UnfurlGenericRaw `codec:"generic,omitempty" json:"generic,omitempty"` + Youtube__ *UnfurlYoutubeRaw `codec:"youtube,omitempty" json:"youtube,omitempty"` + Giphy__ *UnfurlGiphyRaw `codec:"giphy,omitempty" json:"giphy,omitempty"` + Maps__ *UnfurlMapsRaw `codec:"maps,omitempty" json:"maps,omitempty"` +} + +func (o *UnfurlRaw) UnfurlType() (ret UnfurlType, err error) { + switch o.UnfurlType__ { + case UnfurlType_GENERIC: + if o.Generic__ == nil { + err = errors.New("unexpected nil value for Generic__") + return ret, err + } + case UnfurlType_YOUTUBE: + if o.Youtube__ == nil { + err = errors.New("unexpected nil value for Youtube__") + return ret, err + } + case UnfurlType_GIPHY: + if o.Giphy__ == nil { + err = errors.New("unexpected nil value for Giphy__") + return ret, err + } + case UnfurlType_MAPS: + if o.Maps__ == nil { + err = errors.New("unexpected nil value for Maps__") + return ret, err + } + } + return o.UnfurlType__, nil +} + +func (o UnfurlRaw) Generic() (res UnfurlGenericRaw) { + if o.UnfurlType__ != UnfurlType_GENERIC { + panic("wrong case accessed") + } + if o.Generic__ == nil { + return + } + return *o.Generic__ +} + +func (o UnfurlRaw) Youtube() (res UnfurlYoutubeRaw) { + if o.UnfurlType__ != UnfurlType_YOUTUBE { + panic("wrong case accessed") + } + if o.Youtube__ == nil { + return + } + return *o.Youtube__ +} + +func (o UnfurlRaw) Giphy() (res UnfurlGiphyRaw) { + if o.UnfurlType__ != UnfurlType_GIPHY { + panic("wrong case accessed") + } + if o.Giphy__ == nil { + return + } + return *o.Giphy__ +} + +func (o UnfurlRaw) Maps() (res UnfurlMapsRaw) { + if o.UnfurlType__ != UnfurlType_MAPS { + panic("wrong case accessed") + } + if o.Maps__ == nil { + return + } + return *o.Maps__ +} + +func NewUnfurlRawWithGeneric(v UnfurlGenericRaw) UnfurlRaw { + return UnfurlRaw{ + UnfurlType__: UnfurlType_GENERIC, + Generic__: &v, + } +} + +func NewUnfurlRawWithYoutube(v UnfurlYoutubeRaw) UnfurlRaw { + return UnfurlRaw{ + UnfurlType__: UnfurlType_YOUTUBE, + Youtube__: &v, + } +} + +func NewUnfurlRawWithGiphy(v UnfurlGiphyRaw) UnfurlRaw { + return UnfurlRaw{ + UnfurlType__: UnfurlType_GIPHY, + Giphy__: &v, + } +} + +func NewUnfurlRawWithMaps(v UnfurlMapsRaw) UnfurlRaw { + return UnfurlRaw{ + UnfurlType__: UnfurlType_MAPS, + Maps__: &v, + } +} + +func (o UnfurlRaw) DeepCopy() UnfurlRaw { + return UnfurlRaw{ + UnfurlType__: o.UnfurlType__.DeepCopy(), + Generic__: (func(x *UnfurlGenericRaw) *UnfurlGenericRaw { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Generic__), + Youtube__: (func(x *UnfurlYoutubeRaw) *UnfurlYoutubeRaw { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Youtube__), + Giphy__: (func(x *UnfurlGiphyRaw) *UnfurlGiphyRaw { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Giphy__), + Maps__: (func(x *UnfurlMapsRaw) *UnfurlMapsRaw { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Maps__), + } +} + +type UnfurlGenericMapInfo struct { + Coord Coordinate `codec:"coord" json:"coord"` + Time gregor1.Time `codec:"time" json:"time"` + LiveLocationEndTime *gregor1.Time `codec:"liveLocationEndTime,omitempty" json:"liveLocationEndTime,omitempty"` + IsLiveLocationDone bool `codec:"isLiveLocationDone" json:"isLiveLocationDone"` +} + +func (o UnfurlGenericMapInfo) DeepCopy() UnfurlGenericMapInfo { + return UnfurlGenericMapInfo{ + Coord: o.Coord.DeepCopy(), + Time: o.Time.DeepCopy(), + LiveLocationEndTime: (func(x *gregor1.Time) *gregor1.Time { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.LiveLocationEndTime), + IsLiveLocationDone: o.IsLiveLocationDone, + } +} + +type UnfurlGeneric struct { + Title string `codec:"title" json:"title"` + Url string `codec:"url" json:"url"` + SiteName string `codec:"siteName" json:"siteName"` + Favicon *Asset `codec:"favicon,omitempty" json:"favicon,omitempty"` + Image *Asset `codec:"image,omitempty" json:"image,omitempty"` + PublishTime *int `codec:"publishTime,omitempty" json:"publishTime,omitempty"` + Description *string `codec:"description,omitempty" json:"description,omitempty"` + MapInfo *UnfurlGenericMapInfo `codec:"mapInfo,omitempty" json:"mapInfo,omitempty"` +} + +func (o UnfurlGeneric) DeepCopy() UnfurlGeneric { + return UnfurlGeneric{ + Title: o.Title, + Url: o.Url, + SiteName: o.SiteName, + Favicon: (func(x *Asset) *Asset { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Favicon), + Image: (func(x *Asset) *Asset { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Image), + PublishTime: (func(x *int) *int { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.PublishTime), + Description: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Description), + MapInfo: (func(x *UnfurlGenericMapInfo) *UnfurlGenericMapInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.MapInfo), + } +} + +type UnfurlYoutube struct { +} + +func (o UnfurlYoutube) DeepCopy() UnfurlYoutube { + return UnfurlYoutube{} +} + +type UnfurlGiphy struct { + Favicon *Asset `codec:"favicon,omitempty" json:"favicon,omitempty"` + Image *Asset `codec:"image,omitempty" json:"image,omitempty"` + Video *Asset `codec:"video,omitempty" json:"video,omitempty"` +} + +func (o UnfurlGiphy) DeepCopy() UnfurlGiphy { + return UnfurlGiphy{ + Favicon: (func(x *Asset) *Asset { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Favicon), + Image: (func(x *Asset) *Asset { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Image), + Video: (func(x *Asset) *Asset { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Video), + } +} + +type Unfurl struct { + UnfurlType__ UnfurlType `codec:"unfurlType" json:"unfurlType"` + Generic__ *UnfurlGeneric `codec:"generic,omitempty" json:"generic,omitempty"` + Youtube__ *UnfurlYoutube `codec:"youtube,omitempty" json:"youtube,omitempty"` + Giphy__ *UnfurlGiphy `codec:"giphy,omitempty" json:"giphy,omitempty"` +} + +func (o *Unfurl) UnfurlType() (ret UnfurlType, err error) { + switch o.UnfurlType__ { + case UnfurlType_GENERIC: + if o.Generic__ == nil { + err = errors.New("unexpected nil value for Generic__") + return ret, err + } + case UnfurlType_YOUTUBE: + if o.Youtube__ == nil { + err = errors.New("unexpected nil value for Youtube__") + return ret, err + } + case UnfurlType_GIPHY: + if o.Giphy__ == nil { + err = errors.New("unexpected nil value for Giphy__") + return ret, err + } + } + return o.UnfurlType__, nil +} + +func (o Unfurl) Generic() (res UnfurlGeneric) { + if o.UnfurlType__ != UnfurlType_GENERIC { + panic("wrong case accessed") + } + if o.Generic__ == nil { + return + } + return *o.Generic__ +} + +func (o Unfurl) Youtube() (res UnfurlYoutube) { + if o.UnfurlType__ != UnfurlType_YOUTUBE { + panic("wrong case accessed") + } + if o.Youtube__ == nil { + return + } + return *o.Youtube__ +} + +func (o Unfurl) Giphy() (res UnfurlGiphy) { + if o.UnfurlType__ != UnfurlType_GIPHY { + panic("wrong case accessed") + } + if o.Giphy__ == nil { + return + } + return *o.Giphy__ +} + +func NewUnfurlWithGeneric(v UnfurlGeneric) Unfurl { + return Unfurl{ + UnfurlType__: UnfurlType_GENERIC, + Generic__: &v, + } +} + +func NewUnfurlWithYoutube(v UnfurlYoutube) Unfurl { + return Unfurl{ + UnfurlType__: UnfurlType_YOUTUBE, + Youtube__: &v, + } +} + +func NewUnfurlWithGiphy(v UnfurlGiphy) Unfurl { + return Unfurl{ + UnfurlType__: UnfurlType_GIPHY, + Giphy__: &v, + } +} + +func (o Unfurl) DeepCopy() Unfurl { + return Unfurl{ + UnfurlType__: o.UnfurlType__.DeepCopy(), + Generic__: (func(x *UnfurlGeneric) *UnfurlGeneric { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Generic__), + Youtube__: (func(x *UnfurlYoutube) *UnfurlYoutube { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Youtube__), + Giphy__: (func(x *UnfurlGiphy) *UnfurlGiphy { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Giphy__), + } +} + +type UnfurlResult struct { + Unfurl Unfurl `codec:"unfurl" json:"unfurl"` + Url string `codec:"url" json:"url"` +} + +func (o UnfurlResult) DeepCopy() UnfurlResult { + return UnfurlResult{ + Unfurl: o.Unfurl.DeepCopy(), + Url: o.Url, + } +} + +type UnfurlImageDisplay struct { + Url string `codec:"url" json:"url"` + Height int `codec:"height" json:"height"` + Width int `codec:"width" json:"width"` + IsVideo bool `codec:"isVideo" json:"isVideo"` +} + +func (o UnfurlImageDisplay) DeepCopy() UnfurlImageDisplay { + return UnfurlImageDisplay{ + Url: o.Url, + Height: o.Height, + Width: o.Width, + IsVideo: o.IsVideo, + } +} + +type UnfurlGenericDisplay struct { + Title string `codec:"title" json:"title"` + Url string `codec:"url" json:"url"` + SiteName string `codec:"siteName" json:"siteName"` + Favicon *UnfurlImageDisplay `codec:"favicon,omitempty" json:"favicon,omitempty"` + Media *UnfurlImageDisplay `codec:"media,omitempty" json:"media,omitempty"` + PublishTime *int `codec:"publishTime,omitempty" json:"publishTime,omitempty"` + Description *string `codec:"description,omitempty" json:"description,omitempty"` + MapInfo *UnfurlGenericMapInfo `codec:"mapInfo,omitempty" json:"mapInfo,omitempty"` +} + +func (o UnfurlGenericDisplay) DeepCopy() UnfurlGenericDisplay { + return UnfurlGenericDisplay{ + Title: o.Title, + Url: o.Url, + SiteName: o.SiteName, + Favicon: (func(x *UnfurlImageDisplay) *UnfurlImageDisplay { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Favicon), + Media: (func(x *UnfurlImageDisplay) *UnfurlImageDisplay { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Media), + PublishTime: (func(x *int) *int { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.PublishTime), + Description: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Description), + MapInfo: (func(x *UnfurlGenericMapInfo) *UnfurlGenericMapInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.MapInfo), + } +} + +type UnfurlYoutubeDisplay struct { +} + +func (o UnfurlYoutubeDisplay) DeepCopy() UnfurlYoutubeDisplay { + return UnfurlYoutubeDisplay{} +} + +type UnfurlGiphyDisplay struct { + Favicon *UnfurlImageDisplay `codec:"favicon,omitempty" json:"favicon,omitempty"` + Image *UnfurlImageDisplay `codec:"image,omitempty" json:"image,omitempty"` + Video *UnfurlImageDisplay `codec:"video,omitempty" json:"video,omitempty"` +} + +func (o UnfurlGiphyDisplay) DeepCopy() UnfurlGiphyDisplay { + return UnfurlGiphyDisplay{ + Favicon: (func(x *UnfurlImageDisplay) *UnfurlImageDisplay { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Favicon), + Image: (func(x *UnfurlImageDisplay) *UnfurlImageDisplay { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Image), + Video: (func(x *UnfurlImageDisplay) *UnfurlImageDisplay { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Video), + } +} + +type UnfurlDisplay struct { + UnfurlType__ UnfurlType `codec:"unfurlType" json:"unfurlType"` + Generic__ *UnfurlGenericDisplay `codec:"generic,omitempty" json:"generic,omitempty"` + Youtube__ *UnfurlYoutubeDisplay `codec:"youtube,omitempty" json:"youtube,omitempty"` + Giphy__ *UnfurlGiphyDisplay `codec:"giphy,omitempty" json:"giphy,omitempty"` +} + +func (o *UnfurlDisplay) UnfurlType() (ret UnfurlType, err error) { + switch o.UnfurlType__ { + case UnfurlType_GENERIC: + if o.Generic__ == nil { + err = errors.New("unexpected nil value for Generic__") + return ret, err + } + case UnfurlType_YOUTUBE: + if o.Youtube__ == nil { + err = errors.New("unexpected nil value for Youtube__") + return ret, err + } + case UnfurlType_GIPHY: + if o.Giphy__ == nil { + err = errors.New("unexpected nil value for Giphy__") + return ret, err + } + } + return o.UnfurlType__, nil +} + +func (o UnfurlDisplay) Generic() (res UnfurlGenericDisplay) { + if o.UnfurlType__ != UnfurlType_GENERIC { + panic("wrong case accessed") + } + if o.Generic__ == nil { + return + } + return *o.Generic__ +} + +func (o UnfurlDisplay) Youtube() (res UnfurlYoutubeDisplay) { + if o.UnfurlType__ != UnfurlType_YOUTUBE { + panic("wrong case accessed") + } + if o.Youtube__ == nil { + return + } + return *o.Youtube__ +} + +func (o UnfurlDisplay) Giphy() (res UnfurlGiphyDisplay) { + if o.UnfurlType__ != UnfurlType_GIPHY { + panic("wrong case accessed") + } + if o.Giphy__ == nil { + return + } + return *o.Giphy__ +} + +func NewUnfurlDisplayWithGeneric(v UnfurlGenericDisplay) UnfurlDisplay { + return UnfurlDisplay{ + UnfurlType__: UnfurlType_GENERIC, + Generic__: &v, + } +} + +func NewUnfurlDisplayWithYoutube(v UnfurlYoutubeDisplay) UnfurlDisplay { + return UnfurlDisplay{ + UnfurlType__: UnfurlType_YOUTUBE, + Youtube__: &v, + } +} + +func NewUnfurlDisplayWithGiphy(v UnfurlGiphyDisplay) UnfurlDisplay { + return UnfurlDisplay{ + UnfurlType__: UnfurlType_GIPHY, + Giphy__: &v, + } +} + +func (o UnfurlDisplay) DeepCopy() UnfurlDisplay { + return UnfurlDisplay{ + UnfurlType__: o.UnfurlType__.DeepCopy(), + Generic__: (func(x *UnfurlGenericDisplay) *UnfurlGenericDisplay { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Generic__), + Youtube__: (func(x *UnfurlYoutubeDisplay) *UnfurlYoutubeDisplay { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Youtube__), + Giphy__: (func(x *UnfurlGiphyDisplay) *UnfurlGiphyDisplay { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Giphy__), + } +} + +type UnfurlMode int + +const ( + UnfurlMode_ALWAYS UnfurlMode = 0 + UnfurlMode_NEVER UnfurlMode = 1 + UnfurlMode_WHITELISTED UnfurlMode = 2 +) + +func (o UnfurlMode) DeepCopy() UnfurlMode { return o } + +var UnfurlModeMap = map[string]UnfurlMode{ + "ALWAYS": 0, + "NEVER": 1, + "WHITELISTED": 2, +} + +var UnfurlModeRevMap = map[UnfurlMode]string{ + 0: "ALWAYS", + 1: "NEVER", + 2: "WHITELISTED", +} + +func (e UnfurlMode) String() string { + if v, ok := UnfurlModeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type UnfurlSettings struct { + Mode UnfurlMode `codec:"mode" json:"mode"` + Whitelist map[string]bool `codec:"whitelist" json:"whitelist"` +} + +func (o UnfurlSettings) DeepCopy() UnfurlSettings { + return UnfurlSettings{ + Mode: o.Mode.DeepCopy(), + Whitelist: (func(x map[string]bool) map[string]bool { + if x == nil { + return nil + } + ret := make(map[string]bool, len(x)) + for k, v := range x { + kCopy := k + vCopy := v + ret[kCopy] = vCopy + } + return ret + })(o.Whitelist), + } +} + +type UnfurlSettingsDisplay struct { + Mode UnfurlMode `codec:"mode" json:"mode"` + Whitelist []string `codec:"whitelist" json:"whitelist"` +} + +func (o UnfurlSettingsDisplay) DeepCopy() UnfurlSettingsDisplay { + return UnfurlSettingsDisplay{ + Mode: o.Mode.DeepCopy(), + Whitelist: (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.Whitelist), + } +} 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 new file mode 100644 index 00000000..3da25001 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/auth.go @@ -0,0 +1,20 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/gregor1/auth.avdl + +package gregor1 + +type AuthResult struct { + Uid UID `codec:"uid" json:"uid"` + Username string `codec:"username" json:"username"` + Sid SessionID `codec:"sid" json:"sid"` + IsAdmin bool `codec:"isAdmin" json:"isAdmin"` +} + +func (o AuthResult) DeepCopy() AuthResult { + return AuthResult{ + Uid: o.Uid.DeepCopy(), + Username: o.Username, + Sid: o.Sid.DeepCopy(), + IsAdmin: o.IsAdmin, + } +} 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 new file mode 100644 index 00000000..3a0376cb --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/auth_internal.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..74fce37f --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/auth_update.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..27ba51d1 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/common.go @@ -0,0 +1,394 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/gregor1/common.avdl + +package gregor1 + +type TimeOrOffset struct { + Time_ Time `codec:"time" json:"time"` + Offset_ DurationMsec `codec:"offset" json:"offset"` +} + +func (o TimeOrOffset) DeepCopy() TimeOrOffset { + return TimeOrOffset{ + Time_: o.Time_.DeepCopy(), + Offset_: o.Offset_.DeepCopy(), + } +} + +type Metadata struct { + Uid_ UID `codec:"uid" json:"uid"` + MsgID_ MsgID `codec:"msgID" json:"msgID"` + Ctime_ Time `codec:"ctime" json:"ctime"` + DeviceID_ DeviceID `codec:"deviceID" json:"deviceID"` + InBandMsgType_ int `codec:"inBandMsgType" json:"inBandMsgType"` +} + +func (o Metadata) DeepCopy() Metadata { + return Metadata{ + Uid_: o.Uid_.DeepCopy(), + MsgID_: o.MsgID_.DeepCopy(), + Ctime_: o.Ctime_.DeepCopy(), + DeviceID_: o.DeviceID_.DeepCopy(), + InBandMsgType_: o.InBandMsgType_, + } +} + +type InBandMessage struct { + StateUpdate_ *StateUpdateMessage `codec:"stateUpdate,omitempty" json:"stateUpdate,omitempty"` + StateSync_ *StateSyncMessage `codec:"stateSync,omitempty" json:"stateSync,omitempty"` +} + +func (o InBandMessage) DeepCopy() InBandMessage { + return InBandMessage{ + StateUpdate_: (func(x *StateUpdateMessage) *StateUpdateMessage { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.StateUpdate_), + StateSync_: (func(x *StateSyncMessage) *StateSyncMessage { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.StateSync_), + } +} + +type State struct { + Items_ []ItemAndMetadata `codec:"items" json:"items"` +} + +func (o State) DeepCopy() State { + return State{ + Items_: (func(x []ItemAndMetadata) []ItemAndMetadata { + if x == nil { + return nil + } + ret := make([]ItemAndMetadata, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Items_), + } +} + +type StateUpdateMessage struct { + Md_ Metadata `codec:"md" json:"md"` + Creation_ *Item `codec:"creation,omitempty" json:"creation,omitempty"` + Dismissal_ *Dismissal `codec:"dismissal,omitempty" json:"dismissal,omitempty"` +} + +func (o StateUpdateMessage) DeepCopy() StateUpdateMessage { + return StateUpdateMessage{ + Md_: o.Md_.DeepCopy(), + Creation_: (func(x *Item) *Item { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Creation_), + Dismissal_: (func(x *Dismissal) *Dismissal { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Dismissal_), + } +} + +type StateSyncMessage struct { + Md_ Metadata `codec:"md" json:"md"` +} + +func (o StateSyncMessage) DeepCopy() StateSyncMessage { + return StateSyncMessage{ + Md_: o.Md_.DeepCopy(), + } +} + +type MsgRange struct { + EndTime_ TimeOrOffset `codec:"endTime" json:"endTime"` + Category_ Category `codec:"category" json:"category"` + SkipMsgIDs_ []MsgID `codec:"skipMsgIDs" json:"skipMsgIDs"` +} + +func (o MsgRange) DeepCopy() MsgRange { + return MsgRange{ + EndTime_: o.EndTime_.DeepCopy(), + Category_: o.Category_.DeepCopy(), + SkipMsgIDs_: (func(x []MsgID) []MsgID { + if x == nil { + return nil + } + ret := make([]MsgID, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.SkipMsgIDs_), + } +} + +type Dismissal struct { + MsgIDs_ []MsgID `codec:"msgIDs" json:"msgIDs"` + Ranges_ []MsgRange `codec:"ranges" json:"ranges"` +} + +func (o Dismissal) DeepCopy() Dismissal { + return Dismissal{ + MsgIDs_: (func(x []MsgID) []MsgID { + if x == nil { + return nil + } + ret := make([]MsgID, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.MsgIDs_), + Ranges_: (func(x []MsgRange) []MsgRange { + if x == nil { + return nil + } + ret := make([]MsgRange, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Ranges_), + } +} + +type Item struct { + Category_ Category `codec:"category" json:"category"` + Dtime_ TimeOrOffset `codec:"dtime" json:"dtime"` + RemindTimes_ []TimeOrOffset `codec:"remindTimes" json:"remindTimes"` + Body_ Body `codec:"body" json:"body"` +} + +func (o Item) DeepCopy() Item { + return Item{ + Category_: o.Category_.DeepCopy(), + Dtime_: o.Dtime_.DeepCopy(), + RemindTimes_: (func(x []TimeOrOffset) []TimeOrOffset { + if x == nil { + return nil + } + ret := make([]TimeOrOffset, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.RemindTimes_), + Body_: o.Body_.DeepCopy(), + } +} + +type ItemAndMetadata struct { + Md_ *Metadata `codec:"md,omitempty" json:"md,omitempty"` + Item_ *Item `codec:"item,omitempty" json:"item,omitempty"` +} + +func (o ItemAndMetadata) DeepCopy() ItemAndMetadata { + return ItemAndMetadata{ + Md_: (func(x *Metadata) *Metadata { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Md_), + Item_: (func(x *Item) *Item { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Item_), + } +} + +type Reminder struct { + Item_ ItemAndMetadata `codec:"item" json:"item"` + Seqno_ int `codec:"seqno" json:"seqno"` + RemindTime_ Time `codec:"remindTime" json:"remindTime"` +} + +func (o Reminder) DeepCopy() Reminder { + return Reminder{ + Item_: o.Item_.DeepCopy(), + Seqno_: o.Seqno_, + RemindTime_: o.RemindTime_.DeepCopy(), + } +} + +type ReminderID struct { + Uid_ UID `codec:"uid" json:"uid"` + MsgID_ MsgID `codec:"msgID" json:"msgID"` + Seqno_ int `codec:"seqno" json:"seqno"` +} + +func (o ReminderID) DeepCopy() ReminderID { + return ReminderID{ + Uid_: o.Uid_.DeepCopy(), + MsgID_: o.MsgID_.DeepCopy(), + Seqno_: o.Seqno_, + } +} + +type OutOfBandMessage struct { + Uid_ UID `codec:"uid" json:"uid"` + System_ System `codec:"system" json:"system"` + Body_ Body `codec:"body" json:"body"` +} + +func (o OutOfBandMessage) DeepCopy() OutOfBandMessage { + return OutOfBandMessage{ + Uid_: o.Uid_.DeepCopy(), + System_: o.System_.DeepCopy(), + Body_: o.Body_.DeepCopy(), + } +} + +type ReminderSet struct { + Reminders_ []Reminder `codec:"reminders" json:"reminders"` + MoreRemindersReady_ bool `codec:"moreRemindersReady" json:"moreRemindersReady"` +} + +func (o ReminderSet) DeepCopy() ReminderSet { + return ReminderSet{ + Reminders_: (func(x []Reminder) []Reminder { + if x == nil { + return nil + } + ret := make([]Reminder, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Reminders_), + MoreRemindersReady_: o.MoreRemindersReady_, + } +} + +type Message struct { + Oobm_ *OutOfBandMessage `codec:"oobm,omitempty" json:"oobm,omitempty"` + Ibm_ *InBandMessage `codec:"ibm,omitempty" json:"ibm,omitempty"` +} + +func (o Message) DeepCopy() Message { + return Message{ + Oobm_: (func(x *OutOfBandMessage) *OutOfBandMessage { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Oobm_), + Ibm_: (func(x *InBandMessage) *InBandMessage { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Ibm_), + } +} + +type DurationMsec int64 + +func (o DurationMsec) DeepCopy() DurationMsec { + return o +} + +type DurationSec int64 + +func (o DurationSec) DeepCopy() DurationSec { + return o +} + +type Category string + +func (o Category) DeepCopy() Category { + return o +} + +type System string + +func (o System) DeepCopy() System { + return o +} + +type UID []byte + +func (o UID) DeepCopy() UID { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} + +type MsgID []byte + +func (o MsgID) DeepCopy() MsgID { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} + +type DeviceID []byte + +func (o DeviceID) DeepCopy() DeviceID { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} + +type Body []byte + +func (o Body) DeepCopy() Body { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} + +type Time int64 + +func (o Time) DeepCopy() Time { + return o +} + +type SessionID string + +func (o SessionID) DeepCopy() SessionID { + return o +} + +type SessionToken string + +func (o SessionToken) DeepCopy() SessionToken { + return o +} 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 new file mode 100644 index 00000000..153cc160 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/incoming.go @@ -0,0 +1,72 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/gregor1/incoming.avdl + +package gregor1 + +type SyncResult struct { + Msgs []InBandMessage `codec:"msgs" json:"msgs"` + Hash []byte `codec:"hash" json:"hash"` +} + +func (o SyncResult) DeepCopy() SyncResult { + return SyncResult{ + Msgs: (func(x []InBandMessage) []InBandMessage { + if x == nil { + return nil + } + ret := make([]InBandMessage, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Msgs), + Hash: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.Hash), + } +} + +// DescribeConnectedUsers will take a list of users, and return the list of users +// which are connected to any Gregor in the cluster, and what devices (and device type) +// those users are connected with. +type ConnectedDevice struct { + DeviceID DeviceID `codec:"deviceID" json:"deviceID"` + DeviceType string `codec:"deviceType" json:"deviceType"` + DevicePlatform string `codec:"devicePlatform" json:"devicePlatform"` + UserAgent string `codec:"userAgent" json:"userAgent"` +} + +func (o ConnectedDevice) DeepCopy() ConnectedDevice { + return ConnectedDevice{ + DeviceID: o.DeviceID.DeepCopy(), + DeviceType: o.DeviceType, + DevicePlatform: o.DevicePlatform, + UserAgent: o.UserAgent, + } +} + +type ConnectedUser struct { + Uid UID `codec:"uid" json:"uid"` + Devices []ConnectedDevice `codec:"devices" json:"devices"` +} + +func (o ConnectedUser) DeepCopy() ConnectedUser { + return ConnectedUser{ + Uid: o.Uid.DeepCopy(), + Devices: (func(x []ConnectedDevice) []ConnectedDevice { + if x == nil { + return nil + } + ret := make([]ConnectedDevice, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Devices), + } +} 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 new file mode 100644 index 00000000..685ece41 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/outgoing.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..b949c545 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/remind.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..f26f967d --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/account.go @@ -0,0 +1,98 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/account.avdl + +package keybase1 + +type HasServerKeysRes struct { + HasServerKeys bool `codec:"hasServerKeys" json:"hasServerKeys"` +} + +func (o HasServerKeysRes) DeepCopy() HasServerKeysRes { + return HasServerKeysRes{ + HasServerKeys: o.HasServerKeys, + } +} + +type LockdownHistory struct { + Status bool `codec:"status" json:"status"` + CreationTime Time `codec:"creationTime" json:"ctime"` + DeviceID DeviceID `codec:"deviceID" json:"device_id"` + DeviceName string `codec:"deviceName" json:"deviceName"` +} + +func (o LockdownHistory) DeepCopy() LockdownHistory { + return LockdownHistory{ + Status: o.Status, + CreationTime: o.CreationTime.DeepCopy(), + DeviceID: o.DeviceID.DeepCopy(), + DeviceName: o.DeviceName, + } +} + +type GetLockdownResponse struct { + History []LockdownHistory `codec:"history" json:"history"` + Status bool `codec:"status" json:"status"` +} + +func (o GetLockdownResponse) DeepCopy() GetLockdownResponse { + return GetLockdownResponse{ + History: (func(x []LockdownHistory) []LockdownHistory { + if x == nil { + return nil + } + ret := make([]LockdownHistory, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.History), + Status: o.Status, + } +} + +type TeamContactSettings struct { + TeamID TeamID `codec:"teamID" json:"team_id"` + Enabled bool `codec:"enabled" json:"enabled"` +} + +func (o TeamContactSettings) DeepCopy() TeamContactSettings { + return TeamContactSettings{ + TeamID: o.TeamID.DeepCopy(), + Enabled: o.Enabled, + } +} + +type ContactSettings struct { + Version *int `codec:"version,omitempty" json:"version,omitempty"` + AllowFolloweeDegrees int `codec:"allowFolloweeDegrees" json:"allow_followee_degrees"` + AllowGoodTeams bool `codec:"allowGoodTeams" json:"allow_good_teams"` + Enabled bool `codec:"enabled" json:"enabled"` + Teams []TeamContactSettings `codec:"teams" json:"teams"` +} + +func (o ContactSettings) DeepCopy() ContactSettings { + return ContactSettings{ + Version: (func(x *int) *int { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Version), + AllowFolloweeDegrees: o.AllowFolloweeDegrees, + AllowGoodTeams: o.AllowGoodTeams, + Enabled: o.Enabled, + Teams: (func(x []TeamContactSettings) []TeamContactSettings { + if x == nil { + return nil + } + ret := make([]TeamContactSettings, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Teams), + } +} 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 new file mode 100644 index 00000000..ec00de3a --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/airdrop.go @@ -0,0 +1,22 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/airdrop.avdl + +package keybase1 + +type AirdropDetails struct { + Uid UID `codec:"uid" json:"uid"` + Kid BinaryKID `codec:"kid" json:"kid"` + Vid VID `codec:"vid" json:"vid"` + Vers string `codec:"vers" json:"vers"` + Time Time `codec:"time" json:"time"` +} + +func (o AirdropDetails) DeepCopy() AirdropDetails { + return AirdropDetails{ + Uid: o.Uid.DeepCopy(), + Kid: o.Kid.DeepCopy(), + Vid: o.Vid.DeepCopy(), + Vers: o.Vers, + Time: o.Time.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..8e773533 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/apiserver.go @@ -0,0 +1,20 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/apiserver.avdl + +package keybase1 + +type APIRes struct { + Status string `codec:"status" json:"status"` + Body string `codec:"body" json:"body"` + HttpStatus int `codec:"httpStatus" json:"httpStatus"` + AppStatus string `codec:"appStatus" json:"appStatus"` +} + +func (o APIRes) DeepCopy() APIRes { + return APIRes{ + Status: o.Status, + Body: o.Body, + HttpStatus: o.HttpStatus, + AppStatus: o.AppStatus, + } +} 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 new file mode 100644 index 00000000..52478e31 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/appstate.go @@ -0,0 +1,75 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/appstate.avdl + +package keybase1 + +import ( + "fmt" +) + +type MobileAppState int + +const ( + MobileAppState_FOREGROUND MobileAppState = 0 + MobileAppState_BACKGROUND MobileAppState = 1 + MobileAppState_INACTIVE MobileAppState = 2 + MobileAppState_BACKGROUNDACTIVE MobileAppState = 3 +) + +func (o MobileAppState) DeepCopy() MobileAppState { return o } + +var MobileAppStateMap = map[string]MobileAppState{ + "FOREGROUND": 0, + "BACKGROUND": 1, + "INACTIVE": 2, + "BACKGROUNDACTIVE": 3, +} + +var MobileAppStateRevMap = map[MobileAppState]string{ + 0: "FOREGROUND", + 1: "BACKGROUND", + 2: "INACTIVE", + 3: "BACKGROUNDACTIVE", +} + +func (e MobileAppState) String() string { + if v, ok := MobileAppStateRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type MobileNetworkState int + +const ( + MobileNetworkState_NONE MobileNetworkState = 0 + MobileNetworkState_WIFI MobileNetworkState = 1 + MobileNetworkState_CELLULAR MobileNetworkState = 2 + MobileNetworkState_UNKNOWN MobileNetworkState = 3 + MobileNetworkState_NOTAVAILABLE MobileNetworkState = 4 +) + +func (o MobileNetworkState) DeepCopy() MobileNetworkState { return o } + +var MobileNetworkStateMap = map[string]MobileNetworkState{ + "NONE": 0, + "WIFI": 1, + "CELLULAR": 2, + "UNKNOWN": 3, + "NOTAVAILABLE": 4, +} + +var MobileNetworkStateRevMap = map[MobileNetworkState]string{ + 0: "NONE", + 1: "WIFI", + 2: "CELLULAR", + 3: "UNKNOWN", + 4: "NOTAVAILABLE", +} + +func (e MobileNetworkState) String() string { + if v, ok := MobileNetworkStateRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} 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 new file mode 100644 index 00000000..1a4c7223 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/audit.go @@ -0,0 +1,76 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/audit.avdl + +package keybase1 + +import ( + "fmt" +) + +type BoxAuditAttemptResult int + +const ( + BoxAuditAttemptResult_FAILURE_RETRYABLE BoxAuditAttemptResult = 0 + BoxAuditAttemptResult_FAILURE_MALICIOUS_SERVER BoxAuditAttemptResult = 1 + BoxAuditAttemptResult_OK_VERIFIED BoxAuditAttemptResult = 2 + BoxAuditAttemptResult_OK_NOT_ATTEMPTED_ROLE BoxAuditAttemptResult = 3 + BoxAuditAttemptResult_OK_NOT_ATTEMPTED_OPENTEAM BoxAuditAttemptResult = 4 + BoxAuditAttemptResult_OK_NOT_ATTEMPTED_SUBTEAM BoxAuditAttemptResult = 5 +) + +func (o BoxAuditAttemptResult) DeepCopy() BoxAuditAttemptResult { return o } + +var BoxAuditAttemptResultMap = map[string]BoxAuditAttemptResult{ + "FAILURE_RETRYABLE": 0, + "FAILURE_MALICIOUS_SERVER": 1, + "OK_VERIFIED": 2, + "OK_NOT_ATTEMPTED_ROLE": 3, + "OK_NOT_ATTEMPTED_OPENTEAM": 4, + "OK_NOT_ATTEMPTED_SUBTEAM": 5, +} + +var BoxAuditAttemptResultRevMap = map[BoxAuditAttemptResult]string{ + 0: "FAILURE_RETRYABLE", + 1: "FAILURE_MALICIOUS_SERVER", + 2: "OK_VERIFIED", + 3: "OK_NOT_ATTEMPTED_ROLE", + 4: "OK_NOT_ATTEMPTED_OPENTEAM", + 5: "OK_NOT_ATTEMPTED_SUBTEAM", +} + +func (e BoxAuditAttemptResult) String() string { + if v, ok := BoxAuditAttemptResultRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type BoxAuditAttempt struct { + Ctime UnixTime `codec:"ctime" json:"ctime"` + Error *string `codec:"error,omitempty" json:"error,omitempty"` + Result BoxAuditAttemptResult `codec:"result" json:"result"` + Generation *PerTeamKeyGeneration `codec:"generation,omitempty" json:"generation,omitempty"` + Rotated bool `codec:"rotated" json:"rotated"` +} + +func (o BoxAuditAttempt) DeepCopy() BoxAuditAttempt { + return BoxAuditAttempt{ + Ctime: o.Ctime.DeepCopy(), + Error: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Error), + Result: o.Result.DeepCopy(), + Generation: (func(x *PerTeamKeyGeneration) *PerTeamKeyGeneration { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Generation), + Rotated: o.Rotated, + } +} 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 new file mode 100644 index 00000000..9e78e2f8 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/avatars.go @@ -0,0 +1,72 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/avatars.avdl + +package keybase1 + +type AvatarUrl string + +func (o AvatarUrl) DeepCopy() AvatarUrl { + return o +} + +type AvatarFormat string + +func (o AvatarFormat) DeepCopy() AvatarFormat { + return o +} + +type LoadAvatarsRes struct { + Picmap map[string]map[AvatarFormat]AvatarUrl `codec:"picmap" json:"picmap"` +} + +func (o LoadAvatarsRes) DeepCopy() LoadAvatarsRes { + return LoadAvatarsRes{ + Picmap: (func(x map[string]map[AvatarFormat]AvatarUrl) map[string]map[AvatarFormat]AvatarUrl { + if x == nil { + return nil + } + ret := make(map[string]map[AvatarFormat]AvatarUrl, len(x)) + for k, v := range x { + kCopy := k + vCopy := (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 + })(v) + ret[kCopy] = vCopy + } + return ret + })(o.Picmap), + } +} + +type AvatarClearCacheMsg struct { + Name string `codec:"name" json:"name"` + Formats []AvatarFormat `codec:"formats" json:"formats"` + Typ AvatarUpdateType `codec:"typ" json:"typ"` +} + +func (o AvatarClearCacheMsg) DeepCopy() AvatarClearCacheMsg { + return AvatarClearCacheMsg{ + Name: o.Name, + Formats: (func(x []AvatarFormat) []AvatarFormat { + if x == nil { + return nil + } + ret := make([]AvatarFormat, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Formats), + Typ: o.Typ.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..ed83acf3 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/backend_common.go @@ -0,0 +1,63 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/backend_common.avdl + +package keybase1 + +import ( + "fmt" +) + +type BlockType int + +const ( + BlockType_DATA BlockType = 0 + BlockType_MD BlockType = 1 + BlockType_GIT BlockType = 2 +) + +func (o BlockType) DeepCopy() BlockType { return o } + +var BlockTypeMap = map[string]BlockType{ + "DATA": 0, + "MD": 1, + "GIT": 2, +} + +var BlockTypeRevMap = map[BlockType]string{ + 0: "DATA", + 1: "MD", + 2: "GIT", +} + +func (e BlockType) String() string { + if v, ok := BlockTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type BlockIdCombo struct { + BlockHash string `codec:"blockHash" json:"blockHash"` + ChargedTo UserOrTeamID `codec:"chargedTo" json:"chargedTo"` + BlockType BlockType `codec:"blockType" json:"blockType"` +} + +func (o BlockIdCombo) DeepCopy() BlockIdCombo { + return BlockIdCombo{ + BlockHash: o.BlockHash, + ChargedTo: o.ChargedTo.DeepCopy(), + BlockType: o.BlockType.DeepCopy(), + } +} + +type ChallengeInfo struct { + Now int64 `codec:"now" json:"now"` + Challenge string `codec:"challenge" json:"challenge"` +} + +func (o ChallengeInfo) DeepCopy() ChallengeInfo { + return ChallengeInfo{ + Now: o.Now, + Challenge: o.Challenge, + } +} 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 new file mode 100644 index 00000000..b2604354 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/badger.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..cb1b2c37 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/block.go @@ -0,0 +1,153 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/block.avdl + +package keybase1 + +import ( + "fmt" +) + +type BlockStatus int + +const ( + BlockStatus_UNKNOWN BlockStatus = 0 + BlockStatus_LIVE BlockStatus = 1 + BlockStatus_ARCHIVED BlockStatus = 2 +) + +func (o BlockStatus) DeepCopy() BlockStatus { return o } + +var BlockStatusMap = map[string]BlockStatus{ + "UNKNOWN": 0, + "LIVE": 1, + "ARCHIVED": 2, +} + +var BlockStatusRevMap = map[BlockStatus]string{ + 0: "UNKNOWN", + 1: "LIVE", + 2: "ARCHIVED", +} + +func (e BlockStatus) String() string { + if v, ok := BlockStatusRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type GetBlockRes struct { + BlockKey string `codec:"blockKey" json:"blockKey"` + Buf []byte `codec:"buf" json:"buf"` + Size int `codec:"size" json:"size"` + Status BlockStatus `codec:"status" json:"status"` +} + +func (o GetBlockRes) DeepCopy() GetBlockRes { + return GetBlockRes{ + BlockKey: o.BlockKey, + Buf: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.Buf), + Size: o.Size, + Status: o.Status.DeepCopy(), + } +} + +type BlockRefNonce [8]byte + +func (o BlockRefNonce) DeepCopy() BlockRefNonce { + var ret BlockRefNonce + copy(ret[:], o[:]) + return ret +} + +type BlockReference struct { + Bid BlockIdCombo `codec:"bid" json:"bid"` + Nonce BlockRefNonce `codec:"nonce" json:"nonce"` + ChargedTo UserOrTeamID `codec:"chargedTo" json:"chargedTo"` +} + +func (o BlockReference) DeepCopy() BlockReference { + return BlockReference{ + Bid: o.Bid.DeepCopy(), + Nonce: o.Nonce.DeepCopy(), + ChargedTo: o.ChargedTo.DeepCopy(), + } +} + +type BlockReferenceCount struct { + Ref BlockReference `codec:"ref" json:"ref"` + LiveCount int `codec:"liveCount" json:"liveCount"` +} + +func (o BlockReferenceCount) DeepCopy() BlockReferenceCount { + return BlockReferenceCount{ + Ref: o.Ref.DeepCopy(), + LiveCount: o.LiveCount, + } +} + +type DowngradeReferenceRes struct { + Completed []BlockReferenceCount `codec:"completed" json:"completed"` + Failed BlockReference `codec:"failed" json:"failed"` +} + +func (o DowngradeReferenceRes) DeepCopy() DowngradeReferenceRes { + return DowngradeReferenceRes{ + Completed: (func(x []BlockReferenceCount) []BlockReferenceCount { + if x == nil { + return nil + } + ret := make([]BlockReferenceCount, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Completed), + Failed: o.Failed.DeepCopy(), + } +} + +type BlockIdCount struct { + Id BlockIdCombo `codec:"id" json:"id"` + LiveCount int `codec:"liveCount" json:"liveCount"` +} + +func (o BlockIdCount) DeepCopy() BlockIdCount { + return BlockIdCount{ + Id: o.Id.DeepCopy(), + LiveCount: o.LiveCount, + } +} + +type ReferenceCountRes struct { + Counts []BlockIdCount `codec:"counts" json:"counts"` +} + +func (o ReferenceCountRes) DeepCopy() ReferenceCountRes { + return ReferenceCountRes{ + Counts: (func(x []BlockIdCount) []BlockIdCount { + if x == nil { + return nil + } + ret := make([]BlockIdCount, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Counts), + } +} + +type BlockPingResponse struct { +} + +func (o BlockPingResponse) DeepCopy() BlockPingResponse { + return BlockPingResponse{} +} 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 new file mode 100644 index 00000000..8b9306f4 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/bot.go @@ -0,0 +1,22 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/bot.avdl + +package keybase1 + +type BotToken string + +func (o BotToken) DeepCopy() BotToken { + return o +} + +type BotTokenInfo struct { + Token BotToken `codec:"token" json:"bot_token"` + Ctime Time `codec:"ctime" json:"ctime"` +} + +func (o BotTokenInfo) DeepCopy() BotTokenInfo { + return BotTokenInfo{ + Token: o.Token.DeepCopy(), + Ctime: o.Ctime.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..f54533b8 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/btc.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..128329f7 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/common.go @@ -0,0 +1,1090 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/common.avdl + +package keybase1 + +import ( + "errors" + "fmt" +) + +type Time int64 + +func (o Time) DeepCopy() Time { + return o +} + +type UnixTime int64 + +func (o UnixTime) DeepCopy() UnixTime { + return o +} + +type DurationSec float64 + +func (o DurationSec) DeepCopy() DurationSec { + return o +} + +type StringKVPair struct { + Key string `codec:"key" json:"key"` + Value string `codec:"value" json:"value"` +} + +func (o StringKVPair) DeepCopy() StringKVPair { + return StringKVPair{ + Key: o.Key, + Value: o.Value, + } +} + +type Status struct { + Code int `codec:"code" json:"code"` + Name string `codec:"name" json:"name"` + Desc string `codec:"desc" json:"desc"` + Fields []StringKVPair `codec:"fields" json:"fields"` +} + +func (o Status) DeepCopy() Status { + return Status{ + Code: o.Code, + Name: o.Name, + Desc: o.Desc, + Fields: (func(x []StringKVPair) []StringKVPair { + if x == nil { + return nil + } + ret := make([]StringKVPair, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Fields), + } +} + +type UID string + +func (o UID) DeepCopy() UID { + return o +} + +type VID string + +func (o VID) DeepCopy() VID { + return o +} + +type DeviceID string + +func (o DeviceID) DeepCopy() DeviceID { + return o +} + +type SigID string + +func (o SigID) DeepCopy() SigID { + return o +} + +type LeaseID string + +func (o LeaseID) DeepCopy() LeaseID { + return o +} + +type KID string + +func (o KID) DeepCopy() KID { + return o +} + +type PhoneNumber string + +func (o PhoneNumber) DeepCopy() PhoneNumber { + return o +} + +type RawPhoneNumber string + +func (o RawPhoneNumber) DeepCopy() RawPhoneNumber { + return o +} + +type LinkID string + +func (o LinkID) DeepCopy() LinkID { + return o +} + +type BinaryLinkID []byte + +func (o BinaryLinkID) DeepCopy() BinaryLinkID { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} + +type BinaryKID []byte + +func (o BinaryKID) DeepCopy() BinaryKID { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} + +type TLFID string + +func (o TLFID) DeepCopy() TLFID { + return o +} + +type TeamID string + +func (o TeamID) DeepCopy() TeamID { + return o +} + +type UserOrTeamID string + +func (o UserOrTeamID) DeepCopy() UserOrTeamID { + return o +} + +type GitRepoName string + +func (o GitRepoName) DeepCopy() GitRepoName { + return o +} + +type HashMeta []byte + +func (o HashMeta) DeepCopy() HashMeta { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} + +type UserVersion struct { + Uid UID `codec:"uid" json:"uid"` + EldestSeqno Seqno `codec:"eldestSeqno" json:"eldestSeqno"` +} + +func (o UserVersion) DeepCopy() UserVersion { + return UserVersion{ + Uid: o.Uid.DeepCopy(), + EldestSeqno: o.EldestSeqno.DeepCopy(), + } +} + +type TeamType int + +const ( + TeamType_NONE TeamType = 0 + TeamType_LEGACY TeamType = 1 + TeamType_MODERN TeamType = 2 +) + +func (o TeamType) DeepCopy() TeamType { return o } + +var TeamTypeMap = map[string]TeamType{ + "NONE": 0, + "LEGACY": 1, + "MODERN": 2, +} + +var TeamTypeRevMap = map[TeamType]string{ + 0: "NONE", + 1: "LEGACY", + 2: "MODERN", +} + +func (e TeamType) String() string { + if v, ok := TeamTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type CompatibilityTeamID struct { + Typ__ TeamType `codec:"typ" json:"typ"` + Legacy__ *TLFID `codec:"legacy,omitempty" json:"legacy,omitempty"` + Modern__ *TeamID `codec:"modern,omitempty" json:"modern,omitempty"` +} + +func (o *CompatibilityTeamID) Typ() (ret TeamType, err error) { + switch o.Typ__ { + case TeamType_LEGACY: + if o.Legacy__ == nil { + err = errors.New("unexpected nil value for Legacy__") + return ret, err + } + case TeamType_MODERN: + if o.Modern__ == nil { + err = errors.New("unexpected nil value for Modern__") + return ret, err + } + } + return o.Typ__, nil +} + +func (o CompatibilityTeamID) Legacy() (res TLFID) { + if o.Typ__ != TeamType_LEGACY { + panic("wrong case accessed") + } + if o.Legacy__ == nil { + return + } + return *o.Legacy__ +} + +func (o CompatibilityTeamID) Modern() (res TeamID) { + if o.Typ__ != TeamType_MODERN { + panic("wrong case accessed") + } + if o.Modern__ == nil { + return + } + return *o.Modern__ +} + +func NewCompatibilityTeamIDWithLegacy(v TLFID) CompatibilityTeamID { + return CompatibilityTeamID{ + Typ__: TeamType_LEGACY, + Legacy__: &v, + } +} + +func NewCompatibilityTeamIDWithModern(v TeamID) CompatibilityTeamID { + return CompatibilityTeamID{ + Typ__: TeamType_MODERN, + Modern__: &v, + } +} + +func (o CompatibilityTeamID) DeepCopy() CompatibilityTeamID { + return CompatibilityTeamID{ + Typ__: o.Typ__.DeepCopy(), + Legacy__: (func(x *TLFID) *TLFID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Legacy__), + Modern__: (func(x *TeamID) *TeamID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Modern__), + } +} + +type TLFVisibility int + +const ( + TLFVisibility_ANY TLFVisibility = 0 + TLFVisibility_PUBLIC TLFVisibility = 1 + TLFVisibility_PRIVATE TLFVisibility = 2 +) + +func (o TLFVisibility) DeepCopy() TLFVisibility { return o } + +var TLFVisibilityMap = map[string]TLFVisibility{ + "ANY": 0, + "PUBLIC": 1, + "PRIVATE": 2, +} + +var TLFVisibilityRevMap = map[TLFVisibility]string{ + 0: "ANY", + 1: "PUBLIC", + 2: "PRIVATE", +} + +func (e TLFVisibility) String() string { + if v, ok := TLFVisibilityRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type TeamIDWithVisibility struct { + TeamID TeamID `codec:"teamID" json:"teamID"` + Visibility TLFVisibility `codec:"visibility" json:"visibility"` +} + +func (o TeamIDWithVisibility) DeepCopy() TeamIDWithVisibility { + return TeamIDWithVisibility{ + TeamID: o.TeamID.DeepCopy(), + Visibility: o.Visibility.DeepCopy(), + } +} + +type TeamIDAndName struct { + Id TeamID `codec:"id" json:"id"` + Name TeamName `codec:"name" json:"name"` +} + +func (o TeamIDAndName) DeepCopy() TeamIDAndName { + return TeamIDAndName{ + Id: o.Id.DeepCopy(), + Name: o.Name.DeepCopy(), + } +} + +type Seqno int64 + +func (o Seqno) DeepCopy() Seqno { + return o +} + +type SeqType int + +const ( + SeqType_NONE SeqType = 0 + SeqType_PUBLIC SeqType = 1 + SeqType_PRIVATE SeqType = 2 + SeqType_SEMIPRIVATE SeqType = 3 + SeqType_USER_PRIVATE_HIDDEN SeqType = 16 + SeqType_TEAM_PRIVATE_HIDDEN SeqType = 17 +) + +func (o SeqType) DeepCopy() SeqType { return o } + +var SeqTypeMap = map[string]SeqType{ + "NONE": 0, + "PUBLIC": 1, + "PRIVATE": 2, + "SEMIPRIVATE": 3, + "USER_PRIVATE_HIDDEN": 16, + "TEAM_PRIVATE_HIDDEN": 17, +} + +var SeqTypeRevMap = map[SeqType]string{ + 0: "NONE", + 1: "PUBLIC", + 2: "PRIVATE", + 3: "SEMIPRIVATE", + 16: "USER_PRIVATE_HIDDEN", + 17: "TEAM_PRIVATE_HIDDEN", +} + +func (e SeqType) String() string { + if v, ok := SeqTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type Bytes32 [32]byte + +func (o Bytes32) DeepCopy() Bytes32 { + var ret Bytes32 + copy(ret[:], o[:]) + return ret +} + +type Text struct { + Data string `codec:"data" json:"data"` + Markup bool `codec:"markup" json:"markup"` +} + +func (o Text) DeepCopy() Text { + return Text{ + Data: o.Data, + Markup: o.Markup, + } +} + +type PGPIdentity struct { + Username string `codec:"username" json:"username"` + Comment string `codec:"comment" json:"comment"` + Email string `codec:"email" json:"email"` +} + +func (o PGPIdentity) DeepCopy() PGPIdentity { + return PGPIdentity{ + Username: o.Username, + Comment: o.Comment, + Email: o.Email, + } +} + +type PublicKey struct { + KID KID `codec:"KID" json:"KID"` + PGPFingerprint string `codec:"PGPFingerprint" json:"PGPFingerprint"` + PGPIdentities []PGPIdentity `codec:"PGPIdentities" json:"PGPIdentities"` + IsSibkey bool `codec:"isSibkey" json:"isSibkey"` + IsEldest bool `codec:"isEldest" json:"isEldest"` + ParentID string `codec:"parentID" json:"parentID"` + DeviceID DeviceID `codec:"deviceID" json:"deviceID"` + DeviceDescription string `codec:"deviceDescription" json:"deviceDescription"` + DeviceType string `codec:"deviceType" json:"deviceType"` + CTime Time `codec:"cTime" json:"cTime"` + ETime Time `codec:"eTime" json:"eTime"` + IsRevoked bool `codec:"isRevoked" json:"isRevoked"` +} + +func (o PublicKey) DeepCopy() PublicKey { + return PublicKey{ + KID: o.KID.DeepCopy(), + PGPFingerprint: o.PGPFingerprint, + PGPIdentities: (func(x []PGPIdentity) []PGPIdentity { + if x == nil { + return nil + } + ret := make([]PGPIdentity, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.PGPIdentities), + IsSibkey: o.IsSibkey, + IsEldest: o.IsEldest, + ParentID: o.ParentID, + DeviceID: o.DeviceID.DeepCopy(), + DeviceDescription: o.DeviceDescription, + DeviceType: o.DeviceType, + CTime: o.CTime.DeepCopy(), + ETime: o.ETime.DeepCopy(), + IsRevoked: o.IsRevoked, + } +} + +type KeybaseTime struct { + Unix Time `codec:"unix" json:"unix"` + Chain Seqno `codec:"chain" json:"chain"` +} + +func (o KeybaseTime) DeepCopy() KeybaseTime { + return KeybaseTime{ + Unix: o.Unix.DeepCopy(), + Chain: o.Chain.DeepCopy(), + } +} + +type RevokedKey struct { + Key PublicKey `codec:"key" json:"key"` + Time KeybaseTime `codec:"time" json:"time"` + By KID `codec:"by" json:"by"` +} + +func (o RevokedKey) DeepCopy() RevokedKey { + return RevokedKey{ + Key: o.Key.DeepCopy(), + Time: o.Time.DeepCopy(), + By: o.By.DeepCopy(), + } +} + +type User struct { + Uid UID `codec:"uid" json:"uid"` + Username string `codec:"username" json:"username"` +} + +func (o User) DeepCopy() User { + return User{ + Uid: o.Uid.DeepCopy(), + Username: o.Username, + } +} + +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"` +} + +func (o Device) DeepCopy() Device { + return Device{ + Type: o.Type, + Name: o.Name, + DeviceID: o.DeviceID.DeepCopy(), + DeviceNumberOfType: o.DeviceNumberOfType, + CTime: o.CTime.DeepCopy(), + MTime: o.MTime.DeepCopy(), + LastUsedTime: o.LastUsedTime.DeepCopy(), + EncryptKey: o.EncryptKey.DeepCopy(), + VerifyKey: o.VerifyKey.DeepCopy(), + Status: o.Status, + } +} + +type DeviceType int + +const ( + DeviceType_DESKTOP DeviceType = 0 + DeviceType_MOBILE DeviceType = 1 +) + +func (o DeviceType) DeepCopy() DeviceType { return o } + +var DeviceTypeMap = map[string]DeviceType{ + "DESKTOP": 0, + "MOBILE": 1, +} + +var DeviceTypeRevMap = map[DeviceType]string{ + 0: "DESKTOP", + 1: "MOBILE", +} + +func (e DeviceType) String() string { + if v, ok := DeviceTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type Stream struct { + Fd int `codec:"fd" json:"fd"` +} + +func (o Stream) DeepCopy() Stream { + return Stream{ + Fd: o.Fd, + } +} + +type LogLevel int + +const ( + LogLevel_NONE LogLevel = 0 + LogLevel_DEBUG LogLevel = 1 + LogLevel_INFO LogLevel = 2 + LogLevel_NOTICE LogLevel = 3 + LogLevel_WARN LogLevel = 4 + LogLevel_ERROR LogLevel = 5 + LogLevel_CRITICAL LogLevel = 6 + LogLevel_FATAL LogLevel = 7 +) + +func (o LogLevel) DeepCopy() LogLevel { return o } + +var LogLevelMap = map[string]LogLevel{ + "NONE": 0, + "DEBUG": 1, + "INFO": 2, + "NOTICE": 3, + "WARN": 4, + "ERROR": 5, + "CRITICAL": 6, + "FATAL": 7, +} + +var LogLevelRevMap = map[LogLevel]string{ + 0: "NONE", + 1: "DEBUG", + 2: "INFO", + 3: "NOTICE", + 4: "WARN", + 5: "ERROR", + 6: "CRITICAL", + 7: "FATAL", +} + +func (e LogLevel) String() string { + if v, ok := LogLevelRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ClientType int + +const ( + ClientType_NONE ClientType = 0 + ClientType_CLI ClientType = 1 + ClientType_GUI_MAIN ClientType = 2 + ClientType_KBFS ClientType = 3 + ClientType_GUI_HELPER ClientType = 4 +) + +func (o ClientType) DeepCopy() ClientType { return o } + +var ClientTypeMap = map[string]ClientType{ + "NONE": 0, + "CLI": 1, + "GUI_MAIN": 2, + "KBFS": 3, + "GUI_HELPER": 4, +} + +var ClientTypeRevMap = map[ClientType]string{ + 0: "NONE", + 1: "CLI", + 2: "GUI_MAIN", + 3: "KBFS", + 4: "GUI_HELPER", +} + +type KBFSPathInfo struct { + StandardPath string `codec:"standardPath" json:"standardPath"` + DeeplinkPath string `codec:"deeplinkPath" json:"deeplinkPath"` + PlatformAfterMountPath string `codec:"platformAfterMountPath" json:"platformAfterMountPath"` +} + +func (o KBFSPathInfo) DeepCopy() KBFSPathInfo { + return KBFSPathInfo{ + StandardPath: o.StandardPath, + DeeplinkPath: o.DeeplinkPath, + PlatformAfterMountPath: o.PlatformAfterMountPath, + } +} + +type UserVersionVector struct { + Id int64 `codec:"id" json:"id"` + SigHints int `codec:"sigHints" json:"sigHints"` + SigChain int64 `codec:"sigChain" json:"sigChain"` + CachedAt Time `codec:"cachedAt" json:"cachedAt"` +} + +func (o UserVersionVector) DeepCopy() UserVersionVector { + return UserVersionVector{ + Id: o.Id, + SigHints: o.SigHints, + SigChain: o.SigChain, + CachedAt: o.CachedAt.DeepCopy(), + } +} + +type PerUserKeyGeneration int + +func (o PerUserKeyGeneration) DeepCopy() PerUserKeyGeneration { + return o +} + +type PerUserKey struct { + Gen int `codec:"gen" json:"gen"` + Seqno Seqno `codec:"seqno" json:"seqno"` + SigKID KID `codec:"sigKID" json:"sigKID"` + EncKID KID `codec:"encKID" json:"encKID"` + SignedByKID KID `codec:"signedByKID" json:"signedByKID"` +} + +func (o PerUserKey) DeepCopy() PerUserKey { + return PerUserKey{ + Gen: o.Gen, + Seqno: o.Seqno.DeepCopy(), + SigKID: o.SigKID.DeepCopy(), + EncKID: o.EncKID.DeepCopy(), + SignedByKID: o.SignedByKID.DeepCopy(), + } +} + +type UserPlusKeys struct { + Uid UID `codec:"uid" json:"uid"` + Username string `codec:"username" json:"username"` + EldestSeqno Seqno `codec:"eldestSeqno" json:"eldestSeqno"` + Status StatusCode `codec:"status" json:"status"` + DeviceKeys []PublicKey `codec:"deviceKeys" json:"deviceKeys"` + RevokedDeviceKeys []RevokedKey `codec:"revokedDeviceKeys" json:"revokedDeviceKeys"` + PGPKeyCount int `codec:"pgpKeyCount" json:"pgpKeyCount"` + Uvv UserVersionVector `codec:"uvv" json:"uvv"` + DeletedDeviceKeys []PublicKey `codec:"deletedDeviceKeys" json:"deletedDeviceKeys"` + PerUserKeys []PerUserKey `codec:"perUserKeys" json:"perUserKeys"` + Resets []ResetSummary `codec:"resets" json:"resets"` +} + +func (o UserPlusKeys) DeepCopy() UserPlusKeys { + return UserPlusKeys{ + Uid: o.Uid.DeepCopy(), + Username: o.Username, + EldestSeqno: o.EldestSeqno.DeepCopy(), + Status: o.Status.DeepCopy(), + DeviceKeys: (func(x []PublicKey) []PublicKey { + if x == nil { + return nil + } + ret := make([]PublicKey, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.DeviceKeys), + RevokedDeviceKeys: (func(x []RevokedKey) []RevokedKey { + if x == nil { + return nil + } + ret := make([]RevokedKey, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.RevokedDeviceKeys), + PGPKeyCount: o.PGPKeyCount, + Uvv: o.Uvv.DeepCopy(), + DeletedDeviceKeys: (func(x []PublicKey) []PublicKey { + if x == nil { + return nil + } + ret := make([]PublicKey, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.DeletedDeviceKeys), + PerUserKeys: (func(x []PerUserKey) []PerUserKey { + if x == nil { + return nil + } + ret := make([]PerUserKey, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.PerUserKeys), + Resets: (func(x []ResetSummary) []ResetSummary { + if x == nil { + return nil + } + ret := make([]ResetSummary, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Resets), + } +} + +type UserOrTeamLite struct { + Id UserOrTeamID `codec:"id" json:"id"` + Name string `codec:"name" json:"name"` +} + +func (o UserOrTeamLite) DeepCopy() UserOrTeamLite { + return UserOrTeamLite{ + Id: o.Id.DeepCopy(), + Name: o.Name, + } +} + +type UserOrTeamResult int + +const ( + UserOrTeamResult_USER UserOrTeamResult = 1 + UserOrTeamResult_TEAM UserOrTeamResult = 2 +) + +func (o UserOrTeamResult) DeepCopy() UserOrTeamResult { return o } + +var UserOrTeamResultMap = map[string]UserOrTeamResult{ + "USER": 1, + "TEAM": 2, +} + +var UserOrTeamResultRevMap = map[UserOrTeamResult]string{ + 1: "USER", + 2: "TEAM", +} + +func (e UserOrTeamResult) String() string { + if v, ok := UserOrTeamResultRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type RemoteTrack struct { + Username string `codec:"username" json:"username"` + Uid UID `codec:"uid" json:"uid"` + LinkID LinkID `codec:"linkID" json:"linkID"` +} + +func (o RemoteTrack) DeepCopy() RemoteTrack { + return RemoteTrack{ + Username: o.Username, + Uid: o.Uid.DeepCopy(), + LinkID: o.LinkID.DeepCopy(), + } +} + +type UserPlusAllKeys struct { + Base UserPlusKeys `codec:"base" json:"base"` + PGPKeys []PublicKey `codec:"pgpKeys" json:"pgpKeys"` + RemoteTracks []RemoteTrack `codec:"remoteTracks" json:"remoteTracks"` +} + +func (o UserPlusAllKeys) DeepCopy() UserPlusAllKeys { + return UserPlusAllKeys{ + Base: o.Base.DeepCopy(), + PGPKeys: (func(x []PublicKey) []PublicKey { + if x == nil { + return nil + } + ret := make([]PublicKey, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.PGPKeys), + RemoteTracks: (func(x []RemoteTrack) []RemoteTrack { + if x == nil { + return nil + } + ret := make([]RemoteTrack, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.RemoteTracks), + } +} + +type MerkleTreeID int + +const ( + MerkleTreeID_MASTER MerkleTreeID = 0 + MerkleTreeID_KBFS_PUBLIC MerkleTreeID = 1 + MerkleTreeID_KBFS_PRIVATE MerkleTreeID = 2 + MerkleTreeID_KBFS_PRIVATETEAM MerkleTreeID = 3 +) + +func (o MerkleTreeID) DeepCopy() MerkleTreeID { return o } + +var MerkleTreeIDMap = map[string]MerkleTreeID{ + "MASTER": 0, + "KBFS_PUBLIC": 1, + "KBFS_PRIVATE": 2, + "KBFS_PRIVATETEAM": 3, +} + +var MerkleTreeIDRevMap = map[MerkleTreeID]string{ + 0: "MASTER", + 1: "KBFS_PUBLIC", + 2: "KBFS_PRIVATE", + 3: "KBFS_PRIVATETEAM", +} + +// SocialAssertionService is a service that can be used to assert proofs for a +// user. +type SocialAssertionService string + +func (o SocialAssertionService) DeepCopy() SocialAssertionService { + return o +} + +// SocialAssertion contains a service and username for that service, that +// together form an assertion about a user. It can either be a social +// assertion (like "facebook" or "twitter") or a server trust assertion (like +// "phone" or "email"). +// +// If the assertion is for social network, resolving an assertion requires +// that the user posts a Keybase proof on the asserted service as the asserted +// user. +// +// For server trust assertion, we have to trust the server. +type SocialAssertion struct { + User string `codec:"user" json:"user"` + Service SocialAssertionService `codec:"service" json:"service"` +} + +func (o SocialAssertion) DeepCopy() SocialAssertion { + return SocialAssertion{ + User: o.User, + Service: o.Service.DeepCopy(), + } +} + +type FullName string + +func (o FullName) DeepCopy() FullName { + return o +} + +type FullNamePackageVersion int + +const ( + FullNamePackageVersion_V0 FullNamePackageVersion = 0 + FullNamePackageVersion_V1 FullNamePackageVersion = 1 + FullNamePackageVersion_V2 FullNamePackageVersion = 2 +) + +func (o FullNamePackageVersion) DeepCopy() FullNamePackageVersion { return o } + +var FullNamePackageVersionMap = map[string]FullNamePackageVersion{ + "V0": 0, + "V1": 1, + "V2": 2, +} + +var FullNamePackageVersionRevMap = map[FullNamePackageVersion]string{ + 0: "V0", + 1: "V1", + 2: "V2", +} + +func (e FullNamePackageVersion) String() string { + if v, ok := FullNamePackageVersionRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type FullNamePackage struct { + Version FullNamePackageVersion `codec:"version" json:"version"` + FullName FullName `codec:"fullName" json:"fullName"` + EldestSeqno Seqno `codec:"eldestSeqno" json:"eldestSeqno"` + Status StatusCode `codec:"status" json:"status"` + CachedAt Time `codec:"cachedAt" json:"cachedAt"` +} + +func (o FullNamePackage) DeepCopy() FullNamePackage { + return FullNamePackage{ + Version: o.Version.DeepCopy(), + FullName: o.FullName.DeepCopy(), + EldestSeqno: o.EldestSeqno.DeepCopy(), + Status: o.Status.DeepCopy(), + CachedAt: o.CachedAt.DeepCopy(), + } +} + +type ImageCropRect struct { + X0 int `codec:"x0" json:"x0"` + Y0 int `codec:"y0" json:"y0"` + X1 int `codec:"x1" json:"x1"` + Y1 int `codec:"y1" json:"y1"` +} + +func (o ImageCropRect) DeepCopy() ImageCropRect { + return ImageCropRect{ + X0: o.X0, + Y0: o.Y0, + X1: o.X1, + Y1: o.Y1, + } +} + +type PhoneLookupResult struct { + Uid UID `codec:"uid" json:"uid"` + Username string `codec:"username" json:"username"` + Ctime UnixTime `codec:"ctime" json:"ctime"` +} + +func (o PhoneLookupResult) DeepCopy() PhoneLookupResult { + return PhoneLookupResult{ + Uid: o.Uid.DeepCopy(), + Username: o.Username, + Ctime: o.Ctime.DeepCopy(), + } +} + +type IdentityVisibility int + +const ( + IdentityVisibility_PRIVATE IdentityVisibility = 0 + IdentityVisibility_PUBLIC IdentityVisibility = 1 +) + +func (o IdentityVisibility) DeepCopy() IdentityVisibility { return o } + +var IdentityVisibilityMap = map[string]IdentityVisibility{ + "PRIVATE": 0, + "PUBLIC": 1, +} + +var IdentityVisibilityRevMap = map[IdentityVisibility]string{ + 0: "PRIVATE", + 1: "PUBLIC", +} + +func (e IdentityVisibility) String() string { + if v, ok := IdentityVisibilityRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type SizedImage struct { + Path string `codec:"path" json:"path"` + Width int `codec:"width" json:"width"` +} + +func (o SizedImage) DeepCopy() SizedImage { + return SizedImage{ + Path: o.Path, + Width: o.Width, + } +} + +type OfflineAvailability int + +const ( + OfflineAvailability_NONE OfflineAvailability = 0 + OfflineAvailability_BEST_EFFORT OfflineAvailability = 1 +) + +func (o OfflineAvailability) DeepCopy() OfflineAvailability { return o } + +var OfflineAvailabilityMap = map[string]OfflineAvailability{ + "NONE": 0, + "BEST_EFFORT": 1, +} + +var OfflineAvailabilityRevMap = map[OfflineAvailability]string{ + 0: "NONE", + 1: "BEST_EFFORT", +} + +func (e OfflineAvailability) String() string { + if v, ok := OfflineAvailabilityRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ReacjiSkinTone int + +func (o ReacjiSkinTone) DeepCopy() ReacjiSkinTone { + return o +} + +type UserReacjis struct { + TopReacjis []string `codec:"topReacjis" json:"topReacjis"` + SkinTone ReacjiSkinTone `codec:"skinTone" json:"skinTone"` +} + +func (o UserReacjis) DeepCopy() UserReacjis { + return UserReacjis{ + TopReacjis: (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.TopReacjis), + SkinTone: o.SkinTone.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..3700dcad --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/config.go @@ -0,0 +1,842 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/config.avdl + +package keybase1 + +import ( + "errors" + "fmt" +) + +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"` +} + +func (o CurrentStatus) DeepCopy() CurrentStatus { + return CurrentStatus{ + Configured: o.Configured, + Registered: o.Registered, + LoggedIn: o.LoggedIn, + SessionIsValid: o.SessionIsValid, + User: (func(x *User) *User { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.User), + } +} + +type SessionStatus struct { + SessionFor string `codec:"SessionFor" json:"SessionFor"` + Loaded bool `codec:"Loaded" json:"Loaded"` + Cleared bool `codec:"Cleared" json:"Cleared"` + SaltOnly bool `codec:"SaltOnly" json:"SaltOnly"` + Expired bool `codec:"Expired" json:"Expired"` +} + +func (o SessionStatus) DeepCopy() SessionStatus { + return SessionStatus{ + SessionFor: o.SessionFor, + Loaded: o.Loaded, + Cleared: o.Cleared, + SaltOnly: o.SaltOnly, + Expired: o.Expired, + } +} + +type ClientDetails struct { + Pid int `codec:"pid" json:"pid"` + ClientType ClientType `codec:"clientType" json:"clientType"` + Argv []string `codec:"argv" json:"argv"` + Desc string `codec:"desc" json:"desc"` + Version string `codec:"version" json:"version"` +} + +func (o ClientDetails) DeepCopy() ClientDetails { + return ClientDetails{ + Pid: o.Pid, + ClientType: o.ClientType.DeepCopy(), + Argv: (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.Argv), + Desc: o.Desc, + Version: o.Version, + } +} + +type ClientStatus struct { + Details ClientDetails `codec:"details" json:"details"` + ConnectionID int `codec:"connectionID" json:"connectionID"` + NotificationChannels NotificationChannels `codec:"notificationChannels" json:"notificationChannels"` +} + +func (o ClientStatus) DeepCopy() ClientStatus { + return ClientStatus{ + Details: o.Details.DeepCopy(), + ConnectionID: o.ConnectionID, + NotificationChannels: o.NotificationChannels.DeepCopy(), + } +} + +type PlatformInfo struct { + Os string `codec:"os" json:"os"` + OsVersion string `codec:"osVersion" json:"osVersion"` + Arch string `codec:"arch" json:"arch"` + GoVersion string `codec:"goVersion" json:"goVersion"` +} + +func (o PlatformInfo) DeepCopy() PlatformInfo { + return PlatformInfo{ + Os: o.Os, + OsVersion: o.OsVersion, + Arch: o.Arch, + GoVersion: o.GoVersion, + } +} + +type LoadDeviceErr struct { + Where string `codec:"where" json:"where"` + Desc string `codec:"desc" json:"desc"` +} + +func (o LoadDeviceErr) DeepCopy() LoadDeviceErr { + return LoadDeviceErr{ + Where: o.Where, + Desc: o.Desc, + } +} + +type DirSizeInfo struct { + NumFiles int `codec:"numFiles" json:"numFiles"` + Name string `codec:"name" json:"name"` + HumanSize string `codec:"humanSize" json:"humanSize"` +} + +func (o DirSizeInfo) DeepCopy() DirSizeInfo { + return DirSizeInfo{ + NumFiles: o.NumFiles, + Name: o.Name, + HumanSize: o.HumanSize, + } +} + +type ExtendedStatus struct { + Standalone bool `codec:"standalone" json:"standalone"` + PassphraseStreamCached bool `codec:"passphraseStreamCached" json:"passphraseStreamCached"` + TsecCached bool `codec:"tsecCached" json:"tsecCached"` + DeviceSigKeyCached bool `codec:"deviceSigKeyCached" json:"deviceSigKeyCached"` + DeviceEncKeyCached bool `codec:"deviceEncKeyCached" json:"deviceEncKeyCached"` + PaperSigKeyCached bool `codec:"paperSigKeyCached" json:"paperSigKeyCached"` + PaperEncKeyCached bool `codec:"paperEncKeyCached" json:"paperEncKeyCached"` + StoredSecret bool `codec:"storedSecret" json:"storedSecret"` + SecretPromptSkip bool `codec:"secretPromptSkip" json:"secretPromptSkip"` + RememberPassphrase bool `codec:"rememberPassphrase" json:"rememberPassphrase"` + Device *Device `codec:"device,omitempty" json:"device,omitempty"` + DeviceErr *LoadDeviceErr `codec:"deviceErr,omitempty" json:"deviceErr,omitempty"` + LogDir string `codec:"logDir" json:"logDir"` + Session *SessionStatus `codec:"session,omitempty" json:"session,omitempty"` + DefaultUsername string `codec:"defaultUsername" json:"defaultUsername"` + ProvisionedUsernames []string `codec:"provisionedUsernames" json:"provisionedUsernames"` + ConfiguredAccounts []ConfiguredAccount `codec:"configuredAccounts" json:"configuredAccounts"` + Clients []ClientStatus `codec:"Clients" json:"Clients"` + DeviceEkNames []string `codec:"deviceEkNames" json:"deviceEkNames"` + PlatformInfo PlatformInfo `codec:"platformInfo" json:"platformInfo"` + DefaultDeviceID DeviceID `codec:"defaultDeviceID" json:"defaultDeviceID"` + LocalDbStats []string `codec:"localDbStats" json:"localDbStats"` + LocalChatDbStats []string `codec:"localChatDbStats" json:"localChatDbStats"` + LocalBlockCacheDbStats []string `codec:"localBlockCacheDbStats" json:"localBlockCacheDbStats"` + LocalSyncCacheDbStats []string `codec:"localSyncCacheDbStats" json:"localSyncCacheDbStats"` + CacheDirSizeInfo []DirSizeInfo `codec:"cacheDirSizeInfo" json:"cacheDirSizeInfo"` + UiRouterMapping map[string]int `codec:"uiRouterMapping" json:"uiRouterMapping"` +} + +func (o ExtendedStatus) DeepCopy() ExtendedStatus { + return ExtendedStatus{ + Standalone: o.Standalone, + PassphraseStreamCached: o.PassphraseStreamCached, + TsecCached: o.TsecCached, + DeviceSigKeyCached: o.DeviceSigKeyCached, + DeviceEncKeyCached: o.DeviceEncKeyCached, + PaperSigKeyCached: o.PaperSigKeyCached, + PaperEncKeyCached: o.PaperEncKeyCached, + StoredSecret: o.StoredSecret, + SecretPromptSkip: o.SecretPromptSkip, + RememberPassphrase: o.RememberPassphrase, + Device: (func(x *Device) *Device { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Device), + DeviceErr: (func(x *LoadDeviceErr) *LoadDeviceErr { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.DeviceErr), + LogDir: o.LogDir, + Session: (func(x *SessionStatus) *SessionStatus { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Session), + DefaultUsername: o.DefaultUsername, + ProvisionedUsernames: (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.ProvisionedUsernames), + ConfiguredAccounts: (func(x []ConfiguredAccount) []ConfiguredAccount { + if x == nil { + return nil + } + ret := make([]ConfiguredAccount, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.ConfiguredAccounts), + Clients: (func(x []ClientStatus) []ClientStatus { + if x == nil { + return nil + } + ret := make([]ClientStatus, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Clients), + DeviceEkNames: (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.DeviceEkNames), + PlatformInfo: o.PlatformInfo.DeepCopy(), + DefaultDeviceID: o.DefaultDeviceID.DeepCopy(), + LocalDbStats: (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.LocalDbStats), + LocalChatDbStats: (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.LocalChatDbStats), + LocalBlockCacheDbStats: (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.LocalBlockCacheDbStats), + LocalSyncCacheDbStats: (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.LocalSyncCacheDbStats), + CacheDirSizeInfo: (func(x []DirSizeInfo) []DirSizeInfo { + if x == nil { + return nil + } + ret := make([]DirSizeInfo, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.CacheDirSizeInfo), + UiRouterMapping: (func(x map[string]int) map[string]int { + if x == nil { + return nil + } + ret := make(map[string]int, len(x)) + for k, v := range x { + kCopy := k + vCopy := v + ret[kCopy] = vCopy + } + return ret + })(o.UiRouterMapping), + } +} + +type KbClientStatus struct { + Version string `codec:"version" json:"version"` +} + +func (o KbClientStatus) DeepCopy() KbClientStatus { + return KbClientStatus{ + Version: o.Version, + } +} + +type KbServiceStatus struct { + Version string `codec:"version" json:"version"` + Running bool `codec:"running" json:"running"` + Pid string `codec:"pid" json:"pid"` + Log string `codec:"log" json:"log"` + EkLog string `codec:"ekLog" json:"ekLog"` +} + +func (o KbServiceStatus) DeepCopy() KbServiceStatus { + return KbServiceStatus{ + Version: o.Version, + Running: o.Running, + Pid: o.Pid, + Log: o.Log, + EkLog: o.EkLog, + } +} + +type KBFSStatus struct { + Version string `codec:"version" json:"version"` + InstalledVersion string `codec:"installedVersion" json:"installedVersion"` + Running bool `codec:"running" json:"running"` + Pid string `codec:"pid" json:"pid"` + Log string `codec:"log" json:"log"` + Mount string `codec:"mount" json:"mount"` +} + +func (o KBFSStatus) DeepCopy() KBFSStatus { + return KBFSStatus{ + Version: o.Version, + InstalledVersion: o.InstalledVersion, + Running: o.Running, + Pid: o.Pid, + Log: o.Log, + Mount: o.Mount, + } +} + +type DesktopStatus struct { + Version string `codec:"version" json:"version"` + Running bool `codec:"running" json:"running"` + Log string `codec:"log" json:"log"` +} + +func (o DesktopStatus) DeepCopy() DesktopStatus { + return DesktopStatus{ + Version: o.Version, + Running: o.Running, + Log: o.Log, + } +} + +type UpdaterStatus struct { + Log string `codec:"log" json:"log"` +} + +func (o UpdaterStatus) DeepCopy() UpdaterStatus { + return UpdaterStatus{ + Log: o.Log, + } +} + +type StartStatus struct { + Log string `codec:"log" json:"log"` +} + +func (o StartStatus) DeepCopy() StartStatus { + return StartStatus{ + Log: o.Log, + } +} + +type GitStatus struct { + Log string `codec:"log" json:"log"` +} + +func (o GitStatus) DeepCopy() GitStatus { + return GitStatus{ + Log: o.Log, + } +} + +type FullStatus struct { + Username string `codec:"username" json:"username"` + ConfigPath string `codec:"configPath" json:"configPath"` + CurStatus CurrentStatus `codec:"curStatus" json:"curStatus"` + ExtStatus ExtendedStatus `codec:"extStatus" json:"extStatus"` + Client KbClientStatus `codec:"client" json:"client"` + Service KbServiceStatus `codec:"service" json:"service"` + Kbfs KBFSStatus `codec:"kbfs" json:"kbfs"` + Desktop DesktopStatus `codec:"desktop" json:"desktop"` + Updater UpdaterStatus `codec:"updater" json:"updater"` + Start StartStatus `codec:"start" json:"start"` + Git GitStatus `codec:"git" json:"git"` +} + +func (o FullStatus) DeepCopy() FullStatus { + return FullStatus{ + Username: o.Username, + ConfigPath: o.ConfigPath, + CurStatus: o.CurStatus.DeepCopy(), + ExtStatus: o.ExtStatus.DeepCopy(), + Client: o.Client.DeepCopy(), + Service: o.Service.DeepCopy(), + Kbfs: o.Kbfs.DeepCopy(), + Desktop: o.Desktop.DeepCopy(), + Updater: o.Updater.DeepCopy(), + Start: o.Start.DeepCopy(), + Git: o.Git.DeepCopy(), + } +} + +type LogSendID string + +func (o LogSendID) DeepCopy() LogSendID { + return o +} + +type AllProvisionedUsernames struct { + DefaultUsername string `codec:"defaultUsername" json:"defaultUsername"` + ProvisionedUsernames []string `codec:"provisionedUsernames" json:"provisionedUsernames"` + HasProvisionedUser bool `codec:"hasProvisionedUser" json:"hasProvisionedUser"` +} + +func (o AllProvisionedUsernames) DeepCopy() AllProvisionedUsernames { + return AllProvisionedUsernames{ + DefaultUsername: o.DefaultUsername, + ProvisionedUsernames: (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.ProvisionedUsernames), + HasProvisionedUser: o.HasProvisionedUser, + } +} + +type ForkType int + +const ( + ForkType_NONE ForkType = 0 + ForkType_AUTO ForkType = 1 + ForkType_WATCHDOG ForkType = 2 + ForkType_LAUNCHD ForkType = 3 + ForkType_SYSTEMD ForkType = 4 +) + +func (o ForkType) DeepCopy() ForkType { return o } + +var ForkTypeMap = map[string]ForkType{ + "NONE": 0, + "AUTO": 1, + "WATCHDOG": 2, + "LAUNCHD": 3, + "SYSTEMD": 4, +} + +var ForkTypeRevMap = map[ForkType]string{ + 0: "NONE", + 1: "AUTO", + 2: "WATCHDOG", + 3: "LAUNCHD", + 4: "SYSTEMD", +} + +func (e ForkType) String() string { + if v, ok := ForkTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type Config struct { + ServerURI string `codec:"serverURI" json:"serverURI"` + SocketFile string `codec:"socketFile" json:"socketFile"` + Label string `codec:"label" json:"label"` + RunMode string `codec:"runMode" json:"runMode"` + GpgExists bool `codec:"gpgExists" json:"gpgExists"` + GpgPath string `codec:"gpgPath" json:"gpgPath"` + Version string `codec:"version" json:"version"` + Path string `codec:"path" json:"path"` + BinaryRealpath string `codec:"binaryRealpath" json:"binaryRealpath"` + ConfigPath string `codec:"configPath" json:"configPath"` + VersionShort string `codec:"versionShort" json:"versionShort"` + VersionFull string `codec:"versionFull" json:"versionFull"` + IsAutoForked bool `codec:"isAutoForked" json:"isAutoForked"` + ForkType ForkType `codec:"forkType" json:"forkType"` +} + +func (o Config) DeepCopy() Config { + return Config{ + ServerURI: o.ServerURI, + SocketFile: o.SocketFile, + Label: o.Label, + RunMode: o.RunMode, + GpgExists: o.GpgExists, + GpgPath: o.GpgPath, + Version: o.Version, + Path: o.Path, + BinaryRealpath: o.BinaryRealpath, + ConfigPath: o.ConfigPath, + VersionShort: o.VersionShort, + VersionFull: o.VersionFull, + IsAutoForked: o.IsAutoForked, + ForkType: o.ForkType.DeepCopy(), + } +} + +type ConfigValue struct { + IsNull bool `codec:"isNull" json:"isNull"` + B *bool `codec:"b,omitempty" json:"b,omitempty"` + I *int `codec:"i,omitempty" json:"i,omitempty"` + F *float64 `codec:"f,omitempty" json:"f,omitempty"` + S *string `codec:"s,omitempty" json:"s,omitempty"` + O *string `codec:"o,omitempty" json:"o,omitempty"` +} + +func (o ConfigValue) DeepCopy() ConfigValue { + return ConfigValue{ + IsNull: o.IsNull, + B: (func(x *bool) *bool { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.B), + I: (func(x *int) *int { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.I), + F: (func(x *float64) *float64 { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.F), + S: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.S), + O: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.O), + } +} + +type OutOfDateInfo struct { + UpgradeTo string `codec:"upgradeTo" json:"upgradeTo"` + UpgradeURI string `codec:"upgradeURI" json:"upgradeURI"` + CustomMessage string `codec:"customMessage" json:"customMessage"` + CriticalClockSkew int64 `codec:"criticalClockSkew" json:"criticalClockSkew"` +} + +func (o OutOfDateInfo) DeepCopy() OutOfDateInfo { + return OutOfDateInfo{ + UpgradeTo: o.UpgradeTo, + UpgradeURI: o.UpgradeURI, + CustomMessage: o.CustomMessage, + CriticalClockSkew: o.CriticalClockSkew, + } +} + +type UpdateInfoStatus int + +const ( + UpdateInfoStatus_UP_TO_DATE UpdateInfoStatus = 0 + UpdateInfoStatus_NEED_UPDATE UpdateInfoStatus = 1 + UpdateInfoStatus_CRITICALLY_OUT_OF_DATE UpdateInfoStatus = 2 +) + +func (o UpdateInfoStatus) DeepCopy() UpdateInfoStatus { return o } + +var UpdateInfoStatusMap = map[string]UpdateInfoStatus{ + "UP_TO_DATE": 0, + "NEED_UPDATE": 1, + "CRITICALLY_OUT_OF_DATE": 2, +} + +var UpdateInfoStatusRevMap = map[UpdateInfoStatus]string{ + 0: "UP_TO_DATE", + 1: "NEED_UPDATE", + 2: "CRITICALLY_OUT_OF_DATE", +} + +func (e UpdateInfoStatus) String() string { + if v, ok := UpdateInfoStatusRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type UpdateInfo struct { + Status UpdateInfoStatus `codec:"status" json:"status"` + Message string `codec:"message" json:"message"` +} + +func (o UpdateInfo) DeepCopy() UpdateInfo { + return UpdateInfo{ + Status: o.Status.DeepCopy(), + Message: o.Message, + } +} + +type BootstrapStatus struct { + Registered bool `codec:"registered" json:"registered"` + LoggedIn bool `codec:"loggedIn" json:"loggedIn"` + Uid UID `codec:"uid" json:"uid"` + Username string `codec:"username" json:"username"` + DeviceID DeviceID `codec:"deviceID" json:"deviceID"` + DeviceName string `codec:"deviceName" json:"deviceName"` + Fullname FullName `codec:"fullname" json:"fullname"` + UserReacjis UserReacjis `codec:"userReacjis" json:"userReacjis"` + HttpSrvInfo *HttpSrvInfo `codec:"httpSrvInfo,omitempty" json:"httpSrvInfo,omitempty"` +} + +func (o BootstrapStatus) DeepCopy() BootstrapStatus { + return BootstrapStatus{ + Registered: o.Registered, + LoggedIn: o.LoggedIn, + Uid: o.Uid.DeepCopy(), + Username: o.Username, + DeviceID: o.DeviceID.DeepCopy(), + DeviceName: o.DeviceName, + Fullname: o.Fullname.DeepCopy(), + UserReacjis: o.UserReacjis.DeepCopy(), + HttpSrvInfo: (func(x *HttpSrvInfo) *HttpSrvInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.HttpSrvInfo), + } +} + +type UpdateInfoStatus2 int + +const ( + UpdateInfoStatus2_OK UpdateInfoStatus2 = 0 + UpdateInfoStatus2_SUGGESTED UpdateInfoStatus2 = 1 + UpdateInfoStatus2_CRITICAL UpdateInfoStatus2 = 2 +) + +func (o UpdateInfoStatus2) DeepCopy() UpdateInfoStatus2 { return o } + +var UpdateInfoStatus2Map = map[string]UpdateInfoStatus2{ + "OK": 0, + "SUGGESTED": 1, + "CRITICAL": 2, +} + +var UpdateInfoStatus2RevMap = map[UpdateInfoStatus2]string{ + 0: "OK", + 1: "SUGGESTED", + 2: "CRITICAL", +} + +func (e UpdateInfoStatus2) String() string { + if v, ok := UpdateInfoStatus2RevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type UpdateDetails struct { + Message string `codec:"message" json:"message"` +} + +func (o UpdateDetails) DeepCopy() UpdateDetails { + return UpdateDetails{ + Message: o.Message, + } +} + +type UpdateInfo2 struct { + Status__ UpdateInfoStatus2 `codec:"status" json:"status"` + Suggested__ *UpdateDetails `codec:"suggested,omitempty" json:"suggested,omitempty"` + Critical__ *UpdateDetails `codec:"critical,omitempty" json:"critical,omitempty"` +} + +func (o *UpdateInfo2) Status() (ret UpdateInfoStatus2, err error) { + switch o.Status__ { + case UpdateInfoStatus2_SUGGESTED: + if o.Suggested__ == nil { + err = errors.New("unexpected nil value for Suggested__") + return ret, err + } + case UpdateInfoStatus2_CRITICAL: + if o.Critical__ == nil { + err = errors.New("unexpected nil value for Critical__") + return ret, err + } + } + return o.Status__, nil +} + +func (o UpdateInfo2) Suggested() (res UpdateDetails) { + if o.Status__ != UpdateInfoStatus2_SUGGESTED { + panic("wrong case accessed") + } + if o.Suggested__ == nil { + return + } + return *o.Suggested__ +} + +func (o UpdateInfo2) Critical() (res UpdateDetails) { + if o.Status__ != UpdateInfoStatus2_CRITICAL { + panic("wrong case accessed") + } + if o.Critical__ == nil { + return + } + return *o.Critical__ +} + +func NewUpdateInfo2WithOk() UpdateInfo2 { + return UpdateInfo2{ + Status__: UpdateInfoStatus2_OK, + } +} + +func NewUpdateInfo2WithSuggested(v UpdateDetails) UpdateInfo2 { + return UpdateInfo2{ + Status__: UpdateInfoStatus2_SUGGESTED, + Suggested__: &v, + } +} + +func NewUpdateInfo2WithCritical(v UpdateDetails) UpdateInfo2 { + return UpdateInfo2{ + Status__: UpdateInfoStatus2_CRITICAL, + Critical__: &v, + } +} + +func (o UpdateInfo2) DeepCopy() UpdateInfo2 { + return UpdateInfo2{ + Status__: o.Status__.DeepCopy(), + Suggested__: (func(x *UpdateDetails) *UpdateDetails { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Suggested__), + Critical__: (func(x *UpdateDetails) *UpdateDetails { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Critical__), + } +} + +type ProxyType int + +const ( + ProxyType_No_Proxy ProxyType = 0 + ProxyType_HTTP_Connect ProxyType = 1 + ProxyType_Socks ProxyType = 2 +) + +func (o ProxyType) DeepCopy() ProxyType { return o } + +var ProxyTypeMap = map[string]ProxyType{ + "No_Proxy": 0, + "HTTP_Connect": 1, + "Socks": 2, +} + +var ProxyTypeRevMap = map[ProxyType]string{ + 0: "No_Proxy", + 1: "HTTP_Connect", + 2: "Socks", +} + +func (e ProxyType) String() string { + if v, ok := ProxyTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ProxyData struct { + AddressWithPort string `codec:"addressWithPort" json:"addressWithPort"` + ProxyType ProxyType `codec:"proxyType" json:"proxyType"` + CertPinning bool `codec:"certPinning" json:"certPinning"` +} + +func (o ProxyData) DeepCopy() ProxyData { + return ProxyData{ + AddressWithPort: o.AddressWithPort, + ProxyType: o.ProxyType.DeepCopy(), + CertPinning: o.CertPinning, + } +} 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 new file mode 100644 index 00000000..c9d45956 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/constants.go @@ -0,0 +1,724 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/constants.avdl + +package keybase1 + +import ( + "fmt" +) + +type StatusCode int + +const ( + StatusCode_SCOk StatusCode = 0 + StatusCode_SCInputError StatusCode = 100 + StatusCode_SCLoginRequired StatusCode = 201 + StatusCode_SCBadSession StatusCode = 202 + StatusCode_SCBadLoginUserNotFound StatusCode = 203 + StatusCode_SCBadLoginPassword StatusCode = 204 + StatusCode_SCNotFound StatusCode = 205 + StatusCode_SCThrottleControl StatusCode = 210 + StatusCode_SCDeleted StatusCode = 216 + StatusCode_SCGeneric StatusCode = 218 + StatusCode_SCAlreadyLoggedIn StatusCode = 235 + StatusCode_SCExists StatusCode = 230 + StatusCode_SCCanceled StatusCode = 237 + StatusCode_SCInputCanceled StatusCode = 239 + StatusCode_SCBadUsername StatusCode = 243 + StatusCode_SCOffline StatusCode = 267 + StatusCode_SCReloginRequired StatusCode = 274 + StatusCode_SCResolutionFailed StatusCode = 275 + StatusCode_SCProfileNotPublic StatusCode = 276 + StatusCode_SCIdentifyFailed StatusCode = 277 + StatusCode_SCTrackingBroke StatusCode = 278 + StatusCode_SCWrongCryptoFormat StatusCode = 279 + StatusCode_SCDecryptionError StatusCode = 280 + StatusCode_SCInvalidAddress StatusCode = 281 + StatusCode_SCNoSession StatusCode = 283 + StatusCode_SCAccountReset StatusCode = 290 + StatusCode_SCIdentifiesFailed StatusCode = 295 + StatusCode_SCNoSpaceOnDevice StatusCode = 297 + StatusCode_SCMerkleClientError StatusCode = 299 + StatusCode_SCBadEmail StatusCode = 472 + StatusCode_SCRateLimit StatusCode = 602 + StatusCode_SCBadSignupUsernameTaken StatusCode = 701 + StatusCode_SCDuplicate StatusCode = 706 + StatusCode_SCBadInvitationCode StatusCode = 707 + StatusCode_SCBadSignupUsernameReserved StatusCode = 710 + StatusCode_SCBadSignupTeamName StatusCode = 711 + StatusCode_SCFeatureFlag StatusCode = 712 + StatusCode_SCEmailTaken StatusCode = 713 + StatusCode_SCEmailAlreadyAdded StatusCode = 714 + StatusCode_SCEmailLimitExceeded StatusCode = 715 + StatusCode_SCEmailCannotDeletePrimary StatusCode = 716 + StatusCode_SCEmailUnknown StatusCode = 717 + StatusCode_SCBotSignupTokenNotFound StatusCode = 719 + StatusCode_SCNoUpdate StatusCode = 723 + StatusCode_SCMissingResult StatusCode = 801 + StatusCode_SCKeyNotFound StatusCode = 901 + StatusCode_SCKeyCorrupted StatusCode = 905 + StatusCode_SCKeyInUse StatusCode = 907 + StatusCode_SCKeyBadGen StatusCode = 913 + StatusCode_SCKeyNoSecret StatusCode = 914 + StatusCode_SCKeyBadUIDs StatusCode = 915 + StatusCode_SCKeyNoActive StatusCode = 916 + StatusCode_SCKeyNoSig StatusCode = 917 + StatusCode_SCKeyBadSig StatusCode = 918 + StatusCode_SCKeyBadEldest StatusCode = 919 + StatusCode_SCKeyNoEldest StatusCode = 920 + StatusCode_SCKeyDuplicateUpdate StatusCode = 921 + StatusCode_SCSibkeyAlreadyExists StatusCode = 922 + StatusCode_SCDecryptionKeyNotFound StatusCode = 924 + StatusCode_SCKeyNoPGPEncryption StatusCode = 927 + StatusCode_SCKeyNoNaClEncryption StatusCode = 928 + StatusCode_SCKeySyncedPGPNotFound StatusCode = 929 + StatusCode_SCKeyNoMatchingGPG StatusCode = 930 + StatusCode_SCKeyRevoked StatusCode = 931 + StatusCode_SCSigCannotVerify StatusCode = 1002 + StatusCode_SCSigWrongKey StatusCode = 1008 + StatusCode_SCSigOldSeqno StatusCode = 1010 + StatusCode_SCSigCreationDisallowed StatusCode = 1016 + StatusCode_SCSigMissingRatchet StatusCode = 1021 + StatusCode_SCSigBadTotalOrder StatusCode = 1022 + StatusCode_SCBadTrackSession StatusCode = 1301 + StatusCode_SCDeviceBadName StatusCode = 1404 + StatusCode_SCDeviceBadStatus StatusCode = 1405 + StatusCode_SCDeviceNameInUse StatusCode = 1408 + StatusCode_SCDeviceNotFound StatusCode = 1409 + StatusCode_SCDeviceMismatch StatusCode = 1410 + StatusCode_SCDeviceRequired StatusCode = 1411 + StatusCode_SCDevicePrevProvisioned StatusCode = 1413 + StatusCode_SCDeviceNoProvision StatusCode = 1414 + StatusCode_SCDeviceProvisionViaDevice StatusCode = 1415 + StatusCode_SCRevokeCurrentDevice StatusCode = 1416 + StatusCode_SCRevokeLastDevice StatusCode = 1417 + StatusCode_SCDeviceProvisionOffline StatusCode = 1418 + StatusCode_SCRevokeLastDevicePGP StatusCode = 1419 + StatusCode_SCStreamExists StatusCode = 1501 + StatusCode_SCStreamNotFound StatusCode = 1502 + StatusCode_SCStreamWrongKind StatusCode = 1503 + StatusCode_SCStreamEOF StatusCode = 1504 + StatusCode_SCStreamUnknown StatusCode = 1505 + StatusCode_SCGenericAPIError StatusCode = 1600 + StatusCode_SCAPINetworkError StatusCode = 1601 + StatusCode_SCTimeout StatusCode = 1602 + StatusCode_SCProofError StatusCode = 1701 + StatusCode_SCIdentificationExpired StatusCode = 1702 + StatusCode_SCSelfNotFound StatusCode = 1703 + StatusCode_SCBadKexPhrase StatusCode = 1704 + StatusCode_SCNoUIDelegation StatusCode = 1705 + StatusCode_SCNoUI StatusCode = 1706 + StatusCode_SCGPGUnavailable StatusCode = 1707 + StatusCode_SCInvalidVersionError StatusCode = 1800 + StatusCode_SCOldVersionError StatusCode = 1801 + StatusCode_SCInvalidLocationError StatusCode = 1802 + StatusCode_SCServiceStatusError StatusCode = 1803 + StatusCode_SCInstallError StatusCode = 1804 + StatusCode_SCLoadKextError StatusCode = 1810 + StatusCode_SCLoadKextPermError StatusCode = 1811 + StatusCode_SCGitInternal StatusCode = 2300 + StatusCode_SCGitRepoAlreadyExists StatusCode = 2301 + StatusCode_SCGitInvalidRepoName StatusCode = 2302 + StatusCode_SCGitCannotDelete StatusCode = 2303 + StatusCode_SCGitRepoDoesntExist StatusCode = 2304 + StatusCode_SCLoginStateTimeout StatusCode = 2400 + StatusCode_SCChatInternal StatusCode = 2500 + StatusCode_SCChatRateLimit StatusCode = 2501 + StatusCode_SCChatConvExists StatusCode = 2502 + StatusCode_SCChatUnknownTLFID StatusCode = 2503 + StatusCode_SCChatNotInConv StatusCode = 2504 + StatusCode_SCChatBadMsg StatusCode = 2505 + StatusCode_SCChatBroadcast StatusCode = 2506 + StatusCode_SCChatAlreadySuperseded StatusCode = 2507 + StatusCode_SCChatAlreadyDeleted StatusCode = 2508 + StatusCode_SCChatTLFFinalized StatusCode = 2509 + StatusCode_SCChatCollision StatusCode = 2510 + StatusCode_SCIdentifySummaryError StatusCode = 2511 + StatusCode_SCNeedSelfRekey StatusCode = 2512 + StatusCode_SCNeedOtherRekey StatusCode = 2513 + StatusCode_SCChatMessageCollision StatusCode = 2514 + StatusCode_SCChatDuplicateMessage StatusCode = 2515 + StatusCode_SCChatClientError StatusCode = 2516 + StatusCode_SCChatNotInTeam StatusCode = 2517 + StatusCode_SCChatStalePreviousState StatusCode = 2518 + StatusCode_SCChatEphemeralRetentionPolicyViolatedError StatusCode = 2519 + StatusCode_SCTeamBadMembership StatusCode = 2604 + StatusCode_SCTeamSelfNotOwner StatusCode = 2607 + StatusCode_SCTeamNotFound StatusCode = 2614 + StatusCode_SCTeamExists StatusCode = 2619 + StatusCode_SCTeamReadError StatusCode = 2623 + StatusCode_SCTeamWritePermDenied StatusCode = 2625 + StatusCode_SCTeamBadGeneration StatusCode = 2634 + StatusCode_SCNoOp StatusCode = 2638 + StatusCode_SCTeamInviteBadCancel StatusCode = 2645 + StatusCode_SCTeamInviteBadToken StatusCode = 2646 + StatusCode_SCTeamTarDuplicate StatusCode = 2663 + StatusCode_SCTeamTarNotFound StatusCode = 2664 + StatusCode_SCTeamMemberExists StatusCode = 2665 + StatusCode_SCTeamNotReleased StatusCode = 2666 + StatusCode_SCTeamPermanentlyLeft StatusCode = 2667 + StatusCode_SCTeamNeedRootId StatusCode = 2668 + StatusCode_SCTeamHasLiveChildren StatusCode = 2669 + StatusCode_SCTeamDeleteError StatusCode = 2670 + StatusCode_SCTeamBadRootTeam StatusCode = 2671 + StatusCode_SCTeamNameConflictsWithUser StatusCode = 2672 + StatusCode_SCTeamDeleteNoUpPointer StatusCode = 2673 + StatusCode_SCTeamNeedOwner StatusCode = 2674 + StatusCode_SCTeamNoOwnerAllowed StatusCode = 2675 + StatusCode_SCTeamImplicitNoNonSbs StatusCode = 2676 + StatusCode_SCTeamImplicitBadHash StatusCode = 2677 + StatusCode_SCTeamImplicitBadName StatusCode = 2678 + StatusCode_SCTeamImplicitClash StatusCode = 2679 + StatusCode_SCTeamImplicitDuplicate StatusCode = 2680 + StatusCode_SCTeamImplicitBadOp StatusCode = 2681 + StatusCode_SCTeamImplicitBadRole StatusCode = 2682 + StatusCode_SCTeamImplicitNotFound StatusCode = 2683 + StatusCode_SCTeamBadAdminSeqnoType StatusCode = 2684 + StatusCode_SCTeamImplicitBadAdd StatusCode = 2685 + StatusCode_SCTeamImplicitBadRemove StatusCode = 2686 + StatusCode_SCTeamInviteTokenReused StatusCode = 2696 + StatusCode_SCTeamKeyMaskNotFound StatusCode = 2697 + StatusCode_SCTeamBanned StatusCode = 2702 + StatusCode_SCTeamInvalidBan StatusCode = 2703 + StatusCode_SCTeamShowcasePermDenied StatusCode = 2711 + StatusCode_SCTeamProvisionalCanKey StatusCode = 2721 + StatusCode_SCTeamProvisionalCannotKey StatusCode = 2722 + StatusCode_SCTeamFTLOutdated StatusCode = 2736 + StatusCode_SCTeamStorageWrongRevision StatusCode = 2760 + StatusCode_SCTeamStorageBadGeneration StatusCode = 2761 + StatusCode_SCTeamStorageNotFound StatusCode = 2762 + StatusCode_SCTeamContactSettingsBlock StatusCode = 2763 + StatusCode_SCEphemeralKeyBadGeneration StatusCode = 2900 + StatusCode_SCEphemeralKeyUnexpectedBox StatusCode = 2901 + StatusCode_SCEphemeralKeyMissingBox StatusCode = 2902 + StatusCode_SCEphemeralKeyWrongNumberOfKeys StatusCode = 2903 + StatusCode_SCEphemeralKeyMismatchedKey StatusCode = 2904 + StatusCode_SCEphemeralPairwiseMACsMissingUIDs StatusCode = 2905 + StatusCode_SCEphemeralDeviceAfterEK StatusCode = 2906 + StatusCode_SCEphemeralMemberAfterEK StatusCode = 2907 + StatusCode_SCEphemeralDeviceStale StatusCode = 2908 + StatusCode_SCEphemeralUserStale StatusCode = 2909 + StatusCode_SCStellarError StatusCode = 3100 + StatusCode_SCStellarBadInput StatusCode = 3101 + StatusCode_SCStellarWrongRevision StatusCode = 3102 + StatusCode_SCStellarMissingBundle StatusCode = 3103 + StatusCode_SCStellarBadPuk StatusCode = 3104 + StatusCode_SCStellarMissingAccount StatusCode = 3105 + StatusCode_SCStellarBadPrev StatusCode = 3106 + StatusCode_SCStellarWrongPrimary StatusCode = 3107 + StatusCode_SCStellarUnsupportedCurrency StatusCode = 3108 + StatusCode_SCStellarNeedDisclaimer StatusCode = 3109 + StatusCode_SCStellarDeviceNotMobile StatusCode = 3110 + StatusCode_SCStellarMobileOnlyPurgatory StatusCode = 3111 + StatusCode_SCStellarIncompatibleVersion StatusCode = 3112 + StatusCode_SCNISTWrongSize StatusCode = 3201 + StatusCode_SCNISTBadMode StatusCode = 3202 + StatusCode_SCNISTHashWrongSize StatusCode = 3203 + StatusCode_SCNISTSigWrongSize StatusCode = 3204 + StatusCode_SCNISTSigBadInput StatusCode = 3205 + StatusCode_SCNISTSigBadUID StatusCode = 3206 + StatusCode_SCNISTSigBadDeviceID StatusCode = 3207 + StatusCode_SCNISTSigBadNonce StatusCode = 3208 + StatusCode_SCNISTNoSigOrHash StatusCode = 3209 + StatusCode_SCNISTExpired StatusCode = 3210 + StatusCode_SCNISTSigRevoked StatusCode = 3211 + StatusCode_SCNISTKeyRevoked StatusCode = 3212 + StatusCode_SCNISTUserDeleted StatusCode = 3213 + StatusCode_SCNISTNoDevice StatusCode = 3214 + StatusCode_SCNISTSigCannot_verify StatusCode = 3215 + StatusCode_SCNISTReplay StatusCode = 3216 + StatusCode_SCNISTSigBadLifetime StatusCode = 3217 + StatusCode_SCNISTNotFound StatusCode = 3218 + StatusCode_SCNISTBadClock StatusCode = 3219 + StatusCode_SCNISTSigBadCtime StatusCode = 3220 + StatusCode_SCBadSignupUsernameDeleted StatusCode = 3221 + StatusCode_SCPhoneNumberUnknown StatusCode = 3400 + StatusCode_SCPhoneNumberAlreadyVerified StatusCode = 3401 + StatusCode_SCPhoneNumberVerificationCodeExpired StatusCode = 3402 + StatusCode_SCPhoneNumberWrongVerificationCode StatusCode = 3403 + StatusCode_SCPhoneNumberLimitExceeded StatusCode = 3404 + StatusCode_SCNoPaperKeys StatusCode = 3605 + StatusCode_SCTeambotKeyGenerationExists StatusCode = 3800 + StatusCode_SCTeambotKeyOldBoxedGeneration StatusCode = 3801 + StatusCode_SCTeambotKeyBadGeneration StatusCode = 3802 + StatusCode_SCAirdropRegisterFailedMisc StatusCode = 4207 +) + +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, + "SCChatEphemeralRetentionPolicyViolatedError": 2519, + "SCTeamBadMembership": 2604, + "SCTeamSelfNotOwner": 2607, + "SCTeamNotFound": 2614, + "SCTeamExists": 2619, + "SCTeamReadError": 2623, + "SCTeamWritePermDenied": 2625, + "SCTeamBadGeneration": 2634, + "SCNoOp": 2638, + "SCTeamInviteBadCancel": 2645, + "SCTeamInviteBadToken": 2646, + "SCTeamTarDuplicate": 2663, + "SCTeamTarNotFound": 2664, + "SCTeamMemberExists": 2665, + "SCTeamNotReleased": 2666, + "SCTeamPermanentlyLeft": 2667, + "SCTeamNeedRootId": 2668, + "SCTeamHasLiveChildren": 2669, + "SCTeamDeleteError": 2670, + "SCTeamBadRootTeam": 2671, + "SCTeamNameConflictsWithUser": 2672, + "SCTeamDeleteNoUpPointer": 2673, + "SCTeamNeedOwner": 2674, + "SCTeamNoOwnerAllowed": 2675, + "SCTeamImplicitNoNonSbs": 2676, + "SCTeamImplicitBadHash": 2677, + "SCTeamImplicitBadName": 2678, + "SCTeamImplicitClash": 2679, + "SCTeamImplicitDuplicate": 2680, + "SCTeamImplicitBadOp": 2681, + "SCTeamImplicitBadRole": 2682, + "SCTeamImplicitNotFound": 2683, + "SCTeamBadAdminSeqnoType": 2684, + "SCTeamImplicitBadAdd": 2685, + "SCTeamImplicitBadRemove": 2686, + "SCTeamInviteTokenReused": 2696, + "SCTeamKeyMaskNotFound": 2697, + "SCTeamBanned": 2702, + "SCTeamInvalidBan": 2703, + "SCTeamShowcasePermDenied": 2711, + "SCTeamProvisionalCanKey": 2721, + "SCTeamProvisionalCannotKey": 2722, + "SCTeamFTLOutdated": 2736, + "SCTeamStorageWrongRevision": 2760, + "SCTeamStorageBadGeneration": 2761, + "SCTeamStorageNotFound": 2762, + "SCTeamContactSettingsBlock": 2763, + "SCEphemeralKeyBadGeneration": 2900, + "SCEphemeralKeyUnexpectedBox": 2901, + "SCEphemeralKeyMissingBox": 2902, + "SCEphemeralKeyWrongNumberOfKeys": 2903, + "SCEphemeralKeyMismatchedKey": 2904, + "SCEphemeralPairwiseMACsMissingUIDs": 2905, + "SCEphemeralDeviceAfterEK": 2906, + "SCEphemeralMemberAfterEK": 2907, + "SCEphemeralDeviceStale": 2908, + "SCEphemeralUserStale": 2909, + "SCStellarError": 3100, + "SCStellarBadInput": 3101, + "SCStellarWrongRevision": 3102, + "SCStellarMissingBundle": 3103, + "SCStellarBadPuk": 3104, + "SCStellarMissingAccount": 3105, + "SCStellarBadPrev": 3106, + "SCStellarWrongPrimary": 3107, + "SCStellarUnsupportedCurrency": 3108, + "SCStellarNeedDisclaimer": 3109, + "SCStellarDeviceNotMobile": 3110, + "SCStellarMobileOnlyPurgatory": 3111, + "SCStellarIncompatibleVersion": 3112, + "SCNISTWrongSize": 3201, + "SCNISTBadMode": 3202, + "SCNISTHashWrongSize": 3203, + "SCNISTSigWrongSize": 3204, + "SCNISTSigBadInput": 3205, + "SCNISTSigBadUID": 3206, + "SCNISTSigBadDeviceID": 3207, + "SCNISTSigBadNonce": 3208, + "SCNISTNoSigOrHash": 3209, + "SCNISTExpired": 3210, + "SCNISTSigRevoked": 3211, + "SCNISTKeyRevoked": 3212, + "SCNISTUserDeleted": 3213, + "SCNISTNoDevice": 3214, + "SCNISTSigCannot_verify": 3215, + "SCNISTReplay": 3216, + "SCNISTSigBadLifetime": 3217, + "SCNISTNotFound": 3218, + "SCNISTBadClock": 3219, + "SCNISTSigBadCtime": 3220, + "SCBadSignupUsernameDeleted": 3221, + "SCPhoneNumberUnknown": 3400, + "SCPhoneNumberAlreadyVerified": 3401, + "SCPhoneNumberVerificationCodeExpired": 3402, + "SCPhoneNumberWrongVerificationCode": 3403, + "SCPhoneNumberLimitExceeded": 3404, + "SCNoPaperKeys": 3605, + "SCTeambotKeyGenerationExists": 3800, + "SCTeambotKeyOldBoxedGeneration": 3801, + "SCTeambotKeyBadGeneration": 3802, + "SCAirdropRegisterFailedMisc": 4207, +} + +var StatusCodeRevMap = map[StatusCode]string{ + 0: "SCOk", + 100: "SCInputError", + 201: "SCLoginRequired", + 202: "SCBadSession", + 203: "SCBadLoginUserNotFound", + 204: "SCBadLoginPassword", + 205: "SCNotFound", + 210: "SCThrottleControl", + 216: "SCDeleted", + 218: "SCGeneric", + 235: "SCAlreadyLoggedIn", + 230: "SCExists", + 237: "SCCanceled", + 239: "SCInputCanceled", + 243: "SCBadUsername", + 267: "SCOffline", + 274: "SCReloginRequired", + 275: "SCResolutionFailed", + 276: "SCProfileNotPublic", + 277: "SCIdentifyFailed", + 278: "SCTrackingBroke", + 279: "SCWrongCryptoFormat", + 280: "SCDecryptionError", + 281: "SCInvalidAddress", + 283: "SCNoSession", + 290: "SCAccountReset", + 295: "SCIdentifiesFailed", + 297: "SCNoSpaceOnDevice", + 299: "SCMerkleClientError", + 472: "SCBadEmail", + 602: "SCRateLimit", + 701: "SCBadSignupUsernameTaken", + 706: "SCDuplicate", + 707: "SCBadInvitationCode", + 710: "SCBadSignupUsernameReserved", + 711: "SCBadSignupTeamName", + 712: "SCFeatureFlag", + 713: "SCEmailTaken", + 714: "SCEmailAlreadyAdded", + 715: "SCEmailLimitExceeded", + 716: "SCEmailCannotDeletePrimary", + 717: "SCEmailUnknown", + 719: "SCBotSignupTokenNotFound", + 723: "SCNoUpdate", + 801: "SCMissingResult", + 901: "SCKeyNotFound", + 905: "SCKeyCorrupted", + 907: "SCKeyInUse", + 913: "SCKeyBadGen", + 914: "SCKeyNoSecret", + 915: "SCKeyBadUIDs", + 916: "SCKeyNoActive", + 917: "SCKeyNoSig", + 918: "SCKeyBadSig", + 919: "SCKeyBadEldest", + 920: "SCKeyNoEldest", + 921: "SCKeyDuplicateUpdate", + 922: "SCSibkeyAlreadyExists", + 924: "SCDecryptionKeyNotFound", + 927: "SCKeyNoPGPEncryption", + 928: "SCKeyNoNaClEncryption", + 929: "SCKeySyncedPGPNotFound", + 930: "SCKeyNoMatchingGPG", + 931: "SCKeyRevoked", + 1002: "SCSigCannotVerify", + 1008: "SCSigWrongKey", + 1010: "SCSigOldSeqno", + 1016: "SCSigCreationDisallowed", + 1021: "SCSigMissingRatchet", + 1022: "SCSigBadTotalOrder", + 1301: "SCBadTrackSession", + 1404: "SCDeviceBadName", + 1405: "SCDeviceBadStatus", + 1408: "SCDeviceNameInUse", + 1409: "SCDeviceNotFound", + 1410: "SCDeviceMismatch", + 1411: "SCDeviceRequired", + 1413: "SCDevicePrevProvisioned", + 1414: "SCDeviceNoProvision", + 1415: "SCDeviceProvisionViaDevice", + 1416: "SCRevokeCurrentDevice", + 1417: "SCRevokeLastDevice", + 1418: "SCDeviceProvisionOffline", + 1419: "SCRevokeLastDevicePGP", + 1501: "SCStreamExists", + 1502: "SCStreamNotFound", + 1503: "SCStreamWrongKind", + 1504: "SCStreamEOF", + 1505: "SCStreamUnknown", + 1600: "SCGenericAPIError", + 1601: "SCAPINetworkError", + 1602: "SCTimeout", + 1701: "SCProofError", + 1702: "SCIdentificationExpired", + 1703: "SCSelfNotFound", + 1704: "SCBadKexPhrase", + 1705: "SCNoUIDelegation", + 1706: "SCNoUI", + 1707: "SCGPGUnavailable", + 1800: "SCInvalidVersionError", + 1801: "SCOldVersionError", + 1802: "SCInvalidLocationError", + 1803: "SCServiceStatusError", + 1804: "SCInstallError", + 1810: "SCLoadKextError", + 1811: "SCLoadKextPermError", + 2300: "SCGitInternal", + 2301: "SCGitRepoAlreadyExists", + 2302: "SCGitInvalidRepoName", + 2303: "SCGitCannotDelete", + 2304: "SCGitRepoDoesntExist", + 2400: "SCLoginStateTimeout", + 2500: "SCChatInternal", + 2501: "SCChatRateLimit", + 2502: "SCChatConvExists", + 2503: "SCChatUnknownTLFID", + 2504: "SCChatNotInConv", + 2505: "SCChatBadMsg", + 2506: "SCChatBroadcast", + 2507: "SCChatAlreadySuperseded", + 2508: "SCChatAlreadyDeleted", + 2509: "SCChatTLFFinalized", + 2510: "SCChatCollision", + 2511: "SCIdentifySummaryError", + 2512: "SCNeedSelfRekey", + 2513: "SCNeedOtherRekey", + 2514: "SCChatMessageCollision", + 2515: "SCChatDuplicateMessage", + 2516: "SCChatClientError", + 2517: "SCChatNotInTeam", + 2518: "SCChatStalePreviousState", + 2519: "SCChatEphemeralRetentionPolicyViolatedError", + 2604: "SCTeamBadMembership", + 2607: "SCTeamSelfNotOwner", + 2614: "SCTeamNotFound", + 2619: "SCTeamExists", + 2623: "SCTeamReadError", + 2625: "SCTeamWritePermDenied", + 2634: "SCTeamBadGeneration", + 2638: "SCNoOp", + 2645: "SCTeamInviteBadCancel", + 2646: "SCTeamInviteBadToken", + 2663: "SCTeamTarDuplicate", + 2664: "SCTeamTarNotFound", + 2665: "SCTeamMemberExists", + 2666: "SCTeamNotReleased", + 2667: "SCTeamPermanentlyLeft", + 2668: "SCTeamNeedRootId", + 2669: "SCTeamHasLiveChildren", + 2670: "SCTeamDeleteError", + 2671: "SCTeamBadRootTeam", + 2672: "SCTeamNameConflictsWithUser", + 2673: "SCTeamDeleteNoUpPointer", + 2674: "SCTeamNeedOwner", + 2675: "SCTeamNoOwnerAllowed", + 2676: "SCTeamImplicitNoNonSbs", + 2677: "SCTeamImplicitBadHash", + 2678: "SCTeamImplicitBadName", + 2679: "SCTeamImplicitClash", + 2680: "SCTeamImplicitDuplicate", + 2681: "SCTeamImplicitBadOp", + 2682: "SCTeamImplicitBadRole", + 2683: "SCTeamImplicitNotFound", + 2684: "SCTeamBadAdminSeqnoType", + 2685: "SCTeamImplicitBadAdd", + 2686: "SCTeamImplicitBadRemove", + 2696: "SCTeamInviteTokenReused", + 2697: "SCTeamKeyMaskNotFound", + 2702: "SCTeamBanned", + 2703: "SCTeamInvalidBan", + 2711: "SCTeamShowcasePermDenied", + 2721: "SCTeamProvisionalCanKey", + 2722: "SCTeamProvisionalCannotKey", + 2736: "SCTeamFTLOutdated", + 2760: "SCTeamStorageWrongRevision", + 2761: "SCTeamStorageBadGeneration", + 2762: "SCTeamStorageNotFound", + 2763: "SCTeamContactSettingsBlock", + 2900: "SCEphemeralKeyBadGeneration", + 2901: "SCEphemeralKeyUnexpectedBox", + 2902: "SCEphemeralKeyMissingBox", + 2903: "SCEphemeralKeyWrongNumberOfKeys", + 2904: "SCEphemeralKeyMismatchedKey", + 2905: "SCEphemeralPairwiseMACsMissingUIDs", + 2906: "SCEphemeralDeviceAfterEK", + 2907: "SCEphemeralMemberAfterEK", + 2908: "SCEphemeralDeviceStale", + 2909: "SCEphemeralUserStale", + 3100: "SCStellarError", + 3101: "SCStellarBadInput", + 3102: "SCStellarWrongRevision", + 3103: "SCStellarMissingBundle", + 3104: "SCStellarBadPuk", + 3105: "SCStellarMissingAccount", + 3106: "SCStellarBadPrev", + 3107: "SCStellarWrongPrimary", + 3108: "SCStellarUnsupportedCurrency", + 3109: "SCStellarNeedDisclaimer", + 3110: "SCStellarDeviceNotMobile", + 3111: "SCStellarMobileOnlyPurgatory", + 3112: "SCStellarIncompatibleVersion", + 3201: "SCNISTWrongSize", + 3202: "SCNISTBadMode", + 3203: "SCNISTHashWrongSize", + 3204: "SCNISTSigWrongSize", + 3205: "SCNISTSigBadInput", + 3206: "SCNISTSigBadUID", + 3207: "SCNISTSigBadDeviceID", + 3208: "SCNISTSigBadNonce", + 3209: "SCNISTNoSigOrHash", + 3210: "SCNISTExpired", + 3211: "SCNISTSigRevoked", + 3212: "SCNISTKeyRevoked", + 3213: "SCNISTUserDeleted", + 3214: "SCNISTNoDevice", + 3215: "SCNISTSigCannot_verify", + 3216: "SCNISTReplay", + 3217: "SCNISTSigBadLifetime", + 3218: "SCNISTNotFound", + 3219: "SCNISTBadClock", + 3220: "SCNISTSigBadCtime", + 3221: "SCBadSignupUsernameDeleted", + 3400: "SCPhoneNumberUnknown", + 3401: "SCPhoneNumberAlreadyVerified", + 3402: "SCPhoneNumberVerificationCodeExpired", + 3403: "SCPhoneNumberWrongVerificationCode", + 3404: "SCPhoneNumberLimitExceeded", + 3605: "SCNoPaperKeys", + 3800: "SCTeambotKeyGenerationExists", + 3801: "SCTeambotKeyOldBoxedGeneration", + 3802: "SCTeambotKeyBadGeneration", + 4207: "SCAirdropRegisterFailedMisc", +} + +func (e StatusCode) String() string { + if v, ok := StatusCodeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} 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 new file mode 100644 index 00000000..6853945c --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/contacts.go @@ -0,0 +1,127 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/contacts.avdl + +package keybase1 + +type ContactComponent struct { + Label string `codec:"label" json:"label"` + PhoneNumber *RawPhoneNumber `codec:"phoneNumber,omitempty" json:"phoneNumber,omitempty"` + Email *EmailAddress `codec:"email,omitempty" json:"email,omitempty"` +} + +func (o ContactComponent) DeepCopy() ContactComponent { + return ContactComponent{ + Label: o.Label, + PhoneNumber: (func(x *RawPhoneNumber) *RawPhoneNumber { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.PhoneNumber), + Email: (func(x *EmailAddress) *EmailAddress { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Email), + } +} + +type Contact struct { + Name string `codec:"name" json:"name"` + Components []ContactComponent `codec:"components" json:"components"` +} + +func (o Contact) DeepCopy() Contact { + return Contact{ + Name: o.Name, + Components: (func(x []ContactComponent) []ContactComponent { + if x == nil { + return nil + } + ret := make([]ContactComponent, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Components), + } +} + +type ProcessedContact struct { + ContactIndex int `codec:"contactIndex" json:"contactIndex"` + ContactName string `codec:"contactName" json:"contactName"` + Component ContactComponent `codec:"component" json:"component"` + Resolved bool `codec:"resolved" json:"resolved"` + Uid UID `codec:"uid" json:"uid"` + Username string `codec:"username" json:"username"` + FullName string `codec:"fullName" json:"fullName"` + Following bool `codec:"following" json:"following"` + ServiceMap map[string]string `codec:"serviceMap" json:"serviceMap"` + Assertion string `codec:"assertion" json:"assertion"` + DisplayName string `codec:"displayName" json:"displayName"` + DisplayLabel string `codec:"displayLabel" json:"displayLabel"` +} + +func (o ProcessedContact) DeepCopy() ProcessedContact { + return ProcessedContact{ + ContactIndex: o.ContactIndex, + ContactName: o.ContactName, + Component: o.Component.DeepCopy(), + Resolved: o.Resolved, + Uid: o.Uid.DeepCopy(), + Username: o.Username, + FullName: o.FullName, + Following: o.Following, + ServiceMap: (func(x map[string]string) map[string]string { + if x == nil { + return nil + } + ret := make(map[string]string, len(x)) + for k, v := range x { + kCopy := k + vCopy := v + ret[kCopy] = vCopy + } + return ret + })(o.ServiceMap), + Assertion: o.Assertion, + DisplayName: o.DisplayName, + DisplayLabel: o.DisplayLabel, + } +} + +type ContactListResolutionResult struct { + NewlyResolved []ProcessedContact `codec:"newlyResolved" json:"newlyResolved"` + Resolved []ProcessedContact `codec:"resolved" json:"resolved"` +} + +func (o ContactListResolutionResult) DeepCopy() ContactListResolutionResult { + return ContactListResolutionResult{ + NewlyResolved: (func(x []ProcessedContact) []ProcessedContact { + if x == nil { + return nil + } + ret := make([]ProcessedContact, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.NewlyResolved), + Resolved: (func(x []ProcessedContact) []ProcessedContact { + if x == nil { + return nil + } + ret := make([]ProcessedContact, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Resolved), + } +} 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 new file mode 100644 index 00000000..3a492fa0 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/crypto.go @@ -0,0 +1,86 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/crypto.avdl + +package keybase1 + +type ED25519PublicKey [32]byte + +func (o ED25519PublicKey) DeepCopy() ED25519PublicKey { + var ret ED25519PublicKey + copy(ret[:], o[:]) + return ret +} + +type ED25519Signature [64]byte + +func (o ED25519Signature) DeepCopy() ED25519Signature { + var ret ED25519Signature + copy(ret[:], o[:]) + return ret +} + +type ED25519SignatureInfo struct { + Sig ED25519Signature `codec:"sig" json:"sig"` + PublicKey ED25519PublicKey `codec:"publicKey" json:"publicKey"` +} + +func (o ED25519SignatureInfo) DeepCopy() ED25519SignatureInfo { + return ED25519SignatureInfo{ + Sig: o.Sig.DeepCopy(), + PublicKey: o.PublicKey.DeepCopy(), + } +} + +type EncryptedBytes32 [48]byte + +func (o EncryptedBytes32) DeepCopy() EncryptedBytes32 { + var ret EncryptedBytes32 + copy(ret[:], o[:]) + return ret +} + +type BoxNonce [24]byte + +func (o BoxNonce) DeepCopy() BoxNonce { + var ret BoxNonce + copy(ret[:], o[:]) + return ret +} + +type BoxPublicKey [32]byte + +func (o BoxPublicKey) DeepCopy() BoxPublicKey { + var ret BoxPublicKey + copy(ret[:], o[:]) + return ret +} + +type CiphertextBundle struct { + Kid KID `codec:"kid" json:"kid"` + Ciphertext EncryptedBytes32 `codec:"ciphertext" json:"ciphertext"` + Nonce BoxNonce `codec:"nonce" json:"nonce"` + PublicKey BoxPublicKey `codec:"publicKey" json:"publicKey"` +} + +func (o CiphertextBundle) DeepCopy() CiphertextBundle { + return CiphertextBundle{ + Kid: o.Kid.DeepCopy(), + Ciphertext: o.Ciphertext.DeepCopy(), + Nonce: o.Nonce.DeepCopy(), + PublicKey: o.PublicKey.DeepCopy(), + } +} + +type UnboxAnyRes struct { + Kid KID `codec:"kid" json:"kid"` + Plaintext Bytes32 `codec:"plaintext" json:"plaintext"` + Index int `codec:"index" json:"index"` +} + +func (o UnboxAnyRes) DeepCopy() UnboxAnyRes { + return UnboxAnyRes{ + Kid: o.Kid.DeepCopy(), + Plaintext: o.Plaintext.DeepCopy(), + Index: o.Index, + } +} 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 new file mode 100644 index 00000000..477357e7 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/cryptocurrency.go @@ -0,0 +1,16 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/cryptocurrency.avdl + +package keybase1 + +type RegisterAddressRes struct { + Type string `codec:"type" json:"type"` + Family string `codec:"family" json:"family"` +} + +func (o RegisterAddressRes) DeepCopy() RegisterAddressRes { + return RegisterAddressRes{ + Type: o.Type, + Family: o.Family, + } +} 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 new file mode 100644 index 00000000..1621930d --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/ctl.go @@ -0,0 +1,129 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/ctl.avdl + +package keybase1 + +import ( + "fmt" +) + +type ExitCode int + +const ( + ExitCode_OK ExitCode = 0 + ExitCode_NOTOK ExitCode = 2 + ExitCode_RESTART ExitCode = 4 +) + +func (o ExitCode) DeepCopy() ExitCode { return o } + +var ExitCodeMap = map[string]ExitCode{ + "OK": 0, + "NOTOK": 2, + "RESTART": 4, +} + +var ExitCodeRevMap = map[ExitCode]string{ + 0: "OK", + 2: "NOTOK", + 4: "RESTART", +} + +func (e ExitCode) String() string { + if v, ok := ExitCodeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type DbType int + +const ( + DbType_MAIN DbType = 0 + DbType_CHAT DbType = 1 + DbType_FS_BLOCK_CACHE DbType = 2 + DbType_FS_BLOCK_CACHE_META DbType = 3 + DbType_FS_SYNC_BLOCK_CACHE DbType = 4 + DbType_FS_SYNC_BLOCK_CACHE_META DbType = 5 +) + +func (o DbType) DeepCopy() DbType { return o } + +var DbTypeMap = map[string]DbType{ + "MAIN": 0, + "CHAT": 1, + "FS_BLOCK_CACHE": 2, + "FS_BLOCK_CACHE_META": 3, + "FS_SYNC_BLOCK_CACHE": 4, + "FS_SYNC_BLOCK_CACHE_META": 5, +} + +var DbTypeRevMap = map[DbType]string{ + 0: "MAIN", + 1: "CHAT", + 2: "FS_BLOCK_CACHE", + 3: "FS_BLOCK_CACHE_META", + 4: "FS_SYNC_BLOCK_CACHE", + 5: "FS_SYNC_BLOCK_CACHE_META", +} + +func (e DbType) String() string { + if v, ok := DbTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type DbKey struct { + DbType DbType `codec:"dbType" json:"dbType"` + ObjType int `codec:"objType" json:"objType"` + Key string `codec:"key" json:"key"` +} + +func (o DbKey) DeepCopy() DbKey { + return DbKey{ + DbType: o.DbType.DeepCopy(), + ObjType: o.ObjType, + Key: o.Key, + } +} + +type DbValue []byte + +func (o DbValue) DeepCopy() DbValue { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} + +type OnLoginStartupStatus int + +const ( + OnLoginStartupStatus_UNKNOWN OnLoginStartupStatus = 0 + OnLoginStartupStatus_DISABLED OnLoginStartupStatus = 1 + OnLoginStartupStatus_ENABLED OnLoginStartupStatus = 2 +) + +func (o OnLoginStartupStatus) DeepCopy() OnLoginStartupStatus { return o } + +var OnLoginStartupStatusMap = map[string]OnLoginStartupStatus{ + "UNKNOWN": 0, + "DISABLED": 1, + "ENABLED": 2, +} + +var OnLoginStartupStatusRevMap = map[OnLoginStartupStatus]string{ + 0: "UNKNOWN", + 1: "DISABLED", + 2: "ENABLED", +} + +func (e OnLoginStartupStatus) String() string { + if v, ok := OnLoginStartupStatusRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} 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 new file mode 100644 index 00000000..220cd124 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/debugging.go @@ -0,0 +1,14 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/debugging.avdl + +package keybase1 + +type FirstStepResult struct { + ValPlusTwo int `codec:"valPlusTwo" json:"valPlusTwo"` +} + +func (o FirstStepResult) DeepCopy() FirstStepResult { + return FirstStepResult{ + ValPlusTwo: o.ValPlusTwo, + } +} 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 new file mode 100644 index 00000000..527d6fbf --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/delegate_ui_ctl.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..ada7469f --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/device.go @@ -0,0 +1,52 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/device.avdl + +package keybase1 + +type DeviceDetail struct { + Device Device `codec:"device" json:"device"` + Eldest bool `codec:"eldest" json:"eldest"` + Provisioner *Device `codec:"provisioner,omitempty" json:"provisioner,omitempty"` + ProvisionedAt *Time `codec:"provisionedAt,omitempty" json:"provisionedAt,omitempty"` + RevokedAt *Time `codec:"revokedAt,omitempty" json:"revokedAt,omitempty"` + RevokedBy KID `codec:"revokedBy" json:"revokedBy"` + RevokedByDevice *Device `codec:"revokedByDevice,omitempty" json:"revokedByDevice,omitempty"` + CurrentDevice bool `codec:"currentDevice" json:"currentDevice"` +} + +func (o DeviceDetail) DeepCopy() DeviceDetail { + return DeviceDetail{ + Device: o.Device.DeepCopy(), + Eldest: o.Eldest, + Provisioner: (func(x *Device) *Device { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Provisioner), + ProvisionedAt: (func(x *Time) *Time { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ProvisionedAt), + RevokedAt: (func(x *Time) *Time { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RevokedAt), + RevokedBy: o.RevokedBy.DeepCopy(), + RevokedByDevice: (func(x *Device) *Device { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RevokedByDevice), + CurrentDevice: o.CurrentDevice, + } +} 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 new file mode 100644 index 00000000..4fddd5de --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/emails.go @@ -0,0 +1,42 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/emails.avdl + +package keybase1 + +type EmailLookupResult struct { + Email EmailAddress `codec:"email" json:"email"` + Uid *UID `codec:"uid,omitempty" json:"uid,omitempty"` +} + +func (o EmailLookupResult) DeepCopy() EmailLookupResult { + return EmailLookupResult{ + Email: o.Email.DeepCopy(), + Uid: (func(x *UID) *UID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Uid), + } +} + +type EmailAddressVerifiedMsg struct { + Email EmailAddress `codec:"email" json:"email"` +} + +func (o EmailAddressVerifiedMsg) DeepCopy() EmailAddressVerifiedMsg { + return EmailAddressVerifiedMsg{ + Email: o.Email.DeepCopy(), + } +} + +type EmailAddressChangedMsg struct { + Email EmailAddress `codec:"email" json:"email"` +} + +func (o EmailAddressChangedMsg) DeepCopy() EmailAddressChangedMsg { + return EmailAddressChangedMsg{ + Email: o.Email.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..def4172c --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/ephemeral.go @@ -0,0 +1,423 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/ephemeral.avdl + +package keybase1 + +import ( + "errors" + "fmt" +) + +type EkGeneration int64 + +func (o EkGeneration) DeepCopy() EkGeneration { + return o +} + +type DeviceEkMetadata struct { + Kid KID `codec:"kid" json:"device_ephemeral_dh_public"` + HashMeta HashMeta `codec:"hashMeta" json:"hash_meta"` + Generation EkGeneration `codec:"generation" json:"generation"` + Ctime Time `codec:"ctime" json:"ctime"` + DeviceCtime Time `codec:"deviceCtime" json:"deviceCtime"` +} + +func (o DeviceEkMetadata) DeepCopy() DeviceEkMetadata { + return DeviceEkMetadata{ + Kid: o.Kid.DeepCopy(), + HashMeta: o.HashMeta.DeepCopy(), + Generation: o.Generation.DeepCopy(), + Ctime: o.Ctime.DeepCopy(), + DeviceCtime: o.DeviceCtime.DeepCopy(), + } +} + +type DeviceEkStatement struct { + CurrentDeviceEkMetadata DeviceEkMetadata `codec:"currentDeviceEkMetadata" json:"current_device_ek_metadata"` +} + +func (o DeviceEkStatement) DeepCopy() DeviceEkStatement { + return DeviceEkStatement{ + CurrentDeviceEkMetadata: o.CurrentDeviceEkMetadata.DeepCopy(), + } +} + +type DeviceEk struct { + Seed Bytes32 `codec:"seed" json:"seed"` + Metadata DeviceEkMetadata `codec:"metadata" json:"metadata"` +} + +func (o DeviceEk) DeepCopy() DeviceEk { + return DeviceEk{ + Seed: o.Seed.DeepCopy(), + Metadata: o.Metadata.DeepCopy(), + } +} + +type UserEkStatement struct { + CurrentUserEkMetadata UserEkMetadata `codec:"currentUserEkMetadata" json:"current_user_ek_metadata"` +} + +func (o UserEkStatement) DeepCopy() UserEkStatement { + return UserEkStatement{ + CurrentUserEkMetadata: o.CurrentUserEkMetadata.DeepCopy(), + } +} + +type UserEkMetadata struct { + Kid KID `codec:"kid" json:"user_ephemeral_dh_public"` + HashMeta HashMeta `codec:"hashMeta" json:"hash_meta"` + Generation EkGeneration `codec:"generation" json:"generation"` + Ctime Time `codec:"ctime" json:"ctime"` +} + +func (o UserEkMetadata) DeepCopy() UserEkMetadata { + return UserEkMetadata{ + Kid: o.Kid.DeepCopy(), + HashMeta: o.HashMeta.DeepCopy(), + Generation: o.Generation.DeepCopy(), + Ctime: o.Ctime.DeepCopy(), + } +} + +type UserEkBoxed struct { + Box string `codec:"box" json:"box"` + DeviceEkGeneration EkGeneration `codec:"deviceEkGeneration" json:"device_ek_generation"` + Metadata UserEkMetadata `codec:"metadata" json:"metadata"` +} + +func (o UserEkBoxed) DeepCopy() UserEkBoxed { + return UserEkBoxed{ + Box: o.Box, + DeviceEkGeneration: o.DeviceEkGeneration.DeepCopy(), + Metadata: o.Metadata.DeepCopy(), + } +} + +type UserEkBoxMetadata struct { + Box string `codec:"box" json:"box"` + RecipientGeneration EkGeneration `codec:"recipientGeneration" json:"recipient_generation"` + RecipientDeviceID DeviceID `codec:"recipientDeviceID" json:"recipient_device_id"` +} + +func (o UserEkBoxMetadata) DeepCopy() UserEkBoxMetadata { + return UserEkBoxMetadata{ + Box: o.Box, + RecipientGeneration: o.RecipientGeneration.DeepCopy(), + RecipientDeviceID: o.RecipientDeviceID.DeepCopy(), + } +} + +type UserEk struct { + Seed Bytes32 `codec:"seed" json:"seed"` + Metadata UserEkMetadata `codec:"metadata" json:"metadata"` +} + +func (o UserEk) DeepCopy() UserEk { + return UserEk{ + Seed: o.Seed.DeepCopy(), + Metadata: o.Metadata.DeepCopy(), + } +} + +type UserEkReboxArg struct { + UserEkBoxMetadata UserEkBoxMetadata `codec:"userEkBoxMetadata" json:"userEkBoxMetadata"` + DeviceID DeviceID `codec:"deviceID" json:"deviceID"` + DeviceEkStatementSig string `codec:"deviceEkStatementSig" json:"deviceEkStatementSig"` +} + +func (o UserEkReboxArg) DeepCopy() UserEkReboxArg { + return UserEkReboxArg{ + UserEkBoxMetadata: o.UserEkBoxMetadata.DeepCopy(), + DeviceID: o.DeviceID.DeepCopy(), + DeviceEkStatementSig: o.DeviceEkStatementSig, + } +} + +type TeamEkMetadata struct { + Kid KID `codec:"kid" json:"team_ephemeral_dh_public"` + HashMeta HashMeta `codec:"hashMeta" json:"hash_meta"` + Generation EkGeneration `codec:"generation" json:"generation"` + Ctime Time `codec:"ctime" json:"ctime"` +} + +func (o TeamEkMetadata) DeepCopy() TeamEkMetadata { + return TeamEkMetadata{ + Kid: o.Kid.DeepCopy(), + HashMeta: o.HashMeta.DeepCopy(), + Generation: o.Generation.DeepCopy(), + Ctime: o.Ctime.DeepCopy(), + } +} + +type TeamEkStatement struct { + CurrentTeamEkMetadata TeamEkMetadata `codec:"currentTeamEkMetadata" json:"current_team_ek_metadata"` +} + +func (o TeamEkStatement) DeepCopy() TeamEkStatement { + return TeamEkStatement{ + CurrentTeamEkMetadata: o.CurrentTeamEkMetadata.DeepCopy(), + } +} + +type TeamEkBoxed struct { + Box string `codec:"box" json:"box"` + UserEkGeneration EkGeneration `codec:"userEkGeneration" json:"user_ek_generation"` + Metadata TeamEkMetadata `codec:"metadata" json:"metadata"` +} + +func (o TeamEkBoxed) DeepCopy() TeamEkBoxed { + return TeamEkBoxed{ + Box: o.Box, + UserEkGeneration: o.UserEkGeneration.DeepCopy(), + Metadata: o.Metadata.DeepCopy(), + } +} + +type TeamEkBoxMetadata struct { + Box string `codec:"box" json:"box"` + RecipientGeneration EkGeneration `codec:"recipientGeneration" json:"recipient_generation"` + RecipientUID UID `codec:"recipientUID" json:"recipient_uid"` +} + +func (o TeamEkBoxMetadata) DeepCopy() TeamEkBoxMetadata { + return TeamEkBoxMetadata{ + Box: o.Box, + RecipientGeneration: o.RecipientGeneration.DeepCopy(), + RecipientUID: o.RecipientUID.DeepCopy(), + } +} + +type TeamEk struct { + Seed Bytes32 `codec:"seed" json:"seed"` + Metadata TeamEkMetadata `codec:"metadata" json:"metadata"` +} + +func (o TeamEk) DeepCopy() TeamEk { + return TeamEk{ + Seed: o.Seed.DeepCopy(), + Metadata: o.Metadata.DeepCopy(), + } +} + +type TeambotEkMetadata struct { + Kid KID `codec:"kid" json:"teambot_dh_public"` + Generation EkGeneration `codec:"generation" json:"generation"` + Uid UID `codec:"uid" json:"uid"` + UserEkGeneration EkGeneration `codec:"userEkGeneration" json:"user_ek_generation"` + HashMeta HashMeta `codec:"hashMeta" json:"hash_meta"` + Ctime Time `codec:"ctime" json:"ctime"` +} + +func (o TeambotEkMetadata) DeepCopy() TeambotEkMetadata { + return TeambotEkMetadata{ + Kid: o.Kid.DeepCopy(), + Generation: o.Generation.DeepCopy(), + Uid: o.Uid.DeepCopy(), + UserEkGeneration: o.UserEkGeneration.DeepCopy(), + HashMeta: o.HashMeta.DeepCopy(), + Ctime: o.Ctime.DeepCopy(), + } +} + +type TeambotEkBoxed struct { + Box string `codec:"box" json:"box"` + Metadata TeambotEkMetadata `codec:"metadata" json:"metadata"` +} + +func (o TeambotEkBoxed) DeepCopy() TeambotEkBoxed { + return TeambotEkBoxed{ + Box: o.Box, + Metadata: o.Metadata.DeepCopy(), + } +} + +type TeambotEk struct { + Seed Bytes32 `codec:"seed" json:"seed"` + Metadata TeambotEkMetadata `codec:"metadata" json:"metadata"` +} + +func (o TeambotEk) DeepCopy() TeambotEk { + return TeambotEk{ + Seed: o.Seed.DeepCopy(), + Metadata: o.Metadata.DeepCopy(), + } +} + +type TeamEphemeralKeyType int + +const ( + TeamEphemeralKeyType_TEAM TeamEphemeralKeyType = 0 + TeamEphemeralKeyType_TEAMBOT TeamEphemeralKeyType = 1 +) + +func (o TeamEphemeralKeyType) DeepCopy() TeamEphemeralKeyType { return o } + +var TeamEphemeralKeyTypeMap = map[string]TeamEphemeralKeyType{ + "TEAM": 0, + "TEAMBOT": 1, +} + +var TeamEphemeralKeyTypeRevMap = map[TeamEphemeralKeyType]string{ + 0: "TEAM", + 1: "TEAMBOT", +} + +func (e TeamEphemeralKeyType) String() string { + if v, ok := TeamEphemeralKeyTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type TeamEphemeralKey struct { + KeyType__ TeamEphemeralKeyType `codec:"keyType" json:"keyType"` + Team__ *TeamEk `codec:"team,omitempty" json:"team,omitempty"` + Teambot__ *TeambotEk `codec:"teambot,omitempty" json:"teambot,omitempty"` +} + +func (o *TeamEphemeralKey) KeyType() (ret TeamEphemeralKeyType, err error) { + switch o.KeyType__ { + case TeamEphemeralKeyType_TEAM: + if o.Team__ == nil { + err = errors.New("unexpected nil value for Team__") + return ret, err + } + case TeamEphemeralKeyType_TEAMBOT: + if o.Teambot__ == nil { + err = errors.New("unexpected nil value for Teambot__") + return ret, err + } + } + return o.KeyType__, nil +} + +func (o TeamEphemeralKey) Team() (res TeamEk) { + if o.KeyType__ != TeamEphemeralKeyType_TEAM { + panic("wrong case accessed") + } + if o.Team__ == nil { + return + } + return *o.Team__ +} + +func (o TeamEphemeralKey) Teambot() (res TeambotEk) { + if o.KeyType__ != TeamEphemeralKeyType_TEAMBOT { + panic("wrong case accessed") + } + if o.Teambot__ == nil { + return + } + return *o.Teambot__ +} + +func NewTeamEphemeralKeyWithTeam(v TeamEk) TeamEphemeralKey { + return TeamEphemeralKey{ + KeyType__: TeamEphemeralKeyType_TEAM, + Team__: &v, + } +} + +func NewTeamEphemeralKeyWithTeambot(v TeambotEk) TeamEphemeralKey { + return TeamEphemeralKey{ + KeyType__: TeamEphemeralKeyType_TEAMBOT, + Teambot__: &v, + } +} + +func (o TeamEphemeralKey) DeepCopy() TeamEphemeralKey { + return TeamEphemeralKey{ + KeyType__: o.KeyType__.DeepCopy(), + Team__: (func(x *TeamEk) *TeamEk { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Team__), + Teambot__: (func(x *TeambotEk) *TeambotEk { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Teambot__), + } +} + +type TeamEphemeralKeyBoxed struct { + KeyType__ TeamEphemeralKeyType `codec:"keyType" json:"keyType"` + Team__ *TeamEkBoxed `codec:"team,omitempty" json:"team,omitempty"` + Teambot__ *TeambotEkBoxed `codec:"teambot,omitempty" json:"teambot,omitempty"` +} + +func (o *TeamEphemeralKeyBoxed) KeyType() (ret TeamEphemeralKeyType, err error) { + switch o.KeyType__ { + case TeamEphemeralKeyType_TEAM: + if o.Team__ == nil { + err = errors.New("unexpected nil value for Team__") + return ret, err + } + case TeamEphemeralKeyType_TEAMBOT: + if o.Teambot__ == nil { + err = errors.New("unexpected nil value for Teambot__") + return ret, err + } + } + return o.KeyType__, nil +} + +func (o TeamEphemeralKeyBoxed) Team() (res TeamEkBoxed) { + if o.KeyType__ != TeamEphemeralKeyType_TEAM { + panic("wrong case accessed") + } + if o.Team__ == nil { + return + } + return *o.Team__ +} + +func (o TeamEphemeralKeyBoxed) Teambot() (res TeambotEkBoxed) { + if o.KeyType__ != TeamEphemeralKeyType_TEAMBOT { + panic("wrong case accessed") + } + if o.Teambot__ == nil { + return + } + return *o.Teambot__ +} + +func NewTeamEphemeralKeyBoxedWithTeam(v TeamEkBoxed) TeamEphemeralKeyBoxed { + return TeamEphemeralKeyBoxed{ + KeyType__: TeamEphemeralKeyType_TEAM, + Team__: &v, + } +} + +func NewTeamEphemeralKeyBoxedWithTeambot(v TeambotEkBoxed) TeamEphemeralKeyBoxed { + return TeamEphemeralKeyBoxed{ + KeyType__: TeamEphemeralKeyType_TEAMBOT, + Teambot__: &v, + } +} + +func (o TeamEphemeralKeyBoxed) DeepCopy() TeamEphemeralKeyBoxed { + return TeamEphemeralKeyBoxed{ + KeyType__: o.KeyType__.DeepCopy(), + Team__: (func(x *TeamEkBoxed) *TeamEkBoxed { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Team__), + Teambot__: (func(x *TeambotEkBoxed) *TeambotEkBoxed { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Teambot__), + } +} 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 new file mode 100644 index 00000000..6f74e8d9 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/favorite.go @@ -0,0 +1,330 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/favorite.avdl + +package keybase1 + +import ( + "errors" + "fmt" +) + +type FolderType int + +const ( + FolderType_UNKNOWN FolderType = 0 + FolderType_PRIVATE FolderType = 1 + FolderType_PUBLIC FolderType = 2 + FolderType_TEAM FolderType = 3 +) + +func (o FolderType) DeepCopy() FolderType { return o } + +var FolderTypeMap = map[string]FolderType{ + "UNKNOWN": 0, + "PRIVATE": 1, + "PUBLIC": 2, + "TEAM": 3, +} + +var FolderTypeRevMap = map[FolderType]string{ + 0: "UNKNOWN", + 1: "PRIVATE", + 2: "PUBLIC", + 3: "TEAM", +} + +func (e FolderType) String() string { + if v, ok := FolderTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type FolderConflictType int + +const ( + FolderConflictType_NONE FolderConflictType = 0 + FolderConflictType_IN_CONFLICT FolderConflictType = 1 + FolderConflictType_IN_CONFLICT_AND_STUCK FolderConflictType = 2 + FolderConflictType_CLEARED_CONFLICT FolderConflictType = 3 +) + +func (o FolderConflictType) DeepCopy() FolderConflictType { return o } + +var FolderConflictTypeMap = map[string]FolderConflictType{ + "NONE": 0, + "IN_CONFLICT": 1, + "IN_CONFLICT_AND_STUCK": 2, + "CLEARED_CONFLICT": 3, +} + +var FolderConflictTypeRevMap = map[FolderConflictType]string{ + 0: "NONE", + 1: "IN_CONFLICT", + 2: "IN_CONFLICT_AND_STUCK", + 3: "CLEARED_CONFLICT", +} + +func (e FolderConflictType) String() string { + if v, ok := FolderConflictTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ConflictStateType int + +const ( + ConflictStateType_NormalView ConflictStateType = 1 + ConflictStateType_ManualResolvingLocalView ConflictStateType = 2 +) + +func (o ConflictStateType) DeepCopy() ConflictStateType { return o } + +var ConflictStateTypeMap = map[string]ConflictStateType{ + "NormalView": 1, + "ManualResolvingLocalView": 2, +} + +var ConflictStateTypeRevMap = map[ConflictStateType]string{ + 1: "NormalView", + 2: "ManualResolvingLocalView", +} + +func (e ConflictStateType) String() string { + if v, ok := ConflictStateTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type FolderNormalView struct { + ResolvingConflict bool `codec:"resolvingConflict" json:"resolvingConflict"` + StuckInConflict bool `codec:"stuckInConflict" json:"stuckInConflict"` + LocalViews []Path `codec:"localViews" json:"localViews"` +} + +func (o FolderNormalView) DeepCopy() FolderNormalView { + return FolderNormalView{ + ResolvingConflict: o.ResolvingConflict, + StuckInConflict: o.StuckInConflict, + LocalViews: (func(x []Path) []Path { + if x == nil { + return nil + } + ret := make([]Path, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.LocalViews), + } +} + +type FolderConflictManualResolvingLocalView struct { + NormalView Path `codec:"normalView" json:"normalView"` +} + +func (o FolderConflictManualResolvingLocalView) DeepCopy() FolderConflictManualResolvingLocalView { + return FolderConflictManualResolvingLocalView{ + NormalView: o.NormalView.DeepCopy(), + } +} + +type ConflictState struct { + ConflictStateType__ ConflictStateType `codec:"conflictStateType" json:"conflictStateType"` + Normalview__ *FolderNormalView `codec:"normalview,omitempty" json:"normalview,omitempty"` + Manualresolvinglocalview__ *FolderConflictManualResolvingLocalView `codec:"manualresolvinglocalview,omitempty" json:"manualresolvinglocalview,omitempty"` +} + +func (o *ConflictState) ConflictStateType() (ret ConflictStateType, err error) { + switch o.ConflictStateType__ { + case ConflictStateType_NormalView: + if o.Normalview__ == nil { + err = errors.New("unexpected nil value for Normalview__") + return ret, err + } + case ConflictStateType_ManualResolvingLocalView: + if o.Manualresolvinglocalview__ == nil { + err = errors.New("unexpected nil value for Manualresolvinglocalview__") + return ret, err + } + } + return o.ConflictStateType__, nil +} + +func (o ConflictState) Normalview() (res FolderNormalView) { + if o.ConflictStateType__ != ConflictStateType_NormalView { + panic("wrong case accessed") + } + if o.Normalview__ == nil { + return + } + return *o.Normalview__ +} + +func (o ConflictState) Manualresolvinglocalview() (res FolderConflictManualResolvingLocalView) { + if o.ConflictStateType__ != ConflictStateType_ManualResolvingLocalView { + panic("wrong case accessed") + } + if o.Manualresolvinglocalview__ == nil { + return + } + return *o.Manualresolvinglocalview__ +} + +func NewConflictStateWithNormalview(v FolderNormalView) ConflictState { + return ConflictState{ + ConflictStateType__: ConflictStateType_NormalView, + Normalview__: &v, + } +} + +func NewConflictStateWithManualresolvinglocalview(v FolderConflictManualResolvingLocalView) ConflictState { + return ConflictState{ + ConflictStateType__: ConflictStateType_ManualResolvingLocalView, + Manualresolvinglocalview__: &v, + } +} + +func (o ConflictState) DeepCopy() ConflictState { + return ConflictState{ + ConflictStateType__: o.ConflictStateType__.DeepCopy(), + Normalview__: (func(x *FolderNormalView) *FolderNormalView { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Normalview__), + Manualresolvinglocalview__: (func(x *FolderConflictManualResolvingLocalView) *FolderConflictManualResolvingLocalView { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Manualresolvinglocalview__), + } +} + +// Folder represents a favorite top-level folder in kbfs. +// This type is likely to change significantly as all the various parts are +// connected and tested. +type Folder struct { + Name string `codec:"name" json:"name"` + Private bool `codec:"private" json:"private"` + Created bool `codec:"created" json:"created"` + FolderType FolderType `codec:"folderType" json:"folderType"` + TeamID *TeamID `codec:"team_id,omitempty" json:"team_id,omitempty"` + ResetMembers []User `codec:"reset_members" json:"reset_members"` + Mtime *Time `codec:"mtime,omitempty" json:"mtime,omitempty"` + ConflictState *ConflictState `codec:"conflictState,omitempty" json:"conflictState,omitempty"` + SyncConfig *FolderSyncConfig `codec:"syncConfig,omitempty" json:"syncConfig,omitempty"` +} + +func (o Folder) DeepCopy() Folder { + return Folder{ + Name: o.Name, + Private: o.Private, + Created: o.Created, + FolderType: o.FolderType.DeepCopy(), + TeamID: (func(x *TeamID) *TeamID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.TeamID), + ResetMembers: (func(x []User) []User { + if x == nil { + return nil + } + ret := make([]User, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.ResetMembers), + Mtime: (func(x *Time) *Time { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Mtime), + ConflictState: (func(x *ConflictState) *ConflictState { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ConflictState), + SyncConfig: (func(x *FolderSyncConfig) *FolderSyncConfig { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.SyncConfig), + } +} + +type FolderHandle struct { + Name string `codec:"name" json:"name"` + FolderType FolderType `codec:"folderType" json:"folderType"` + Created bool `codec:"created" json:"created"` +} + +func (o FolderHandle) DeepCopy() FolderHandle { + return FolderHandle{ + Name: o.Name, + FolderType: o.FolderType.DeepCopy(), + Created: o.Created, + } +} + +type FavoritesResult struct { + FavoriteFolders []Folder `codec:"favoriteFolders" json:"favoriteFolders"` + IgnoredFolders []Folder `codec:"ignoredFolders" json:"ignoredFolders"` + NewFolders []Folder `codec:"newFolders" json:"newFolders"` +} + +func (o FavoritesResult) DeepCopy() FavoritesResult { + return FavoritesResult{ + FavoriteFolders: (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.FavoriteFolders), + IgnoredFolders: (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.IgnoredFolders), + NewFolders: (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.NewFolders), + } +} 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 new file mode 100644 index 00000000..d526f935 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/featured_bot.go @@ -0,0 +1,84 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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"` +} + +func (o FeaturedBot) DeepCopy() FeaturedBot { + return FeaturedBot{ + BotAlias: o.BotAlias, + Description: o.Description, + ExtendedDescription: o.ExtendedDescription, + BotUsername: o.BotUsername, + OwnerTeam: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.OwnerTeam), + OwnerUser: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.OwnerUser), + Rank: o.Rank, + IsPromoted: o.IsPromoted, + } +} + +type FeaturedBotsRes struct { + Bots []FeaturedBot `codec:"bots" json:"bots"` + IsLastPage bool `codec:"isLastPage" json:"isLastPage"` +} + +func (o FeaturedBotsRes) DeepCopy() FeaturedBotsRes { + return FeaturedBotsRes{ + Bots: (func(x []FeaturedBot) []FeaturedBot { + if x == nil { + return nil + } + ret := make([]FeaturedBot, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Bots), + IsLastPage: o.IsLastPage, + } +} + +type SearchRes struct { + Bots []FeaturedBot `codec:"bots" json:"bots"` + IsLastPage bool `codec:"isLastPage" json:"isLastPage"` +} + +func (o SearchRes) DeepCopy() SearchRes { + return SearchRes{ + Bots: (func(x []FeaturedBot) []FeaturedBot { + if x == nil { + return nil + } + ret := make([]FeaturedBot, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Bots), + IsLastPage: o.IsLastPage, + } +} 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 new file mode 100644 index 00000000..ee2bdc11 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/fs.go @@ -0,0 +1,34 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/fs.avdl + +package keybase1 + +type File struct { + Path string `codec:"path" json:"path"` +} + +func (o File) DeepCopy() File { + return File{ + Path: o.Path, + } +} + +type ListResult struct { + Files []File `codec:"files" json:"files"` +} + +func (o ListResult) DeepCopy() ListResult { + return ListResult{ + Files: (func(x []File) []File { + if x == nil { + return nil + } + ret := make([]File, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Files), + } +} 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 new file mode 100644 index 00000000..f2283550 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/git.go @@ -0,0 +1,382 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/git.avdl + +package keybase1 + +import ( + "errors" + "fmt" +) + +type EncryptedGitMetadata struct { + V int `codec:"v" json:"v"` + E []byte `codec:"e" json:"e"` + N BoxNonce `codec:"n" json:"n"` + Gen PerTeamKeyGeneration `codec:"gen" json:"gen"` +} + +func (o EncryptedGitMetadata) DeepCopy() EncryptedGitMetadata { + return EncryptedGitMetadata{ + V: o.V, + E: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.E), + N: o.N.DeepCopy(), + Gen: o.Gen.DeepCopy(), + } +} + +type RepoID string + +func (o RepoID) DeepCopy() RepoID { + return o +} + +type GitLocalMetadataVersion int + +const ( + GitLocalMetadataVersion_V1 GitLocalMetadataVersion = 1 +) + +func (o GitLocalMetadataVersion) DeepCopy() GitLocalMetadataVersion { return o } + +var GitLocalMetadataVersionMap = map[string]GitLocalMetadataVersion{ + "V1": 1, +} + +var GitLocalMetadataVersionRevMap = map[GitLocalMetadataVersion]string{ + 1: "V1", +} + +func (e GitLocalMetadataVersion) String() string { + if v, ok := GitLocalMetadataVersionRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type GitLocalMetadataV1 struct { + RepoName GitRepoName `codec:"repoName" json:"repoName"` +} + +func (o GitLocalMetadataV1) DeepCopy() GitLocalMetadataV1 { + return GitLocalMetadataV1{ + RepoName: o.RepoName.DeepCopy(), + } +} + +type GitLocalMetadataVersioned struct { + Version__ GitLocalMetadataVersion `codec:"version" json:"version"` + V1__ *GitLocalMetadataV1 `codec:"v1,omitempty" json:"v1,omitempty"` +} + +func (o *GitLocalMetadataVersioned) Version() (ret GitLocalMetadataVersion, err error) { + switch o.Version__ { + case GitLocalMetadataVersion_V1: + if o.V1__ == nil { + err = errors.New("unexpected nil value for V1__") + return ret, err + } + } + return o.Version__, nil +} + +func (o GitLocalMetadataVersioned) V1() (res GitLocalMetadataV1) { + if o.Version__ != GitLocalMetadataVersion_V1 { + panic("wrong case accessed") + } + if o.V1__ == nil { + return + } + return *o.V1__ +} + +func NewGitLocalMetadataVersionedWithV1(v GitLocalMetadataV1) GitLocalMetadataVersioned { + return GitLocalMetadataVersioned{ + Version__: GitLocalMetadataVersion_V1, + V1__: &v, + } +} + +func (o GitLocalMetadataVersioned) DeepCopy() GitLocalMetadataVersioned { + return GitLocalMetadataVersioned{ + Version__: o.Version__.DeepCopy(), + V1__: (func(x *GitLocalMetadataV1) *GitLocalMetadataV1 { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V1__), + } +} + +type GitCommit struct { + CommitHash string `codec:"commitHash" json:"commitHash"` + Message string `codec:"message" json:"message"` + AuthorName string `codec:"authorName" json:"authorName"` + AuthorEmail string `codec:"authorEmail" json:"authorEmail"` + Ctime Time `codec:"ctime" json:"ctime"` +} + +func (o GitCommit) DeepCopy() GitCommit { + return GitCommit{ + CommitHash: o.CommitHash, + Message: o.Message, + AuthorName: o.AuthorName, + AuthorEmail: o.AuthorEmail, + Ctime: o.Ctime.DeepCopy(), + } +} + +type GitPushType int + +const ( + GitPushType_DEFAULT GitPushType = 0 + GitPushType_CREATEREPO GitPushType = 1 + GitPushType_RENAMEREPO GitPushType = 3 +) + +func (o GitPushType) DeepCopy() GitPushType { return o } + +var GitPushTypeMap = map[string]GitPushType{ + "DEFAULT": 0, + "CREATEREPO": 1, + "RENAMEREPO": 3, +} + +var GitPushTypeRevMap = map[GitPushType]string{ + 0: "DEFAULT", + 1: "CREATEREPO", + 3: "RENAMEREPO", +} + +func (e GitPushType) String() string { + if v, ok := GitPushTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type GitRefMetadata struct { + RefName string `codec:"refName" json:"refName"` + Commits []GitCommit `codec:"commits" json:"commits"` + MoreCommitsAvailable bool `codec:"moreCommitsAvailable" json:"moreCommitsAvailable"` + IsDelete bool `codec:"isDelete" json:"isDelete"` +} + +func (o GitRefMetadata) DeepCopy() GitRefMetadata { + return GitRefMetadata{ + RefName: o.RefName, + Commits: (func(x []GitCommit) []GitCommit { + if x == nil { + return nil + } + ret := make([]GitCommit, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Commits), + MoreCommitsAvailable: o.MoreCommitsAvailable, + IsDelete: o.IsDelete, + } +} + +type GitLocalMetadata struct { + RepoName GitRepoName `codec:"repoName" json:"repoName"` + Refs []GitRefMetadata `codec:"refs" json:"refs"` + PushType GitPushType `codec:"pushType" json:"pushType"` + PreviousRepoName GitRepoName `codec:"previousRepoName" json:"previousRepoName"` +} + +func (o GitLocalMetadata) DeepCopy() GitLocalMetadata { + return GitLocalMetadata{ + RepoName: o.RepoName.DeepCopy(), + Refs: (func(x []GitRefMetadata) []GitRefMetadata { + if x == nil { + return nil + } + ret := make([]GitRefMetadata, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Refs), + PushType: o.PushType.DeepCopy(), + PreviousRepoName: o.PreviousRepoName.DeepCopy(), + } +} + +type GitServerMetadata struct { + Ctime Time `codec:"ctime" json:"ctime"` + Mtime Time `codec:"mtime" json:"mtime"` + LastModifyingUsername string `codec:"lastModifyingUsername" json:"lastModifyingUsername"` + LastModifyingDeviceID DeviceID `codec:"lastModifyingDeviceID" json:"lastModifyingDeviceID"` + LastModifyingDeviceName string `codec:"lastModifyingDeviceName" json:"lastModifyingDeviceName"` +} + +func (o GitServerMetadata) DeepCopy() GitServerMetadata { + return GitServerMetadata{ + Ctime: o.Ctime.DeepCopy(), + Mtime: o.Mtime.DeepCopy(), + LastModifyingUsername: o.LastModifyingUsername, + LastModifyingDeviceID: o.LastModifyingDeviceID.DeepCopy(), + LastModifyingDeviceName: o.LastModifyingDeviceName, + } +} + +type GitRepoResultState int + +const ( + GitRepoResultState_ERR GitRepoResultState = 0 + GitRepoResultState_OK GitRepoResultState = 1 +) + +func (o GitRepoResultState) DeepCopy() GitRepoResultState { return o } + +var GitRepoResultStateMap = map[string]GitRepoResultState{ + "ERR": 0, + "OK": 1, +} + +var GitRepoResultStateRevMap = map[GitRepoResultState]string{ + 0: "ERR", + 1: "OK", +} + +func (e GitRepoResultState) String() string { + if v, ok := GitRepoResultStateRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type GitRepoResult struct { + State__ GitRepoResultState `codec:"state" json:"state"` + Err__ *string `codec:"err,omitempty" json:"err,omitempty"` + Ok__ *GitRepoInfo `codec:"ok,omitempty" json:"ok,omitempty"` +} + +func (o *GitRepoResult) State() (ret GitRepoResultState, err error) { + switch o.State__ { + case GitRepoResultState_ERR: + if o.Err__ == nil { + err = errors.New("unexpected nil value for Err__") + return ret, err + } + case GitRepoResultState_OK: + if o.Ok__ == nil { + err = errors.New("unexpected nil value for Ok__") + return ret, err + } + } + return o.State__, nil +} + +func (o GitRepoResult) Err() (res string) { + if o.State__ != GitRepoResultState_ERR { + panic("wrong case accessed") + } + if o.Err__ == nil { + return + } + return *o.Err__ +} + +func (o GitRepoResult) Ok() (res GitRepoInfo) { + if o.State__ != GitRepoResultState_OK { + panic("wrong case accessed") + } + if o.Ok__ == nil { + return + } + return *o.Ok__ +} + +func NewGitRepoResultWithErr(v string) GitRepoResult { + return GitRepoResult{ + State__: GitRepoResultState_ERR, + Err__: &v, + } +} + +func NewGitRepoResultWithOk(v GitRepoInfo) GitRepoResult { + return GitRepoResult{ + State__: GitRepoResultState_OK, + Ok__: &v, + } +} + +func (o GitRepoResult) DeepCopy() GitRepoResult { + return GitRepoResult{ + State__: o.State__.DeepCopy(), + Err__: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Err__), + Ok__: (func(x *GitRepoInfo) *GitRepoInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Ok__), + } +} + +type GitRepoInfo struct { + Folder FolderHandle `codec:"folder" json:"folder"` + RepoID RepoID `codec:"repoID" json:"repoID"` + LocalMetadata GitLocalMetadata `codec:"localMetadata" json:"localMetadata"` + ServerMetadata GitServerMetadata `codec:"serverMetadata" json:"serverMetadata"` + RepoUrl string `codec:"repoUrl" json:"repoUrl"` + GlobalUniqueID string `codec:"globalUniqueID" json:"globalUniqueID"` + CanDelete bool `codec:"canDelete" json:"canDelete"` + TeamRepoSettings *GitTeamRepoSettings `codec:"teamRepoSettings,omitempty" json:"teamRepoSettings,omitempty"` +} + +func (o GitRepoInfo) DeepCopy() GitRepoInfo { + return GitRepoInfo{ + Folder: o.Folder.DeepCopy(), + RepoID: o.RepoID.DeepCopy(), + LocalMetadata: o.LocalMetadata.DeepCopy(), + ServerMetadata: o.ServerMetadata.DeepCopy(), + RepoUrl: o.RepoUrl, + GlobalUniqueID: o.GlobalUniqueID, + CanDelete: o.CanDelete, + TeamRepoSettings: (func(x *GitTeamRepoSettings) *GitTeamRepoSettings { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.TeamRepoSettings), + } +} + +type GitTeamRepoSettings struct { + ChannelName *string `codec:"channelName,omitempty" json:"channelName,omitempty"` + ChatDisabled bool `codec:"chatDisabled" json:"chatDisabled"` +} + +func (o GitTeamRepoSettings) DeepCopy() GitTeamRepoSettings { + return GitTeamRepoSettings{ + ChannelName: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.ChannelName), + ChatDisabled: o.ChatDisabled, + } +} 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 new file mode 100644 index 00000000..d351b2b3 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/gpg_common.go @@ -0,0 +1,32 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/gpg_common.avdl + +package keybase1 + +type GPGKey struct { + Algorithm string `codec:"algorithm" json:"algorithm"` + KeyID string `codec:"keyID" json:"keyID"` + Creation string `codec:"creation" json:"creation"` + Expiration string `codec:"expiration" json:"expiration"` + Identities []PGPIdentity `codec:"identities" json:"identities"` +} + +func (o GPGKey) DeepCopy() GPGKey { + return GPGKey{ + Algorithm: o.Algorithm, + KeyID: o.KeyID, + Creation: o.Creation, + Expiration: o.Expiration, + Identities: (func(x []PGPIdentity) []PGPIdentity { + if x == nil { + return nil + } + ret := make([]PGPIdentity, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Identities), + } +} 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 new file mode 100644 index 00000000..ca7b6b54 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/gpg_ui.go @@ -0,0 +1,16 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/gpg_ui.avdl + +package keybase1 + +type SelectKeyRes struct { + KeyID string `codec:"keyID" json:"keyID"` + DoSecretPush bool `codec:"doSecretPush" json:"doSecretPush"` +} + +func (o SelectKeyRes) DeepCopy() SelectKeyRes { + return SelectKeyRes{ + KeyID: o.KeyID, + DoSecretPush: o.DoSecretPush, + } +} 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 new file mode 100644 index 00000000..c1a15270 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/gregor.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..5d9ce81e --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/gregor_ui.go @@ -0,0 +1,37 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/gregor_ui.avdl + +package keybase1 + +import ( + "fmt" +) + +type PushReason int + +const ( + PushReason_NONE PushReason = 0 + PushReason_RECONNECTED PushReason = 1 + PushReason_NEW_DATA PushReason = 2 +) + +func (o PushReason) DeepCopy() PushReason { return o } + +var PushReasonMap = map[string]PushReason{ + "NONE": 0, + "RECONNECTED": 1, + "NEW_DATA": 2, +} + +var PushReasonRevMap = map[PushReason]string{ + 0: "NONE", + 1: "RECONNECTED", + 2: "NEW_DATA", +} + +func (e PushReason) String() string { + if v, ok := PushReasonRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} 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 new file mode 100644 index 00000000..ad9ddf89 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/home.go @@ -0,0 +1,884 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/home.avdl + +package keybase1 + +import ( + "errors" + "fmt" +) + +type HomeScreenItemID string + +func (o HomeScreenItemID) DeepCopy() HomeScreenItemID { + return o +} + +type HomeScreenItemType int + +const ( + HomeScreenItemType_TODO HomeScreenItemType = 1 + HomeScreenItemType_PEOPLE HomeScreenItemType = 2 + HomeScreenItemType_ANNOUNCEMENT HomeScreenItemType = 3 +) + +func (o HomeScreenItemType) DeepCopy() HomeScreenItemType { return o } + +var HomeScreenItemTypeMap = map[string]HomeScreenItemType{ + "TODO": 1, + "PEOPLE": 2, + "ANNOUNCEMENT": 3, +} + +var HomeScreenItemTypeRevMap = map[HomeScreenItemType]string{ + 1: "TODO", + 2: "PEOPLE", + 3: "ANNOUNCEMENT", +} + +func (e HomeScreenItemType) String() string { + if v, ok := HomeScreenItemTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type HomeScreenItemData struct { + T__ HomeScreenItemType `codec:"t" json:"t"` + Todo__ *HomeScreenTodo `codec:"todo,omitempty" json:"todo,omitempty"` + People__ *HomeScreenPeopleNotification `codec:"people,omitempty" json:"people,omitempty"` + Announcement__ *HomeScreenAnnouncement `codec:"announcement,omitempty" json:"announcement,omitempty"` +} + +func (o *HomeScreenItemData) T() (ret HomeScreenItemType, err error) { + switch o.T__ { + case HomeScreenItemType_TODO: + if o.Todo__ == nil { + err = errors.New("unexpected nil value for Todo__") + return ret, err + } + case HomeScreenItemType_PEOPLE: + if o.People__ == nil { + err = errors.New("unexpected nil value for People__") + return ret, err + } + case HomeScreenItemType_ANNOUNCEMENT: + if o.Announcement__ == nil { + err = errors.New("unexpected nil value for Announcement__") + return ret, err + } + } + return o.T__, nil +} + +func (o HomeScreenItemData) Todo() (res HomeScreenTodo) { + if o.T__ != HomeScreenItemType_TODO { + panic("wrong case accessed") + } + if o.Todo__ == nil { + return + } + return *o.Todo__ +} + +func (o HomeScreenItemData) People() (res HomeScreenPeopleNotification) { + if o.T__ != HomeScreenItemType_PEOPLE { + panic("wrong case accessed") + } + if o.People__ == nil { + return + } + return *o.People__ +} + +func (o HomeScreenItemData) Announcement() (res HomeScreenAnnouncement) { + if o.T__ != HomeScreenItemType_ANNOUNCEMENT { + panic("wrong case accessed") + } + if o.Announcement__ == nil { + return + } + return *o.Announcement__ +} + +func NewHomeScreenItemDataWithTodo(v HomeScreenTodo) HomeScreenItemData { + return HomeScreenItemData{ + T__: HomeScreenItemType_TODO, + Todo__: &v, + } +} + +func NewHomeScreenItemDataWithPeople(v HomeScreenPeopleNotification) HomeScreenItemData { + return HomeScreenItemData{ + T__: HomeScreenItemType_PEOPLE, + People__: &v, + } +} + +func NewHomeScreenItemDataWithAnnouncement(v HomeScreenAnnouncement) HomeScreenItemData { + return HomeScreenItemData{ + T__: HomeScreenItemType_ANNOUNCEMENT, + Announcement__: &v, + } +} + +func NewHomeScreenItemDataDefault(t HomeScreenItemType) HomeScreenItemData { + return HomeScreenItemData{ + T__: t, + } +} + +func (o HomeScreenItemData) DeepCopy() HomeScreenItemData { + return HomeScreenItemData{ + T__: o.T__.DeepCopy(), + Todo__: (func(x *HomeScreenTodo) *HomeScreenTodo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Todo__), + People__: (func(x *HomeScreenPeopleNotification) *HomeScreenPeopleNotification { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.People__), + Announcement__: (func(x *HomeScreenAnnouncement) *HomeScreenAnnouncement { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Announcement__), + } +} + +type HomeScreenItemDataExt struct { + T__ HomeScreenItemType `codec:"t" json:"t"` + Todo__ *HomeScreenTodoExt `codec:"todo,omitempty" json:"todo,omitempty"` +} + +func (o *HomeScreenItemDataExt) T() (ret HomeScreenItemType, err error) { + switch o.T__ { + case HomeScreenItemType_TODO: + if o.Todo__ == nil { + err = errors.New("unexpected nil value for Todo__") + return ret, err + } + } + return o.T__, nil +} + +func (o HomeScreenItemDataExt) Todo() (res HomeScreenTodoExt) { + if o.T__ != HomeScreenItemType_TODO { + panic("wrong case accessed") + } + if o.Todo__ == nil { + return + } + return *o.Todo__ +} + +func NewHomeScreenItemDataExtWithTodo(v HomeScreenTodoExt) HomeScreenItemDataExt { + return HomeScreenItemDataExt{ + T__: HomeScreenItemType_TODO, + Todo__: &v, + } +} + +func NewHomeScreenItemDataExtDefault(t HomeScreenItemType) HomeScreenItemDataExt { + return HomeScreenItemDataExt{ + T__: t, + } +} + +func (o HomeScreenItemDataExt) DeepCopy() HomeScreenItemDataExt { + return HomeScreenItemDataExt{ + T__: o.T__.DeepCopy(), + Todo__: (func(x *HomeScreenTodoExt) *HomeScreenTodoExt { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Todo__), + } +} + +type AppLinkType int + +const ( + AppLinkType_NONE AppLinkType = 0 + AppLinkType_PEOPLE AppLinkType = 1 + AppLinkType_CHAT AppLinkType = 2 + AppLinkType_FILES AppLinkType = 3 + AppLinkType_WALLET AppLinkType = 4 + AppLinkType_GIT AppLinkType = 5 + AppLinkType_DEVICES AppLinkType = 6 + AppLinkType_SETTINGS AppLinkType = 7 + AppLinkType_TEAMS AppLinkType = 8 +) + +func (o AppLinkType) DeepCopy() AppLinkType { return o } + +var AppLinkTypeMap = map[string]AppLinkType{ + "NONE": 0, + "PEOPLE": 1, + "CHAT": 2, + "FILES": 3, + "WALLET": 4, + "GIT": 5, + "DEVICES": 6, + "SETTINGS": 7, + "TEAMS": 8, +} + +var AppLinkTypeRevMap = map[AppLinkType]string{ + 0: "NONE", + 1: "PEOPLE", + 2: "CHAT", + 3: "FILES", + 4: "WALLET", + 5: "GIT", + 6: "DEVICES", + 7: "SETTINGS", + 8: "TEAMS", +} + +func (e AppLinkType) String() string { + if v, ok := AppLinkTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type HomeScreenAnnouncementID int + +func (o HomeScreenAnnouncementID) DeepCopy() HomeScreenAnnouncementID { + return o +} + +type HomeScreenAnnouncementVersion int + +func (o HomeScreenAnnouncementVersion) DeepCopy() HomeScreenAnnouncementVersion { + return o +} + +type HomeScreenAnnouncement struct { + Id HomeScreenAnnouncementID `codec:"id" json:"id"` + Version HomeScreenAnnouncementVersion `codec:"version" json:"version"` + AppLink AppLinkType `codec:"appLink" json:"appLink"` + ConfirmLabel string `codec:"confirmLabel" json:"confirmLabel"` + Dismissable bool `codec:"dismissable" json:"dismissable"` + IconUrl string `codec:"iconUrl" json:"iconUrl"` + Text string `codec:"text" json:"text"` + Url string `codec:"url" json:"url"` +} + +func (o HomeScreenAnnouncement) DeepCopy() HomeScreenAnnouncement { + return HomeScreenAnnouncement{ + Id: o.Id.DeepCopy(), + Version: o.Version.DeepCopy(), + AppLink: o.AppLink.DeepCopy(), + ConfirmLabel: o.ConfirmLabel, + Dismissable: o.Dismissable, + IconUrl: o.IconUrl, + Text: o.Text, + Url: o.Url, + } +} + +type HomeScreenTodoType int + +const ( + HomeScreenTodoType_NONE HomeScreenTodoType = 0 + HomeScreenTodoType_BIO HomeScreenTodoType = 1 + 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_ANNONCEMENT_PLACEHOLDER HomeScreenTodoType = 10000 +) + +func (o HomeScreenTodoType) DeepCopy() HomeScreenTodoType { return o } + +var HomeScreenTodoTypeMap = map[string]HomeScreenTodoType{ + "NONE": 0, + "BIO": 1, + "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, + "ANNONCEMENT_PLACEHOLDER": 10000, +} + +var HomeScreenTodoTypeRevMap = map[HomeScreenTodoType]string{ + 0: "NONE", + 1: "BIO", + 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", + 10000: "ANNONCEMENT_PLACEHOLDER", +} + +func (e HomeScreenTodoType) String() string { + if v, ok := HomeScreenTodoTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +// Most of TODO items do not carry additional data, but some do. e.g. TODO +// item to tell user to verify their email address will carry that email +// address. +// +// All new TODO data bundle types should be records rather than single fields +// to support adding new data to existing TODOs. If a legacy TODO (such as +// VERIFY_ALL_EMAIL) uses a single field, the "TodoExt" field should be used to +// introduce more data to the payload. +type HomeScreenTodo struct { + T__ HomeScreenTodoType `codec:"t" json:"t"` + VerifyAllPhoneNumber__ *PhoneNumber `codec:"verifyAllPhoneNumber,omitempty" json:"verifyAllPhoneNumber,omitempty"` + VerifyAllEmail__ *EmailAddress `codec:"verifyAllEmail,omitempty" json:"verifyAllEmail,omitempty"` + LegacyEmailVisibility__ *EmailAddress `codec:"legacyEmailVisibility,omitempty" json:"legacyEmailVisibility,omitempty"` +} + +func (o *HomeScreenTodo) T() (ret HomeScreenTodoType, err error) { + switch o.T__ { + case HomeScreenTodoType_VERIFY_ALL_PHONE_NUMBER: + if o.VerifyAllPhoneNumber__ == nil { + err = errors.New("unexpected nil value for VerifyAllPhoneNumber__") + return ret, err + } + case HomeScreenTodoType_VERIFY_ALL_EMAIL: + if o.VerifyAllEmail__ == nil { + err = errors.New("unexpected nil value for VerifyAllEmail__") + return ret, err + } + case HomeScreenTodoType_LEGACY_EMAIL_VISIBILITY: + if o.LegacyEmailVisibility__ == nil { + err = errors.New("unexpected nil value for LegacyEmailVisibility__") + return ret, err + } + } + return o.T__, nil +} + +func (o HomeScreenTodo) VerifyAllPhoneNumber() (res PhoneNumber) { + if o.T__ != HomeScreenTodoType_VERIFY_ALL_PHONE_NUMBER { + panic("wrong case accessed") + } + if o.VerifyAllPhoneNumber__ == nil { + return + } + return *o.VerifyAllPhoneNumber__ +} + +func (o HomeScreenTodo) VerifyAllEmail() (res EmailAddress) { + if o.T__ != HomeScreenTodoType_VERIFY_ALL_EMAIL { + panic("wrong case accessed") + } + if o.VerifyAllEmail__ == nil { + return + } + return *o.VerifyAllEmail__ +} + +func (o HomeScreenTodo) LegacyEmailVisibility() (res EmailAddress) { + if o.T__ != HomeScreenTodoType_LEGACY_EMAIL_VISIBILITY { + panic("wrong case accessed") + } + if o.LegacyEmailVisibility__ == nil { + return + } + return *o.LegacyEmailVisibility__ +} + +func NewHomeScreenTodoWithVerifyAllPhoneNumber(v PhoneNumber) HomeScreenTodo { + return HomeScreenTodo{ + T__: HomeScreenTodoType_VERIFY_ALL_PHONE_NUMBER, + VerifyAllPhoneNumber__: &v, + } +} + +func NewHomeScreenTodoWithVerifyAllEmail(v EmailAddress) HomeScreenTodo { + return HomeScreenTodo{ + T__: HomeScreenTodoType_VERIFY_ALL_EMAIL, + VerifyAllEmail__: &v, + } +} + +func NewHomeScreenTodoWithLegacyEmailVisibility(v EmailAddress) HomeScreenTodo { + return HomeScreenTodo{ + T__: HomeScreenTodoType_LEGACY_EMAIL_VISIBILITY, + LegacyEmailVisibility__: &v, + } +} + +func NewHomeScreenTodoDefault(t HomeScreenTodoType) HomeScreenTodo { + return HomeScreenTodo{ + T__: t, + } +} + +func (o HomeScreenTodo) DeepCopy() HomeScreenTodo { + return HomeScreenTodo{ + T__: o.T__.DeepCopy(), + VerifyAllPhoneNumber__: (func(x *PhoneNumber) *PhoneNumber { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.VerifyAllPhoneNumber__), + VerifyAllEmail__: (func(x *EmailAddress) *EmailAddress { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.VerifyAllEmail__), + LegacyEmailVisibility__: (func(x *EmailAddress) *EmailAddress { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.LegacyEmailVisibility__), + } +} + +type HomeScreenTodoExt struct { + T__ HomeScreenTodoType `codec:"t" json:"t"` + VerifyAllEmail__ *VerifyAllEmailTodoExt `codec:"verifyAllEmail,omitempty" json:"verifyAllEmail,omitempty"` +} + +func (o *HomeScreenTodoExt) T() (ret HomeScreenTodoType, err error) { + switch o.T__ { + case HomeScreenTodoType_VERIFY_ALL_EMAIL: + if o.VerifyAllEmail__ == nil { + err = errors.New("unexpected nil value for VerifyAllEmail__") + return ret, err + } + } + return o.T__, nil +} + +func (o HomeScreenTodoExt) VerifyAllEmail() (res VerifyAllEmailTodoExt) { + if o.T__ != HomeScreenTodoType_VERIFY_ALL_EMAIL { + panic("wrong case accessed") + } + if o.VerifyAllEmail__ == nil { + return + } + return *o.VerifyAllEmail__ +} + +func NewHomeScreenTodoExtWithVerifyAllEmail(v VerifyAllEmailTodoExt) HomeScreenTodoExt { + return HomeScreenTodoExt{ + T__: HomeScreenTodoType_VERIFY_ALL_EMAIL, + VerifyAllEmail__: &v, + } +} + +func NewHomeScreenTodoExtDefault(t HomeScreenTodoType) HomeScreenTodoExt { + return HomeScreenTodoExt{ + T__: t, + } +} + +func (o HomeScreenTodoExt) DeepCopy() HomeScreenTodoExt { + return HomeScreenTodoExt{ + T__: o.T__.DeepCopy(), + VerifyAllEmail__: (func(x *VerifyAllEmailTodoExt) *VerifyAllEmailTodoExt { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.VerifyAllEmail__), + } +} + +type VerifyAllEmailTodoExt struct { + LastVerifyEmailDate UnixTime `codec:"lastVerifyEmailDate" json:"lastVerifyEmailDate"` +} + +func (o VerifyAllEmailTodoExt) DeepCopy() VerifyAllEmailTodoExt { + return VerifyAllEmailTodoExt{ + LastVerifyEmailDate: o.LastVerifyEmailDate.DeepCopy(), + } +} + +type HomeScreenPeopleNotificationType int + +const ( + HomeScreenPeopleNotificationType_FOLLOWED HomeScreenPeopleNotificationType = 1 + HomeScreenPeopleNotificationType_FOLLOWED_MULTI HomeScreenPeopleNotificationType = 2 + HomeScreenPeopleNotificationType_CONTACT HomeScreenPeopleNotificationType = 3 + HomeScreenPeopleNotificationType_CONTACT_MULTI HomeScreenPeopleNotificationType = 4 +) + +func (o HomeScreenPeopleNotificationType) DeepCopy() HomeScreenPeopleNotificationType { return o } + +var HomeScreenPeopleNotificationTypeMap = map[string]HomeScreenPeopleNotificationType{ + "FOLLOWED": 1, + "FOLLOWED_MULTI": 2, + "CONTACT": 3, + "CONTACT_MULTI": 4, +} + +var HomeScreenPeopleNotificationTypeRevMap = map[HomeScreenPeopleNotificationType]string{ + 1: "FOLLOWED", + 2: "FOLLOWED_MULTI", + 3: "CONTACT", + 4: "CONTACT_MULTI", +} + +func (e HomeScreenPeopleNotificationType) String() string { + if v, ok := HomeScreenPeopleNotificationTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type HomeScreenPeopleNotificationFollowed struct { + FollowTime Time `codec:"followTime" json:"followTime"` + FollowedBack bool `codec:"followedBack" json:"followedBack"` + User UserSummary `codec:"user" json:"user"` +} + +func (o HomeScreenPeopleNotificationFollowed) DeepCopy() HomeScreenPeopleNotificationFollowed { + return HomeScreenPeopleNotificationFollowed{ + FollowTime: o.FollowTime.DeepCopy(), + FollowedBack: o.FollowedBack, + User: o.User.DeepCopy(), + } +} + +type HomeScreenPeopleNotificationFollowedMulti struct { + Followers []HomeScreenPeopleNotificationFollowed `codec:"followers" json:"followers"` + NumOthers int `codec:"numOthers" json:"numOthers"` +} + +func (o HomeScreenPeopleNotificationFollowedMulti) DeepCopy() HomeScreenPeopleNotificationFollowedMulti { + return HomeScreenPeopleNotificationFollowedMulti{ + Followers: (func(x []HomeScreenPeopleNotificationFollowed) []HomeScreenPeopleNotificationFollowed { + if x == nil { + return nil + } + ret := make([]HomeScreenPeopleNotificationFollowed, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Followers), + NumOthers: o.NumOthers, + } +} + +type HomeScreenPeopleNotificationContact struct { + ResolveTime Time `codec:"resolveTime" json:"resolveTime"` + Username string `codec:"username" json:"username"` + Description string `codec:"description" json:"description"` + ResolvedContactBlob string `codec:"resolvedContactBlob" json:"resolvedContactBlob"` +} + +func (o HomeScreenPeopleNotificationContact) DeepCopy() HomeScreenPeopleNotificationContact { + return HomeScreenPeopleNotificationContact{ + ResolveTime: o.ResolveTime.DeepCopy(), + Username: o.Username, + Description: o.Description, + ResolvedContactBlob: o.ResolvedContactBlob, + } +} + +type HomeScreenPeopleNotificationContactMulti struct { + Contacts []HomeScreenPeopleNotificationContact `codec:"contacts" json:"contacts"` + NumOthers int `codec:"numOthers" json:"numOthers"` +} + +func (o HomeScreenPeopleNotificationContactMulti) DeepCopy() HomeScreenPeopleNotificationContactMulti { + return HomeScreenPeopleNotificationContactMulti{ + Contacts: (func(x []HomeScreenPeopleNotificationContact) []HomeScreenPeopleNotificationContact { + if x == nil { + return nil + } + ret := make([]HomeScreenPeopleNotificationContact, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Contacts), + NumOthers: o.NumOthers, + } +} + +type HomeScreenPeopleNotification struct { + T__ HomeScreenPeopleNotificationType `codec:"t" json:"t"` + Followed__ *HomeScreenPeopleNotificationFollowed `codec:"followed,omitempty" json:"followed,omitempty"` + FollowedMulti__ *HomeScreenPeopleNotificationFollowedMulti `codec:"followedMulti,omitempty" json:"followedMulti,omitempty"` + Contact__ *HomeScreenPeopleNotificationContact `codec:"contact,omitempty" json:"contact,omitempty"` + ContactMulti__ *HomeScreenPeopleNotificationContactMulti `codec:"contactMulti,omitempty" json:"contactMulti,omitempty"` +} + +func (o *HomeScreenPeopleNotification) T() (ret HomeScreenPeopleNotificationType, err error) { + switch o.T__ { + case HomeScreenPeopleNotificationType_FOLLOWED: + if o.Followed__ == nil { + err = errors.New("unexpected nil value for Followed__") + return ret, err + } + case HomeScreenPeopleNotificationType_FOLLOWED_MULTI: + if o.FollowedMulti__ == nil { + err = errors.New("unexpected nil value for FollowedMulti__") + return ret, err + } + case HomeScreenPeopleNotificationType_CONTACT: + if o.Contact__ == nil { + err = errors.New("unexpected nil value for Contact__") + return ret, err + } + case HomeScreenPeopleNotificationType_CONTACT_MULTI: + if o.ContactMulti__ == nil { + err = errors.New("unexpected nil value for ContactMulti__") + return ret, err + } + } + return o.T__, nil +} + +func (o HomeScreenPeopleNotification) Followed() (res HomeScreenPeopleNotificationFollowed) { + if o.T__ != HomeScreenPeopleNotificationType_FOLLOWED { + panic("wrong case accessed") + } + if o.Followed__ == nil { + return + } + return *o.Followed__ +} + +func (o HomeScreenPeopleNotification) FollowedMulti() (res HomeScreenPeopleNotificationFollowedMulti) { + if o.T__ != HomeScreenPeopleNotificationType_FOLLOWED_MULTI { + panic("wrong case accessed") + } + if o.FollowedMulti__ == nil { + return + } + return *o.FollowedMulti__ +} + +func (o HomeScreenPeopleNotification) Contact() (res HomeScreenPeopleNotificationContact) { + if o.T__ != HomeScreenPeopleNotificationType_CONTACT { + panic("wrong case accessed") + } + if o.Contact__ == nil { + return + } + return *o.Contact__ +} + +func (o HomeScreenPeopleNotification) ContactMulti() (res HomeScreenPeopleNotificationContactMulti) { + if o.T__ != HomeScreenPeopleNotificationType_CONTACT_MULTI { + panic("wrong case accessed") + } + if o.ContactMulti__ == nil { + return + } + return *o.ContactMulti__ +} + +func NewHomeScreenPeopleNotificationWithFollowed(v HomeScreenPeopleNotificationFollowed) HomeScreenPeopleNotification { + return HomeScreenPeopleNotification{ + T__: HomeScreenPeopleNotificationType_FOLLOWED, + Followed__: &v, + } +} + +func NewHomeScreenPeopleNotificationWithFollowedMulti(v HomeScreenPeopleNotificationFollowedMulti) HomeScreenPeopleNotification { + return HomeScreenPeopleNotification{ + T__: HomeScreenPeopleNotificationType_FOLLOWED_MULTI, + FollowedMulti__: &v, + } +} + +func NewHomeScreenPeopleNotificationWithContact(v HomeScreenPeopleNotificationContact) HomeScreenPeopleNotification { + return HomeScreenPeopleNotification{ + T__: HomeScreenPeopleNotificationType_CONTACT, + Contact__: &v, + } +} + +func NewHomeScreenPeopleNotificationWithContactMulti(v HomeScreenPeopleNotificationContactMulti) HomeScreenPeopleNotification { + return HomeScreenPeopleNotification{ + T__: HomeScreenPeopleNotificationType_CONTACT_MULTI, + ContactMulti__: &v, + } +} + +func (o HomeScreenPeopleNotification) DeepCopy() HomeScreenPeopleNotification { + return HomeScreenPeopleNotification{ + T__: o.T__.DeepCopy(), + Followed__: (func(x *HomeScreenPeopleNotificationFollowed) *HomeScreenPeopleNotificationFollowed { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Followed__), + FollowedMulti__: (func(x *HomeScreenPeopleNotificationFollowedMulti) *HomeScreenPeopleNotificationFollowedMulti { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.FollowedMulti__), + Contact__: (func(x *HomeScreenPeopleNotificationContact) *HomeScreenPeopleNotificationContact { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Contact__), + ContactMulti__: (func(x *HomeScreenPeopleNotificationContactMulti) *HomeScreenPeopleNotificationContactMulti { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ContactMulti__), + } +} + +type HomeScreenItem struct { + Badged bool `codec:"badged" json:"badged"` + Data HomeScreenItemData `codec:"data" json:"data"` + DataExt HomeScreenItemDataExt `codec:"dataExt" json:"dataExt"` +} + +func (o HomeScreenItem) DeepCopy() HomeScreenItem { + return HomeScreenItem{ + Badged: o.Badged, + Data: o.Data.DeepCopy(), + DataExt: o.DataExt.DeepCopy(), + } +} + +type Pics struct { + Square40 string `codec:"square40" json:"square_40"` + Square200 string `codec:"square200" json:"square_200"` + Square360 string `codec:"square360" json:"square_360"` +} + +func (o Pics) DeepCopy() Pics { + return Pics{ + Square40: o.Square40, + Square200: o.Square200, + Square360: o.Square360, + } +} + +type HomeUserSummary struct { + Uid UID `codec:"uid" json:"uid"` + Username string `codec:"username" json:"username"` + Bio string `codec:"bio" json:"bio"` + FullName string `codec:"fullName" json:"full_name"` + Pics *Pics `codec:"pics,omitempty" json:"pics,omitempty"` +} + +func (o HomeUserSummary) DeepCopy() HomeUserSummary { + return HomeUserSummary{ + Uid: o.Uid.DeepCopy(), + Username: o.Username, + Bio: o.Bio, + FullName: o.FullName, + Pics: (func(x *Pics) *Pics { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Pics), + } +} + +type HomeScreen struct { + LastViewed Time `codec:"lastViewed" json:"lastViewed"` + Version int `codec:"version" json:"version"` + Visits int `codec:"visits" json:"visits"` + Items []HomeScreenItem `codec:"items" json:"items"` + FollowSuggestions []HomeUserSummary `codec:"followSuggestions" json:"followSuggestions"` + AnnouncementsVersion int `codec:"announcementsVersion" json:"announcementsVersion"` +} + +func (o HomeScreen) DeepCopy() HomeScreen { + return HomeScreen{ + LastViewed: o.LastViewed.DeepCopy(), + Version: o.Version, + Visits: o.Visits, + Items: (func(x []HomeScreenItem) []HomeScreenItem { + if x == nil { + return nil + } + ret := make([]HomeScreenItem, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Items), + FollowSuggestions: (func(x []HomeUserSummary) []HomeUserSummary { + if x == nil { + return nil + } + ret := make([]HomeUserSummary, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.FollowSuggestions), + AnnouncementsVersion: o.AnnouncementsVersion, + } +} 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 new file mode 100644 index 00000000..a7671a41 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/home_ui.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..3a810197 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify.go @@ -0,0 +1,145 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/identify.avdl + +package keybase1 + +type IdentifyProofBreak struct { + RemoteProof RemoteProof `codec:"remoteProof" json:"remoteProof"` + Lcr LinkCheckResult `codec:"lcr" json:"lcr"` +} + +func (o IdentifyProofBreak) DeepCopy() IdentifyProofBreak { + return IdentifyProofBreak{ + RemoteProof: o.RemoteProof.DeepCopy(), + Lcr: o.Lcr.DeepCopy(), + } +} + +type IdentifyTrackBreaks struct { + Keys []IdentifyKey `codec:"keys" json:"keys"` + Proofs []IdentifyProofBreak `codec:"proofs" json:"proofs"` +} + +func (o IdentifyTrackBreaks) DeepCopy() IdentifyTrackBreaks { + return IdentifyTrackBreaks{ + Keys: (func(x []IdentifyKey) []IdentifyKey { + if x == nil { + return nil + } + ret := make([]IdentifyKey, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Keys), + Proofs: (func(x []IdentifyProofBreak) []IdentifyProofBreak { + if x == nil { + return nil + } + ret := make([]IdentifyProofBreak, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Proofs), + } +} + +type Identify2Res struct { + Upk UserPlusKeys `codec:"upk" json:"upk"` + IdentifiedAt Time `codec:"identifiedAt" json:"identifiedAt"` + TrackBreaks *IdentifyTrackBreaks `codec:"trackBreaks,omitempty" json:"trackBreaks,omitempty"` +} + +func (o Identify2Res) DeepCopy() Identify2Res { + return Identify2Res{ + Upk: o.Upk.DeepCopy(), + IdentifiedAt: o.IdentifiedAt.DeepCopy(), + TrackBreaks: (func(x *IdentifyTrackBreaks) *IdentifyTrackBreaks { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.TrackBreaks), + } +} + +type Identify2ResUPK2 struct { + Upk UserPlusKeysV2AllIncarnations `codec:"upk" json:"upk"` + IdentifiedAt Time `codec:"identifiedAt" json:"identifiedAt"` + TrackBreaks *IdentifyTrackBreaks `codec:"trackBreaks,omitempty" json:"trackBreaks,omitempty"` +} + +func (o Identify2ResUPK2) DeepCopy() Identify2ResUPK2 { + return Identify2ResUPK2{ + Upk: o.Upk.DeepCopy(), + IdentifiedAt: o.IdentifiedAt.DeepCopy(), + TrackBreaks: (func(x *IdentifyTrackBreaks) *IdentifyTrackBreaks { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.TrackBreaks), + } +} + +type IdentifyLiteRes struct { + Ul UserOrTeamLite `codec:"ul" json:"ul"` + TrackBreaks *IdentifyTrackBreaks `codec:"trackBreaks,omitempty" json:"trackBreaks,omitempty"` +} + +func (o IdentifyLiteRes) DeepCopy() IdentifyLiteRes { + return IdentifyLiteRes{ + Ul: o.Ul.DeepCopy(), + TrackBreaks: (func(x *IdentifyTrackBreaks) *IdentifyTrackBreaks { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.TrackBreaks), + } +} + +type ResolveIdentifyImplicitTeamRes struct { + DisplayName string `codec:"displayName" json:"displayName"` + TeamID TeamID `codec:"teamID" json:"teamID"` + Writers []UserVersion `codec:"writers" json:"writers"` + TrackBreaks map[UserVersion]IdentifyTrackBreaks `codec:"trackBreaks" json:"trackBreaks"` + FolderID TLFID `codec:"folderID" json:"folderID"` +} + +func (o ResolveIdentifyImplicitTeamRes) DeepCopy() ResolveIdentifyImplicitTeamRes { + return ResolveIdentifyImplicitTeamRes{ + DisplayName: o.DisplayName, + TeamID: o.TeamID.DeepCopy(), + Writers: (func(x []UserVersion) []UserVersion { + if x == nil { + return nil + } + ret := make([]UserVersion, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Writers), + TrackBreaks: (func(x map[UserVersion]IdentifyTrackBreaks) map[UserVersion]IdentifyTrackBreaks { + if x == nil { + return nil + } + ret := make(map[UserVersion]IdentifyTrackBreaks, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.TrackBreaks), + FolderID: o.FolderID.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..af462f3c --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify3.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..78b5377f --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify3_common.go @@ -0,0 +1,16 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/identify3_common.avdl + +package keybase1 + +type Identify3Assertion string + +func (o Identify3Assertion) DeepCopy() Identify3Assertion { + return o +} + +type Identify3GUIID string + +func (o Identify3GUIID) DeepCopy() Identify3GUIID { + return o +} 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 new file mode 100644 index 00000000..1b3f34a2 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify3_ui.go @@ -0,0 +1,212 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/identify3_ui.avdl + +package keybase1 + +import ( + "fmt" +) + +type Identify3RowState int + +const ( + Identify3RowState_CHECKING Identify3RowState = 1 + Identify3RowState_VALID Identify3RowState = 2 + Identify3RowState_ERROR Identify3RowState = 3 + Identify3RowState_WARNING Identify3RowState = 4 + Identify3RowState_REVOKED Identify3RowState = 5 +) + +func (o Identify3RowState) DeepCopy() Identify3RowState { return o } + +var Identify3RowStateMap = map[string]Identify3RowState{ + "CHECKING": 1, + "VALID": 2, + "ERROR": 3, + "WARNING": 4, + "REVOKED": 5, +} + +var Identify3RowStateRevMap = map[Identify3RowState]string{ + 1: "CHECKING", + 2: "VALID", + 3: "ERROR", + 4: "WARNING", + 5: "REVOKED", +} + +func (e Identify3RowState) String() string { + if v, ok := Identify3RowStateRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type Identify3RowColor int + +const ( + Identify3RowColor_BLUE Identify3RowColor = 1 + Identify3RowColor_RED Identify3RowColor = 2 + Identify3RowColor_BLACK Identify3RowColor = 3 + Identify3RowColor_GREEN Identify3RowColor = 4 + Identify3RowColor_GRAY Identify3RowColor = 5 + Identify3RowColor_YELLOW Identify3RowColor = 6 + Identify3RowColor_ORANGE Identify3RowColor = 7 +) + +func (o Identify3RowColor) DeepCopy() Identify3RowColor { return o } + +var Identify3RowColorMap = map[string]Identify3RowColor{ + "BLUE": 1, + "RED": 2, + "BLACK": 3, + "GREEN": 4, + "GRAY": 5, + "YELLOW": 6, + "ORANGE": 7, +} + +var Identify3RowColorRevMap = map[Identify3RowColor]string{ + 1: "BLUE", + 2: "RED", + 3: "BLACK", + 4: "GREEN", + 5: "GRAY", + 6: "YELLOW", + 7: "ORANGE", +} + +func (e Identify3RowColor) String() string { + if v, ok := Identify3RowColorRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type Identify3ResultType int + +const ( + Identify3ResultType_OK Identify3ResultType = 0 + Identify3ResultType_BROKEN Identify3ResultType = 1 + Identify3ResultType_NEEDS_UPGRADE Identify3ResultType = 2 + Identify3ResultType_CANCELED Identify3ResultType = 3 +) + +func (o Identify3ResultType) DeepCopy() Identify3ResultType { return o } + +var Identify3ResultTypeMap = map[string]Identify3ResultType{ + "OK": 0, + "BROKEN": 1, + "NEEDS_UPGRADE": 2, + "CANCELED": 3, +} + +var Identify3ResultTypeRevMap = map[Identify3ResultType]string{ + 0: "OK", + 1: "BROKEN", + 2: "NEEDS_UPGRADE", + 3: "CANCELED", +} + +func (e Identify3ResultType) String() string { + if v, ok := Identify3ResultTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type Identify3RowMeta struct { + Color Identify3RowColor `codec:"color" json:"color"` + Label string `codec:"label" json:"label"` +} + +func (o Identify3RowMeta) DeepCopy() Identify3RowMeta { + return Identify3RowMeta{ + Color: o.Color.DeepCopy(), + Label: o.Label, + } +} + +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"` +} + +func (o Identify3Row) DeepCopy() Identify3Row { + return Identify3Row{ + GuiID: o.GuiID.DeepCopy(), + Key: o.Key, + Value: o.Value, + Priority: o.Priority, + SiteURL: o.SiteURL, + SiteIcon: (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.SiteIcon), + SiteIconFull: (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.SiteIconFull), + SiteIconWhite: (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.SiteIconWhite), + ProofURL: o.ProofURL, + SigID: o.SigID.DeepCopy(), + Ctime: o.Ctime.DeepCopy(), + State: o.State.DeepCopy(), + Metas: (func(x []Identify3RowMeta) []Identify3RowMeta { + if x == nil { + return nil + } + ret := make([]Identify3RowMeta, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Metas), + Color: o.Color.DeepCopy(), + Kid: (func(x *KID) *KID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Kid), + } +} 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 new file mode 100644 index 00000000..bd1ff200 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify_common.go @@ -0,0 +1,322 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/identify_common.avdl + +package keybase1 + +import ( + "fmt" +) + +type TrackToken string + +func (o TrackToken) DeepCopy() TrackToken { + return o +} + +type SigVersion int + +func (o SigVersion) DeepCopy() SigVersion { + return o +} + +type TrackDiffType int + +const ( + TrackDiffType_NONE TrackDiffType = 0 + TrackDiffType_ERROR TrackDiffType = 1 + TrackDiffType_CLASH TrackDiffType = 2 + TrackDiffType_REVOKED TrackDiffType = 3 + TrackDiffType_UPGRADED TrackDiffType = 4 + TrackDiffType_NEW TrackDiffType = 5 + TrackDiffType_REMOTE_FAIL TrackDiffType = 6 + TrackDiffType_REMOTE_WORKING TrackDiffType = 7 + TrackDiffType_REMOTE_CHANGED TrackDiffType = 8 + TrackDiffType_NEW_ELDEST TrackDiffType = 9 + TrackDiffType_NONE_VIA_TEMPORARY TrackDiffType = 10 +) + +func (o TrackDiffType) DeepCopy() TrackDiffType { return o } + +var TrackDiffTypeMap = map[string]TrackDiffType{ + "NONE": 0, + "ERROR": 1, + "CLASH": 2, + "REVOKED": 3, + "UPGRADED": 4, + "NEW": 5, + "REMOTE_FAIL": 6, + "REMOTE_WORKING": 7, + "REMOTE_CHANGED": 8, + "NEW_ELDEST": 9, + "NONE_VIA_TEMPORARY": 10, +} + +var TrackDiffTypeRevMap = map[TrackDiffType]string{ + 0: "NONE", + 1: "ERROR", + 2: "CLASH", + 3: "REVOKED", + 4: "UPGRADED", + 5: "NEW", + 6: "REMOTE_FAIL", + 7: "REMOTE_WORKING", + 8: "REMOTE_CHANGED", + 9: "NEW_ELDEST", + 10: "NONE_VIA_TEMPORARY", +} + +func (e TrackDiffType) String() string { + if v, ok := TrackDiffTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type TrackDiff struct { + Type TrackDiffType `codec:"type" json:"type"` + DisplayMarkup string `codec:"displayMarkup" json:"displayMarkup"` +} + +func (o TrackDiff) DeepCopy() TrackDiff { + return TrackDiff{ + Type: o.Type.DeepCopy(), + DisplayMarkup: o.DisplayMarkup, + } +} + +type TrackSummary struct { + Username string `codec:"username" json:"username"` + Time Time `codec:"time" json:"time"` + IsRemote bool `codec:"isRemote" json:"isRemote"` +} + +func (o TrackSummary) DeepCopy() TrackSummary { + return TrackSummary{ + Username: o.Username, + Time: o.Time.DeepCopy(), + IsRemote: o.IsRemote, + } +} + +// TrackStatus is a summary of this track before the track is approved by the +// user. +// NEW_*: New tracks +// UPDATE_*: Update to an existing track +// NEW_OK: Everything ok +// NEW_ZERO_PROOFS: User being tracked has no proofs +// NEW_FAIL_PROOFS: User being tracked has some failed proofs +// UPDATE_BROKEN: Previous tracking statement broken, this one will fix it. +// UPDATE_NEW_PROOFS: Previous tracking statement ok, but there are new proofs since previous tracking statement generated +// UPDATE_OK: No changes to previous tracking statement +type TrackStatus int + +const ( + TrackStatus_NEW_OK TrackStatus = 1 + TrackStatus_NEW_ZERO_PROOFS TrackStatus = 2 + TrackStatus_NEW_FAIL_PROOFS TrackStatus = 3 + TrackStatus_UPDATE_BROKEN_FAILED_PROOFS TrackStatus = 4 + TrackStatus_UPDATE_NEW_PROOFS TrackStatus = 5 + TrackStatus_UPDATE_OK TrackStatus = 6 + TrackStatus_UPDATE_BROKEN_REVOKED TrackStatus = 7 +) + +func (o TrackStatus) DeepCopy() TrackStatus { return o } + +var TrackStatusMap = map[string]TrackStatus{ + "NEW_OK": 1, + "NEW_ZERO_PROOFS": 2, + "NEW_FAIL_PROOFS": 3, + "UPDATE_BROKEN_FAILED_PROOFS": 4, + "UPDATE_NEW_PROOFS": 5, + "UPDATE_OK": 6, + "UPDATE_BROKEN_REVOKED": 7, +} + +var TrackStatusRevMap = map[TrackStatus]string{ + 1: "NEW_OK", + 2: "NEW_ZERO_PROOFS", + 3: "NEW_FAIL_PROOFS", + 4: "UPDATE_BROKEN_FAILED_PROOFS", + 5: "UPDATE_NEW_PROOFS", + 6: "UPDATE_OK", + 7: "UPDATE_BROKEN_REVOKED", +} + +func (e TrackStatus) String() string { + if v, ok := TrackStatusRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type TrackOptions struct { + LocalOnly bool `codec:"localOnly" json:"localOnly"` + BypassConfirm bool `codec:"bypassConfirm" json:"bypassConfirm"` + ForceRetrack bool `codec:"forceRetrack" json:"forceRetrack"` + ExpiringLocal bool `codec:"expiringLocal" json:"expiringLocal"` + ForPGPPull bool `codec:"forPGPPull" json:"forPGPPull"` + SigVersion *SigVersion `codec:"sigVersion,omitempty" json:"sigVersion,omitempty"` +} + +func (o TrackOptions) DeepCopy() TrackOptions { + return TrackOptions{ + LocalOnly: o.LocalOnly, + BypassConfirm: o.BypassConfirm, + ForceRetrack: o.ForceRetrack, + ExpiringLocal: o.ExpiringLocal, + ForPGPPull: o.ForPGPPull, + SigVersion: (func(x *SigVersion) *SigVersion { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.SigVersion), + } +} + +type IdentifyReasonType int + +const ( + IdentifyReasonType_NONE IdentifyReasonType = 0 + IdentifyReasonType_ID IdentifyReasonType = 1 + IdentifyReasonType_TRACK IdentifyReasonType = 2 + IdentifyReasonType_ENCRYPT IdentifyReasonType = 3 + IdentifyReasonType_DECRYPT IdentifyReasonType = 4 + IdentifyReasonType_VERIFY IdentifyReasonType = 5 + IdentifyReasonType_RESOURCE IdentifyReasonType = 6 + IdentifyReasonType_BACKGROUND IdentifyReasonType = 7 +) + +func (o IdentifyReasonType) DeepCopy() IdentifyReasonType { return o } + +var IdentifyReasonTypeMap = map[string]IdentifyReasonType{ + "NONE": 0, + "ID": 1, + "TRACK": 2, + "ENCRYPT": 3, + "DECRYPT": 4, + "VERIFY": 5, + "RESOURCE": 6, + "BACKGROUND": 7, +} + +var IdentifyReasonTypeRevMap = map[IdentifyReasonType]string{ + 0: "NONE", + 1: "ID", + 2: "TRACK", + 3: "ENCRYPT", + 4: "DECRYPT", + 5: "VERIFY", + 6: "RESOURCE", + 7: "BACKGROUND", +} + +func (e IdentifyReasonType) String() string { + if v, ok := IdentifyReasonTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type IdentifyReason struct { + Type IdentifyReasonType `codec:"type" json:"type"` + Reason string `codec:"reason" json:"reason"` + Resource string `codec:"resource" json:"resource"` +} + +func (o IdentifyReason) DeepCopy() IdentifyReason { + return IdentifyReason{ + Type: o.Type.DeepCopy(), + Reason: o.Reason, + Resource: o.Resource, + } +} + +type IdentifyOutcome struct { + Username string `codec:"username" json:"username"` + Status *Status `codec:"status,omitempty" json:"status,omitempty"` + Warnings []string `codec:"warnings" json:"warnings"` + TrackUsed *TrackSummary `codec:"trackUsed,omitempty" json:"trackUsed,omitempty"` + TrackStatus TrackStatus `codec:"trackStatus" json:"trackStatus"` + NumTrackFailures int `codec:"numTrackFailures" json:"numTrackFailures"` + NumTrackChanges int `codec:"numTrackChanges" json:"numTrackChanges"` + NumProofFailures int `codec:"numProofFailures" json:"numProofFailures"` + NumRevoked int `codec:"numRevoked" json:"numRevoked"` + NumProofSuccesses int `codec:"numProofSuccesses" json:"numProofSuccesses"` + Revoked []TrackDiff `codec:"revoked" json:"revoked"` + TrackOptions TrackOptions `codec:"trackOptions" json:"trackOptions"` + ForPGPPull bool `codec:"forPGPPull" json:"forPGPPull"` + Reason IdentifyReason `codec:"reason" json:"reason"` +} + +func (o IdentifyOutcome) DeepCopy() IdentifyOutcome { + return IdentifyOutcome{ + Username: o.Username, + Status: (func(x *Status) *Status { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Status), + 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), + TrackUsed: (func(x *TrackSummary) *TrackSummary { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.TrackUsed), + TrackStatus: o.TrackStatus.DeepCopy(), + NumTrackFailures: o.NumTrackFailures, + NumTrackChanges: o.NumTrackChanges, + NumProofFailures: o.NumProofFailures, + NumRevoked: o.NumRevoked, + NumProofSuccesses: o.NumProofSuccesses, + Revoked: (func(x []TrackDiff) []TrackDiff { + if x == nil { + return nil + } + ret := make([]TrackDiff, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Revoked), + TrackOptions: o.TrackOptions.DeepCopy(), + ForPGPPull: o.ForPGPPull, + Reason: o.Reason.DeepCopy(), + } +} + +type RemoteProof struct { + ProofType ProofType `codec:"proofType" json:"proofType"` + Key string `codec:"key" json:"key"` + Value string `codec:"value" json:"value"` + DisplayMarkup string `codec:"displayMarkup" json:"displayMarkup"` + SigID SigID `codec:"sigID" json:"sigID"` + MTime Time `codec:"mTime" json:"mTime"` +} + +func (o RemoteProof) DeepCopy() RemoteProof { + return RemoteProof{ + ProofType: o.ProofType.DeepCopy(), + Key: o.Key, + Value: o.Value, + DisplayMarkup: o.DisplayMarkup, + SigID: o.SigID.DeepCopy(), + MTime: o.MTime.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..e8118f9f --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify_ui.go @@ -0,0 +1,443 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/identify_ui.avdl + +package keybase1 + +import ( + "fmt" +) + +type ProofResult struct { + State ProofState `codec:"state" json:"state"` + Status ProofStatus `codec:"status" json:"status"` + Desc string `codec:"desc" json:"desc"` +} + +func (o ProofResult) DeepCopy() ProofResult { + return ProofResult{ + State: o.State.DeepCopy(), + Status: o.Status.DeepCopy(), + Desc: o.Desc, + } +} + +type IdentifyRow struct { + RowId int `codec:"rowId" json:"rowId"` + Proof RemoteProof `codec:"proof" json:"proof"` + TrackDiff *TrackDiff `codec:"trackDiff,omitempty" json:"trackDiff,omitempty"` +} + +func (o IdentifyRow) DeepCopy() IdentifyRow { + return IdentifyRow{ + RowId: o.RowId, + Proof: o.Proof.DeepCopy(), + TrackDiff: (func(x *TrackDiff) *TrackDiff { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.TrackDiff), + } +} + +type IdentifyKey struct { + PGPFingerprint []byte `codec:"pgpFingerprint" json:"pgpFingerprint"` + KID KID `codec:"KID" json:"KID"` + TrackDiff *TrackDiff `codec:"trackDiff,omitempty" json:"trackDiff,omitempty"` + BreaksTracking bool `codec:"breaksTracking" json:"breaksTracking"` + SigID SigID `codec:"sigID" json:"sigID"` +} + +func (o IdentifyKey) DeepCopy() IdentifyKey { + return IdentifyKey{ + PGPFingerprint: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.PGPFingerprint), + KID: o.KID.DeepCopy(), + TrackDiff: (func(x *TrackDiff) *TrackDiff { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.TrackDiff), + BreaksTracking: o.BreaksTracking, + SigID: o.SigID.DeepCopy(), + } +} + +type Cryptocurrency struct { + RowId int `codec:"rowId" json:"rowId"` + Pkhash []byte `codec:"pkhash" json:"pkhash"` + Address string `codec:"address" json:"address"` + SigID SigID `codec:"sigID" json:"sigID"` + Type string `codec:"type" json:"type"` + Family string `codec:"family" json:"family"` +} + +func (o Cryptocurrency) DeepCopy() Cryptocurrency { + return Cryptocurrency{ + RowId: o.RowId, + Pkhash: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.Pkhash), + Address: o.Address, + SigID: o.SigID.DeepCopy(), + Type: o.Type, + Family: o.Family, + } +} + +type StellarAccount struct { + AccountID string `codec:"accountID" json:"accountID"` + FederationAddress string `codec:"federationAddress" json:"federationAddress"` + SigID SigID `codec:"sigID" json:"sigID"` + Hidden bool `codec:"hidden" json:"hidden"` +} + +func (o StellarAccount) DeepCopy() StellarAccount { + return StellarAccount{ + AccountID: o.AccountID, + FederationAddress: o.FederationAddress, + SigID: o.SigID.DeepCopy(), + Hidden: o.Hidden, + } +} + +type RevokedProof struct { + Proof RemoteProof `codec:"proof" json:"proof"` + Diff TrackDiff `codec:"diff" json:"diff"` + Snoozed bool `codec:"snoozed" json:"snoozed"` +} + +func (o RevokedProof) DeepCopy() RevokedProof { + return RevokedProof{ + Proof: o.Proof.DeepCopy(), + Diff: o.Diff.DeepCopy(), + Snoozed: o.Snoozed, + } +} + +type Identity struct { + Status *Status `codec:"status,omitempty" json:"status,omitempty"` + WhenLastTracked Time `codec:"whenLastTracked" json:"whenLastTracked"` + Proofs []IdentifyRow `codec:"proofs" json:"proofs"` + Cryptocurrency []Cryptocurrency `codec:"cryptocurrency" json:"cryptocurrency"` + Revoked []TrackDiff `codec:"revoked" json:"revoked"` + RevokedDetails []RevokedProof `codec:"revokedDetails" json:"revokedDetails"` + BreaksTracking bool `codec:"breaksTracking" json:"breaksTracking"` +} + +func (o Identity) DeepCopy() Identity { + return Identity{ + Status: (func(x *Status) *Status { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Status), + WhenLastTracked: o.WhenLastTracked.DeepCopy(), + Proofs: (func(x []IdentifyRow) []IdentifyRow { + if x == nil { + return nil + } + ret := make([]IdentifyRow, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Proofs), + Cryptocurrency: (func(x []Cryptocurrency) []Cryptocurrency { + if x == nil { + return nil + } + ret := make([]Cryptocurrency, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Cryptocurrency), + Revoked: (func(x []TrackDiff) []TrackDiff { + if x == nil { + return nil + } + ret := make([]TrackDiff, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Revoked), + RevokedDetails: (func(x []RevokedProof) []RevokedProof { + if x == nil { + return nil + } + ret := make([]RevokedProof, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.RevokedDetails), + BreaksTracking: o.BreaksTracking, + } +} + +type SigHint struct { + RemoteId string `codec:"remoteId" json:"remoteId"` + HumanUrl string `codec:"humanUrl" json:"humanUrl"` + ApiUrl string `codec:"apiUrl" json:"apiUrl"` + CheckText string `codec:"checkText" json:"checkText"` +} + +func (o SigHint) DeepCopy() SigHint { + return SigHint{ + RemoteId: o.RemoteId, + HumanUrl: o.HumanUrl, + ApiUrl: o.ApiUrl, + CheckText: o.CheckText, + } +} + +type CheckResultFreshness int + +const ( + CheckResultFreshness_FRESH CheckResultFreshness = 0 + CheckResultFreshness_AGED CheckResultFreshness = 1 + CheckResultFreshness_RANCID CheckResultFreshness = 2 +) + +func (o CheckResultFreshness) DeepCopy() CheckResultFreshness { return o } + +var CheckResultFreshnessMap = map[string]CheckResultFreshness{ + "FRESH": 0, + "AGED": 1, + "RANCID": 2, +} + +var CheckResultFreshnessRevMap = map[CheckResultFreshness]string{ + 0: "FRESH", + 1: "AGED", + 2: "RANCID", +} + +func (e CheckResultFreshness) String() string { + if v, ok := CheckResultFreshnessRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type CheckResult struct { + ProofResult ProofResult `codec:"proofResult" json:"proofResult"` + Time Time `codec:"time" json:"time"` + Freshness CheckResultFreshness `codec:"freshness" json:"freshness"` +} + +func (o CheckResult) DeepCopy() CheckResult { + return CheckResult{ + ProofResult: o.ProofResult.DeepCopy(), + Time: o.Time.DeepCopy(), + Freshness: o.Freshness.DeepCopy(), + } +} + +type LinkCheckResult struct { + ProofId int `codec:"proofId" json:"proofId"` + ProofResult ProofResult `codec:"proofResult" json:"proofResult"` + SnoozedResult ProofResult `codec:"snoozedResult" json:"snoozedResult"` + TorWarning bool `codec:"torWarning" json:"torWarning"` + TmpTrackExpireTime Time `codec:"tmpTrackExpireTime" json:"tmpTrackExpireTime"` + Cached *CheckResult `codec:"cached,omitempty" json:"cached,omitempty"` + Diff *TrackDiff `codec:"diff,omitempty" json:"diff,omitempty"` + RemoteDiff *TrackDiff `codec:"remoteDiff,omitempty" json:"remoteDiff,omitempty"` + Hint *SigHint `codec:"hint,omitempty" json:"hint,omitempty"` + BreaksTracking bool `codec:"breaksTracking" json:"breaksTracking"` +} + +func (o LinkCheckResult) DeepCopy() LinkCheckResult { + return LinkCheckResult{ + ProofId: o.ProofId, + ProofResult: o.ProofResult.DeepCopy(), + SnoozedResult: o.SnoozedResult.DeepCopy(), + TorWarning: o.TorWarning, + TmpTrackExpireTime: o.TmpTrackExpireTime.DeepCopy(), + Cached: (func(x *CheckResult) *CheckResult { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Cached), + Diff: (func(x *TrackDiff) *TrackDiff { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Diff), + RemoteDiff: (func(x *TrackDiff) *TrackDiff { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.RemoteDiff), + Hint: (func(x *SigHint) *SigHint { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Hint), + BreaksTracking: o.BreaksTracking, + } +} + +type UserTeamShowcase struct { + FqName string `codec:"fqName" json:"fq_name"` + Open bool `codec:"open" json:"open"` + TeamIsShowcased bool `codec:"teamIsShowcased" json:"team_is_showcased"` + Description string `codec:"description" json:"description"` + Role TeamRole `codec:"role" json:"role"` + PublicAdmins []string `codec:"publicAdmins" json:"public_admins"` + NumMembers int `codec:"numMembers" json:"num_members"` +} + +func (o UserTeamShowcase) DeepCopy() UserTeamShowcase { + return UserTeamShowcase{ + FqName: o.FqName, + Open: o.Open, + TeamIsShowcased: o.TeamIsShowcased, + Description: o.Description, + Role: o.Role.DeepCopy(), + 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, + } +} + +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"` +} + +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, + TeamShowcase: (func(x []UserTeamShowcase) []UserTeamShowcase { + if x == nil { + return nil + } + ret := make([]UserTeamShowcase, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.TeamShowcase), + RegisteredForAirdrop: o.RegisteredForAirdrop, + StellarHidden: o.StellarHidden, + Blocked: o.Blocked, + HidFromFollowers: o.HidFromFollowers, + } +} + +type ConfirmResult struct { + IdentityConfirmed bool `codec:"identityConfirmed" json:"identityConfirmed"` + RemoteConfirmed bool `codec:"remoteConfirmed" json:"remoteConfirmed"` + ExpiringLocal bool `codec:"expiringLocal" json:"expiringLocal"` + AutoConfirmed bool `codec:"autoConfirmed" json:"autoConfirmed"` +} + +func (o ConfirmResult) DeepCopy() ConfirmResult { + return ConfirmResult{ + IdentityConfirmed: o.IdentityConfirmed, + RemoteConfirmed: o.RemoteConfirmed, + ExpiringLocal: o.ExpiringLocal, + AutoConfirmed: o.AutoConfirmed, + } +} + +type DismissReasonType int + +const ( + DismissReasonType_NONE DismissReasonType = 0 + DismissReasonType_HANDLED_ELSEWHERE DismissReasonType = 1 +) + +func (o DismissReasonType) DeepCopy() DismissReasonType { return o } + +var DismissReasonTypeMap = map[string]DismissReasonType{ + "NONE": 0, + "HANDLED_ELSEWHERE": 1, +} + +var DismissReasonTypeRevMap = map[DismissReasonType]string{ + 0: "NONE", + 1: "HANDLED_ELSEWHERE", +} + +func (e DismissReasonType) String() string { + if v, ok := DismissReasonTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type DismissReason struct { + Type DismissReasonType `codec:"type" json:"type"` + Reason string `codec:"reason" json:"reason"` + Resource string `codec:"resource" json:"resource"` +} + +func (o DismissReason) DeepCopy() DismissReason { + return DismissReason{ + Type: o.Type.DeepCopy(), + Reason: o.Reason, + Resource: o.Resource, + } +} 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 new file mode 100644 index 00000000..703ac01d --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/implicit_team_migration.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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/install.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/install.go new file mode 100644 index 00000000..2b31fd3e --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/install.go @@ -0,0 +1,236 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/install.avdl + +package keybase1 + +// Install status describes state of install for a component or service. +type InstallStatus int + +const ( + InstallStatus_UNKNOWN InstallStatus = 0 + InstallStatus_ERROR InstallStatus = 1 + InstallStatus_NOT_INSTALLED InstallStatus = 2 + InstallStatus_INSTALLED InstallStatus = 4 +) + +func (o InstallStatus) DeepCopy() InstallStatus { return o } + +var InstallStatusMap = map[string]InstallStatus{ + "UNKNOWN": 0, + "ERROR": 1, + "NOT_INSTALLED": 2, + "INSTALLED": 4, +} + +var InstallStatusRevMap = map[InstallStatus]string{ + 0: "UNKNOWN", + 1: "ERROR", + 2: "NOT_INSTALLED", + 4: "INSTALLED", +} + +type InstallAction int + +const ( + InstallAction_UNKNOWN InstallAction = 0 + InstallAction_NONE InstallAction = 1 + InstallAction_UPGRADE InstallAction = 2 + InstallAction_REINSTALL InstallAction = 3 + InstallAction_INSTALL InstallAction = 4 +) + +func (o InstallAction) DeepCopy() InstallAction { return o } + +var InstallActionMap = map[string]InstallAction{ + "UNKNOWN": 0, + "NONE": 1, + "UPGRADE": 2, + "REINSTALL": 3, + "INSTALL": 4, +} + +var InstallActionRevMap = map[InstallAction]string{ + 0: "UNKNOWN", + 1: "NONE", + 2: "UPGRADE", + 3: "REINSTALL", + 4: "INSTALL", +} + +type ServiceStatus struct { + Version string `codec:"version" json:"version"` + Label string `codec:"label" json:"label"` + Pid string `codec:"pid" json:"pid"` + LastExitStatus string `codec:"lastExitStatus" json:"lastExitStatus"` + BundleVersion string `codec:"bundleVersion" json:"bundleVersion"` + InstallStatus InstallStatus `codec:"installStatus" json:"installStatus"` + InstallAction InstallAction `codec:"installAction" json:"installAction"` + Status Status `codec:"status" json:"status"` +} + +func (o ServiceStatus) DeepCopy() ServiceStatus { + return ServiceStatus{ + Version: o.Version, + Label: o.Label, + Pid: o.Pid, + LastExitStatus: o.LastExitStatus, + BundleVersion: o.BundleVersion, + InstallStatus: o.InstallStatus.DeepCopy(), + InstallAction: o.InstallAction.DeepCopy(), + Status: o.Status.DeepCopy(), + } +} + +type ServicesStatus struct { + Service []ServiceStatus `codec:"service" json:"service"` + Kbfs []ServiceStatus `codec:"kbfs" json:"kbfs"` + Updater []ServiceStatus `codec:"updater" json:"updater"` +} + +func (o ServicesStatus) DeepCopy() ServicesStatus { + return ServicesStatus{ + Service: (func(x []ServiceStatus) []ServiceStatus { + if x == nil { + return nil + } + ret := make([]ServiceStatus, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Service), + Kbfs: (func(x []ServiceStatus) []ServiceStatus { + if x == nil { + return nil + } + ret := make([]ServiceStatus, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Kbfs), + Updater: (func(x []ServiceStatus) []ServiceStatus { + if x == nil { + return nil + } + ret := make([]ServiceStatus, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Updater), + } +} + +type FuseMountInfo struct { + Path string `codec:"path" json:"path"` + Fstype string `codec:"fstype" json:"fstype"` + Output string `codec:"output" json:"output"` +} + +func (o FuseMountInfo) DeepCopy() FuseMountInfo { + return FuseMountInfo{ + Path: o.Path, + Fstype: o.Fstype, + Output: o.Output, + } +} + +type FuseStatus struct { + Version string `codec:"version" json:"version"` + BundleVersion string `codec:"bundleVersion" json:"bundleVersion"` + KextID string `codec:"kextID" json:"kextID"` + Path string `codec:"path" json:"path"` + KextStarted bool `codec:"kextStarted" json:"kextStarted"` + InstallStatus InstallStatus `codec:"installStatus" json:"installStatus"` + InstallAction InstallAction `codec:"installAction" json:"installAction"` + MountInfos []FuseMountInfo `codec:"mountInfos" json:"mountInfos"` + Status Status `codec:"status" json:"status"` +} + +func (o FuseStatus) DeepCopy() FuseStatus { + return FuseStatus{ + Version: o.Version, + BundleVersion: o.BundleVersion, + KextID: o.KextID, + Path: o.Path, + KextStarted: o.KextStarted, + InstallStatus: o.InstallStatus.DeepCopy(), + InstallAction: o.InstallAction.DeepCopy(), + MountInfos: (func(x []FuseMountInfo) []FuseMountInfo { + if x == nil { + return nil + } + ret := make([]FuseMountInfo, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.MountInfos), + Status: o.Status.DeepCopy(), + } +} + +type ComponentResult struct { + Name string `codec:"name" json:"name"` + Status Status `codec:"status" json:"status"` + ExitCode int `codec:"exitCode" json:"exitCode"` +} + +func (o ComponentResult) DeepCopy() ComponentResult { + return ComponentResult{ + Name: o.Name, + Status: o.Status.DeepCopy(), + ExitCode: o.ExitCode, + } +} + +type InstallResult struct { + ComponentResults []ComponentResult `codec:"componentResults" json:"componentResults"` + Status Status `codec:"status" json:"status"` + Fatal bool `codec:"fatal" json:"fatal"` +} + +func (o InstallResult) DeepCopy() InstallResult { + return InstallResult{ + ComponentResults: (func(x []ComponentResult) []ComponentResult { + if x == nil { + return nil + } + ret := make([]ComponentResult, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.ComponentResults), + Status: o.Status.DeepCopy(), + Fatal: o.Fatal, + } +} + +type UninstallResult struct { + ComponentResults []ComponentResult `codec:"componentResults" json:"componentResults"` + Status Status `codec:"status" json:"status"` +} + +func (o UninstallResult) DeepCopy() UninstallResult { + return UninstallResult{ + ComponentResults: (func(x []ComponentResult) []ComponentResult { + if x == nil { + return nil + } + ret := make([]ComponentResult, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.ComponentResults), + Status: o.Status.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..b32228aa --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kbfs.go @@ -0,0 +1,14 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/kbfs.avdl + +package keybase1 + +type KBFSTeamSettings struct { + TlfID TLFID `codec:"tlfID" json:"tlfID"` +} + +func (o KBFSTeamSettings) DeepCopy() KBFSTeamSettings { + return KBFSTeamSettings{ + TlfID: o.TlfID.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..682044fa --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kbfs_common.go @@ -0,0 +1,366 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/kbfs_common.avdl + +package keybase1 + +import ( + "fmt" +) + +type FSStatusCode int + +const ( + FSStatusCode_START FSStatusCode = 0 + FSStatusCode_FINISH FSStatusCode = 1 + FSStatusCode_ERROR FSStatusCode = 2 +) + +func (o FSStatusCode) DeepCopy() FSStatusCode { return o } + +var FSStatusCodeMap = map[string]FSStatusCode{ + "START": 0, + "FINISH": 1, + "ERROR": 2, +} + +var FSStatusCodeRevMap = map[FSStatusCode]string{ + 0: "START", + 1: "FINISH", + 2: "ERROR", +} + +func (e FSStatusCode) String() string { + if v, ok := FSStatusCodeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type FSNotificationType int + +const ( + FSNotificationType_ENCRYPTING FSNotificationType = 0 + FSNotificationType_DECRYPTING FSNotificationType = 1 + FSNotificationType_SIGNING FSNotificationType = 2 + FSNotificationType_VERIFYING FSNotificationType = 3 + FSNotificationType_REKEYING FSNotificationType = 4 + FSNotificationType_CONNECTION FSNotificationType = 5 + FSNotificationType_MD_READ_SUCCESS FSNotificationType = 6 + FSNotificationType_FILE_CREATED FSNotificationType = 7 + FSNotificationType_FILE_MODIFIED FSNotificationType = 8 + FSNotificationType_FILE_DELETED FSNotificationType = 9 + FSNotificationType_FILE_RENAMED FSNotificationType = 10 + FSNotificationType_INITIALIZED FSNotificationType = 11 + FSNotificationType_SYNC_CONFIG_CHANGED FSNotificationType = 12 +) + +func (o FSNotificationType) DeepCopy() FSNotificationType { return o } + +var FSNotificationTypeMap = map[string]FSNotificationType{ + "ENCRYPTING": 0, + "DECRYPTING": 1, + "SIGNING": 2, + "VERIFYING": 3, + "REKEYING": 4, + "CONNECTION": 5, + "MD_READ_SUCCESS": 6, + "FILE_CREATED": 7, + "FILE_MODIFIED": 8, + "FILE_DELETED": 9, + "FILE_RENAMED": 10, + "INITIALIZED": 11, + "SYNC_CONFIG_CHANGED": 12, +} + +var FSNotificationTypeRevMap = map[FSNotificationType]string{ + 0: "ENCRYPTING", + 1: "DECRYPTING", + 2: "SIGNING", + 3: "VERIFYING", + 4: "REKEYING", + 5: "CONNECTION", + 6: "MD_READ_SUCCESS", + 7: "FILE_CREATED", + 8: "FILE_MODIFIED", + 9: "FILE_DELETED", + 10: "FILE_RENAMED", + 11: "INITIALIZED", + 12: "SYNC_CONFIG_CHANGED", +} + +func (e FSNotificationType) String() string { + if v, ok := FSNotificationTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type FSErrorType int + +const ( + FSErrorType_ACCESS_DENIED FSErrorType = 0 + FSErrorType_USER_NOT_FOUND FSErrorType = 1 + FSErrorType_REVOKED_DATA_DETECTED FSErrorType = 2 + FSErrorType_NOT_LOGGED_IN FSErrorType = 3 + FSErrorType_TIMEOUT FSErrorType = 4 + FSErrorType_REKEY_NEEDED FSErrorType = 5 + FSErrorType_BAD_FOLDER FSErrorType = 6 + FSErrorType_NOT_IMPLEMENTED FSErrorType = 7 + FSErrorType_OLD_VERSION FSErrorType = 8 + FSErrorType_OVER_QUOTA FSErrorType = 9 + FSErrorType_NO_SIG_CHAIN FSErrorType = 10 + FSErrorType_TOO_MANY_FOLDERS FSErrorType = 11 + FSErrorType_EXDEV_NOT_SUPPORTED FSErrorType = 12 + FSErrorType_DISK_LIMIT_REACHED FSErrorType = 13 + FSErrorType_DISK_CACHE_ERROR_LOG_SEND FSErrorType = 14 + FSErrorType_OFFLINE_ARCHIVED FSErrorType = 15 + FSErrorType_OFFLINE_UNSYNCED FSErrorType = 16 +) + +func (o FSErrorType) DeepCopy() FSErrorType { return o } + +var FSErrorTypeMap = map[string]FSErrorType{ + "ACCESS_DENIED": 0, + "USER_NOT_FOUND": 1, + "REVOKED_DATA_DETECTED": 2, + "NOT_LOGGED_IN": 3, + "TIMEOUT": 4, + "REKEY_NEEDED": 5, + "BAD_FOLDER": 6, + "NOT_IMPLEMENTED": 7, + "OLD_VERSION": 8, + "OVER_QUOTA": 9, + "NO_SIG_CHAIN": 10, + "TOO_MANY_FOLDERS": 11, + "EXDEV_NOT_SUPPORTED": 12, + "DISK_LIMIT_REACHED": 13, + "DISK_CACHE_ERROR_LOG_SEND": 14, + "OFFLINE_ARCHIVED": 15, + "OFFLINE_UNSYNCED": 16, +} + +var FSErrorTypeRevMap = map[FSErrorType]string{ + 0: "ACCESS_DENIED", + 1: "USER_NOT_FOUND", + 2: "REVOKED_DATA_DETECTED", + 3: "NOT_LOGGED_IN", + 4: "TIMEOUT", + 5: "REKEY_NEEDED", + 6: "BAD_FOLDER", + 7: "NOT_IMPLEMENTED", + 8: "OLD_VERSION", + 9: "OVER_QUOTA", + 10: "NO_SIG_CHAIN", + 11: "TOO_MANY_FOLDERS", + 12: "EXDEV_NOT_SUPPORTED", + 13: "DISK_LIMIT_REACHED", + 14: "DISK_CACHE_ERROR_LOG_SEND", + 15: "OFFLINE_ARCHIVED", + 16: "OFFLINE_UNSYNCED", +} + +func (e FSErrorType) String() string { + if v, ok := FSErrorTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type FSNotification struct { + Filename string `codec:"filename" json:"filename"` + Status string `codec:"status" json:"status"` + StatusCode FSStatusCode `codec:"statusCode" json:"statusCode"` + NotificationType FSNotificationType `codec:"notificationType" json:"notificationType"` + ErrorType FSErrorType `codec:"errorType" json:"errorType"` + Params map[string]string `codec:"params" json:"params"` + WriterUid UID `codec:"writerUid" json:"writerUid"` + LocalTime Time `codec:"localTime" json:"localTime"` + FolderType FolderType `codec:"folderType" json:"folderType"` +} + +func (o FSNotification) DeepCopy() FSNotification { + return FSNotification{ + Filename: o.Filename, + Status: o.Status, + StatusCode: o.StatusCode.DeepCopy(), + NotificationType: o.NotificationType.DeepCopy(), + ErrorType: o.ErrorType.DeepCopy(), + Params: (func(x map[string]string) map[string]string { + if x == nil { + return nil + } + ret := make(map[string]string, len(x)) + for k, v := range x { + kCopy := k + vCopy := v + ret[kCopy] = vCopy + } + return ret + })(o.Params), + WriterUid: o.WriterUid.DeepCopy(), + LocalTime: o.LocalTime.DeepCopy(), + FolderType: o.FolderType.DeepCopy(), + } +} + +type FSEditListRequest struct { + Folder Folder `codec:"folder" json:"folder"` + RequestID int `codec:"requestID" json:"requestID"` +} + +func (o FSEditListRequest) DeepCopy() FSEditListRequest { + return FSEditListRequest{ + Folder: o.Folder.DeepCopy(), + RequestID: o.RequestID, + } +} + +type FSFolderWriterEdit struct { + Filename string `codec:"filename" json:"filename"` + NotificationType FSNotificationType `codec:"notificationType" json:"notificationType"` + ServerTime Time `codec:"serverTime" json:"serverTime"` +} + +func (o FSFolderWriterEdit) DeepCopy() FSFolderWriterEdit { + return FSFolderWriterEdit{ + Filename: o.Filename, + NotificationType: o.NotificationType.DeepCopy(), + ServerTime: o.ServerTime.DeepCopy(), + } +} + +type FSFolderWriterEditHistory struct { + WriterName string `codec:"writerName" json:"writerName"` + Edits []FSFolderWriterEdit `codec:"edits" json:"edits"` + Deletes []FSFolderWriterEdit `codec:"deletes" json:"deletes"` +} + +func (o FSFolderWriterEditHistory) DeepCopy() FSFolderWriterEditHistory { + return FSFolderWriterEditHistory{ + WriterName: o.WriterName, + Edits: (func(x []FSFolderWriterEdit) []FSFolderWriterEdit { + if x == nil { + return nil + } + ret := make([]FSFolderWriterEdit, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Edits), + Deletes: (func(x []FSFolderWriterEdit) []FSFolderWriterEdit { + if x == nil { + return nil + } + ret := make([]FSFolderWriterEdit, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Deletes), + } +} + +type FSFolderEditHistory struct { + Folder Folder `codec:"folder" json:"folder"` + ServerTime Time `codec:"serverTime" json:"serverTime"` + History []FSFolderWriterEditHistory `codec:"history" json:"history"` +} + +func (o FSFolderEditHistory) DeepCopy() FSFolderEditHistory { + return FSFolderEditHistory{ + Folder: o.Folder.DeepCopy(), + ServerTime: o.ServerTime.DeepCopy(), + History: (func(x []FSFolderWriterEditHistory) []FSFolderWriterEditHistory { + if x == nil { + return nil + } + ret := make([]FSFolderWriterEditHistory, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.History), + } +} + +type FSSyncStatusRequest struct { + RequestID int `codec:"requestID" json:"requestID"` +} + +func (o FSSyncStatusRequest) DeepCopy() FSSyncStatusRequest { + return FSSyncStatusRequest{ + RequestID: o.RequestID, + } +} + +type FSPathSyncStatus struct { + FolderType FolderType `codec:"folderType" json:"folderType"` + Path string `codec:"path" json:"path"` + SyncingBytes int64 `codec:"syncingBytes" json:"syncingBytes"` + SyncingOps int64 `codec:"syncingOps" json:"syncingOps"` + SyncedBytes int64 `codec:"syncedBytes" json:"syncedBytes"` +} + +func (o FSPathSyncStatus) DeepCopy() FSPathSyncStatus { + return FSPathSyncStatus{ + FolderType: o.FolderType.DeepCopy(), + Path: o.Path, + SyncingBytes: o.SyncingBytes, + SyncingOps: o.SyncingOps, + SyncedBytes: o.SyncedBytes, + } +} + +type FSSyncStatus struct { + TotalSyncingBytes int64 `codec:"totalSyncingBytes" json:"totalSyncingBytes"` + SyncingPaths []string `codec:"syncingPaths" json:"syncingPaths"` + EndEstimate *Time `codec:"endEstimate,omitempty" json:"endEstimate,omitempty"` +} + +func (o FSSyncStatus) DeepCopy() FSSyncStatus { + return FSSyncStatus{ + TotalSyncingBytes: o.TotalSyncingBytes, + SyncingPaths: (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.SyncingPaths), + EndEstimate: (func(x *Time) *Time { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.EndEstimate), + } +} + +type FolderSyncStatus struct { + LocalDiskBytesAvailable int64 `codec:"localDiskBytesAvailable" json:"localDiskBytesAvailable"` + LocalDiskBytesTotal int64 `codec:"localDiskBytesTotal" json:"localDiskBytesTotal"` + PrefetchStatus PrefetchStatus `codec:"prefetchStatus" json:"prefetchStatus"` + PrefetchProgress PrefetchProgress `codec:"prefetchProgress" json:"prefetchProgress"` + StoredBytesTotal int64 `codec:"storedBytesTotal" json:"storedBytesTotal"` + OutOfSyncSpace bool `codec:"outOfSyncSpace" json:"outOfSyncSpace"` +} + +func (o FolderSyncStatus) DeepCopy() FolderSyncStatus { + return FolderSyncStatus{ + LocalDiskBytesAvailable: o.LocalDiskBytesAvailable, + LocalDiskBytesTotal: o.LocalDiskBytesTotal, + PrefetchStatus: o.PrefetchStatus.DeepCopy(), + PrefetchProgress: o.PrefetchProgress.DeepCopy(), + StoredBytesTotal: o.StoredBytesTotal, + OutOfSyncSpace: o.OutOfSyncSpace, + } +} 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 new file mode 100644 index 00000000..a9e81d83 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kbfs_git.go @@ -0,0 +1,20 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/kbfs_git.avdl + +package keybase1 + +type GcOptions struct { + MaxLooseRefs int `codec:"maxLooseRefs" json:"maxLooseRefs"` + PruneMinLooseObjects int `codec:"pruneMinLooseObjects" json:"pruneMinLooseObjects"` + PruneExpireTime Time `codec:"pruneExpireTime" json:"pruneExpireTime"` + MaxObjectPacks int `codec:"maxObjectPacks" json:"maxObjectPacks"` +} + +func (o GcOptions) DeepCopy() GcOptions { + return GcOptions{ + MaxLooseRefs: o.MaxLooseRefs, + PruneMinLooseObjects: o.PruneMinLooseObjects, + PruneExpireTime: o.PruneExpireTime.DeepCopy(), + MaxObjectPacks: o.MaxObjectPacks, + } +} 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 new file mode 100644 index 00000000..d9d727f1 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kbfsmount.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..1dc8010c --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kex2provisionee.go @@ -0,0 +1,39 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/kex2provisionee.avdl + +package keybase1 + +type PassphraseStream struct { + PassphraseStream []byte `codec:"passphraseStream" json:"passphraseStream"` + Generation int `codec:"generation" json:"generation"` +} + +func (o PassphraseStream) DeepCopy() PassphraseStream { + return PassphraseStream{ + PassphraseStream: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.PassphraseStream), + Generation: o.Generation, + } +} + +type SessionToken string + +func (o SessionToken) DeepCopy() SessionToken { + return o +} + +type CsrfToken string + +func (o CsrfToken) DeepCopy() CsrfToken { + return o +} + +type HelloRes string + +func (o HelloRes) DeepCopy() HelloRes { + return o +} 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 new file mode 100644 index 00000000..148c8fad --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kex2provisionee2.go @@ -0,0 +1,32 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/kex2provisionee2.avdl + +package keybase1 + +type Hello2Res struct { + EncryptionKey KID `codec:"encryptionKey" json:"encryptionKey"` + SigPayload HelloRes `codec:"sigPayload" json:"sigPayload"` + DeviceEkKID KID `codec:"deviceEkKID" json:"deviceEkKID"` +} + +func (o Hello2Res) DeepCopy() Hello2Res { + return Hello2Res{ + EncryptionKey: o.EncryptionKey.DeepCopy(), + SigPayload: o.SigPayload.DeepCopy(), + DeviceEkKID: o.DeviceEkKID.DeepCopy(), + } +} + +type PerUserKeyBox struct { + Generation PerUserKeyGeneration `codec:"generation" json:"generation"` + Box string `codec:"box" json:"box"` + ReceiverKID KID `codec:"receiverKID" json:"receiver_kid"` +} + +func (o PerUserKeyBox) DeepCopy() PerUserKeyBox { + return PerUserKeyBox{ + Generation: o.Generation.DeepCopy(), + Box: o.Box, + ReceiverKID: o.ReceiverKID.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..e24d4e88 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kex2provisioner.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..cbb8d945 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kvstore.go @@ -0,0 +1,150 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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"` +} + +func (o KVGetResult) DeepCopy() KVGetResult { + return KVGetResult{ + TeamName: o.TeamName, + Namespace: o.Namespace, + EntryKey: o.EntryKey, + EntryValue: o.EntryValue, + Revision: o.Revision, + } +} + +type KVPutResult struct { + TeamName string `codec:"teamName" json:"teamName"` + Namespace string `codec:"namespace" json:"namespace"` + EntryKey string `codec:"entryKey" json:"entryKey"` + Revision int `codec:"revision" json:"revision"` +} + +func (o KVPutResult) DeepCopy() KVPutResult { + return KVPutResult{ + TeamName: o.TeamName, + Namespace: o.Namespace, + EntryKey: o.EntryKey, + Revision: o.Revision, + } +} + +type KVEntryID struct { + TeamID TeamID `codec:"teamID" json:"teamID"` + Namespace string `codec:"namespace" json:"namespace"` + EntryKey string `codec:"entryKey" json:"entryKey"` +} + +func (o KVEntryID) DeepCopy() KVEntryID { + return KVEntryID{ + TeamID: o.TeamID.DeepCopy(), + Namespace: o.Namespace, + EntryKey: o.EntryKey, + } +} + +type EncryptedKVEntry struct { + V int `codec:"v" json:"v"` + E []byte `codec:"e" json:"e"` + N []byte `codec:"n" json:"n"` +} + +func (o EncryptedKVEntry) DeepCopy() EncryptedKVEntry { + return EncryptedKVEntry{ + V: o.V, + E: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.E), + N: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.N), + } +} + +type KVListNamespaceResult struct { + TeamName string `codec:"teamName" json:"teamName"` + Namespaces []string `codec:"namespaces" json:"namespaces"` +} + +func (o KVListNamespaceResult) DeepCopy() KVListNamespaceResult { + return KVListNamespaceResult{ + TeamName: o.TeamName, + Namespaces: (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.Namespaces), + } +} + +type KVListEntryKey struct { + EntryKey string `codec:"entryKey" json:"entryKey"` + Revision int `codec:"revision" json:"revision"` +} + +func (o KVListEntryKey) DeepCopy() KVListEntryKey { + return KVListEntryKey{ + EntryKey: o.EntryKey, + Revision: o.Revision, + } +} + +type KVListEntryResult struct { + TeamName string `codec:"teamName" json:"teamName"` + Namespace string `codec:"namespace" json:"namespace"` + EntryKeys []KVListEntryKey `codec:"entryKeys" json:"entryKeys"` +} + +func (o KVListEntryResult) DeepCopy() KVListEntryResult { + return KVListEntryResult{ + TeamName: o.TeamName, + Namespace: o.Namespace, + EntryKeys: (func(x []KVListEntryKey) []KVListEntryKey { + if x == nil { + return nil + } + ret := make([]KVListEntryKey, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.EntryKeys), + } +} + +type KVDeleteEntryResult struct { + TeamName string `codec:"teamName" json:"teamName"` + Namespace string `codec:"namespace" json:"namespace"` + EntryKey string `codec:"entryKey" json:"entryKey"` + Revision int `codec:"revision" json:"revision"` +} + +func (o KVDeleteEntryResult) DeepCopy() KVDeleteEntryResult { + return KVDeleteEntryResult{ + TeamName: o.TeamName, + Namespace: o.Namespace, + EntryKey: o.EntryKey, + 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 new file mode 100644 index 00000000..2874c1ef --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/log.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..39bd218c --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/log_ui.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..86e383e8 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/login.go @@ -0,0 +1,20 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/login.avdl + +package keybase1 + +type ConfiguredAccount struct { + Username string `codec:"username" json:"username"` + Fullname FullName `codec:"fullname" json:"fullname"` + HasStoredSecret bool `codec:"hasStoredSecret" json:"hasStoredSecret"` + IsCurrent bool `codec:"isCurrent" json:"isCurrent"` +} + +func (o ConfiguredAccount) DeepCopy() ConfiguredAccount { + return ConfiguredAccount{ + Username: o.Username, + Fullname: o.Fullname.DeepCopy(), + HasStoredSecret: o.HasStoredSecret, + IsCurrent: o.IsCurrent, + } +} 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 new file mode 100644 index 00000000..124ff2b3 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/login_ui.go @@ -0,0 +1,196 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/login_ui.avdl + +package keybase1 + +import ( + "errors" + "fmt" +) + +type ResetPromptType int + +const ( + ResetPromptType_COMPLETE ResetPromptType = 0 + ResetPromptType_ENTER_NO_DEVICES ResetPromptType = 1 + ResetPromptType_ENTER_FORGOT_PW ResetPromptType = 2 + ResetPromptType_ENTER_RESET_PW ResetPromptType = 3 +) + +func (o ResetPromptType) DeepCopy() ResetPromptType { return o } + +var ResetPromptTypeMap = map[string]ResetPromptType{ + "COMPLETE": 0, + "ENTER_NO_DEVICES": 1, + "ENTER_FORGOT_PW": 2, + "ENTER_RESET_PW": 3, +} + +var ResetPromptTypeRevMap = map[ResetPromptType]string{ + 0: "COMPLETE", + 1: "ENTER_NO_DEVICES", + 2: "ENTER_FORGOT_PW", + 3: "ENTER_RESET_PW", +} + +func (e ResetPromptType) String() string { + if v, ok := ResetPromptTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ResetPromptInfo struct { + HasWallet bool `codec:"hasWallet" json:"hasWallet"` +} + +func (o ResetPromptInfo) DeepCopy() ResetPromptInfo { + return ResetPromptInfo{ + HasWallet: o.HasWallet, + } +} + +type ResetPrompt struct { + T__ ResetPromptType `codec:"t" json:"t"` + Complete__ *ResetPromptInfo `codec:"complete,omitempty" json:"complete,omitempty"` +} + +func (o *ResetPrompt) T() (ret ResetPromptType, err error) { + switch o.T__ { + case ResetPromptType_COMPLETE: + if o.Complete__ == nil { + err = errors.New("unexpected nil value for Complete__") + return ret, err + } + } + return o.T__, nil +} + +func (o ResetPrompt) Complete() (res ResetPromptInfo) { + if o.T__ != ResetPromptType_COMPLETE { + panic("wrong case accessed") + } + if o.Complete__ == nil { + return + } + return *o.Complete__ +} + +func NewResetPromptWithComplete(v ResetPromptInfo) ResetPrompt { + return ResetPrompt{ + T__: ResetPromptType_COMPLETE, + Complete__: &v, + } +} + +func NewResetPromptDefault(t ResetPromptType) ResetPrompt { + return ResetPrompt{ + T__: t, + } +} + +func (o ResetPrompt) DeepCopy() ResetPrompt { + return ResetPrompt{ + T__: o.T__.DeepCopy(), + Complete__: (func(x *ResetPromptInfo) *ResetPromptInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Complete__), + } +} + +type ResetPromptResponse int + +const ( + ResetPromptResponse_NOTHING ResetPromptResponse = 0 + ResetPromptResponse_CANCEL_RESET ResetPromptResponse = 1 + ResetPromptResponse_CONFIRM_RESET ResetPromptResponse = 2 +) + +func (o ResetPromptResponse) DeepCopy() ResetPromptResponse { return o } + +var ResetPromptResponseMap = map[string]ResetPromptResponse{ + "NOTHING": 0, + "CANCEL_RESET": 1, + "CONFIRM_RESET": 2, +} + +var ResetPromptResponseRevMap = map[ResetPromptResponse]string{ + 0: "NOTHING", + 1: "CANCEL_RESET", + 2: "CONFIRM_RESET", +} + +func (e ResetPromptResponse) String() string { + if v, ok := ResetPromptResponseRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type PassphraseRecoveryPromptType int + +const ( + PassphraseRecoveryPromptType_ENCRYPTED_PGP_KEYS PassphraseRecoveryPromptType = 0 +) + +func (o PassphraseRecoveryPromptType) DeepCopy() PassphraseRecoveryPromptType { return o } + +var PassphraseRecoveryPromptTypeMap = map[string]PassphraseRecoveryPromptType{ + "ENCRYPTED_PGP_KEYS": 0, +} + +var PassphraseRecoveryPromptTypeRevMap = map[PassphraseRecoveryPromptType]string{ + 0: "ENCRYPTED_PGP_KEYS", +} + +func (e PassphraseRecoveryPromptType) String() string { + if v, ok := PassphraseRecoveryPromptTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ResetMessage int + +const ( + ResetMessage_ENTERED_VERIFIED ResetMessage = 0 + ResetMessage_ENTERED_PASSWORDLESS ResetMessage = 1 + ResetMessage_REQUEST_VERIFIED ResetMessage = 2 + ResetMessage_NOT_COMPLETED ResetMessage = 3 + ResetMessage_CANCELED ResetMessage = 4 + ResetMessage_COMPLETED ResetMessage = 5 + ResetMessage_RESET_LINK_SENT ResetMessage = 6 +) + +func (o ResetMessage) DeepCopy() ResetMessage { return o } + +var ResetMessageMap = map[string]ResetMessage{ + "ENTERED_VERIFIED": 0, + "ENTERED_PASSWORDLESS": 1, + "REQUEST_VERIFIED": 2, + "NOT_COMPLETED": 3, + "CANCELED": 4, + "COMPLETED": 5, + "RESET_LINK_SENT": 6, +} + +var ResetMessageRevMap = map[ResetMessage]string{ + 0: "ENTERED_VERIFIED", + 1: "ENTERED_PASSWORDLESS", + 2: "REQUEST_VERIFIED", + 3: "NOT_COMPLETED", + 4: "CANCELED", + 5: "COMPLETED", + 6: "RESET_LINK_SENT", +} + +func (e ResetMessage) String() string { + if v, ok := ResetMessageRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} 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 new file mode 100644 index 00000000..55df5fb9 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/logsend.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..f8c4320a --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/merkle.go @@ -0,0 +1,41 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/merkle.avdl + +package keybase1 + +type MerkleRootAndTime struct { + Root MerkleRootV2 `codec:"root" json:"root"` + UpdateTime Time `codec:"updateTime" json:"updateTime"` + FetchTime Time `codec:"fetchTime" json:"fetchTime"` +} + +func (o MerkleRootAndTime) DeepCopy() MerkleRootAndTime { + return MerkleRootAndTime{ + Root: o.Root.DeepCopy(), + UpdateTime: o.UpdateTime.DeepCopy(), + FetchTime: o.FetchTime.DeepCopy(), + } +} + +type KBFSRootHash []byte + +func (o KBFSRootHash) DeepCopy() KBFSRootHash { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} + +type KBFSRoot struct { + TreeID MerkleTreeID `codec:"treeID" json:"treeID"` + Root KBFSRootHash `codec:"root" json:"root"` +} + +func (o KBFSRoot) DeepCopy() KBFSRoot { + return KBFSRoot{ + TreeID: o.TreeID.DeepCopy(), + Root: o.Root.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..a8ea0091 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/merkle_store.go @@ -0,0 +1,40 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/merkle_store.avdl + +package keybase1 + +type MerkleStoreSupportedVersion int + +func (o MerkleStoreSupportedVersion) DeepCopy() MerkleStoreSupportedVersion { + return o +} + +type MerkleStoreKitHash string + +func (o MerkleStoreKitHash) DeepCopy() MerkleStoreKitHash { + return o +} + +type MerkleStoreKit string + +func (o MerkleStoreKit) DeepCopy() MerkleStoreKit { + return o +} + +type MerkleStoreEntryString string + +func (o MerkleStoreEntryString) DeepCopy() MerkleStoreEntryString { + return o +} + +type MerkleStoreEntry struct { + Hash MerkleStoreKitHash `codec:"hash" json:"hash"` + Entry MerkleStoreEntryString `codec:"entry" json:"entry"` +} + +func (o MerkleStoreEntry) DeepCopy() MerkleStoreEntry { + return MerkleStoreEntry{ + Hash: o.Hash.DeepCopy(), + Entry: o.Entry.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..1dc761f0 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/metadata.go @@ -0,0 +1,175 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/metadata.avdl + +package keybase1 + +type KeyHalf struct { + User UID `codec:"user" json:"user"` + DeviceKID KID `codec:"deviceKID" json:"deviceKID"` + Key []byte `codec:"key" json:"key"` +} + +func (o KeyHalf) DeepCopy() KeyHalf { + return KeyHalf{ + User: o.User.DeepCopy(), + DeviceKID: o.DeviceKID.DeepCopy(), + Key: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.Key), + } +} + +type MDBlock struct { + Version int `codec:"version" json:"version"` + Timestamp Time `codec:"timestamp" json:"timestamp"` + Block []byte `codec:"block" json:"block"` +} + +func (o MDBlock) DeepCopy() MDBlock { + return MDBlock{ + Version: o.Version, + Timestamp: o.Timestamp.DeepCopy(), + Block: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.Block), + } +} + +type KeyBundle struct { + Version int `codec:"version" json:"version"` + Bundle []byte `codec:"bundle" json:"bundle"` +} + +func (o KeyBundle) DeepCopy() KeyBundle { + return KeyBundle{ + Version: o.Version, + Bundle: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.Bundle), + } +} + +type MetadataResponse struct { + FolderID string `codec:"folderID" json:"folderID"` + MdBlocks []MDBlock `codec:"mdBlocks" json:"mdBlocks"` +} + +func (o MetadataResponse) DeepCopy() MetadataResponse { + return MetadataResponse{ + FolderID: o.FolderID, + MdBlocks: (func(x []MDBlock) []MDBlock { + if x == nil { + return nil + } + ret := make([]MDBlock, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.MdBlocks), + } +} + +type MerkleRoot struct { + Version int `codec:"version" json:"version"` + Root []byte `codec:"root" json:"root"` +} + +func (o MerkleRoot) DeepCopy() MerkleRoot { + return MerkleRoot{ + Version: o.Version, + Root: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.Root), + } +} + +type PingResponse struct { + Timestamp Time `codec:"timestamp" json:"timestamp"` +} + +func (o PingResponse) DeepCopy() PingResponse { + return PingResponse{ + Timestamp: o.Timestamp.DeepCopy(), + } +} + +type KeyBundleResponse struct { + WriterBundle KeyBundle `codec:"WriterBundle" json:"WriterBundle"` + ReaderBundle KeyBundle `codec:"ReaderBundle" json:"ReaderBundle"` +} + +func (o KeyBundleResponse) DeepCopy() KeyBundleResponse { + return KeyBundleResponse{ + WriterBundle: o.WriterBundle.DeepCopy(), + ReaderBundle: o.ReaderBundle.DeepCopy(), + } +} + +type LockID int64 + +func (o LockID) DeepCopy() LockID { + return o +} + +type MDPriority int + +func (o MDPriority) DeepCopy() MDPriority { + return o +} + +type LockContext struct { + RequireLockID LockID `codec:"requireLockID" json:"requireLockID"` + ReleaseAfterSuccess bool `codec:"releaseAfterSuccess" json:"releaseAfterSuccess"` +} + +func (o LockContext) DeepCopy() LockContext { + return LockContext{ + RequireLockID: o.RequireLockID.DeepCopy(), + ReleaseAfterSuccess: o.ReleaseAfterSuccess, + } +} + +type FindNextMDResponse struct { + KbfsRoot MerkleRoot `codec:"kbfsRoot" json:"kbfsRoot"` + MerkleNodes [][]byte `codec:"merkleNodes" json:"merkleNodes"` + RootSeqno Seqno `codec:"rootSeqno" json:"rootSeqno"` + RootHash HashMeta `codec:"rootHash" json:"rootHash"` +} + +func (o FindNextMDResponse) DeepCopy() FindNextMDResponse { + return FindNextMDResponse{ + KbfsRoot: o.KbfsRoot.DeepCopy(), + MerkleNodes: (func(x [][]byte) [][]byte { + if x == nil { + return nil + } + ret := make([][]byte, len(x)) + for i, v := range x { + vCopy := (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(v) + ret[i] = vCopy + } + return ret + })(o.MerkleNodes), + RootSeqno: o.RootSeqno.DeepCopy(), + RootHash: o.RootHash.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..85d49c81 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/metadata_update.go @@ -0,0 +1,16 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/metadata_update.avdl + +package keybase1 + +type RekeyRequest struct { + FolderID string `codec:"folderID" json:"folderID"` + Revision int64 `codec:"revision" json:"revision"` +} + +func (o RekeyRequest) DeepCopy() RekeyRequest { + return RekeyRequest{ + FolderID: o.FolderID, + Revision: o.Revision, + } +} 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 new file mode 100644 index 00000000..64f76c79 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_app.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..8a39a98e --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_audit.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..b3541b99 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_badges.go @@ -0,0 +1,232 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/notify_badges.avdl + +package keybase1 + +import ( + gregor1 "github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1" +) + +type ChatConversationID []byte + +func (o ChatConversationID) DeepCopy() ChatConversationID { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} + +type TeamMemberOutReset struct { + TeamID TeamID `codec:"teamID" json:"teamID"` + Teamname string `codec:"teamname" json:"teamname"` + Username string `codec:"username" json:"username"` + Uid UID `codec:"uid" json:"uid"` + Id gregor1.MsgID `codec:"id" json:"id"` +} + +func (o TeamMemberOutReset) DeepCopy() TeamMemberOutReset { + return TeamMemberOutReset{ + TeamID: o.TeamID.DeepCopy(), + Teamname: o.Teamname, + Username: o.Username, + Uid: o.Uid.DeepCopy(), + Id: o.Id.DeepCopy(), + } +} + +type DeletedTeamInfo struct { + TeamName string `codec:"teamName" json:"teamName"` + DeletedBy string `codec:"deletedBy" json:"deletedBy"` + Id gregor1.MsgID `codec:"id" json:"id"` +} + +func (o DeletedTeamInfo) DeepCopy() DeletedTeamInfo { + return DeletedTeamInfo{ + TeamName: o.TeamName, + DeletedBy: o.DeletedBy, + Id: o.Id.DeepCopy(), + } +} + +type WalletAccountInfo struct { + AccountID string `codec:"accountID" json:"accountID"` + NumUnread int `codec:"numUnread" json:"numUnread"` +} + +func (o WalletAccountInfo) DeepCopy() WalletAccountInfo { + return WalletAccountInfo{ + AccountID: o.AccountID, + NumUnread: o.NumUnread, + } +} + +type ResetState struct { + EndTime Time `codec:"endTime" json:"end_time"` + Active bool `codec:"active" json:"active"` +} + +func (o ResetState) DeepCopy() ResetState { + return ResetState{ + EndTime: o.EndTime.DeepCopy(), + Active: o.Active, + } +} + +type BadgeState struct { + NewTlfs int `codec:"newTlfs" json:"newTlfs"` + RekeysNeeded int `codec:"rekeysNeeded" json:"rekeysNeeded"` + NewFollowers int `codec:"newFollowers" json:"newFollowers"` + InboxVers int `codec:"inboxVers" json:"inboxVers"` + HomeTodoItems int `codec:"homeTodoItems" json:"homeTodoItems"` + UnverifiedEmails int `codec:"unverifiedEmails" json:"unverifiedEmails"` + UnverifiedPhones int `codec:"unverifiedPhones" json:"unverifiedPhones"` + 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"` + 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, + NewDevices: (func(x []DeviceID) []DeviceID { + if x == nil { + return nil + } + ret := make([]DeviceID, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.NewDevices), + RevokedDevices: (func(x []DeviceID) []DeviceID { + if x == nil { + return nil + } + ret := make([]DeviceID, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.RevokedDevices), + Conversations: (func(x []BadgeConversationInfo) []BadgeConversationInfo { + if x == nil { + return nil + } + ret := make([]BadgeConversationInfo, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Conversations), + NewGitRepoGlobalUniqueIDs: (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.NewGitRepoGlobalUniqueIDs), + NewTeams: (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.NewTeams), + DeletedTeams: (func(x []DeletedTeamInfo) []DeletedTeamInfo { + if x == nil { + return nil + } + ret := make([]DeletedTeamInfo, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + 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 + } + ret := make([]TeamMemberOutReset, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.TeamsWithResetUsers), + UnreadWalletAccounts: (func(x []WalletAccountInfo) []WalletAccountInfo { + if x == nil { + return nil + } + ret := make([]WalletAccountInfo, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.UnreadWalletAccounts), + ResetState: o.ResetState.DeepCopy(), + } +} + +type BadgeConversationInfo struct { + ConvID ChatConversationID `codec:"convID" json:"convID"` + BadgeCounts map[DeviceType]int `codec:"badgeCounts" json:"badgeCounts"` + 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), + 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 new file mode 100644 index 00000000..92be0aa3 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_can_user_perform.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..a937a7d6 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_ctl.go @@ -0,0 +1,70 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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"` +} + +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, + } +} 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 new file mode 100644 index 00000000..61bfa51c --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_device_clone.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..297afae3 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_email.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..f23a9fa0 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_ephemeral.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..5a30b97f --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_favorites.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..ac43c6bf --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_featuredbots.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..aadffd81 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_fs.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..a5d9259f --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_fs_request.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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_keyfamily.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_keyfamily.go new file mode 100644 index 00000000..36fa67b3 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_keyfamily.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..4ea5435c --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_paperkey.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..7f8a6070 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_pgp.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..42c5e0f9 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_phone.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..99906ffa --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_runtimestats.go @@ -0,0 +1,141 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/notify_runtimestats.avdl + +package keybase1 + +import ( + "fmt" +) + +type StatsSeverityLevel int + +const ( + StatsSeverityLevel_NORMAL StatsSeverityLevel = 0 + StatsSeverityLevel_WARNING StatsSeverityLevel = 1 + StatsSeverityLevel_SEVERE StatsSeverityLevel = 2 +) + +func (o StatsSeverityLevel) DeepCopy() StatsSeverityLevel { return o } + +var StatsSeverityLevelMap = map[string]StatsSeverityLevel{ + "NORMAL": 0, + "WARNING": 1, + "SEVERE": 2, +} + +var StatsSeverityLevelRevMap = map[StatsSeverityLevel]string{ + 0: "NORMAL", + 1: "WARNING", + 2: "SEVERE", +} + +func (e StatsSeverityLevel) String() string { + if v, ok := StatsSeverityLevelRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type DbStats struct { + Type DbType `codec:"type" json:"type"` + MemCompActive bool `codec:"memCompActive" json:"memCompActive"` + TableCompActive bool `codec:"tableCompActive" json:"tableCompActive"` +} + +func (o DbStats) DeepCopy() DbStats { + return DbStats{ + Type: o.Type.DeepCopy(), + MemCompActive: o.MemCompActive, + TableCompActive: o.TableCompActive, + } +} + +type ProcessType int + +const ( + ProcessType_MAIN ProcessType = 0 + ProcessType_KBFS ProcessType = 1 +) + +func (o ProcessType) DeepCopy() ProcessType { return o } + +var ProcessTypeMap = map[string]ProcessType{ + "MAIN": 0, + "KBFS": 1, +} + +var ProcessTypeRevMap = map[ProcessType]string{ + 0: "MAIN", + 1: "KBFS", +} + +func (e ProcessType) String() string { + if v, ok := ProcessTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ProcessRuntimeStats struct { + Type ProcessType `codec:"type" json:"type"` + Cpu string `codec:"cpu" json:"cpu"` + Resident string `codec:"resident" json:"resident"` + Virt string `codec:"virt" json:"virt"` + Free string `codec:"free" json:"free"` + Goheap string `codec:"goheap" json:"goheap"` + Goheapsys string `codec:"goheapsys" json:"goheapsys"` + Goreleased string `codec:"goreleased" json:"goreleased"` + CpuSeverity StatsSeverityLevel `codec:"cpuSeverity" json:"cpuSeverity"` + ResidentSeverity StatsSeverityLevel `codec:"residentSeverity" json:"residentSeverity"` +} + +func (o ProcessRuntimeStats) DeepCopy() ProcessRuntimeStats { + return ProcessRuntimeStats{ + Type: o.Type.DeepCopy(), + Cpu: o.Cpu, + Resident: o.Resident, + Virt: o.Virt, + Free: o.Free, + Goheap: o.Goheap, + Goheapsys: o.Goheapsys, + Goreleased: o.Goreleased, + CpuSeverity: o.CpuSeverity.DeepCopy(), + ResidentSeverity: o.ResidentSeverity.DeepCopy(), + } +} + +type RuntimeStats struct { + ProcessStats []ProcessRuntimeStats `codec:"processStats" json:"processStats"` + DbStats []DbStats `codec:"dbStats" json:"dbStats"` + ConvLoaderActive bool `codec:"convLoaderActive" json:"convLoaderActive"` + SelectiveSyncActive bool `codec:"selectiveSyncActive" json:"selectiveSyncActive"` +} + +func (o RuntimeStats) DeepCopy() RuntimeStats { + return RuntimeStats{ + ProcessStats: (func(x []ProcessRuntimeStats) []ProcessRuntimeStats { + if x == nil { + return nil + } + ret := make([]ProcessRuntimeStats, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.ProcessStats), + DbStats: (func(x []DbStats) []DbStats { + if x == nil { + return nil + } + ret := make([]DbStats, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.DbStats), + 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 new file mode 100644 index 00000000..8df8a8d9 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_saltpack.go @@ -0,0 +1,40 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/notify_saltpack.avdl + +package keybase1 + +import ( + "fmt" +) + +type SaltpackOperationType int + +const ( + SaltpackOperationType_ENCRYPT SaltpackOperationType = 0 + SaltpackOperationType_DECRYPT SaltpackOperationType = 1 + SaltpackOperationType_SIGN SaltpackOperationType = 2 + SaltpackOperationType_VERIFY SaltpackOperationType = 3 +) + +func (o SaltpackOperationType) DeepCopy() SaltpackOperationType { return o } + +var SaltpackOperationTypeMap = map[string]SaltpackOperationType{ + "ENCRYPT": 0, + "DECRYPT": 1, + "SIGN": 2, + "VERIFY": 3, +} + +var SaltpackOperationTypeRevMap = map[SaltpackOperationType]string{ + 0: "ENCRYPT", + 1: "DECRYPT", + 2: "SIGN", + 3: "VERIFY", +} + +func (e SaltpackOperationType) String() string { + if v, ok := SaltpackOperationTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} 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 new file mode 100644 index 00000000..e96d4ddf --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_service.go @@ -0,0 +1,16 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/notify_service.avdl + +package keybase1 + +type HttpSrvInfo struct { + Address string `codec:"address" json:"address"` + Token string `codec:"token" json:"token"` +} + +func (o HttpSrvInfo) DeepCopy() HttpSrvInfo { + return HttpSrvInfo{ + Address: o.Address, + Token: o.Token, + } +} 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 new file mode 100644 index 00000000..3f89041e --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_session.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..b90f13e4 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_team.go @@ -0,0 +1,53 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/notify_team.avdl + +package keybase1 + +import ( + "fmt" +) + +type TeamChangeSet struct { + MembershipChanged bool `codec:"membershipChanged" json:"membershipChanged"` + KeyRotated bool `codec:"keyRotated" json:"keyRotated"` + Renamed bool `codec:"renamed" json:"renamed"` + Misc bool `codec:"misc" json:"misc"` +} + +func (o TeamChangeSet) DeepCopy() TeamChangeSet { + return TeamChangeSet{ + MembershipChanged: o.MembershipChanged, + KeyRotated: o.KeyRotated, + Renamed: o.Renamed, + Misc: o.Misc, + } +} + +type AvatarUpdateType int + +const ( + AvatarUpdateType_NONE AvatarUpdateType = 0 + AvatarUpdateType_USER AvatarUpdateType = 1 + AvatarUpdateType_TEAM AvatarUpdateType = 2 +) + +func (o AvatarUpdateType) DeepCopy() AvatarUpdateType { return o } + +var AvatarUpdateTypeMap = map[string]AvatarUpdateType{ + "NONE": 0, + "USER": 1, + "TEAM": 2, +} + +var AvatarUpdateTypeRevMap = map[AvatarUpdateType]string{ + 0: "NONE", + 1: "USER", + 2: "TEAM", +} + +func (e AvatarUpdateType) String() string { + if v, ok := AvatarUpdateTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} 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 new file mode 100644 index 00000000..64d8242a --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_teambot.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..ecb4a58a --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_tracking.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..10aa26b9 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_users.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..1efd93ed --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/os.go @@ -0,0 +1,40 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/os.avdl + +package keybase1 + +import ( + "fmt" +) + +type RuntimeGroup int + +const ( + RuntimeGroup_UNKNOWN RuntimeGroup = 0 + RuntimeGroup_LINUXLIKE RuntimeGroup = 1 + RuntimeGroup_DARWINLIKE RuntimeGroup = 2 + RuntimeGroup_WINDOWSLIKE RuntimeGroup = 3 +) + +func (o RuntimeGroup) DeepCopy() RuntimeGroup { return o } + +var RuntimeGroupMap = map[string]RuntimeGroup{ + "UNKNOWN": 0, + "LINUXLIKE": 1, + "DARWINLIKE": 2, + "WINDOWSLIKE": 3, +} + +var RuntimeGroupRevMap = map[RuntimeGroup]string{ + 0: "UNKNOWN", + 1: "LINUXLIKE", + 2: "DARWINLIKE", + 3: "WINDOWSLIKE", +} + +func (e RuntimeGroup) String() string { + if v, ok := RuntimeGroupRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} 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 new file mode 100644 index 00000000..eafff4e0 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/paperprovision.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..1d31f46e --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/passphrase_common.go @@ -0,0 +1,102 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/passphrase_common.avdl + +package keybase1 + +import ( + "fmt" +) + +type Feature struct { + Allow bool `codec:"allow" json:"allow"` + DefaultValue bool `codec:"defaultValue" json:"defaultValue"` + Readonly bool `codec:"readonly" json:"readonly"` + Label string `codec:"label" json:"label"` +} + +func (o Feature) DeepCopy() Feature { + return Feature{ + Allow: o.Allow, + DefaultValue: o.DefaultValue, + Readonly: o.Readonly, + Label: o.Label, + } +} + +type GUIEntryFeatures struct { + ShowTyping Feature `codec:"showTyping" json:"showTyping"` +} + +func (o GUIEntryFeatures) DeepCopy() GUIEntryFeatures { + return GUIEntryFeatures{ + ShowTyping: o.ShowTyping.DeepCopy(), + } +} + +type PassphraseType int + +const ( + PassphraseType_NONE PassphraseType = 0 + PassphraseType_PAPER_KEY PassphraseType = 1 + PassphraseType_PASS_PHRASE PassphraseType = 2 + PassphraseType_VERIFY_PASS_PHRASE PassphraseType = 3 +) + +func (o PassphraseType) DeepCopy() PassphraseType { return o } + +var PassphraseTypeMap = map[string]PassphraseType{ + "NONE": 0, + "PAPER_KEY": 1, + "PASS_PHRASE": 2, + "VERIFY_PASS_PHRASE": 3, +} + +var PassphraseTypeRevMap = map[PassphraseType]string{ + 0: "NONE", + 1: "PAPER_KEY", + 2: "PASS_PHRASE", + 3: "VERIFY_PASS_PHRASE", +} + +func (e PassphraseType) String() string { + if v, ok := PassphraseTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type GUIEntryArg struct { + WindowTitle string `codec:"windowTitle" json:"windowTitle"` + Prompt string `codec:"prompt" json:"prompt"` + Username string `codec:"username" json:"username"` + SubmitLabel string `codec:"submitLabel" json:"submitLabel"` + CancelLabel string `codec:"cancelLabel" json:"cancelLabel"` + RetryLabel string `codec:"retryLabel" json:"retryLabel"` + Type PassphraseType `codec:"type" json:"type"` + Features GUIEntryFeatures `codec:"features" json:"features"` +} + +func (o GUIEntryArg) DeepCopy() GUIEntryArg { + return GUIEntryArg{ + WindowTitle: o.WindowTitle, + Prompt: o.Prompt, + Username: o.Username, + SubmitLabel: o.SubmitLabel, + CancelLabel: o.CancelLabel, + RetryLabel: o.RetryLabel, + Type: o.Type.DeepCopy(), + Features: o.Features.DeepCopy(), + } +} + +type GetPassphraseRes struct { + Passphrase string `codec:"passphrase" json:"passphrase"` + StoreSecret bool `codec:"storeSecret" json:"storeSecret"` +} + +func (o GetPassphraseRes) DeepCopy() GetPassphraseRes { + return GetPassphraseRes{ + Passphrase: o.Passphrase, + StoreSecret: o.StoreSecret, + } +} 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 new file mode 100644 index 00000000..c2869fa5 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/pgp.go @@ -0,0 +1,200 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/pgp.avdl + +package keybase1 + +import ( + "fmt" +) + +type SignMode int + +const ( + SignMode_ATTACHED SignMode = 0 + SignMode_DETACHED SignMode = 1 + SignMode_CLEAR SignMode = 2 +) + +func (o SignMode) DeepCopy() SignMode { return o } + +var SignModeMap = map[string]SignMode{ + "ATTACHED": 0, + "DETACHED": 1, + "CLEAR": 2, +} + +var SignModeRevMap = map[SignMode]string{ + 0: "ATTACHED", + 1: "DETACHED", + 2: "CLEAR", +} + +func (e SignMode) String() string { + if v, ok := SignModeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type PGPSignOptions struct { + KeyQuery string `codec:"keyQuery" json:"keyQuery"` + Mode SignMode `codec:"mode" json:"mode"` + BinaryIn bool `codec:"binaryIn" json:"binaryIn"` + BinaryOut bool `codec:"binaryOut" json:"binaryOut"` +} + +func (o PGPSignOptions) DeepCopy() PGPSignOptions { + return PGPSignOptions{ + KeyQuery: o.KeyQuery, + Mode: o.Mode.DeepCopy(), + BinaryIn: o.BinaryIn, + BinaryOut: o.BinaryOut, + } +} + +type PGPEncryptOptions struct { + Recipients []string `codec:"recipients" json:"recipients"` + NoSign bool `codec:"noSign" json:"noSign"` + NoSelf bool `codec:"noSelf" json:"noSelf"` + BinaryOut bool `codec:"binaryOut" json:"binaryOut"` + KeyQuery string `codec:"keyQuery" json:"keyQuery"` +} + +func (o PGPEncryptOptions) DeepCopy() PGPEncryptOptions { + return PGPEncryptOptions{ + Recipients: (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.Recipients), + NoSign: o.NoSign, + NoSelf: o.NoSelf, + BinaryOut: o.BinaryOut, + KeyQuery: o.KeyQuery, + } +} + +// PGPSigVerification is returned by pgpDecrypt and pgpVerify with information +// about the signature verification. If isSigned is false, there was no +// signature, and the rest of the fields should be ignored. +type PGPSigVerification struct { + IsSigned bool `codec:"isSigned" json:"isSigned"` + Verified bool `codec:"verified" json:"verified"` + Signer User `codec:"signer" json:"signer"` + SignKey PublicKey `codec:"signKey" json:"signKey"` +} + +func (o PGPSigVerification) DeepCopy() PGPSigVerification { + return PGPSigVerification{ + IsSigned: o.IsSigned, + Verified: o.Verified, + Signer: o.Signer.DeepCopy(), + SignKey: o.SignKey.DeepCopy(), + } +} + +type PGPDecryptOptions struct { + AssertSigned bool `codec:"assertSigned" json:"assertSigned"` + SignedBy string `codec:"signedBy" json:"signedBy"` +} + +func (o PGPDecryptOptions) DeepCopy() PGPDecryptOptions { + return PGPDecryptOptions{ + AssertSigned: o.AssertSigned, + SignedBy: o.SignedBy, + } +} + +type PGPVerifyOptions struct { + SignedBy string `codec:"signedBy" json:"signedBy"` + Signature []byte `codec:"signature" json:"signature"` +} + +func (o PGPVerifyOptions) DeepCopy() PGPVerifyOptions { + return PGPVerifyOptions{ + SignedBy: o.SignedBy, + Signature: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.Signature), + } +} + +type KeyInfo struct { + Fingerprint string `codec:"fingerprint" json:"fingerprint"` + Key string `codec:"key" json:"key"` + Desc string `codec:"desc" json:"desc"` +} + +func (o KeyInfo) DeepCopy() KeyInfo { + return KeyInfo{ + Fingerprint: o.Fingerprint, + Key: o.Key, + Desc: o.Desc, + } +} + +type PGPQuery struct { + Secret bool `codec:"secret" json:"secret"` + Query string `codec:"query" json:"query"` + ExactMatch bool `codec:"exactMatch" json:"exactMatch"` +} + +func (o PGPQuery) DeepCopy() PGPQuery { + return PGPQuery{ + Secret: o.Secret, + Query: o.Query, + ExactMatch: o.ExactMatch, + } +} + +type PGPCreateUids struct { + UseDefault bool `codec:"useDefault" json:"useDefault"` + Ids []PGPIdentity `codec:"ids" json:"ids"` +} + +func (o PGPCreateUids) DeepCopy() PGPCreateUids { + return PGPCreateUids{ + UseDefault: o.UseDefault, + Ids: (func(x []PGPIdentity) []PGPIdentity { + if x == nil { + return nil + } + ret := make([]PGPIdentity, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Ids), + } +} + +// Export all pgp keys in lksec, then if doPurge is true, remove the keys from lksec. +type PGPPurgeRes struct { + Filenames []string `codec:"filenames" json:"filenames"` +} + +func (o PGPPurgeRes) DeepCopy() PGPPurgeRes { + return PGPPurgeRes{ + Filenames: (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.Filenames), + } +} 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 new file mode 100644 index 00000000..1dd3ae74 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/pgp_ui.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..0ac2fe45 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/phone_numbers.go @@ -0,0 +1,61 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/phone_numbers.avdl + +package keybase1 + +// Phone number support for TOFU chats. +type UserPhoneNumber struct { + PhoneNumber PhoneNumber `codec:"phoneNumber" json:"phone_number"` + Verified bool `codec:"verified" json:"verified"` + Superseded bool `codec:"superseded" json:"superseded"` + Visibility IdentityVisibility `codec:"visibility" json:"visibility"` + Ctime UnixTime `codec:"ctime" json:"ctime"` +} + +func (o UserPhoneNumber) DeepCopy() UserPhoneNumber { + return UserPhoneNumber{ + PhoneNumber: o.PhoneNumber.DeepCopy(), + Verified: o.Verified, + Superseded: o.Superseded, + Visibility: o.Visibility.DeepCopy(), + Ctime: o.Ctime.DeepCopy(), + } +} + +type PhoneNumberLookupResult struct { + PhoneNumber RawPhoneNumber `codec:"phoneNumber" json:"phone_number"` + CoercedPhoneNumber PhoneNumber `codec:"coercedPhoneNumber" json:"coerced_phone_number"` + Err *string `codec:"err,omitempty" json:"err,omitempty"` + Uid *UID `codec:"uid,omitempty" json:"uid,omitempty"` +} + +func (o PhoneNumberLookupResult) DeepCopy() PhoneNumberLookupResult { + return PhoneNumberLookupResult{ + PhoneNumber: o.PhoneNumber.DeepCopy(), + CoercedPhoneNumber: o.CoercedPhoneNumber.DeepCopy(), + Err: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Err), + Uid: (func(x *UID) *UID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Uid), + } +} + +type PhoneNumberChangedMsg struct { + PhoneNumber PhoneNumber `codec:"phoneNumber" json:"phone"` +} + +func (o PhoneNumberChangedMsg) DeepCopy() PhoneNumberChangedMsg { + return PhoneNumberChangedMsg{ + PhoneNumber: o.PhoneNumber.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..3670f9ae --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/pprof.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..276acd63 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/process.go @@ -0,0 +1,73 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/process.avdl + +package keybase1 + +import ( + "fmt" +) + +type FileType int + +const ( + FileType_UNKNOWN FileType = 0 + FileType_DIRECTORY FileType = 1 + FileType_FILE FileType = 2 +) + +func (o FileType) DeepCopy() FileType { return o } + +var FileTypeMap = map[string]FileType{ + "UNKNOWN": 0, + "DIRECTORY": 1, + "FILE": 2, +} + +var FileTypeRevMap = map[FileType]string{ + 0: "UNKNOWN", + 1: "DIRECTORY", + 2: "FILE", +} + +func (e FileType) String() string { + if v, ok := FileTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type FileDescriptor struct { + Name string `codec:"name" json:"name"` + Type FileType `codec:"type" json:"type"` +} + +func (o FileDescriptor) DeepCopy() FileDescriptor { + return FileDescriptor{ + Name: o.Name, + Type: o.Type.DeepCopy(), + } +} + +type Process struct { + Pid string `codec:"pid" json:"pid"` + Command string `codec:"command" json:"command"` + FileDescriptors []FileDescriptor `codec:"fileDescriptors" json:"fileDescriptors"` +} + +func (o Process) DeepCopy() Process { + return Process{ + Pid: o.Pid, + Command: o.Command, + FileDescriptors: (func(x []FileDescriptor) []FileDescriptor { + if x == nil { + return nil + } + ret := make([]FileDescriptor, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.FileDescriptors), + } +} 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 new file mode 100644 index 00000000..4d5d8f5e --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/prove.go @@ -0,0 +1,30 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/prove.avdl + +package keybase1 + +type CheckProofStatus struct { + Found bool `codec:"found" json:"found"` + Status ProofStatus `codec:"status" json:"status"` + ProofText string `codec:"proofText" json:"proofText"` + State ProofState `codec:"state" json:"state"` +} + +func (o CheckProofStatus) DeepCopy() CheckProofStatus { + return CheckProofStatus{ + Found: o.Found, + Status: o.Status.DeepCopy(), + ProofText: o.ProofText, + State: o.State.DeepCopy(), + } +} + +type StartProofResult struct { + SigID SigID `codec:"sigID" json:"sigID"` +} + +func (o StartProofResult) DeepCopy() StartProofResult { + return StartProofResult{ + SigID: o.SigID.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..b263e16e --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/prove_common.go @@ -0,0 +1,439 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/prove_common.avdl + +package keybase1 + +import ( + "fmt" +) + +type ProofState int + +const ( + ProofState_NONE ProofState = 0 + ProofState_OK ProofState = 1 + ProofState_TEMP_FAILURE ProofState = 2 + ProofState_PERM_FAILURE ProofState = 3 + ProofState_LOOKING ProofState = 4 + ProofState_SUPERSEDED ProofState = 5 + ProofState_POSTED ProofState = 6 + ProofState_REVOKED ProofState = 7 + ProofState_DELETED ProofState = 8 + ProofState_UNKNOWN_TYPE ProofState = 9 + ProofState_SIG_HINT_MISSING ProofState = 10 + ProofState_UNCHECKED ProofState = 11 +) + +func (o ProofState) DeepCopy() ProofState { return o } + +var ProofStateMap = map[string]ProofState{ + "NONE": 0, + "OK": 1, + "TEMP_FAILURE": 2, + "PERM_FAILURE": 3, + "LOOKING": 4, + "SUPERSEDED": 5, + "POSTED": 6, + "REVOKED": 7, + "DELETED": 8, + "UNKNOWN_TYPE": 9, + "SIG_HINT_MISSING": 10, + "UNCHECKED": 11, +} + +var ProofStateRevMap = map[ProofState]string{ + 0: "NONE", + 1: "OK", + 2: "TEMP_FAILURE", + 3: "PERM_FAILURE", + 4: "LOOKING", + 5: "SUPERSEDED", + 6: "POSTED", + 7: "REVOKED", + 8: "DELETED", + 9: "UNKNOWN_TYPE", + 10: "SIG_HINT_MISSING", + 11: "UNCHECKED", +} + +func (e ProofState) String() string { + if v, ok := ProofStateRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +// 3: It's been found in the hunt, but not proven yet +// 1xx: Retryable soft errors; note that this will be put in the proof_cache, but won't +// be returned from the proof cache in most cases. Their freshness will always be +// RANCID. +// 2xx: Will likely result in a hard error, if repeated enough +// 3xx: Hard final errors +type ProofStatus int + +const ( + ProofStatus_NONE ProofStatus = 0 + ProofStatus_OK ProofStatus = 1 + ProofStatus_LOCAL ProofStatus = 2 + ProofStatus_FOUND ProofStatus = 3 + ProofStatus_BASE_ERROR ProofStatus = 100 + ProofStatus_HOST_UNREACHABLE ProofStatus = 101 + ProofStatus_PERMISSION_DENIED ProofStatus = 103 + ProofStatus_FAILED_PARSE ProofStatus = 106 + ProofStatus_DNS_ERROR ProofStatus = 107 + ProofStatus_AUTH_FAILED ProofStatus = 108 + ProofStatus_HTTP_429 ProofStatus = 129 + ProofStatus_HTTP_500 ProofStatus = 150 + ProofStatus_TIMEOUT ProofStatus = 160 + ProofStatus_INTERNAL_ERROR ProofStatus = 170 + ProofStatus_UNCHECKED ProofStatus = 171 + ProofStatus_MISSING_PVL ProofStatus = 172 + ProofStatus_BASE_HARD_ERROR ProofStatus = 200 + ProofStatus_NOT_FOUND ProofStatus = 201 + ProofStatus_CONTENT_FAILURE ProofStatus = 202 + ProofStatus_BAD_USERNAME ProofStatus = 203 + ProofStatus_BAD_REMOTE_ID ProofStatus = 204 + ProofStatus_TEXT_NOT_FOUND ProofStatus = 205 + ProofStatus_BAD_ARGS ProofStatus = 206 + ProofStatus_CONTENT_MISSING ProofStatus = 207 + ProofStatus_TITLE_NOT_FOUND ProofStatus = 208 + ProofStatus_SERVICE_ERROR ProofStatus = 209 + ProofStatus_TOR_SKIPPED ProofStatus = 210 + ProofStatus_TOR_INCOMPATIBLE ProofStatus = 211 + ProofStatus_HTTP_300 ProofStatus = 230 + ProofStatus_HTTP_400 ProofStatus = 240 + ProofStatus_HTTP_OTHER ProofStatus = 260 + ProofStatus_EMPTY_JSON ProofStatus = 270 + ProofStatus_DELETED ProofStatus = 301 + ProofStatus_SERVICE_DEAD ProofStatus = 302 + ProofStatus_BAD_SIGNATURE ProofStatus = 303 + ProofStatus_BAD_API_URL ProofStatus = 304 + ProofStatus_UNKNOWN_TYPE ProofStatus = 305 + ProofStatus_NO_HINT ProofStatus = 306 + ProofStatus_BAD_HINT_TEXT ProofStatus = 307 + ProofStatus_INVALID_PVL ProofStatus = 308 +) + +func (o ProofStatus) DeepCopy() ProofStatus { return o } + +var ProofStatusMap = map[string]ProofStatus{ + "NONE": 0, + "OK": 1, + "LOCAL": 2, + "FOUND": 3, + "BASE_ERROR": 100, + "HOST_UNREACHABLE": 101, + "PERMISSION_DENIED": 103, + "FAILED_PARSE": 106, + "DNS_ERROR": 107, + "AUTH_FAILED": 108, + "HTTP_429": 129, + "HTTP_500": 150, + "TIMEOUT": 160, + "INTERNAL_ERROR": 170, + "UNCHECKED": 171, + "MISSING_PVL": 172, + "BASE_HARD_ERROR": 200, + "NOT_FOUND": 201, + "CONTENT_FAILURE": 202, + "BAD_USERNAME": 203, + "BAD_REMOTE_ID": 204, + "TEXT_NOT_FOUND": 205, + "BAD_ARGS": 206, + "CONTENT_MISSING": 207, + "TITLE_NOT_FOUND": 208, + "SERVICE_ERROR": 209, + "TOR_SKIPPED": 210, + "TOR_INCOMPATIBLE": 211, + "HTTP_300": 230, + "HTTP_400": 240, + "HTTP_OTHER": 260, + "EMPTY_JSON": 270, + "DELETED": 301, + "SERVICE_DEAD": 302, + "BAD_SIGNATURE": 303, + "BAD_API_URL": 304, + "UNKNOWN_TYPE": 305, + "NO_HINT": 306, + "BAD_HINT_TEXT": 307, + "INVALID_PVL": 308, +} + +var ProofStatusRevMap = map[ProofStatus]string{ + 0: "NONE", + 1: "OK", + 2: "LOCAL", + 3: "FOUND", + 100: "BASE_ERROR", + 101: "HOST_UNREACHABLE", + 103: "PERMISSION_DENIED", + 106: "FAILED_PARSE", + 107: "DNS_ERROR", + 108: "AUTH_FAILED", + 129: "HTTP_429", + 150: "HTTP_500", + 160: "TIMEOUT", + 170: "INTERNAL_ERROR", + 171: "UNCHECKED", + 172: "MISSING_PVL", + 200: "BASE_HARD_ERROR", + 201: "NOT_FOUND", + 202: "CONTENT_FAILURE", + 203: "BAD_USERNAME", + 204: "BAD_REMOTE_ID", + 205: "TEXT_NOT_FOUND", + 206: "BAD_ARGS", + 207: "CONTENT_MISSING", + 208: "TITLE_NOT_FOUND", + 209: "SERVICE_ERROR", + 210: "TOR_SKIPPED", + 211: "TOR_INCOMPATIBLE", + 230: "HTTP_300", + 240: "HTTP_400", + 260: "HTTP_OTHER", + 270: "EMPTY_JSON", + 301: "DELETED", + 302: "SERVICE_DEAD", + 303: "BAD_SIGNATURE", + 304: "BAD_API_URL", + 305: "UNKNOWN_TYPE", + 306: "NO_HINT", + 307: "BAD_HINT_TEXT", + 308: "INVALID_PVL", +} + +func (e ProofStatus) String() string { + if v, ok := ProofStatusRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ProofType int + +const ( + ProofType_NONE ProofType = 0 + ProofType_KEYBASE ProofType = 1 + ProofType_TWITTER ProofType = 2 + ProofType_GITHUB ProofType = 3 + ProofType_REDDIT ProofType = 4 + ProofType_COINBASE ProofType = 5 + ProofType_HACKERNEWS ProofType = 6 + ProofType_FACEBOOK ProofType = 8 + ProofType_GENERIC_SOCIAL ProofType = 9 + ProofType_GENERIC_WEB_SITE ProofType = 1000 + ProofType_DNS ProofType = 1001 + ProofType_PGP ProofType = 1002 + ProofType_ROOTER ProofType = 100001 +) + +func (o ProofType) DeepCopy() ProofType { return o } + +var ProofTypeMap = map[string]ProofType{ + "NONE": 0, + "KEYBASE": 1, + "TWITTER": 2, + "GITHUB": 3, + "REDDIT": 4, + "COINBASE": 5, + "HACKERNEWS": 6, + "FACEBOOK": 8, + "GENERIC_SOCIAL": 9, + "GENERIC_WEB_SITE": 1000, + "DNS": 1001, + "PGP": 1002, + "ROOTER": 100001, +} + +var ProofTypeRevMap = map[ProofType]string{ + 0: "NONE", + 1: "KEYBASE", + 2: "TWITTER", + 3: "GITHUB", + 4: "REDDIT", + 5: "COINBASE", + 6: "HACKERNEWS", + 8: "FACEBOOK", + 9: "GENERIC_SOCIAL", + 1000: "GENERIC_WEB_SITE", + 1001: "DNS", + 1002: "PGP", + 100001: "ROOTER", +} + +func (e ProofType) String() string { + if v, ok := ProofTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type SelectorEntry struct { + IsIndex bool `codec:"isIndex" json:"isIndex"` + Index int `codec:"index" json:"index"` + IsKey bool `codec:"isKey" json:"isKey"` + Key string `codec:"key" json:"key"` + IsAll bool `codec:"isAll" json:"isAll"` + IsContents bool `codec:"isContents" json:"isContents"` +} + +func (o SelectorEntry) DeepCopy() SelectorEntry { + return SelectorEntry{ + IsIndex: o.IsIndex, + Index: o.Index, + IsKey: o.IsKey, + Key: o.Key, + IsAll: o.IsAll, + IsContents: o.IsContents, + } +} + +type ParamProofJSON struct { + SigHash SigID `codec:"sigHash" json:"sig_hash"` + KbUsername string `codec:"kbUsername" json:"kb_username"` +} + +func (o ParamProofJSON) DeepCopy() ParamProofJSON { + return ParamProofJSON{ + SigHash: o.SigHash.DeepCopy(), + KbUsername: o.KbUsername, + } +} + +type ParamProofUsernameConfig struct { + Re string `codec:"re" json:"re"` + Min int `codec:"min" json:"min"` + Max int `codec:"max" json:"max"` +} + +func (o ParamProofUsernameConfig) DeepCopy() ParamProofUsernameConfig { + return ParamProofUsernameConfig{ + Re: o.Re, + Min: o.Min, + Max: o.Max, + } +} + +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"` + PrefillUrl string `codec:"prefillUrl" json:"prefill_url"` + ProfileUrl string `codec:"profileUrl" json:"profile_url"` + CheckUrl string `codec:"checkUrl" json:"check_url"` + CheckPath []SelectorEntry `codec:"checkPath" json:"check_path"` + AvatarPath []SelectorEntry `codec:"avatarPath" json:"avatar_path"` +} + +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), + Description: o.Description, + UsernameConfig: o.UsernameConfig.DeepCopy(), + BrandColor: o.BrandColor, + PrefillUrl: o.PrefillUrl, + ProfileUrl: o.ProfileUrl, + CheckUrl: o.CheckUrl, + CheckPath: (func(x []SelectorEntry) []SelectorEntry { + if x == nil { + return nil + } + ret := make([]SelectorEntry, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.CheckPath), + AvatarPath: (func(x []SelectorEntry) []SelectorEntry { + if x == nil { + return nil + } + ret := make([]SelectorEntry, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.AvatarPath), + } +} + +type ServiceDisplayConfig struct { + CreationDisabled bool `codec:"creationDisabled" json:"creation_disabled"` + Priority int `codec:"priority" json:"priority"` + Key string `codec:"key" json:"key"` + Group *string `codec:"group,omitempty" json:"group,omitempty"` + New bool `codec:"new" json:"new"` + LogoKey string `codec:"logoKey" json:"logo_key"` +} + +func (o ServiceDisplayConfig) DeepCopy() ServiceDisplayConfig { + return ServiceDisplayConfig{ + CreationDisabled: o.CreationDisabled, + Priority: o.Priority, + Key: o.Key, + Group: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Group), + New: o.New, + LogoKey: o.LogoKey, + } +} + +type ExternalServiceConfig struct { + SchemaVersion int `codec:"schemaVersion" json:"schema_version"` + Display *ServiceDisplayConfig `codec:"display,omitempty" json:"display,omitempty"` + Config *ParamProofServiceConfig `codec:"config,omitempty" json:"config,omitempty"` +} + +func (o ExternalServiceConfig) DeepCopy() ExternalServiceConfig { + return ExternalServiceConfig{ + SchemaVersion: o.SchemaVersion, + Display: (func(x *ServiceDisplayConfig) *ServiceDisplayConfig { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Display), + Config: (func(x *ParamProofServiceConfig) *ParamProofServiceConfig { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Config), + } +} 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 new file mode 100644 index 00000000..a9dc6a3b --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/prove_ui.go @@ -0,0 +1,86 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/prove_ui.avdl + +package keybase1 + +import ( + "fmt" +) + +type PromptOverwriteType int + +const ( + PromptOverwriteType_SOCIAL PromptOverwriteType = 0 + PromptOverwriteType_SITE PromptOverwriteType = 1 +) + +func (o PromptOverwriteType) DeepCopy() PromptOverwriteType { return o } + +var PromptOverwriteTypeMap = map[string]PromptOverwriteType{ + "SOCIAL": 0, + "SITE": 1, +} + +var PromptOverwriteTypeRevMap = map[PromptOverwriteType]string{ + 0: "SOCIAL", + 1: "SITE", +} + +func (e PromptOverwriteType) String() string { + if v, ok := PromptOverwriteTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ProveParameters struct { + LogoFull []SizedImage `codec:"logoFull" json:"logoFull"` + LogoBlack []SizedImage `codec:"logoBlack" json:"logoBlack"` + LogoWhite []SizedImage `codec:"logoWhite" json:"logoWhite"` + Title string `codec:"title" json:"title"` + Subtext string `codec:"subtext" json:"subtext"` + Suffix string `codec:"suffix" json:"suffix"` + ButtonLabel string `codec:"buttonLabel" json:"buttonLabel"` +} + +func (o ProveParameters) DeepCopy() ProveParameters { + return ProveParameters{ + LogoFull: (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.LogoFull), + LogoBlack: (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.LogoBlack), + LogoWhite: (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.LogoWhite), + Title: o.Title, + Subtext: o.Subtext, + Suffix: o.Suffix, + ButtonLabel: o.ButtonLabel, + } +} 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 new file mode 100644 index 00000000..af88e609 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/provision_ui.go @@ -0,0 +1,116 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/provision_ui.avdl + +package keybase1 + +import ( + "fmt" +) + +type ProvisionMethod int + +const ( + ProvisionMethod_DEVICE ProvisionMethod = 0 + ProvisionMethod_PAPER_KEY ProvisionMethod = 1 + ProvisionMethod_PASSPHRASE ProvisionMethod = 2 + ProvisionMethod_GPG_IMPORT ProvisionMethod = 3 + ProvisionMethod_GPG_SIGN ProvisionMethod = 4 +) + +func (o ProvisionMethod) DeepCopy() ProvisionMethod { return o } + +var ProvisionMethodMap = map[string]ProvisionMethod{ + "DEVICE": 0, + "PAPER_KEY": 1, + "PASSPHRASE": 2, + "GPG_IMPORT": 3, + "GPG_SIGN": 4, +} + +var ProvisionMethodRevMap = map[ProvisionMethod]string{ + 0: "DEVICE", + 1: "PAPER_KEY", + 2: "PASSPHRASE", + 3: "GPG_IMPORT", + 4: "GPG_SIGN", +} + +func (e ProvisionMethod) String() string { + if v, ok := ProvisionMethodRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type GPGMethod int + +const ( + GPGMethod_GPG_NONE GPGMethod = 0 + GPGMethod_GPG_IMPORT GPGMethod = 1 + GPGMethod_GPG_SIGN GPGMethod = 2 +) + +func (o GPGMethod) DeepCopy() GPGMethod { return o } + +var GPGMethodMap = map[string]GPGMethod{ + "GPG_NONE": 0, + "GPG_IMPORT": 1, + "GPG_SIGN": 2, +} + +var GPGMethodRevMap = map[GPGMethod]string{ + 0: "GPG_NONE", + 1: "GPG_IMPORT", + 2: "GPG_SIGN", +} + +func (e GPGMethod) String() string { + if v, ok := GPGMethodRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ChooseType int + +const ( + ChooseType_EXISTING_DEVICE ChooseType = 0 + ChooseType_NEW_DEVICE ChooseType = 1 +) + +func (o ChooseType) DeepCopy() ChooseType { return o } + +var ChooseTypeMap = map[string]ChooseType{ + "EXISTING_DEVICE": 0, + "NEW_DEVICE": 1, +} + +var ChooseTypeRevMap = map[ChooseType]string{ + 0: "EXISTING_DEVICE", + 1: "NEW_DEVICE", +} + +func (e ChooseType) String() string { + if v, ok := ChooseTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +// SecretResponse should be returned by DisplayAndPromptSecret. Use either secret or phrase. +type SecretResponse struct { + Secret []byte `codec:"secret" json:"secret"` + Phrase string `codec:"phrase" json:"phrase"` +} + +func (o SecretResponse) DeepCopy() SecretResponse { + return SecretResponse{ + Secret: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.Secret), + Phrase: o.Phrase, + } +} 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 new file mode 100644 index 00000000..4656fae8 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/quota.go @@ -0,0 +1,20 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/quota.avdl + +package keybase1 + +type VerifySessionRes struct { + Uid UID `codec:"uid" json:"uid"` + Sid string `codec:"sid" json:"sid"` + Generated int `codec:"generated" json:"generated"` + Lifetime int `codec:"lifetime" json:"lifetime"` +} + +func (o VerifySessionRes) DeepCopy() VerifySessionRes { + return VerifySessionRes{ + Uid: o.Uid.DeepCopy(), + Sid: o.Sid, + Generated: o.Generated, + Lifetime: o.Lifetime, + } +} 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 new file mode 100644 index 00000000..20a8d4f2 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/reachability.go @@ -0,0 +1,47 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/reachability.avdl + +package keybase1 + +import ( + "fmt" +) + +type Reachable int + +const ( + Reachable_UNKNOWN Reachable = 0 + Reachable_YES Reachable = 1 + Reachable_NO Reachable = 2 +) + +func (o Reachable) DeepCopy() Reachable { return o } + +var ReachableMap = map[string]Reachable{ + "UNKNOWN": 0, + "YES": 1, + "NO": 2, +} + +var ReachableRevMap = map[Reachable]string{ + 0: "UNKNOWN", + 1: "YES", + 2: "NO", +} + +func (e Reachable) String() string { + if v, ok := ReachableRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type Reachability struct { + Reachable Reachable `codec:"reachable" json:"reachable"` +} + +func (o Reachability) DeepCopy() Reachability { + return Reachability{ + Reachable: o.Reachable.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..d5e60c42 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/rekey.go @@ -0,0 +1,169 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/rekey.avdl + +package keybase1 + +import ( + "fmt" +) + +type TLF struct { + Id TLFID `codec:"id" json:"id"` + Name string `codec:"name" json:"name"` + Writers []string `codec:"writers" json:"writers"` + Readers []string `codec:"readers" json:"readers"` + IsPrivate bool `codec:"isPrivate" json:"isPrivate"` +} + +func (o TLF) DeepCopy() TLF { + return TLF{ + Id: o.Id.DeepCopy(), + Name: o.Name, + 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), + IsPrivate: o.IsPrivate, + } +} + +type ProblemTLF struct { + Tlf TLF `codec:"tlf" json:"tlf"` + Score int `codec:"score" json:"score"` + Solution_kids []KID `codec:"solution_kids" json:"solution_kids"` +} + +func (o ProblemTLF) DeepCopy() ProblemTLF { + return ProblemTLF{ + Tlf: o.Tlf.DeepCopy(), + Score: o.Score, + Solution_kids: (func(x []KID) []KID { + if x == nil { + return nil + } + ret := make([]KID, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Solution_kids), + } +} + +// ProblemSet is for a particular (user,kid) that initiated a rekey problem. +// This problem consists of one or more problem TLFs, which are individually scored +// and have attendant solutions --- devices that if they came online can rekey and +// solve the ProblemTLF. +type ProblemSet struct { + User User `codec:"user" json:"user"` + Kid KID `codec:"kid" json:"kid"` + Tlfs []ProblemTLF `codec:"tlfs" json:"tlfs"` +} + +func (o ProblemSet) DeepCopy() ProblemSet { + return ProblemSet{ + User: o.User.DeepCopy(), + Kid: o.Kid.DeepCopy(), + Tlfs: (func(x []ProblemTLF) []ProblemTLF { + if x == nil { + return nil + } + ret := make([]ProblemTLF, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Tlfs), + } +} + +type ProblemSetDevices struct { + ProblemSet ProblemSet `codec:"problemSet" json:"problemSet"` + Devices []Device `codec:"devices" json:"devices"` +} + +func (o ProblemSetDevices) DeepCopy() ProblemSetDevices { + return ProblemSetDevices{ + ProblemSet: o.ProblemSet.DeepCopy(), + Devices: (func(x []Device) []Device { + if x == nil { + return nil + } + ret := make([]Device, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Devices), + } +} + +type Outcome int + +const ( + Outcome_NONE Outcome = 0 + Outcome_FIXED Outcome = 1 + Outcome_IGNORED Outcome = 2 +) + +func (o Outcome) DeepCopy() Outcome { return o } + +var OutcomeMap = map[string]Outcome{ + "NONE": 0, + "FIXED": 1, + "IGNORED": 2, +} + +var OutcomeRevMap = map[Outcome]string{ + 0: "NONE", + 1: "FIXED", + 2: "IGNORED", +} + +func (e Outcome) String() string { + if v, ok := OutcomeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type RevokeWarning struct { + EndangeredTLFs []TLF `codec:"endangeredTLFs" json:"endangeredTLFs"` +} + +func (o RevokeWarning) DeepCopy() RevokeWarning { + return RevokeWarning{ + EndangeredTLFs: (func(x []TLF) []TLF { + if x == nil { + return nil + } + ret := make([]TLF, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.EndangeredTLFs), + } +} 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 new file mode 100644 index 00000000..83798426 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/rekey_ui.go @@ -0,0 +1,67 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/rekey_ui.avdl + +package keybase1 + +import ( + "fmt" +) + +type RekeyEventType int + +const ( + RekeyEventType_NONE RekeyEventType = 0 + RekeyEventType_NOT_LOGGED_IN RekeyEventType = 1 + RekeyEventType_API_ERROR RekeyEventType = 2 + RekeyEventType_NO_PROBLEMS RekeyEventType = 3 + RekeyEventType_LOAD_ME_ERROR RekeyEventType = 4 + RekeyEventType_CURRENT_DEVICE_CAN_REKEY RekeyEventType = 5 + RekeyEventType_DEVICE_LOAD_ERROR RekeyEventType = 6 + RekeyEventType_HARASS RekeyEventType = 7 + RekeyEventType_NO_GREGOR_MESSAGES RekeyEventType = 8 +) + +func (o RekeyEventType) DeepCopy() RekeyEventType { return o } + +var RekeyEventTypeMap = map[string]RekeyEventType{ + "NONE": 0, + "NOT_LOGGED_IN": 1, + "API_ERROR": 2, + "NO_PROBLEMS": 3, + "LOAD_ME_ERROR": 4, + "CURRENT_DEVICE_CAN_REKEY": 5, + "DEVICE_LOAD_ERROR": 6, + "HARASS": 7, + "NO_GREGOR_MESSAGES": 8, +} + +var RekeyEventTypeRevMap = map[RekeyEventType]string{ + 0: "NONE", + 1: "NOT_LOGGED_IN", + 2: "API_ERROR", + 3: "NO_PROBLEMS", + 4: "LOAD_ME_ERROR", + 5: "CURRENT_DEVICE_CAN_REKEY", + 6: "DEVICE_LOAD_ERROR", + 7: "HARASS", + 8: "NO_GREGOR_MESSAGES", +} + +func (e RekeyEventType) String() string { + if v, ok := RekeyEventTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type RekeyEvent struct { + EventType RekeyEventType `codec:"eventType" json:"eventType"` + InterruptType int `codec:"interruptType" json:"interruptType"` +} + +func (o RekeyEvent) DeepCopy() RekeyEvent { + return RekeyEvent{ + EventType: o.EventType.DeepCopy(), + InterruptType: o.InterruptType, + } +} 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 new file mode 100644 index 00000000..c7d28b81 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/reset.go @@ -0,0 +1,118 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/reset.avdl + +package keybase1 + +import ( + "fmt" +) + +type SHA512 []byte + +func (o SHA512) DeepCopy() SHA512 { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} + +type ResetType int + +const ( + ResetType_NONE ResetType = 0 + ResetType_RESET ResetType = 1 + ResetType_DELETE ResetType = 2 +) + +func (o ResetType) DeepCopy() ResetType { return o } + +var ResetTypeMap = map[string]ResetType{ + "NONE": 0, + "RESET": 1, + "DELETE": 2, +} + +var ResetTypeRevMap = map[ResetType]string{ + 0: "NONE", + 1: "RESET", + 2: "DELETE", +} + +func (e ResetType) String() string { + if v, ok := ResetTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ResetMerkleRoot struct { + HashMeta HashMeta `codec:"hashMeta" json:"hash_meta"` + Seqno Seqno `codec:"seqno" json:"seqno"` +} + +func (o ResetMerkleRoot) DeepCopy() ResetMerkleRoot { + return ResetMerkleRoot{ + HashMeta: o.HashMeta.DeepCopy(), + Seqno: o.Seqno.DeepCopy(), + } +} + +type ResetPrev struct { + EldestKID *KID `codec:"eldestKID,omitempty" json:"eldest_kid,omitempty"` + LastSeqno Seqno `codec:"lastSeqno" json:"public_seqno"` + Reset SHA512 `codec:"reset" json:"reset"` +} + +func (o ResetPrev) DeepCopy() ResetPrev { + return ResetPrev{ + EldestKID: (func(x *KID) *KID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.EldestKID), + LastSeqno: o.LastSeqno.DeepCopy(), + Reset: o.Reset.DeepCopy(), + } +} + +type ResetLink struct { + Ctime UnixTime `codec:"ctime" json:"ctime"` + MerkleRoot ResetMerkleRoot `codec:"merkleRoot" json:"merkle_root"` + Prev ResetPrev `codec:"prev" json:"prev"` + ResetSeqno Seqno `codec:"resetSeqno" json:"reset_seqno"` + Type ResetType `codec:"type" json:"type"` + Uid UID `codec:"uid" json:"uid"` +} + +func (o ResetLink) DeepCopy() ResetLink { + return ResetLink{ + Ctime: o.Ctime.DeepCopy(), + MerkleRoot: o.MerkleRoot.DeepCopy(), + Prev: o.Prev.DeepCopy(), + ResetSeqno: o.ResetSeqno.DeepCopy(), + Type: o.Type.DeepCopy(), + Uid: o.Uid.DeepCopy(), + } +} + +type ResetSummary struct { + Ctime UnixTime `codec:"ctime" json:"ctime"` + MerkleRoot ResetMerkleRoot `codec:"merkleRoot" json:"merkleRoot"` + ResetSeqno Seqno `codec:"resetSeqno" json:"resetSeqno"` + EldestSeqno Seqno `codec:"eldestSeqno" json:"eldestSeqno"` + Type ResetType `codec:"type" json:"type"` +} + +func (o ResetSummary) DeepCopy() ResetSummary { + return ResetSummary{ + Ctime: o.Ctime.DeepCopy(), + MerkleRoot: o.MerkleRoot.DeepCopy(), + ResetSeqno: o.ResetSeqno.DeepCopy(), + EldestSeqno: o.EldestSeqno.DeepCopy(), + Type: o.Type.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..0f7faab8 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/revoke.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..994648cd --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/saltpack.go @@ -0,0 +1,280 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/saltpack.avdl + +package keybase1 + +import ( + "fmt" +) + +type AuthenticityType int + +const ( + AuthenticityType_SIGNED AuthenticityType = 0 + AuthenticityType_REPUDIABLE AuthenticityType = 1 + AuthenticityType_ANONYMOUS AuthenticityType = 2 +) + +func (o AuthenticityType) DeepCopy() AuthenticityType { return o } + +var AuthenticityTypeMap = map[string]AuthenticityType{ + "SIGNED": 0, + "REPUDIABLE": 1, + "ANONYMOUS": 2, +} + +var AuthenticityTypeRevMap = map[AuthenticityType]string{ + 0: "SIGNED", + 1: "REPUDIABLE", + 2: "ANONYMOUS", +} + +func (e AuthenticityType) String() string { + if v, ok := AuthenticityTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type SaltpackEncryptOptions struct { + Recipients []string `codec:"recipients" json:"recipients"` + TeamRecipients []string `codec:"teamRecipients" json:"teamRecipients"` + AuthenticityType AuthenticityType `codec:"authenticityType" json:"authenticityType"` + UseEntityKeys bool `codec:"useEntityKeys" json:"useEntityKeys"` + UseDeviceKeys bool `codec:"useDeviceKeys" json:"useDeviceKeys"` + UsePaperKeys bool `codec:"usePaperKeys" json:"usePaperKeys"` + NoSelfEncrypt bool `codec:"noSelfEncrypt" json:"noSelfEncrypt"` + Binary bool `codec:"binary" json:"binary"` + SaltpackVersion int `codec:"saltpackVersion" json:"saltpackVersion"` + UseKBFSKeysOnlyForTesting bool `codec:"useKBFSKeysOnlyForTesting" json:"useKBFSKeysOnlyForTesting"` +} + +func (o SaltpackEncryptOptions) DeepCopy() SaltpackEncryptOptions { + return SaltpackEncryptOptions{ + Recipients: (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.Recipients), + TeamRecipients: (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.TeamRecipients), + AuthenticityType: o.AuthenticityType.DeepCopy(), + UseEntityKeys: o.UseEntityKeys, + UseDeviceKeys: o.UseDeviceKeys, + UsePaperKeys: o.UsePaperKeys, + NoSelfEncrypt: o.NoSelfEncrypt, + Binary: o.Binary, + SaltpackVersion: o.SaltpackVersion, + UseKBFSKeysOnlyForTesting: o.UseKBFSKeysOnlyForTesting, + } +} + +type SaltpackDecryptOptions struct { + Interactive bool `codec:"interactive" json:"interactive"` + ForceRemoteCheck bool `codec:"forceRemoteCheck" json:"forceRemoteCheck"` + UsePaperKey bool `codec:"usePaperKey" json:"usePaperKey"` +} + +func (o SaltpackDecryptOptions) DeepCopy() SaltpackDecryptOptions { + return SaltpackDecryptOptions{ + Interactive: o.Interactive, + ForceRemoteCheck: o.ForceRemoteCheck, + UsePaperKey: o.UsePaperKey, + } +} + +type SaltpackSignOptions struct { + Detached bool `codec:"detached" json:"detached"` + Binary bool `codec:"binary" json:"binary"` + SaltpackVersion int `codec:"saltpackVersion" json:"saltpackVersion"` +} + +func (o SaltpackSignOptions) DeepCopy() SaltpackSignOptions { + return SaltpackSignOptions{ + Detached: o.Detached, + Binary: o.Binary, + SaltpackVersion: o.SaltpackVersion, + } +} + +type SaltpackVerifyOptions struct { + SignedBy string `codec:"signedBy" json:"signedBy"` + Signature []byte `codec:"signature" json:"signature"` +} + +func (o SaltpackVerifyOptions) DeepCopy() SaltpackVerifyOptions { + return SaltpackVerifyOptions{ + SignedBy: o.SignedBy, + Signature: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.Signature), + } +} + +type SaltpackEncryptResult struct { + UsedUnresolvedSBS bool `codec:"usedUnresolvedSBS" json:"usedUnresolvedSBS"` + UnresolvedSBSAssertion string `codec:"unresolvedSBSAssertion" json:"unresolvedSBSAssertion"` +} + +func (o SaltpackEncryptResult) DeepCopy() SaltpackEncryptResult { + return SaltpackEncryptResult{ + UsedUnresolvedSBS: o.UsedUnresolvedSBS, + UnresolvedSBSAssertion: o.UnresolvedSBSAssertion, + } +} + +type SaltpackEncryptedMessageInfo struct { + Devices []Device `codec:"devices" json:"devices"` + NumAnonReceivers int `codec:"numAnonReceivers" json:"numAnonReceivers"` + ReceiverIsAnon bool `codec:"receiverIsAnon" json:"receiverIsAnon"` + Sender SaltpackSender `codec:"sender" json:"sender"` +} + +func (o SaltpackEncryptedMessageInfo) DeepCopy() SaltpackEncryptedMessageInfo { + return SaltpackEncryptedMessageInfo{ + Devices: (func(x []Device) []Device { + if x == nil { + return nil + } + ret := make([]Device, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Devices), + NumAnonReceivers: o.NumAnonReceivers, + ReceiverIsAnon: o.ReceiverIsAnon, + Sender: o.Sender.DeepCopy(), + } +} + +type SaltpackFrontendEncryptOptions struct { + Recipients []string `codec:"recipients" json:"recipients"` + Signed bool `codec:"signed" json:"signed"` + IncludeSelf bool `codec:"includeSelf" json:"includeSelf"` +} + +func (o SaltpackFrontendEncryptOptions) DeepCopy() SaltpackFrontendEncryptOptions { + return SaltpackFrontendEncryptOptions{ + Recipients: (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.Recipients), + Signed: o.Signed, + IncludeSelf: o.IncludeSelf, + } +} + +type SaltpackEncryptStringResult struct { + UsedUnresolvedSBS bool `codec:"usedUnresolvedSBS" json:"usedUnresolvedSBS"` + UnresolvedSBSAssertion string `codec:"unresolvedSBSAssertion" json:"unresolvedSBSAssertion"` + Ciphertext string `codec:"ciphertext" json:"ciphertext"` +} + +func (o SaltpackEncryptStringResult) DeepCopy() SaltpackEncryptStringResult { + return SaltpackEncryptStringResult{ + UsedUnresolvedSBS: o.UsedUnresolvedSBS, + UnresolvedSBSAssertion: o.UnresolvedSBSAssertion, + Ciphertext: o.Ciphertext, + } +} + +type SaltpackEncryptFileResult struct { + UsedUnresolvedSBS bool `codec:"usedUnresolvedSBS" json:"usedUnresolvedSBS"` + UnresolvedSBSAssertion string `codec:"unresolvedSBSAssertion" json:"unresolvedSBSAssertion"` + Filename string `codec:"filename" json:"filename"` +} + +func (o SaltpackEncryptFileResult) DeepCopy() SaltpackEncryptFileResult { + return SaltpackEncryptFileResult{ + UsedUnresolvedSBS: o.UsedUnresolvedSBS, + UnresolvedSBSAssertion: o.UnresolvedSBSAssertion, + Filename: o.Filename, + } +} + +type SaltpackPlaintextResult struct { + Info SaltpackEncryptedMessageInfo `codec:"info" json:"info"` + Plaintext string `codec:"plaintext" json:"plaintext"` + Signed bool `codec:"signed" json:"signed"` +} + +func (o SaltpackPlaintextResult) DeepCopy() SaltpackPlaintextResult { + return SaltpackPlaintextResult{ + Info: o.Info.DeepCopy(), + Plaintext: o.Plaintext, + Signed: o.Signed, + } +} + +type SaltpackFileResult struct { + Info SaltpackEncryptedMessageInfo `codec:"info" json:"info"` + DecryptedFilename string `codec:"decryptedFilename" json:"decryptedFilename"` + Signed bool `codec:"signed" json:"signed"` +} + +func (o SaltpackFileResult) DeepCopy() SaltpackFileResult { + return SaltpackFileResult{ + Info: o.Info.DeepCopy(), + DecryptedFilename: o.DecryptedFilename, + Signed: o.Signed, + } +} + +type SaltpackVerifyResult struct { + SigningKID KID `codec:"signingKID" json:"signingKID"` + Sender SaltpackSender `codec:"sender" json:"sender"` + Plaintext string `codec:"plaintext" json:"plaintext"` + Verified bool `codec:"verified" json:"verified"` +} + +func (o SaltpackVerifyResult) DeepCopy() SaltpackVerifyResult { + return SaltpackVerifyResult{ + SigningKID: o.SigningKID.DeepCopy(), + Sender: o.Sender.DeepCopy(), + Plaintext: o.Plaintext, + Verified: o.Verified, + } +} + +type SaltpackVerifyFileResult struct { + SigningKID KID `codec:"signingKID" json:"signingKID"` + Sender SaltpackSender `codec:"sender" json:"sender"` + VerifiedFilename string `codec:"verifiedFilename" json:"verifiedFilename"` + Verified bool `codec:"verified" json:"verified"` +} + +func (o SaltpackVerifyFileResult) DeepCopy() SaltpackVerifyFileResult { + return SaltpackVerifyFileResult{ + SigningKID: o.SigningKID.DeepCopy(), + Sender: o.Sender.DeepCopy(), + VerifiedFilename: o.VerifiedFilename, + Verified: o.Verified, + } +} 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 new file mode 100644 index 00000000..39748b8e --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/saltpack_ui.go @@ -0,0 +1,66 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/saltpack_ui.avdl + +package keybase1 + +import ( + "fmt" +) + +type SaltpackSenderType int + +const ( + SaltpackSenderType_NOT_TRACKED SaltpackSenderType = 0 + SaltpackSenderType_UNKNOWN SaltpackSenderType = 1 + SaltpackSenderType_ANONYMOUS SaltpackSenderType = 2 + SaltpackSenderType_TRACKING_BROKE SaltpackSenderType = 3 + SaltpackSenderType_TRACKING_OK SaltpackSenderType = 4 + SaltpackSenderType_SELF SaltpackSenderType = 5 + SaltpackSenderType_REVOKED SaltpackSenderType = 6 + SaltpackSenderType_EXPIRED SaltpackSenderType = 7 +) + +func (o SaltpackSenderType) DeepCopy() SaltpackSenderType { return o } + +var SaltpackSenderTypeMap = map[string]SaltpackSenderType{ + "NOT_TRACKED": 0, + "UNKNOWN": 1, + "ANONYMOUS": 2, + "TRACKING_BROKE": 3, + "TRACKING_OK": 4, + "SELF": 5, + "REVOKED": 6, + "EXPIRED": 7, +} + +var SaltpackSenderTypeRevMap = map[SaltpackSenderType]string{ + 0: "NOT_TRACKED", + 1: "UNKNOWN", + 2: "ANONYMOUS", + 3: "TRACKING_BROKE", + 4: "TRACKING_OK", + 5: "SELF", + 6: "REVOKED", + 7: "EXPIRED", +} + +func (e SaltpackSenderType) String() string { + if v, ok := SaltpackSenderTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type SaltpackSender struct { + Uid UID `codec:"uid" json:"uid"` + Username string `codec:"username" json:"username"` + SenderType SaltpackSenderType `codec:"senderType" json:"senderType"` +} + +func (o SaltpackSender) DeepCopy() SaltpackSender { + return SaltpackSender{ + Uid: o.Uid.DeepCopy(), + Username: o.Username, + 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 new file mode 100644 index 00000000..61e1140d --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/scanproofs.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..d48e8b48 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/secret_ui.go @@ -0,0 +1,40 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/secret_ui.avdl + +package keybase1 + +type SecretEntryArg struct { + Desc string `codec:"desc" json:"desc"` + Prompt string `codec:"prompt" json:"prompt"` + Err string `codec:"err" json:"err"` + Cancel string `codec:"cancel" json:"cancel"` + Ok string `codec:"ok" json:"ok"` + Reason string `codec:"reason" json:"reason"` + ShowTyping bool `codec:"showTyping" json:"showTyping"` +} + +func (o SecretEntryArg) DeepCopy() SecretEntryArg { + return SecretEntryArg{ + Desc: o.Desc, + Prompt: o.Prompt, + Err: o.Err, + Cancel: o.Cancel, + Ok: o.Ok, + Reason: o.Reason, + ShowTyping: o.ShowTyping, + } +} + +type SecretEntryRes struct { + Text string `codec:"text" json:"text"` + Canceled bool `codec:"canceled" json:"canceled"` + StoreSecret bool `codec:"storeSecret" json:"storeSecret"` +} + +func (o SecretEntryRes) DeepCopy() SecretEntryRes { + return SecretEntryRes{ + Text: o.Text, + Canceled: o.Canceled, + StoreSecret: o.StoreSecret, + } +} 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 new file mode 100644 index 00000000..e7aeb754 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/secretkeys.go @@ -0,0 +1,48 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/secretkeys.avdl + +package keybase1 + +type NaclSigningKeyPublic [32]byte + +func (o NaclSigningKeyPublic) DeepCopy() NaclSigningKeyPublic { + var ret NaclSigningKeyPublic + copy(ret[:], o[:]) + return ret +} + +type NaclSigningKeyPrivate [64]byte + +func (o NaclSigningKeyPrivate) DeepCopy() NaclSigningKeyPrivate { + var ret NaclSigningKeyPrivate + copy(ret[:], o[:]) + return ret +} + +type NaclDHKeyPublic [32]byte + +func (o NaclDHKeyPublic) DeepCopy() NaclDHKeyPublic { + var ret NaclDHKeyPublic + copy(ret[:], o[:]) + return ret +} + +type NaclDHKeyPrivate [32]byte + +func (o NaclDHKeyPrivate) DeepCopy() NaclDHKeyPrivate { + var ret NaclDHKeyPrivate + copy(ret[:], o[:]) + return ret +} + +type SecretKeys struct { + Signing NaclSigningKeyPrivate `codec:"signing" json:"signing"` + Encryption NaclDHKeyPrivate `codec:"encryption" json:"encryption"` +} + +func (o SecretKeys) DeepCopy() SecretKeys { + return SecretKeys{ + Signing: o.Signing.DeepCopy(), + Encryption: o.Encryption.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..3a89450a --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/selfprovision.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..0c13b9e3 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/session.go @@ -0,0 +1,22 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/session.avdl + +package keybase1 + +type Session struct { + Uid UID `codec:"uid" json:"uid"` + Username string `codec:"username" json:"username"` + Token string `codec:"token" json:"token"` + DeviceSubkeyKid KID `codec:"deviceSubkeyKid" json:"deviceSubkeyKid"` + DeviceSibkeyKid KID `codec:"deviceSibkeyKid" json:"deviceSibkeyKid"` +} + +func (o Session) DeepCopy() Session { + return Session{ + Uid: o.Uid.DeepCopy(), + Username: o.Username, + Token: o.Token, + DeviceSubkeyKid: o.DeviceSubkeyKid.DeepCopy(), + DeviceSibkeyKid: o.DeviceSibkeyKid.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..fb8fa57a --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/signup.go @@ -0,0 +1,20 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/signup.avdl + +package keybase1 + +type SignupRes struct { + PassphraseOk bool `codec:"passphraseOk" json:"passphraseOk"` + PostOk bool `codec:"postOk" json:"postOk"` + WriteOk bool `codec:"writeOk" json:"writeOk"` + PaperKey string `codec:"paperKey" json:"paperKey"` +} + +func (o SignupRes) DeepCopy() SignupRes { + return SignupRes{ + PassphraseOk: o.PassphraseOk, + PostOk: o.PostOk, + WriteOk: o.WriteOk, + PaperKey: o.PaperKey, + } +} 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 new file mode 100644 index 00000000..09abc8ca --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/sigs.go @@ -0,0 +1,74 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/sigs.avdl + +package keybase1 + +type Sig struct { + Seqno Seqno `codec:"seqno" json:"seqno"` + SigID SigID `codec:"sigID" json:"sigID"` + SigIDDisplay string `codec:"sigIDDisplay" json:"sigIDDisplay"` + Type string `codec:"type" json:"type"` + CTime Time `codec:"cTime" json:"cTime"` + Revoked bool `codec:"revoked" json:"revoked"` + Active bool `codec:"active" json:"active"` + Key string `codec:"key" json:"key"` + Body string `codec:"body" json:"body"` +} + +func (o Sig) DeepCopy() Sig { + return Sig{ + Seqno: o.Seqno.DeepCopy(), + SigID: o.SigID.DeepCopy(), + SigIDDisplay: o.SigIDDisplay, + Type: o.Type, + CTime: o.CTime.DeepCopy(), + Revoked: o.Revoked, + Active: o.Active, + Key: o.Key, + Body: o.Body, + } +} + +type SigTypes struct { + Track bool `codec:"track" json:"track"` + Proof bool `codec:"proof" json:"proof"` + Cryptocurrency bool `codec:"cryptocurrency" json:"cryptocurrency"` + IsSelf bool `codec:"isSelf" json:"isSelf"` +} + +func (o SigTypes) DeepCopy() SigTypes { + return SigTypes{ + Track: o.Track, + Proof: o.Proof, + Cryptocurrency: o.Cryptocurrency, + IsSelf: o.IsSelf, + } +} + +type SigListArgs struct { + SessionID int `codec:"sessionID" json:"sessionID"` + Username string `codec:"username" json:"username"` + AllKeys bool `codec:"allKeys" json:"allKeys"` + Types *SigTypes `codec:"types,omitempty" json:"types,omitempty"` + Filterx string `codec:"filterx" json:"filterx"` + Verbose bool `codec:"verbose" json:"verbose"` + Revoked bool `codec:"revoked" json:"revoked"` +} + +func (o SigListArgs) DeepCopy() SigListArgs { + return SigListArgs{ + SessionID: o.SessionID, + Username: o.Username, + AllKeys: o.AllKeys, + Types: (func(x *SigTypes) *SigTypes { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Types), + Filterx: o.Filterx, + Verbose: o.Verbose, + Revoked: o.Revoked, + } +} 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 new file mode 100644 index 00000000..0fb77019 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/simple_fs.go @@ -0,0 +1,1565 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/simple_fs.avdl + +package keybase1 + +import ( + "errors" + "fmt" +) + +type OpID [16]byte + +func (o OpID) DeepCopy() OpID { + var ret OpID + copy(ret[:], o[:]) + return ret +} + +type KBFSRevision int64 + +func (o KBFSRevision) DeepCopy() KBFSRevision { + return o +} + +type KBFSArchivedType int + +const ( + KBFSArchivedType_REVISION KBFSArchivedType = 0 + KBFSArchivedType_TIME KBFSArchivedType = 1 + KBFSArchivedType_TIME_STRING KBFSArchivedType = 2 + KBFSArchivedType_REL_TIME_STRING KBFSArchivedType = 3 +) + +func (o KBFSArchivedType) DeepCopy() KBFSArchivedType { return o } + +var KBFSArchivedTypeMap = map[string]KBFSArchivedType{ + "REVISION": 0, + "TIME": 1, + "TIME_STRING": 2, + "REL_TIME_STRING": 3, +} + +var KBFSArchivedTypeRevMap = map[KBFSArchivedType]string{ + 0: "REVISION", + 1: "TIME", + 2: "TIME_STRING", + 3: "REL_TIME_STRING", +} + +func (e KBFSArchivedType) String() string { + if v, ok := KBFSArchivedTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type KBFSArchivedParam struct { + KBFSArchivedType__ KBFSArchivedType `codec:"KBFSArchivedType" json:"KBFSArchivedType"` + Revision__ *KBFSRevision `codec:"revision,omitempty" json:"revision,omitempty"` + Time__ *Time `codec:"time,omitempty" json:"time,omitempty"` + TimeString__ *string `codec:"timeString,omitempty" json:"timeString,omitempty"` + RelTimeString__ *string `codec:"relTimeString,omitempty" json:"relTimeString,omitempty"` +} + +func (o *KBFSArchivedParam) KBFSArchivedType() (ret KBFSArchivedType, err error) { + switch o.KBFSArchivedType__ { + case KBFSArchivedType_REVISION: + if o.Revision__ == nil { + err = errors.New("unexpected nil value for Revision__") + return ret, err + } + case KBFSArchivedType_TIME: + if o.Time__ == nil { + err = errors.New("unexpected nil value for Time__") + return ret, err + } + case KBFSArchivedType_TIME_STRING: + if o.TimeString__ == nil { + err = errors.New("unexpected nil value for TimeString__") + return ret, err + } + case KBFSArchivedType_REL_TIME_STRING: + if o.RelTimeString__ == nil { + err = errors.New("unexpected nil value for RelTimeString__") + return ret, err + } + } + return o.KBFSArchivedType__, nil +} + +func (o KBFSArchivedParam) Revision() (res KBFSRevision) { + if o.KBFSArchivedType__ != KBFSArchivedType_REVISION { + panic("wrong case accessed") + } + if o.Revision__ == nil { + return + } + return *o.Revision__ +} + +func (o KBFSArchivedParam) Time() (res Time) { + if o.KBFSArchivedType__ != KBFSArchivedType_TIME { + panic("wrong case accessed") + } + if o.Time__ == nil { + return + } + return *o.Time__ +} + +func (o KBFSArchivedParam) TimeString() (res string) { + if o.KBFSArchivedType__ != KBFSArchivedType_TIME_STRING { + panic("wrong case accessed") + } + if o.TimeString__ == nil { + return + } + return *o.TimeString__ +} + +func (o KBFSArchivedParam) RelTimeString() (res string) { + if o.KBFSArchivedType__ != KBFSArchivedType_REL_TIME_STRING { + panic("wrong case accessed") + } + if o.RelTimeString__ == nil { + return + } + return *o.RelTimeString__ +} + +func NewKBFSArchivedParamWithRevision(v KBFSRevision) KBFSArchivedParam { + return KBFSArchivedParam{ + KBFSArchivedType__: KBFSArchivedType_REVISION, + Revision__: &v, + } +} + +func NewKBFSArchivedParamWithTime(v Time) KBFSArchivedParam { + return KBFSArchivedParam{ + KBFSArchivedType__: KBFSArchivedType_TIME, + Time__: &v, + } +} + +func NewKBFSArchivedParamWithTimeString(v string) KBFSArchivedParam { + return KBFSArchivedParam{ + KBFSArchivedType__: KBFSArchivedType_TIME_STRING, + TimeString__: &v, + } +} + +func NewKBFSArchivedParamWithRelTimeString(v string) KBFSArchivedParam { + return KBFSArchivedParam{ + KBFSArchivedType__: KBFSArchivedType_REL_TIME_STRING, + RelTimeString__: &v, + } +} + +func (o KBFSArchivedParam) DeepCopy() KBFSArchivedParam { + return KBFSArchivedParam{ + KBFSArchivedType__: o.KBFSArchivedType__.DeepCopy(), + Revision__: (func(x *KBFSRevision) *KBFSRevision { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Revision__), + Time__: (func(x *Time) *Time { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Time__), + TimeString__: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.TimeString__), + RelTimeString__: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.RelTimeString__), + } +} + +type KBFSArchivedPath struct { + Path string `codec:"path" json:"path"` + ArchivedParam KBFSArchivedParam `codec:"archivedParam" json:"archivedParam"` + IdentifyBehavior *TLFIdentifyBehavior `codec:"identifyBehavior,omitempty" json:"identifyBehavior,omitempty"` +} + +func (o KBFSArchivedPath) DeepCopy() KBFSArchivedPath { + return KBFSArchivedPath{ + Path: o.Path, + ArchivedParam: o.ArchivedParam.DeepCopy(), + IdentifyBehavior: (func(x *TLFIdentifyBehavior) *TLFIdentifyBehavior { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.IdentifyBehavior), + } +} + +type KBFSPath struct { + Path string `codec:"path" json:"path"` + IdentifyBehavior *TLFIdentifyBehavior `codec:"identifyBehavior,omitempty" json:"identifyBehavior,omitempty"` +} + +func (o KBFSPath) DeepCopy() KBFSPath { + return KBFSPath{ + Path: o.Path, + IdentifyBehavior: (func(x *TLFIdentifyBehavior) *TLFIdentifyBehavior { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.IdentifyBehavior), + } +} + +type PathType int + +const ( + PathType_LOCAL PathType = 0 + PathType_KBFS PathType = 1 + PathType_KBFS_ARCHIVED PathType = 2 +) + +func (o PathType) DeepCopy() PathType { return o } + +var PathTypeMap = map[string]PathType{ + "LOCAL": 0, + "KBFS": 1, + "KBFS_ARCHIVED": 2, +} + +var PathTypeRevMap = map[PathType]string{ + 0: "LOCAL", + 1: "KBFS", + 2: "KBFS_ARCHIVED", +} + +func (e PathType) String() string { + if v, ok := PathTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type Path struct { + PathType__ PathType `codec:"PathType" json:"PathType"` + Local__ *string `codec:"local,omitempty" json:"local,omitempty"` + Kbfs__ *KBFSPath `codec:"kbfs,omitempty" json:"kbfs,omitempty"` + KbfsArchived__ *KBFSArchivedPath `codec:"kbfsArchived,omitempty" json:"kbfsArchived,omitempty"` +} + +func (o *Path) PathType() (ret PathType, err error) { + switch o.PathType__ { + case PathType_LOCAL: + if o.Local__ == nil { + err = errors.New("unexpected nil value for Local__") + return ret, err + } + case PathType_KBFS: + if o.Kbfs__ == nil { + err = errors.New("unexpected nil value for Kbfs__") + return ret, err + } + case PathType_KBFS_ARCHIVED: + if o.KbfsArchived__ == nil { + err = errors.New("unexpected nil value for KbfsArchived__") + return ret, err + } + } + return o.PathType__, nil +} + +func (o Path) Local() (res string) { + if o.PathType__ != PathType_LOCAL { + panic("wrong case accessed") + } + if o.Local__ == nil { + return + } + return *o.Local__ +} + +func (o Path) Kbfs() (res KBFSPath) { + if o.PathType__ != PathType_KBFS { + panic("wrong case accessed") + } + if o.Kbfs__ == nil { + return + } + return *o.Kbfs__ +} + +func (o Path) KbfsArchived() (res KBFSArchivedPath) { + if o.PathType__ != PathType_KBFS_ARCHIVED { + panic("wrong case accessed") + } + if o.KbfsArchived__ == nil { + return + } + return *o.KbfsArchived__ +} + +func NewPathWithLocal(v string) Path { + return Path{ + PathType__: PathType_LOCAL, + Local__: &v, + } +} + +func NewPathWithKbfs(v KBFSPath) Path { + return Path{ + PathType__: PathType_KBFS, + Kbfs__: &v, + } +} + +func NewPathWithKbfsArchived(v KBFSArchivedPath) Path { + return Path{ + PathType__: PathType_KBFS_ARCHIVED, + KbfsArchived__: &v, + } +} + +func (o Path) DeepCopy() Path { + return Path{ + PathType__: o.PathType__.DeepCopy(), + Local__: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Local__), + Kbfs__: (func(x *KBFSPath) *KBFSPath { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Kbfs__), + KbfsArchived__: (func(x *KBFSArchivedPath) *KBFSArchivedPath { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.KbfsArchived__), + } +} + +type DirentType int + +const ( + DirentType_FILE DirentType = 0 + DirentType_DIR DirentType = 1 + DirentType_SYM DirentType = 2 + DirentType_EXEC DirentType = 3 +) + +func (o DirentType) DeepCopy() DirentType { return o } + +var DirentTypeMap = map[string]DirentType{ + "FILE": 0, + "DIR": 1, + "SYM": 2, + "EXEC": 3, +} + +var DirentTypeRevMap = map[DirentType]string{ + 0: "FILE", + 1: "DIR", + 2: "SYM", + 3: "EXEC", +} + +func (e DirentType) String() string { + if v, ok := DirentTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type PrefetchStatus int + +const ( + PrefetchStatus_NOT_STARTED PrefetchStatus = 0 + PrefetchStatus_IN_PROGRESS PrefetchStatus = 1 + PrefetchStatus_COMPLETE PrefetchStatus = 2 +) + +func (o PrefetchStatus) DeepCopy() PrefetchStatus { return o } + +var PrefetchStatusMap = map[string]PrefetchStatus{ + "NOT_STARTED": 0, + "IN_PROGRESS": 1, + "COMPLETE": 2, +} + +var PrefetchStatusRevMap = map[PrefetchStatus]string{ + 0: "NOT_STARTED", + 1: "IN_PROGRESS", + 2: "COMPLETE", +} + +func (e PrefetchStatus) String() string { + if v, ok := PrefetchStatusRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type PrefetchProgress struct { + Start Time `codec:"start" json:"start"` + EndEstimate Time `codec:"endEstimate" json:"endEstimate"` + BytesTotal int64 `codec:"bytesTotal" json:"bytesTotal"` + BytesFetched int64 `codec:"bytesFetched" json:"bytesFetched"` +} + +func (o PrefetchProgress) DeepCopy() PrefetchProgress { + return PrefetchProgress{ + Start: o.Start.DeepCopy(), + EndEstimate: o.EndEstimate.DeepCopy(), + BytesTotal: o.BytesTotal, + BytesFetched: o.BytesFetched, + } +} + +type Dirent struct { + Time Time `codec:"time" json:"time"` + Size int `codec:"size" json:"size"` + Name string `codec:"name" json:"name"` + DirentType DirentType `codec:"direntType" json:"direntType"` + LastWriterUnverified User `codec:"lastWriterUnverified" json:"lastWriterUnverified"` + Writable bool `codec:"writable" json:"writable"` + PrefetchStatus PrefetchStatus `codec:"prefetchStatus" json:"prefetchStatus"` + PrefetchProgress PrefetchProgress `codec:"prefetchProgress" json:"prefetchProgress"` + SymlinkTarget string `codec:"symlinkTarget" json:"symlinkTarget"` +} + +func (o Dirent) DeepCopy() Dirent { + return Dirent{ + Time: o.Time.DeepCopy(), + Size: o.Size, + Name: o.Name, + DirentType: o.DirentType.DeepCopy(), + LastWriterUnverified: o.LastWriterUnverified.DeepCopy(), + Writable: o.Writable, + PrefetchStatus: o.PrefetchStatus.DeepCopy(), + PrefetchProgress: o.PrefetchProgress.DeepCopy(), + SymlinkTarget: o.SymlinkTarget, + } +} + +type DirentWithRevision struct { + Entry Dirent `codec:"entry" json:"entry"` + Revision KBFSRevision `codec:"revision" json:"revision"` +} + +func (o DirentWithRevision) DeepCopy() DirentWithRevision { + return DirentWithRevision{ + Entry: o.Entry.DeepCopy(), + Revision: o.Revision.DeepCopy(), + } +} + +type RevisionSpanType int + +const ( + RevisionSpanType_DEFAULT RevisionSpanType = 0 + RevisionSpanType_LAST_FIVE RevisionSpanType = 1 +) + +func (o RevisionSpanType) DeepCopy() RevisionSpanType { return o } + +var RevisionSpanTypeMap = map[string]RevisionSpanType{ + "DEFAULT": 0, + "LAST_FIVE": 1, +} + +var RevisionSpanTypeRevMap = map[RevisionSpanType]string{ + 0: "DEFAULT", + 1: "LAST_FIVE", +} + +func (e RevisionSpanType) String() string { + if v, ok := RevisionSpanTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ErrorNum int + +func (o ErrorNum) DeepCopy() ErrorNum { + return o +} + +type OpenFlags int + +const ( + OpenFlags_READ OpenFlags = 0 + OpenFlags_REPLACE OpenFlags = 1 + OpenFlags_EXISTING OpenFlags = 2 + OpenFlags_WRITE OpenFlags = 4 + OpenFlags_APPEND OpenFlags = 8 + OpenFlags_DIRECTORY OpenFlags = 16 +) + +func (o OpenFlags) DeepCopy() OpenFlags { return o } + +var OpenFlagsMap = map[string]OpenFlags{ + "READ": 0, + "REPLACE": 1, + "EXISTING": 2, + "WRITE": 4, + "APPEND": 8, + "DIRECTORY": 16, +} + +var OpenFlagsRevMap = map[OpenFlags]string{ + 0: "READ", + 1: "REPLACE", + 2: "EXISTING", + 4: "WRITE", + 8: "APPEND", + 16: "DIRECTORY", +} + +func (e OpenFlags) String() string { + if v, ok := OpenFlagsRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type Progress int + +func (o Progress) DeepCopy() Progress { + return o +} + +type SimpleFSListResult struct { + Entries []Dirent `codec:"entries" json:"entries"` + Progress Progress `codec:"progress" json:"progress"` +} + +func (o SimpleFSListResult) DeepCopy() SimpleFSListResult { + return SimpleFSListResult{ + Entries: (func(x []Dirent) []Dirent { + if x == nil { + return nil + } + ret := make([]Dirent, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Entries), + Progress: o.Progress.DeepCopy(), + } +} + +type FileContent struct { + Data []byte `codec:"data" json:"data"` + Progress Progress `codec:"progress" json:"progress"` +} + +func (o FileContent) DeepCopy() FileContent { + return FileContent{ + Data: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.Data), + Progress: o.Progress.DeepCopy(), + } +} + +type AsyncOps int + +const ( + AsyncOps_LIST AsyncOps = 0 + AsyncOps_LIST_RECURSIVE AsyncOps = 1 + AsyncOps_READ AsyncOps = 2 + AsyncOps_WRITE AsyncOps = 3 + AsyncOps_COPY AsyncOps = 4 + AsyncOps_MOVE AsyncOps = 5 + AsyncOps_REMOVE AsyncOps = 6 + AsyncOps_LIST_RECURSIVE_TO_DEPTH AsyncOps = 7 + AsyncOps_GET_REVISIONS AsyncOps = 8 +) + +func (o AsyncOps) DeepCopy() AsyncOps { return o } + +var AsyncOpsMap = map[string]AsyncOps{ + "LIST": 0, + "LIST_RECURSIVE": 1, + "READ": 2, + "WRITE": 3, + "COPY": 4, + "MOVE": 5, + "REMOVE": 6, + "LIST_RECURSIVE_TO_DEPTH": 7, + "GET_REVISIONS": 8, +} + +var AsyncOpsRevMap = map[AsyncOps]string{ + 0: "LIST", + 1: "LIST_RECURSIVE", + 2: "READ", + 3: "WRITE", + 4: "COPY", + 5: "MOVE", + 6: "REMOVE", + 7: "LIST_RECURSIVE_TO_DEPTH", + 8: "GET_REVISIONS", +} + +func (e AsyncOps) String() string { + if v, ok := AsyncOpsRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ListFilter int + +const ( + ListFilter_NO_FILTER ListFilter = 0 + ListFilter_FILTER_ALL_HIDDEN ListFilter = 1 + ListFilter_FILTER_SYSTEM_HIDDEN ListFilter = 2 +) + +func (o ListFilter) DeepCopy() ListFilter { return o } + +var ListFilterMap = map[string]ListFilter{ + "NO_FILTER": 0, + "FILTER_ALL_HIDDEN": 1, + "FILTER_SYSTEM_HIDDEN": 2, +} + +var ListFilterRevMap = map[ListFilter]string{ + 0: "NO_FILTER", + 1: "FILTER_ALL_HIDDEN", + 2: "FILTER_SYSTEM_HIDDEN", +} + +func (e ListFilter) String() string { + if v, ok := ListFilterRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ListArgs struct { + OpID OpID `codec:"opID" json:"opID"` + Path Path `codec:"path" json:"path"` + Filter ListFilter `codec:"filter" json:"filter"` +} + +func (o ListArgs) DeepCopy() ListArgs { + return ListArgs{ + OpID: o.OpID.DeepCopy(), + Path: o.Path.DeepCopy(), + Filter: o.Filter.DeepCopy(), + } +} + +type ListToDepthArgs struct { + OpID OpID `codec:"opID" json:"opID"` + Path Path `codec:"path" json:"path"` + Filter ListFilter `codec:"filter" json:"filter"` + Depth int `codec:"depth" json:"depth"` +} + +func (o ListToDepthArgs) DeepCopy() ListToDepthArgs { + return ListToDepthArgs{ + OpID: o.OpID.DeepCopy(), + Path: o.Path.DeepCopy(), + Filter: o.Filter.DeepCopy(), + Depth: o.Depth, + } +} + +type RemoveArgs struct { + OpID OpID `codec:"opID" json:"opID"` + Path Path `codec:"path" json:"path"` + Recursive bool `codec:"recursive" json:"recursive"` +} + +func (o RemoveArgs) DeepCopy() RemoveArgs { + return RemoveArgs{ + OpID: o.OpID.DeepCopy(), + Path: o.Path.DeepCopy(), + Recursive: o.Recursive, + } +} + +type ReadArgs struct { + OpID OpID `codec:"opID" json:"opID"` + Path Path `codec:"path" json:"path"` + Offset int64 `codec:"offset" json:"offset"` + Size int `codec:"size" json:"size"` +} + +func (o ReadArgs) DeepCopy() ReadArgs { + return ReadArgs{ + OpID: o.OpID.DeepCopy(), + Path: o.Path.DeepCopy(), + Offset: o.Offset, + Size: o.Size, + } +} + +type WriteArgs struct { + OpID OpID `codec:"opID" json:"opID"` + Path Path `codec:"path" json:"path"` + Offset int64 `codec:"offset" json:"offset"` +} + +func (o WriteArgs) DeepCopy() WriteArgs { + return WriteArgs{ + OpID: o.OpID.DeepCopy(), + Path: o.Path.DeepCopy(), + Offset: o.Offset, + } +} + +type CopyArgs struct { + OpID OpID `codec:"opID" json:"opID"` + Src Path `codec:"src" json:"src"` + Dest Path `codec:"dest" json:"dest"` +} + +func (o CopyArgs) DeepCopy() CopyArgs { + return CopyArgs{ + OpID: o.OpID.DeepCopy(), + Src: o.Src.DeepCopy(), + Dest: o.Dest.DeepCopy(), + } +} + +type MoveArgs struct { + OpID OpID `codec:"opID" json:"opID"` + Src Path `codec:"src" json:"src"` + Dest Path `codec:"dest" json:"dest"` +} + +func (o MoveArgs) DeepCopy() MoveArgs { + return MoveArgs{ + OpID: o.OpID.DeepCopy(), + Src: o.Src.DeepCopy(), + Dest: o.Dest.DeepCopy(), + } +} + +type GetRevisionsArgs struct { + OpID OpID `codec:"opID" json:"opID"` + Path Path `codec:"path" json:"path"` + SpanType RevisionSpanType `codec:"spanType" json:"spanType"` +} + +func (o GetRevisionsArgs) DeepCopy() GetRevisionsArgs { + return GetRevisionsArgs{ + OpID: o.OpID.DeepCopy(), + Path: o.Path.DeepCopy(), + SpanType: o.SpanType.DeepCopy(), + } +} + +type OpDescription struct { + AsyncOp__ AsyncOps `codec:"asyncOp" json:"asyncOp"` + List__ *ListArgs `codec:"list,omitempty" json:"list,omitempty"` + ListRecursive__ *ListArgs `codec:"listRecursive,omitempty" json:"listRecursive,omitempty"` + ListRecursiveToDepth__ *ListToDepthArgs `codec:"listRecursiveToDepth,omitempty" json:"listRecursiveToDepth,omitempty"` + Read__ *ReadArgs `codec:"read,omitempty" json:"read,omitempty"` + Write__ *WriteArgs `codec:"write,omitempty" json:"write,omitempty"` + Copy__ *CopyArgs `codec:"copy,omitempty" json:"copy,omitempty"` + Move__ *MoveArgs `codec:"move,omitempty" json:"move,omitempty"` + Remove__ *RemoveArgs `codec:"remove,omitempty" json:"remove,omitempty"` + GetRevisions__ *GetRevisionsArgs `codec:"getRevisions,omitempty" json:"getRevisions,omitempty"` +} + +func (o *OpDescription) AsyncOp() (ret AsyncOps, err error) { + switch o.AsyncOp__ { + case AsyncOps_LIST: + if o.List__ == nil { + err = errors.New("unexpected nil value for List__") + return ret, err + } + case AsyncOps_LIST_RECURSIVE: + if o.ListRecursive__ == nil { + err = errors.New("unexpected nil value for ListRecursive__") + return ret, err + } + case AsyncOps_LIST_RECURSIVE_TO_DEPTH: + if o.ListRecursiveToDepth__ == nil { + err = errors.New("unexpected nil value for ListRecursiveToDepth__") + return ret, err + } + case AsyncOps_READ: + if o.Read__ == nil { + err = errors.New("unexpected nil value for Read__") + return ret, err + } + case AsyncOps_WRITE: + if o.Write__ == nil { + err = errors.New("unexpected nil value for Write__") + return ret, err + } + case AsyncOps_COPY: + if o.Copy__ == nil { + err = errors.New("unexpected nil value for Copy__") + return ret, err + } + case AsyncOps_MOVE: + if o.Move__ == nil { + err = errors.New("unexpected nil value for Move__") + return ret, err + } + case AsyncOps_REMOVE: + if o.Remove__ == nil { + err = errors.New("unexpected nil value for Remove__") + return ret, err + } + case AsyncOps_GET_REVISIONS: + if o.GetRevisions__ == nil { + err = errors.New("unexpected nil value for GetRevisions__") + return ret, err + } + } + return o.AsyncOp__, nil +} + +func (o OpDescription) List() (res ListArgs) { + if o.AsyncOp__ != AsyncOps_LIST { + panic("wrong case accessed") + } + if o.List__ == nil { + return + } + return *o.List__ +} + +func (o OpDescription) ListRecursive() (res ListArgs) { + if o.AsyncOp__ != AsyncOps_LIST_RECURSIVE { + panic("wrong case accessed") + } + if o.ListRecursive__ == nil { + return + } + return *o.ListRecursive__ +} + +func (o OpDescription) ListRecursiveToDepth() (res ListToDepthArgs) { + if o.AsyncOp__ != AsyncOps_LIST_RECURSIVE_TO_DEPTH { + panic("wrong case accessed") + } + if o.ListRecursiveToDepth__ == nil { + return + } + return *o.ListRecursiveToDepth__ +} + +func (o OpDescription) Read() (res ReadArgs) { + if o.AsyncOp__ != AsyncOps_READ { + panic("wrong case accessed") + } + if o.Read__ == nil { + return + } + return *o.Read__ +} + +func (o OpDescription) Write() (res WriteArgs) { + if o.AsyncOp__ != AsyncOps_WRITE { + panic("wrong case accessed") + } + if o.Write__ == nil { + return + } + return *o.Write__ +} + +func (o OpDescription) Copy() (res CopyArgs) { + if o.AsyncOp__ != AsyncOps_COPY { + panic("wrong case accessed") + } + if o.Copy__ == nil { + return + } + return *o.Copy__ +} + +func (o OpDescription) Move() (res MoveArgs) { + if o.AsyncOp__ != AsyncOps_MOVE { + panic("wrong case accessed") + } + if o.Move__ == nil { + return + } + return *o.Move__ +} + +func (o OpDescription) Remove() (res RemoveArgs) { + if o.AsyncOp__ != AsyncOps_REMOVE { + panic("wrong case accessed") + } + if o.Remove__ == nil { + return + } + return *o.Remove__ +} + +func (o OpDescription) GetRevisions() (res GetRevisionsArgs) { + if o.AsyncOp__ != AsyncOps_GET_REVISIONS { + panic("wrong case accessed") + } + if o.GetRevisions__ == nil { + return + } + return *o.GetRevisions__ +} + +func NewOpDescriptionWithList(v ListArgs) OpDescription { + return OpDescription{ + AsyncOp__: AsyncOps_LIST, + List__: &v, + } +} + +func NewOpDescriptionWithListRecursive(v ListArgs) OpDescription { + return OpDescription{ + AsyncOp__: AsyncOps_LIST_RECURSIVE, + ListRecursive__: &v, + } +} + +func NewOpDescriptionWithListRecursiveToDepth(v ListToDepthArgs) OpDescription { + return OpDescription{ + AsyncOp__: AsyncOps_LIST_RECURSIVE_TO_DEPTH, + ListRecursiveToDepth__: &v, + } +} + +func NewOpDescriptionWithRead(v ReadArgs) OpDescription { + return OpDescription{ + AsyncOp__: AsyncOps_READ, + Read__: &v, + } +} + +func NewOpDescriptionWithWrite(v WriteArgs) OpDescription { + return OpDescription{ + AsyncOp__: AsyncOps_WRITE, + Write__: &v, + } +} + +func NewOpDescriptionWithCopy(v CopyArgs) OpDescription { + return OpDescription{ + AsyncOp__: AsyncOps_COPY, + Copy__: &v, + } +} + +func NewOpDescriptionWithMove(v MoveArgs) OpDescription { + return OpDescription{ + AsyncOp__: AsyncOps_MOVE, + Move__: &v, + } +} + +func NewOpDescriptionWithRemove(v RemoveArgs) OpDescription { + return OpDescription{ + AsyncOp__: AsyncOps_REMOVE, + Remove__: &v, + } +} + +func NewOpDescriptionWithGetRevisions(v GetRevisionsArgs) OpDescription { + return OpDescription{ + AsyncOp__: AsyncOps_GET_REVISIONS, + GetRevisions__: &v, + } +} + +func (o OpDescription) DeepCopy() OpDescription { + return OpDescription{ + AsyncOp__: o.AsyncOp__.DeepCopy(), + List__: (func(x *ListArgs) *ListArgs { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.List__), + ListRecursive__: (func(x *ListArgs) *ListArgs { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ListRecursive__), + ListRecursiveToDepth__: (func(x *ListToDepthArgs) *ListToDepthArgs { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ListRecursiveToDepth__), + Read__: (func(x *ReadArgs) *ReadArgs { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Read__), + Write__: (func(x *WriteArgs) *WriteArgs { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Write__), + Copy__: (func(x *CopyArgs) *CopyArgs { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Copy__), + Move__: (func(x *MoveArgs) *MoveArgs { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Move__), + Remove__: (func(x *RemoveArgs) *RemoveArgs { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Remove__), + GetRevisions__: (func(x *GetRevisionsArgs) *GetRevisionsArgs { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.GetRevisions__), + } +} + +type GetRevisionsResult struct { + Revisions []DirentWithRevision `codec:"revisions" json:"revisions"` + Progress Progress `codec:"progress" json:"progress"` +} + +func (o GetRevisionsResult) DeepCopy() GetRevisionsResult { + return GetRevisionsResult{ + Revisions: (func(x []DirentWithRevision) []DirentWithRevision { + if x == nil { + return nil + } + ret := make([]DirentWithRevision, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Revisions), + Progress: o.Progress.DeepCopy(), + } +} + +type OpProgress struct { + Start Time `codec:"start" json:"start"` + EndEstimate Time `codec:"endEstimate" json:"endEstimate"` + OpType AsyncOps `codec:"opType" json:"opType"` + BytesTotal int64 `codec:"bytesTotal" json:"bytesTotal"` + BytesRead int64 `codec:"bytesRead" json:"bytesRead"` + BytesWritten int64 `codec:"bytesWritten" json:"bytesWritten"` + FilesTotal int64 `codec:"filesTotal" json:"filesTotal"` + FilesRead int64 `codec:"filesRead" json:"filesRead"` + FilesWritten int64 `codec:"filesWritten" json:"filesWritten"` +} + +func (o OpProgress) DeepCopy() OpProgress { + return OpProgress{ + Start: o.Start.DeepCopy(), + EndEstimate: o.EndEstimate.DeepCopy(), + OpType: o.OpType.DeepCopy(), + BytesTotal: o.BytesTotal, + BytesRead: o.BytesRead, + BytesWritten: o.BytesWritten, + FilesTotal: o.FilesTotal, + FilesRead: o.FilesRead, + FilesWritten: o.FilesWritten, + } +} + +type SimpleFSQuotaUsage struct { + UsageBytes int64 `codec:"usageBytes" json:"usageBytes"` + ArchiveBytes int64 `codec:"archiveBytes" json:"archiveBytes"` + LimitBytes int64 `codec:"limitBytes" json:"limitBytes"` + GitUsageBytes int64 `codec:"gitUsageBytes" json:"gitUsageBytes"` + GitArchiveBytes int64 `codec:"gitArchiveBytes" json:"gitArchiveBytes"` + GitLimitBytes int64 `codec:"gitLimitBytes" json:"gitLimitBytes"` +} + +func (o SimpleFSQuotaUsage) DeepCopy() SimpleFSQuotaUsage { + return SimpleFSQuotaUsage{ + UsageBytes: o.UsageBytes, + ArchiveBytes: o.ArchiveBytes, + LimitBytes: o.LimitBytes, + GitUsageBytes: o.GitUsageBytes, + GitArchiveBytes: o.GitArchiveBytes, + GitLimitBytes: o.GitLimitBytes, + } +} + +type FolderSyncMode int + +const ( + FolderSyncMode_DISABLED FolderSyncMode = 0 + FolderSyncMode_ENABLED FolderSyncMode = 1 + FolderSyncMode_PARTIAL FolderSyncMode = 2 +) + +func (o FolderSyncMode) DeepCopy() FolderSyncMode { return o } + +var FolderSyncModeMap = map[string]FolderSyncMode{ + "DISABLED": 0, + "ENABLED": 1, + "PARTIAL": 2, +} + +var FolderSyncModeRevMap = map[FolderSyncMode]string{ + 0: "DISABLED", + 1: "ENABLED", + 2: "PARTIAL", +} + +func (e FolderSyncMode) String() string { + if v, ok := FolderSyncModeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type FolderSyncConfig struct { + Mode FolderSyncMode `codec:"mode" json:"mode"` + Paths []string `codec:"paths" json:"paths"` +} + +func (o FolderSyncConfig) DeepCopy() FolderSyncConfig { + return FolderSyncConfig{ + Mode: o.Mode.DeepCopy(), + Paths: (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.Paths), + } +} + +type FolderSyncConfigAndStatus struct { + Config FolderSyncConfig `codec:"config" json:"config"` + Status FolderSyncStatus `codec:"status" json:"status"` +} + +func (o FolderSyncConfigAndStatus) DeepCopy() FolderSyncConfigAndStatus { + return FolderSyncConfigAndStatus{ + Config: o.Config.DeepCopy(), + Status: o.Status.DeepCopy(), + } +} + +type FolderSyncConfigAndStatusWithFolder struct { + Folder Folder `codec:"folder" json:"folder"` + Config FolderSyncConfig `codec:"config" json:"config"` + Status FolderSyncStatus `codec:"status" json:"status"` +} + +func (o FolderSyncConfigAndStatusWithFolder) DeepCopy() FolderSyncConfigAndStatusWithFolder { + return FolderSyncConfigAndStatusWithFolder{ + Folder: o.Folder.DeepCopy(), + Config: o.Config.DeepCopy(), + Status: o.Status.DeepCopy(), + } +} + +type SyncConfigAndStatusRes struct { + Folders []FolderSyncConfigAndStatusWithFolder `codec:"folders" json:"folders"` + OverallStatus FolderSyncStatus `codec:"overallStatus" json:"overallStatus"` +} + +func (o SyncConfigAndStatusRes) DeepCopy() SyncConfigAndStatusRes { + return SyncConfigAndStatusRes{ + Folders: (func(x []FolderSyncConfigAndStatusWithFolder) []FolderSyncConfigAndStatusWithFolder { + if x == nil { + return nil + } + ret := make([]FolderSyncConfigAndStatusWithFolder, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Folders), + OverallStatus: o.OverallStatus.DeepCopy(), + } +} + +type FolderWithFavFlags struct { + Folder Folder `codec:"folder" json:"folder"` + IsFavorite bool `codec:"isFavorite" json:"isFavorite"` + IsIgnored bool `codec:"isIgnored" json:"isIgnored"` + IsNew bool `codec:"isNew" json:"isNew"` +} + +func (o FolderWithFavFlags) DeepCopy() FolderWithFavFlags { + return FolderWithFavFlags{ + Folder: o.Folder.DeepCopy(), + IsFavorite: o.IsFavorite, + IsIgnored: o.IsIgnored, + IsNew: o.IsNew, + } +} + +type KbfsOnlineStatus int + +const ( + KbfsOnlineStatus_OFFLINE KbfsOnlineStatus = 0 + KbfsOnlineStatus_TRYING KbfsOnlineStatus = 1 + KbfsOnlineStatus_ONLINE KbfsOnlineStatus = 2 +) + +func (o KbfsOnlineStatus) DeepCopy() KbfsOnlineStatus { return o } + +var KbfsOnlineStatusMap = map[string]KbfsOnlineStatus{ + "OFFLINE": 0, + "TRYING": 1, + "ONLINE": 2, +} + +var KbfsOnlineStatusRevMap = map[KbfsOnlineStatus]string{ + 0: "OFFLINE", + 1: "TRYING", + 2: "ONLINE", +} + +func (e KbfsOnlineStatus) String() string { + if v, ok := KbfsOnlineStatusRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type FSSettings struct { + SpaceAvailableNotificationThreshold int64 `codec:"spaceAvailableNotificationThreshold" json:"spaceAvailableNotificationThreshold"` + SfmiBannerDismissed bool `codec:"sfmiBannerDismissed" json:"sfmiBannerDismissed"` +} + +func (o FSSettings) DeepCopy() FSSettings { + return FSSettings{ + SpaceAvailableNotificationThreshold: o.SpaceAvailableNotificationThreshold, + SfmiBannerDismissed: o.SfmiBannerDismissed, + } +} + +type SimpleFSStats struct { + ProcessStats ProcessRuntimeStats `codec:"processStats" json:"processStats"` + BlockCacheDbStats []string `codec:"blockCacheDbStats" json:"blockCacheDbStats"` + SyncCacheDbStats []string `codec:"syncCacheDbStats" json:"syncCacheDbStats"` + RuntimeDbStats []DbStats `codec:"runtimeDbStats" json:"runtimeDbStats"` +} + +func (o SimpleFSStats) DeepCopy() SimpleFSStats { + return SimpleFSStats{ + ProcessStats: o.ProcessStats.DeepCopy(), + BlockCacheDbStats: (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.BlockCacheDbStats), + SyncCacheDbStats: (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.SyncCacheDbStats), + RuntimeDbStats: (func(x []DbStats) []DbStats { + if x == nil { + return nil + } + ret := make([]DbStats, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.RuntimeDbStats), + } +} + +type SubscriptionTopic int + +const ( + SubscriptionTopic_FAVORITES SubscriptionTopic = 0 + SubscriptionTopic_JOURNAL_STATUS SubscriptionTopic = 1 + SubscriptionTopic_ONLINE_STATUS SubscriptionTopic = 2 + SubscriptionTopic_DOWNLOAD_STATUS SubscriptionTopic = 3 + SubscriptionTopic_FILES_TAB_BADGE SubscriptionTopic = 4 + SubscriptionTopic_OVERALL_SYNC_STATUS SubscriptionTopic = 5 + SubscriptionTopic_SETTINGS SubscriptionTopic = 6 +) + +func (o SubscriptionTopic) DeepCopy() SubscriptionTopic { return o } + +var SubscriptionTopicMap = map[string]SubscriptionTopic{ + "FAVORITES": 0, + "JOURNAL_STATUS": 1, + "ONLINE_STATUS": 2, + "DOWNLOAD_STATUS": 3, + "FILES_TAB_BADGE": 4, + "OVERALL_SYNC_STATUS": 5, + "SETTINGS": 6, +} + +var SubscriptionTopicRevMap = map[SubscriptionTopic]string{ + 0: "FAVORITES", + 1: "JOURNAL_STATUS", + 2: "ONLINE_STATUS", + 3: "DOWNLOAD_STATUS", + 4: "FILES_TAB_BADGE", + 5: "OVERALL_SYNC_STATUS", + 6: "SETTINGS", +} + +func (e SubscriptionTopic) String() string { + if v, ok := SubscriptionTopicRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type PathSubscriptionTopic int + +const ( + PathSubscriptionTopic_CHILDREN PathSubscriptionTopic = 0 + PathSubscriptionTopic_STAT PathSubscriptionTopic = 1 +) + +func (o PathSubscriptionTopic) DeepCopy() PathSubscriptionTopic { return o } + +var PathSubscriptionTopicMap = map[string]PathSubscriptionTopic{ + "CHILDREN": 0, + "STAT": 1, +} + +var PathSubscriptionTopicRevMap = map[PathSubscriptionTopic]string{ + 0: "CHILDREN", + 1: "STAT", +} + +func (e PathSubscriptionTopic) String() string { + if v, ok := PathSubscriptionTopicRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type DownloadInfo struct { + DownloadID string `codec:"downloadID" json:"downloadID"` + Path KBFSPath `codec:"path" json:"path"` + Filename string `codec:"filename" json:"filename"` + StartTime Time `codec:"startTime" json:"startTime"` + IsRegularDownload bool `codec:"isRegularDownload" json:"isRegularDownload"` +} + +func (o DownloadInfo) DeepCopy() DownloadInfo { + return DownloadInfo{ + DownloadID: o.DownloadID, + Path: o.Path.DeepCopy(), + Filename: o.Filename, + StartTime: o.StartTime.DeepCopy(), + IsRegularDownload: o.IsRegularDownload, + } +} + +type DownloadState struct { + DownloadID string `codec:"downloadID" json:"downloadID"` + Progress float64 `codec:"progress" json:"progress"` + EndEstimate Time `codec:"endEstimate" json:"endEstimate"` + LocalPath string `codec:"localPath" json:"localPath"` + Error string `codec:"error" json:"error"` + Done bool `codec:"done" json:"done"` + Canceled bool `codec:"canceled" json:"canceled"` +} + +func (o DownloadState) DeepCopy() DownloadState { + return DownloadState{ + DownloadID: o.DownloadID, + Progress: o.Progress, + EndEstimate: o.EndEstimate.DeepCopy(), + LocalPath: o.LocalPath, + Error: o.Error, + Done: o.Done, + Canceled: o.Canceled, + } +} + +type DownloadStatus struct { + RegularDownloadIDs []string `codec:"regularDownloadIDs" json:"regularDownloadIDs"` + States []DownloadState `codec:"states" json:"states"` +} + +func (o DownloadStatus) DeepCopy() DownloadStatus { + return DownloadStatus{ + RegularDownloadIDs: (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.RegularDownloadIDs), + States: (func(x []DownloadState) []DownloadState { + if x == nil { + return nil + } + ret := make([]DownloadState, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.States), + } +} + +type FilesTabBadge int + +const ( + FilesTabBadge_NONE FilesTabBadge = 0 + FilesTabBadge_UPLOADING_STUCK FilesTabBadge = 1 + FilesTabBadge_AWAITING_UPLOAD FilesTabBadge = 2 + FilesTabBadge_UPLOADING FilesTabBadge = 3 +) + +func (o FilesTabBadge) DeepCopy() FilesTabBadge { return o } + +var FilesTabBadgeMap = map[string]FilesTabBadge{ + "NONE": 0, + "UPLOADING_STUCK": 1, + "AWAITING_UPLOAD": 2, + "UPLOADING": 3, +} + +var FilesTabBadgeRevMap = map[FilesTabBadge]string{ + 0: "NONE", + 1: "UPLOADING_STUCK", + 2: "AWAITING_UPLOAD", + 3: "UPLOADING", +} + +func (e FilesTabBadge) String() string { + if v, ok := FilesTabBadgeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type GUIViewType int + +const ( + GUIViewType_DEFAULT GUIViewType = 0 + GUIViewType_TEXT GUIViewType = 1 + GUIViewType_IMAGE GUIViewType = 2 + GUIViewType_AUDIO GUIViewType = 3 + GUIViewType_VIDEO GUIViewType = 4 + GUIViewType_PDF GUIViewType = 5 +) + +func (o GUIViewType) DeepCopy() GUIViewType { return o } + +var GUIViewTypeMap = map[string]GUIViewType{ + "DEFAULT": 0, + "TEXT": 1, + "IMAGE": 2, + "AUDIO": 3, + "VIDEO": 4, + "PDF": 5, +} + +var GUIViewTypeRevMap = map[GUIViewType]string{ + 0: "DEFAULT", + 1: "TEXT", + 2: "IMAGE", + 3: "AUDIO", + 4: "VIDEO", + 5: "PDF", +} + +func (e GUIViewType) String() string { + if v, ok := GUIViewTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type GUIFileContext struct { + ViewType GUIViewType `codec:"viewType" json:"viewType"` + ContentType string `codec:"contentType" json:"contentType"` + Url string `codec:"url" json:"url"` +} + +func (o GUIFileContext) DeepCopy() GUIFileContext { + return GUIFileContext{ + ViewType: o.ViewType.DeepCopy(), + ContentType: o.ContentType, + Url: o.Url, + } +} 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 new file mode 100644 index 00000000..ac4f43c9 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/stream_ui.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..e9be6638 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/teambot.go @@ -0,0 +1,52 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/teambot.avdl + +package keybase1 + +type TeambotKeyGeneration int64 + +func (o TeambotKeyGeneration) DeepCopy() TeambotKeyGeneration { + return o +} + +type TeambotKeyMetadata struct { + Kid KID `codec:"kid" json:"teambot_dh_public"` + Generation TeambotKeyGeneration `codec:"generation" json:"generation"` + Uid UID `codec:"uid" json:"uid"` + PukGeneration PerUserKeyGeneration `codec:"pukGeneration" json:"puk_generation"` + Application TeamApplication `codec:"application" json:"application"` +} + +func (o TeambotKeyMetadata) DeepCopy() TeambotKeyMetadata { + return TeambotKeyMetadata{ + Kid: o.Kid.DeepCopy(), + Generation: o.Generation.DeepCopy(), + Uid: o.Uid.DeepCopy(), + PukGeneration: o.PukGeneration.DeepCopy(), + Application: o.Application.DeepCopy(), + } +} + +type TeambotKeyBoxed struct { + Box string `codec:"box" json:"box"` + Metadata TeambotKeyMetadata `codec:"metadata" json:"metadata"` +} + +func (o TeambotKeyBoxed) DeepCopy() TeambotKeyBoxed { + return TeambotKeyBoxed{ + Box: o.Box, + Metadata: o.Metadata.DeepCopy(), + } +} + +type TeambotKey struct { + Seed Bytes32 `codec:"seed" json:"seed"` + Metadata TeambotKeyMetadata `codec:"metadata" json:"metadata"` +} + +func (o TeambotKey) DeepCopy() TeambotKey { + return TeambotKey{ + Seed: o.Seed.DeepCopy(), + Metadata: o.Metadata.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..bc2648fa --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/teams.go @@ -0,0 +1,3514 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/teams.avdl + +package keybase1 + +import ( + "errors" + "fmt" +) + +type TeamRole int + +const ( + TeamRole_NONE TeamRole = 0 + TeamRole_READER TeamRole = 1 + TeamRole_WRITER TeamRole = 2 + TeamRole_ADMIN TeamRole = 3 + TeamRole_OWNER TeamRole = 4 + TeamRole_BOT TeamRole = 5 + TeamRole_RESTRICTEDBOT TeamRole = 6 +) + +func (o TeamRole) DeepCopy() TeamRole { return o } + +var TeamRoleMap = map[string]TeamRole{ + "NONE": 0, + "READER": 1, + "WRITER": 2, + "ADMIN": 3, + "OWNER": 4, + "BOT": 5, + "RESTRICTEDBOT": 6, +} + +var TeamRoleRevMap = map[TeamRole]string{ + 0: "NONE", + 1: "READER", + 2: "WRITER", + 3: "ADMIN", + 4: "OWNER", + 5: "BOT", + 6: "RESTRICTEDBOT", +} + +func (e TeamRole) String() string { + if v, ok := TeamRoleRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type TeamApplication int + +const ( + TeamApplication_KBFS TeamApplication = 1 + TeamApplication_CHAT TeamApplication = 2 + TeamApplication_SALTPACK TeamApplication = 3 + TeamApplication_GIT_METADATA TeamApplication = 4 + TeamApplication_SEITAN_INVITE_TOKEN TeamApplication = 5 + TeamApplication_STELLAR_RELAY TeamApplication = 6 + TeamApplication_KVSTORE TeamApplication = 7 +) + +func (o TeamApplication) DeepCopy() TeamApplication { return o } + +var TeamApplicationMap = map[string]TeamApplication{ + "KBFS": 1, + "CHAT": 2, + "SALTPACK": 3, + "GIT_METADATA": 4, + "SEITAN_INVITE_TOKEN": 5, + "STELLAR_RELAY": 6, + "KVSTORE": 7, +} + +var TeamApplicationRevMap = map[TeamApplication]string{ + 1: "KBFS", + 2: "CHAT", + 3: "SALTPACK", + 4: "GIT_METADATA", + 5: "SEITAN_INVITE_TOKEN", + 6: "STELLAR_RELAY", + 7: "KVSTORE", +} + +func (e TeamApplication) String() string { + if v, ok := TeamApplicationRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type TeamStatus int + +const ( + TeamStatus_NONE TeamStatus = 0 + TeamStatus_LIVE TeamStatus = 1 + TeamStatus_DELETED TeamStatus = 2 + TeamStatus_ABANDONED TeamStatus = 3 +) + +func (o TeamStatus) DeepCopy() TeamStatus { return o } + +var TeamStatusMap = map[string]TeamStatus{ + "NONE": 0, + "LIVE": 1, + "DELETED": 2, + "ABANDONED": 3, +} + +var TeamStatusRevMap = map[TeamStatus]string{ + 0: "NONE", + 1: "LIVE", + 2: "DELETED", + 3: "ABANDONED", +} + +func (e TeamStatus) String() string { + if v, ok := TeamStatusRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type AuditMode int + +const ( + AuditMode_STANDARD AuditMode = 0 + AuditMode_JUST_CREATED AuditMode = 1 + AuditMode_SKIP AuditMode = 2 + AuditMode_STANDARD_NO_HIDDEN AuditMode = 3 +) + +func (o AuditMode) DeepCopy() AuditMode { return o } + +var AuditModeMap = map[string]AuditMode{ + "STANDARD": 0, + "JUST_CREATED": 1, + "SKIP": 2, + "STANDARD_NO_HIDDEN": 3, +} + +var AuditModeRevMap = map[AuditMode]string{ + 0: "STANDARD", + 1: "JUST_CREATED", + 2: "SKIP", + 3: "STANDARD_NO_HIDDEN", +} + +func (e AuditMode) String() string { + if v, ok := AuditModeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type PerTeamKeyGeneration int + +func (o PerTeamKeyGeneration) DeepCopy() PerTeamKeyGeneration { + return o +} + +type PTKType int + +const ( + PTKType_READER PTKType = 0 +) + +func (o PTKType) DeepCopy() PTKType { return o } + +var PTKTypeMap = map[string]PTKType{ + "READER": 0, +} + +var PTKTypeRevMap = map[PTKType]string{ + 0: "READER", +} + +func (e PTKType) String() string { + if v, ok := PTKTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type PerTeamSeedCheckVersion int + +const ( + PerTeamSeedCheckVersion_V1 PerTeamSeedCheckVersion = 1 +) + +func (o PerTeamSeedCheckVersion) DeepCopy() PerTeamSeedCheckVersion { return o } + +var PerTeamSeedCheckVersionMap = map[string]PerTeamSeedCheckVersion{ + "V1": 1, +} + +var PerTeamSeedCheckVersionRevMap = map[PerTeamSeedCheckVersion]string{ + 1: "V1", +} + +func (e PerTeamSeedCheckVersion) String() string { + if v, ok := PerTeamSeedCheckVersionRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type PerTeamSeedCheck struct { + Version PerTeamSeedCheckVersion `codec:"version" json:"version"` + Value PerTeamSeedCheckValue `codec:"value" json:"value"` +} + +func (o PerTeamSeedCheck) DeepCopy() PerTeamSeedCheck { + return PerTeamSeedCheck{ + Version: o.Version.DeepCopy(), + Value: o.Value.DeepCopy(), + } +} + +type PerTeamSeedCheckValue []byte + +func (o PerTeamSeedCheckValue) DeepCopy() PerTeamSeedCheckValue { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} + +type PerTeamSeedCheckValuePostImage []byte + +func (o PerTeamSeedCheckValuePostImage) DeepCopy() PerTeamSeedCheckValuePostImage { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} + +type PerTeamSeedCheckPostImage struct { + Value PerTeamSeedCheckValuePostImage `codec:"h" json:"h"` + Version PerTeamSeedCheckVersion `codec:"v" json:"v"` +} + +func (o PerTeamSeedCheckPostImage) DeepCopy() PerTeamSeedCheckPostImage { + return PerTeamSeedCheckPostImage{ + Value: o.Value.DeepCopy(), + Version: o.Version.DeepCopy(), + } +} + +type TeamApplicationKey struct { + Application TeamApplication `codec:"application" json:"application"` + KeyGeneration PerTeamKeyGeneration `codec:"keyGeneration" json:"keyGeneration"` + Key Bytes32 `codec:"key" json:"key"` +} + +func (o TeamApplicationKey) DeepCopy() TeamApplicationKey { + return TeamApplicationKey{ + Application: o.Application.DeepCopy(), + KeyGeneration: o.KeyGeneration.DeepCopy(), + Key: o.Key.DeepCopy(), + } +} + +type MaskB64 []byte + +func (o MaskB64) DeepCopy() MaskB64 { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} + +type TeamInviteID string + +func (o TeamInviteID) DeepCopy() TeamInviteID { + return o +} + +type ReaderKeyMask struct { + Application TeamApplication `codec:"application" json:"application"` + Generation PerTeamKeyGeneration `codec:"generation" json:"generation"` + Mask MaskB64 `codec:"mask" json:"mask"` +} + +func (o ReaderKeyMask) DeepCopy() ReaderKeyMask { + return ReaderKeyMask{ + Application: o.Application.DeepCopy(), + Generation: o.Generation.DeepCopy(), + Mask: o.Mask.DeepCopy(), + } +} + +type PerTeamKey struct { + Gen PerTeamKeyGeneration `codec:"gen" json:"gen"` + Seqno Seqno `codec:"seqno" json:"seqno"` + SigKID KID `codec:"sigKID" json:"sigKID"` + EncKID KID `codec:"encKID" json:"encKID"` +} + +func (o PerTeamKey) DeepCopy() PerTeamKey { + return PerTeamKey{ + Gen: o.Gen.DeepCopy(), + Seqno: o.Seqno.DeepCopy(), + SigKID: o.SigKID.DeepCopy(), + EncKID: o.EncKID.DeepCopy(), + } +} + +type PerTeamKeyAndCheck struct { + Ptk PerTeamKey `codec:"ptk" json:"ptk"` + Check PerTeamSeedCheckPostImage `codec:"check" json:"check"` +} + +func (o PerTeamKeyAndCheck) DeepCopy() PerTeamKeyAndCheck { + return PerTeamKeyAndCheck{ + Ptk: o.Ptk.DeepCopy(), + Check: o.Check.DeepCopy(), + } +} + +type PerTeamKeySeed [32]byte + +func (o PerTeamKeySeed) DeepCopy() PerTeamKeySeed { + var ret PerTeamKeySeed + copy(ret[:], o[:]) + return ret +} + +type PerTeamKeySeedItem struct { + Seed PerTeamKeySeed `codec:"seed" json:"seed"` + Generation PerTeamKeyGeneration `codec:"generation" json:"generation"` + Seqno Seqno `codec:"seqno" json:"seqno"` + Check *PerTeamSeedCheck `codec:"check,omitempty" json:"check,omitempty"` +} + +func (o PerTeamKeySeedItem) DeepCopy() PerTeamKeySeedItem { + return PerTeamKeySeedItem{ + Seed: o.Seed.DeepCopy(), + Generation: o.Generation.DeepCopy(), + Seqno: o.Seqno.DeepCopy(), + Check: (func(x *PerTeamSeedCheck) *PerTeamSeedCheck { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Check), + } +} + +type TeamMember struct { + Uid UID `codec:"uid" json:"uid"` + Role TeamRole `codec:"role" json:"role"` + EldestSeqno Seqno `codec:"eldestSeqno" json:"eldestSeqno"` + Status TeamMemberStatus `codec:"status" json:"status"` + BotSettings *TeamBotSettings `codec:"botSettings,omitempty" json:"botSettings,omitempty"` +} + +func (o TeamMember) DeepCopy() TeamMember { + return TeamMember{ + Uid: o.Uid.DeepCopy(), + Role: o.Role.DeepCopy(), + EldestSeqno: o.EldestSeqno.DeepCopy(), + Status: o.Status.DeepCopy(), + BotSettings: (func(x *TeamBotSettings) *TeamBotSettings { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.BotSettings), + } +} + +type TeamMembers struct { + Owners []UserVersion `codec:"owners" json:"owners"` + Admins []UserVersion `codec:"admins" json:"admins"` + Writers []UserVersion `codec:"writers" json:"writers"` + Readers []UserVersion `codec:"readers" json:"readers"` + Bots []UserVersion `codec:"bots" json:"bots"` + RestrictedBots []UserVersion `codec:"restrictedBots" json:"restrictedBots"` +} + +func (o TeamMembers) DeepCopy() TeamMembers { + return TeamMembers{ + Owners: (func(x []UserVersion) []UserVersion { + if x == nil { + return nil + } + ret := make([]UserVersion, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Owners), + Admins: (func(x []UserVersion) []UserVersion { + if x == nil { + return nil + } + ret := make([]UserVersion, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Admins), + Writers: (func(x []UserVersion) []UserVersion { + if x == nil { + return nil + } + ret := make([]UserVersion, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Writers), + Readers: (func(x []UserVersion) []UserVersion { + if x == nil { + return nil + } + ret := make([]UserVersion, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Readers), + Bots: (func(x []UserVersion) []UserVersion { + if x == nil { + return nil + } + ret := make([]UserVersion, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Bots), + RestrictedBots: (func(x []UserVersion) []UserVersion { + if x == nil { + return nil + } + ret := make([]UserVersion, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.RestrictedBots), + } +} + +type TeamMemberStatus int + +const ( + TeamMemberStatus_ACTIVE TeamMemberStatus = 0 + TeamMemberStatus_RESET TeamMemberStatus = 1 + TeamMemberStatus_DELETED TeamMemberStatus = 2 +) + +func (o TeamMemberStatus) DeepCopy() TeamMemberStatus { return o } + +var TeamMemberStatusMap = map[string]TeamMemberStatus{ + "ACTIVE": 0, + "RESET": 1, + "DELETED": 2, +} + +var TeamMemberStatusRevMap = map[TeamMemberStatus]string{ + 0: "ACTIVE", + 1: "RESET", + 2: "DELETED", +} + +func (e TeamMemberStatus) String() string { + if v, ok := TeamMemberStatusRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type TeamMemberDetails struct { + Uv UserVersion `codec:"uv" json:"uv"` + Username string `codec:"username" json:"username"` + FullName FullName `codec:"fullName" json:"fullName"` + NeedsPUK bool `codec:"needsPUK" json:"needsPUK"` + Status TeamMemberStatus `codec:"status" json:"status"` +} + +func (o TeamMemberDetails) DeepCopy() TeamMemberDetails { + return TeamMemberDetails{ + Uv: o.Uv.DeepCopy(), + Username: o.Username, + FullName: o.FullName.DeepCopy(), + NeedsPUK: o.NeedsPUK, + Status: o.Status.DeepCopy(), + } +} + +type TeamMembersDetails struct { + Owners []TeamMemberDetails `codec:"owners" json:"owners"` + Admins []TeamMemberDetails `codec:"admins" json:"admins"` + Writers []TeamMemberDetails `codec:"writers" json:"writers"` + Readers []TeamMemberDetails `codec:"readers" json:"readers"` + Bots []TeamMemberDetails `codec:"bots" json:"bots"` + RestrictedBots []TeamMemberDetails `codec:"restrictedBots" json:"restrictedBots"` +} + +func (o TeamMembersDetails) DeepCopy() TeamMembersDetails { + return TeamMembersDetails{ + Owners: (func(x []TeamMemberDetails) []TeamMemberDetails { + if x == nil { + return nil + } + ret := make([]TeamMemberDetails, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Owners), + Admins: (func(x []TeamMemberDetails) []TeamMemberDetails { + if x == nil { + return nil + } + ret := make([]TeamMemberDetails, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Admins), + Writers: (func(x []TeamMemberDetails) []TeamMemberDetails { + if x == nil { + return nil + } + ret := make([]TeamMemberDetails, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Writers), + Readers: (func(x []TeamMemberDetails) []TeamMemberDetails { + if x == nil { + return nil + } + ret := make([]TeamMemberDetails, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Readers), + Bots: (func(x []TeamMemberDetails) []TeamMemberDetails { + if x == nil { + return nil + } + ret := make([]TeamMemberDetails, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Bots), + RestrictedBots: (func(x []TeamMemberDetails) []TeamMemberDetails { + if x == nil { + return nil + } + ret := make([]TeamMemberDetails, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.RestrictedBots), + } +} + +type TeamDetails struct { + Name string `codec:"name" json:"name"` + Members TeamMembersDetails `codec:"members" json:"members"` + KeyGeneration PerTeamKeyGeneration `codec:"keyGeneration" json:"keyGeneration"` + AnnotatedActiveInvites map[TeamInviteID]AnnotatedTeamInvite `codec:"annotatedActiveInvites" json:"annotatedActiveInvites"` + Settings TeamSettings `codec:"settings" json:"settings"` + Showcase TeamShowcase `codec:"showcase" json:"showcase"` +} + +func (o TeamDetails) DeepCopy() TeamDetails { + return TeamDetails{ + Name: o.Name, + Members: o.Members.DeepCopy(), + KeyGeneration: o.KeyGeneration.DeepCopy(), + AnnotatedActiveInvites: (func(x map[TeamInviteID]AnnotatedTeamInvite) map[TeamInviteID]AnnotatedTeamInvite { + if x == nil { + return nil + } + ret := make(map[TeamInviteID]AnnotatedTeamInvite, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.AnnotatedActiveInvites), + Settings: o.Settings.DeepCopy(), + Showcase: o.Showcase.DeepCopy(), + } +} + +type UserVersionPercentForm string + +func (o UserVersionPercentForm) DeepCopy() UserVersionPercentForm { + return o +} + +type TeamChangeReq struct { + Owners []UserVersion `codec:"owners" json:"owners"` + Admins []UserVersion `codec:"admins" json:"admins"` + Writers []UserVersion `codec:"writers" json:"writers"` + Readers []UserVersion `codec:"readers" json:"readers"` + Bots []UserVersion `codec:"bots" json:"bots"` + RestrictedBots map[UserVersion]TeamBotSettings `codec:"restrictedBots" json:"restrictedBots"` + None []UserVersion `codec:"none" json:"none"` + CompletedInvites map[TeamInviteID]UserVersionPercentForm `codec:"completedInvites" json:"completedInvites"` +} + +func (o TeamChangeReq) DeepCopy() TeamChangeReq { + return TeamChangeReq{ + Owners: (func(x []UserVersion) []UserVersion { + if x == nil { + return nil + } + ret := make([]UserVersion, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Owners), + Admins: (func(x []UserVersion) []UserVersion { + if x == nil { + return nil + } + ret := make([]UserVersion, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Admins), + Writers: (func(x []UserVersion) []UserVersion { + if x == nil { + return nil + } + ret := make([]UserVersion, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Writers), + Readers: (func(x []UserVersion) []UserVersion { + if x == nil { + return nil + } + ret := make([]UserVersion, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Readers), + Bots: (func(x []UserVersion) []UserVersion { + if x == nil { + return nil + } + ret := make([]UserVersion, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Bots), + RestrictedBots: (func(x map[UserVersion]TeamBotSettings) map[UserVersion]TeamBotSettings { + if x == nil { + return nil + } + ret := make(map[UserVersion]TeamBotSettings, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.RestrictedBots), + None: (func(x []UserVersion) []UserVersion { + if x == nil { + return nil + } + ret := make([]UserVersion, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.None), + CompletedInvites: (func(x map[TeamInviteID]UserVersionPercentForm) map[TeamInviteID]UserVersionPercentForm { + if x == nil { + return nil + } + ret := make(map[TeamInviteID]UserVersionPercentForm, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.CompletedInvites), + } +} + +type TeamPlusApplicationKeys struct { + Id TeamID `codec:"id" json:"id"` + Name string `codec:"name" json:"name"` + Implicit bool `codec:"implicit" json:"implicit"` + Public bool `codec:"public" json:"public"` + Application TeamApplication `codec:"application" json:"application"` + Writers []UserVersion `codec:"writers" json:"writers"` + OnlyReaders []UserVersion `codec:"onlyReaders" json:"onlyReaders"` + OnlyRestrictedBots []UserVersion `codec:"onlyRestrictedBots" json:"onlyRestrictedBots"` + ApplicationKeys []TeamApplicationKey `codec:"applicationKeys" json:"applicationKeys"` +} + +func (o TeamPlusApplicationKeys) DeepCopy() TeamPlusApplicationKeys { + return TeamPlusApplicationKeys{ + Id: o.Id.DeepCopy(), + Name: o.Name, + Implicit: o.Implicit, + Public: o.Public, + Application: o.Application.DeepCopy(), + Writers: (func(x []UserVersion) []UserVersion { + if x == nil { + return nil + } + ret := make([]UserVersion, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Writers), + OnlyReaders: (func(x []UserVersion) []UserVersion { + if x == nil { + return nil + } + ret := make([]UserVersion, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.OnlyReaders), + OnlyRestrictedBots: (func(x []UserVersion) []UserVersion { + if x == nil { + return nil + } + ret := make([]UserVersion, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.OnlyRestrictedBots), + ApplicationKeys: (func(x []TeamApplicationKey) []TeamApplicationKey { + if x == nil { + return nil + } + ret := make([]TeamApplicationKey, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.ApplicationKeys), + } +} + +type TeamData struct { + Subversion int `codec:"v" json:"v"` + Frozen bool `codec:"frozen" json:"frozen"` + Tombstoned bool `codec:"tombstoned" json:"tombstoned"` + Secretless bool `codec:"secretless" json:"secretless"` + Name TeamName `codec:"name" json:"name"` + Chain TeamSigChainState `codec:"chain" json:"chain"` + PerTeamKeySeedsUnverified map[PerTeamKeyGeneration]PerTeamKeySeedItem `codec:"perTeamKeySeeds" json:"perTeamKeySeedsUnverified"` + ReaderKeyMasks map[TeamApplication]map[PerTeamKeyGeneration]MaskB64 `codec:"readerKeyMasks" json:"readerKeyMasks"` + LatestSeqnoHint Seqno `codec:"latestSeqnoHint" json:"latestSeqnoHint"` + CachedAt Time `codec:"cachedAt" json:"cachedAt"` + TlfCryptKeys map[TeamApplication][]CryptKey `codec:"tlfCryptKeys" json:"tlfCryptKeys"` +} + +func (o TeamData) DeepCopy() TeamData { + return TeamData{ + Subversion: o.Subversion, + Frozen: o.Frozen, + Tombstoned: o.Tombstoned, + Secretless: o.Secretless, + Name: o.Name.DeepCopy(), + Chain: o.Chain.DeepCopy(), + PerTeamKeySeedsUnverified: (func(x map[PerTeamKeyGeneration]PerTeamKeySeedItem) map[PerTeamKeyGeneration]PerTeamKeySeedItem { + if x == nil { + return nil + } + ret := make(map[PerTeamKeyGeneration]PerTeamKeySeedItem, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.PerTeamKeySeedsUnverified), + ReaderKeyMasks: (func(x map[TeamApplication]map[PerTeamKeyGeneration]MaskB64) map[TeamApplication]map[PerTeamKeyGeneration]MaskB64 { + if x == nil { + return nil + } + ret := make(map[TeamApplication]map[PerTeamKeyGeneration]MaskB64, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := (func(x map[PerTeamKeyGeneration]MaskB64) map[PerTeamKeyGeneration]MaskB64 { + if x == nil { + return nil + } + ret := make(map[PerTeamKeyGeneration]MaskB64, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(v) + ret[kCopy] = vCopy + } + return ret + })(o.ReaderKeyMasks), + LatestSeqnoHint: o.LatestSeqnoHint.DeepCopy(), + CachedAt: o.CachedAt.DeepCopy(), + TlfCryptKeys: (func(x map[TeamApplication][]CryptKey) map[TeamApplication][]CryptKey { + if x == nil { + return nil + } + ret := make(map[TeamApplication][]CryptKey, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := (func(x []CryptKey) []CryptKey { + if x == nil { + return nil + } + ret := make([]CryptKey, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(v) + ret[kCopy] = vCopy + } + return ret + })(o.TlfCryptKeys), + } +} + +type FastTeamData struct { + Frozen bool `codec:"frozen" json:"frozen"` + Subversion int `codec:"subversion" json:"subversion"` + Tombstoned bool `codec:"tombstoned" json:"tombstoned"` + Name TeamName `codec:"name" json:"name"` + Chain FastTeamSigChainState `codec:"chain" json:"chain"` + PerTeamKeySeedsUnverified map[PerTeamKeyGeneration]PerTeamKeySeed `codec:"perTeamKeySeeds" json:"perTeamKeySeedsUnverified"` + MaxContinuousPTKGeneration PerTeamKeyGeneration `codec:"maxContinuousPTKGeneration" json:"maxContinuousPTKGeneration"` + SeedChecks map[PerTeamKeyGeneration]PerTeamSeedCheck `codec:"seedChecks" json:"seedChecks"` + LatestKeyGeneration PerTeamKeyGeneration `codec:"latestKeyGeneration" json:"latestKeyGeneration"` + ReaderKeyMasks map[TeamApplication]map[PerTeamKeyGeneration]MaskB64 `codec:"readerKeyMasks" json:"readerKeyMasks"` + LatestSeqnoHint Seqno `codec:"latestSeqnoHint" json:"latestSeqnoHint"` + CachedAt Time `codec:"cachedAt" json:"cachedAt"` + LoadedLatest bool `codec:"loadedLatest" json:"loadedLatest"` +} + +func (o FastTeamData) DeepCopy() FastTeamData { + return FastTeamData{ + Frozen: o.Frozen, + Subversion: o.Subversion, + Tombstoned: o.Tombstoned, + Name: o.Name.DeepCopy(), + Chain: o.Chain.DeepCopy(), + PerTeamKeySeedsUnverified: (func(x map[PerTeamKeyGeneration]PerTeamKeySeed) map[PerTeamKeyGeneration]PerTeamKeySeed { + if x == nil { + return nil + } + ret := make(map[PerTeamKeyGeneration]PerTeamKeySeed, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.PerTeamKeySeedsUnverified), + MaxContinuousPTKGeneration: o.MaxContinuousPTKGeneration.DeepCopy(), + SeedChecks: (func(x map[PerTeamKeyGeneration]PerTeamSeedCheck) map[PerTeamKeyGeneration]PerTeamSeedCheck { + if x == nil { + return nil + } + ret := make(map[PerTeamKeyGeneration]PerTeamSeedCheck, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.SeedChecks), + LatestKeyGeneration: o.LatestKeyGeneration.DeepCopy(), + ReaderKeyMasks: (func(x map[TeamApplication]map[PerTeamKeyGeneration]MaskB64) map[TeamApplication]map[PerTeamKeyGeneration]MaskB64 { + if x == nil { + return nil + } + ret := make(map[TeamApplication]map[PerTeamKeyGeneration]MaskB64, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := (func(x map[PerTeamKeyGeneration]MaskB64) map[PerTeamKeyGeneration]MaskB64 { + if x == nil { + return nil + } + ret := make(map[PerTeamKeyGeneration]MaskB64, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(v) + ret[kCopy] = vCopy + } + return ret + })(o.ReaderKeyMasks), + LatestSeqnoHint: o.LatestSeqnoHint.DeepCopy(), + CachedAt: o.CachedAt.DeepCopy(), + LoadedLatest: o.LoadedLatest, + } +} + +type RatchetType int + +const ( + RatchetType_MAIN RatchetType = 0 + RatchetType_BLINDED RatchetType = 1 + RatchetType_SELF RatchetType = 2 + RatchetType_UNCOMMITTED RatchetType = 3 +) + +func (o RatchetType) DeepCopy() RatchetType { return o } + +var RatchetTypeMap = map[string]RatchetType{ + "MAIN": 0, + "BLINDED": 1, + "SELF": 2, + "UNCOMMITTED": 3, +} + +var RatchetTypeRevMap = map[RatchetType]string{ + 0: "MAIN", + 1: "BLINDED", + 2: "SELF", + 3: "UNCOMMITTED", +} + +func (e RatchetType) String() string { + if v, ok := RatchetTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type HiddenTeamChainRatchetSet struct { + Ratchets map[RatchetType]LinkTripleAndTime `codec:"ratchets" json:"ratchets"` +} + +func (o HiddenTeamChainRatchetSet) DeepCopy() HiddenTeamChainRatchetSet { + return HiddenTeamChainRatchetSet{ + Ratchets: (func(x map[RatchetType]LinkTripleAndTime) map[RatchetType]LinkTripleAndTime { + if x == nil { + return nil + } + ret := make(map[RatchetType]LinkTripleAndTime, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.Ratchets), + } +} + +type HiddenTeamChain struct { + Id TeamID `codec:"id" json:"id"` + Subversion int `codec:"subversion" json:"subversion"` + Public bool `codec:"public" json:"public"` + Frozen bool `codec:"frozen" json:"frozen"` + Tombstoned bool `codec:"tombstoned" json:"tombstoned"` + Last Seqno `codec:"last" json:"last"` + LastFull Seqno `codec:"lastFull" json:"lastFull"` + LatestSeqnoHint Seqno `codec:"latestSeqnoHint" json:"latestSeqnoHint"` + LastCommittedSeqno Seqno `codec:"lastCommittedSeqno" json:"lastCommittedSeqno"` + LinkReceiptTimes map[Seqno]Time `codec:"linkReceiptTimes" json:"linkReceiptTimes"` + LastPerTeamKeys map[PTKType]Seqno `codec:"lastPerTeamKeys" json:"lastPerTeamKeys"` + Outer map[Seqno]LinkID `codec:"outer" json:"outer"` + Inner map[Seqno]HiddenTeamChainLink `codec:"inner" json:"inner"` + ReaderPerTeamKeys map[PerTeamKeyGeneration]Seqno `codec:"readerPerTeamKeys" json:"readerPerTeamKeys"` + RatchetSet HiddenTeamChainRatchetSet `codec:"ratchetSet" json:"ratchetSet"` + CachedAt Time `codec:"cachedAt" json:"cachedAt"` + NeedRotate bool `codec:"needRotate" json:"needRotate"` + MerkleRoots map[Seqno]MerkleRootV2 `codec:"merkleRoots" json:"merkleRoots"` +} + +func (o HiddenTeamChain) DeepCopy() HiddenTeamChain { + return HiddenTeamChain{ + Id: o.Id.DeepCopy(), + Subversion: o.Subversion, + Public: o.Public, + Frozen: o.Frozen, + Tombstoned: o.Tombstoned, + Last: o.Last.DeepCopy(), + LastFull: o.LastFull.DeepCopy(), + LatestSeqnoHint: o.LatestSeqnoHint.DeepCopy(), + LastCommittedSeqno: o.LastCommittedSeqno.DeepCopy(), + LinkReceiptTimes: (func(x map[Seqno]Time) map[Seqno]Time { + if x == nil { + return nil + } + ret := make(map[Seqno]Time, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.LinkReceiptTimes), + LastPerTeamKeys: (func(x map[PTKType]Seqno) map[PTKType]Seqno { + if x == nil { + return nil + } + ret := make(map[PTKType]Seqno, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.LastPerTeamKeys), + Outer: (func(x map[Seqno]LinkID) map[Seqno]LinkID { + if x == nil { + return nil + } + ret := make(map[Seqno]LinkID, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.Outer), + Inner: (func(x map[Seqno]HiddenTeamChainLink) map[Seqno]HiddenTeamChainLink { + if x == nil { + return nil + } + ret := make(map[Seqno]HiddenTeamChainLink, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.Inner), + ReaderPerTeamKeys: (func(x map[PerTeamKeyGeneration]Seqno) map[PerTeamKeyGeneration]Seqno { + if x == nil { + return nil + } + ret := make(map[PerTeamKeyGeneration]Seqno, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.ReaderPerTeamKeys), + RatchetSet: o.RatchetSet.DeepCopy(), + CachedAt: o.CachedAt.DeepCopy(), + NeedRotate: o.NeedRotate, + MerkleRoots: (func(x map[Seqno]MerkleRootV2) map[Seqno]MerkleRootV2 { + if x == nil { + return nil + } + ret := make(map[Seqno]MerkleRootV2, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.MerkleRoots), + } +} + +type LinkTriple struct { + Seqno Seqno `codec:"seqno" json:"seqno"` + SeqType SeqType `codec:"seqType" json:"seqType"` + LinkID LinkID `codec:"linkID" json:"linkID"` +} + +func (o LinkTriple) DeepCopy() LinkTriple { + return LinkTriple{ + Seqno: o.Seqno.DeepCopy(), + SeqType: o.SeqType.DeepCopy(), + LinkID: o.LinkID.DeepCopy(), + } +} + +type LinkTripleAndTime struct { + Triple LinkTriple `codec:"triple" json:"triple"` + Time Time `codec:"time" json:"time"` +} + +func (o LinkTripleAndTime) DeepCopy() LinkTripleAndTime { + return LinkTripleAndTime{ + Triple: o.Triple.DeepCopy(), + Time: o.Time.DeepCopy(), + } +} + +type UpPointer struct { + OurSeqno Seqno `codec:"ourSeqno" json:"ourSeqno"` + ParentID TeamID `codec:"parentID" json:"parentID"` + ParentSeqno Seqno `codec:"parentSeqno" json:"parentSeqno"` + Deletion bool `codec:"deletion" json:"deletion"` +} + +func (o UpPointer) DeepCopy() UpPointer { + return UpPointer{ + OurSeqno: o.OurSeqno.DeepCopy(), + ParentID: o.ParentID.DeepCopy(), + ParentSeqno: o.ParentSeqno.DeepCopy(), + Deletion: o.Deletion, + } +} + +type DownPointer struct { + Id TeamID `codec:"id" json:"id"` + NameComponent string `codec:"nameComponent" json:"nameComponent"` + IsDeleted bool `codec:"isDeleted" json:"isDeleted"` +} + +func (o DownPointer) DeepCopy() DownPointer { + return DownPointer{ + Id: o.Id.DeepCopy(), + NameComponent: o.NameComponent, + IsDeleted: o.IsDeleted, + } +} + +type Signer struct { + E Seqno `codec:"e" json:"e"` + K KID `codec:"k" json:"k"` + U UID `codec:"u" json:"u"` +} + +func (o Signer) DeepCopy() Signer { + return Signer{ + E: o.E.DeepCopy(), + K: o.K.DeepCopy(), + U: o.U.DeepCopy(), + } +} + +type HiddenTeamChainLink struct { + MerkleRoot MerkleRootV2 `codec:"m" json:"m"` + ParentChain LinkTriple `codec:"p" json:"p"` + Signer Signer `codec:"s" json:"s"` + Ptk map[PTKType]PerTeamKeyAndCheck `codec:"k" json:"k"` +} + +func (o HiddenTeamChainLink) DeepCopy() HiddenTeamChainLink { + return HiddenTeamChainLink{ + MerkleRoot: o.MerkleRoot.DeepCopy(), + ParentChain: o.ParentChain.DeepCopy(), + Signer: o.Signer.DeepCopy(), + Ptk: (func(x map[PTKType]PerTeamKeyAndCheck) map[PTKType]PerTeamKeyAndCheck { + if x == nil { + return nil + } + ret := make(map[PTKType]PerTeamKeyAndCheck, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.Ptk), + } +} + +type FastTeamSigChainState struct { + ID TeamID `codec:"ID" json:"ID"` + Public bool `codec:"public" json:"public"` + RootAncestor TeamName `codec:"rootAncestor" json:"rootAncestor"` + NameDepth int `codec:"nameDepth" json:"nameDepth"` + Last *LinkTriple `codec:"last,omitempty" json:"last,omitempty"` + PerTeamKeys map[PerTeamKeyGeneration]PerTeamKey `codec:"perTeamKeys" json:"perTeamKeys"` + PerTeamKeySeedsVerified map[PerTeamKeyGeneration]PerTeamKeySeed `codec:"perTeamKeySeedsVerified" json:"perTeamKeySeedsVerified"` + DownPointers map[Seqno]DownPointer `codec:"downPointers" json:"downPointers"` + LastUpPointer *UpPointer `codec:"lastUpPointer,omitempty" json:"lastUpPointer,omitempty"` + PerTeamKeyCTime UnixTime `codec:"perTeamKeyCTime" json:"perTeamKeyCTime"` + LinkIDs map[Seqno]LinkID `codec:"linkIDs" json:"linkIDs"` + MerkleInfo map[Seqno]MerkleRootV2 `codec:"merkleInfo" json:"merkleInfo"` +} + +func (o FastTeamSigChainState) DeepCopy() FastTeamSigChainState { + return FastTeamSigChainState{ + ID: o.ID.DeepCopy(), + Public: o.Public, + RootAncestor: o.RootAncestor.DeepCopy(), + NameDepth: o.NameDepth, + Last: (func(x *LinkTriple) *LinkTriple { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Last), + PerTeamKeys: (func(x map[PerTeamKeyGeneration]PerTeamKey) map[PerTeamKeyGeneration]PerTeamKey { + if x == nil { + return nil + } + ret := make(map[PerTeamKeyGeneration]PerTeamKey, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.PerTeamKeys), + PerTeamKeySeedsVerified: (func(x map[PerTeamKeyGeneration]PerTeamKeySeed) map[PerTeamKeyGeneration]PerTeamKeySeed { + if x == nil { + return nil + } + ret := make(map[PerTeamKeyGeneration]PerTeamKeySeed, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.PerTeamKeySeedsVerified), + DownPointers: (func(x map[Seqno]DownPointer) map[Seqno]DownPointer { + if x == nil { + return nil + } + ret := make(map[Seqno]DownPointer, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.DownPointers), + LastUpPointer: (func(x *UpPointer) *UpPointer { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.LastUpPointer), + PerTeamKeyCTime: o.PerTeamKeyCTime.DeepCopy(), + LinkIDs: (func(x map[Seqno]LinkID) map[Seqno]LinkID { + if x == nil { + return nil + } + ret := make(map[Seqno]LinkID, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.LinkIDs), + MerkleInfo: (func(x map[Seqno]MerkleRootV2) map[Seqno]MerkleRootV2 { + if x == nil { + return nil + } + ret := make(map[Seqno]MerkleRootV2, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.MerkleInfo), + } +} + +type Audit struct { + Time Time `codec:"time" json:"time"` + MaxMerkleSeqno Seqno `codec:"mms" json:"mms"` + MaxChainSeqno Seqno `codec:"mcs" json:"mcs"` + MaxHiddenSeqno Seqno `codec:"mhs" json:"mhs"` + MaxMerkleProbe Seqno `codec:"mmp" json:"mmp"` +} + +func (o Audit) DeepCopy() Audit { + return Audit{ + Time: o.Time.DeepCopy(), + MaxMerkleSeqno: o.MaxMerkleSeqno.DeepCopy(), + MaxChainSeqno: o.MaxChainSeqno.DeepCopy(), + MaxHiddenSeqno: o.MaxHiddenSeqno.DeepCopy(), + MaxMerkleProbe: o.MaxMerkleProbe.DeepCopy(), + } +} + +type Probe struct { + Index int `codec:"i" json:"i"` + TeamSeqno Seqno `codec:"s" json:"t"` + TeamHiddenSeqno Seqno `codec:"h" json:"h"` +} + +func (o Probe) DeepCopy() Probe { + return Probe{ + Index: o.Index, + TeamSeqno: o.TeamSeqno.DeepCopy(), + TeamHiddenSeqno: o.TeamHiddenSeqno.DeepCopy(), + } +} + +type AuditVersion int + +const ( + AuditVersion_V0 AuditVersion = 0 + AuditVersion_V1 AuditVersion = 1 + AuditVersion_V2 AuditVersion = 2 + AuditVersion_V3 AuditVersion = 3 + AuditVersion_V4 AuditVersion = 4 +) + +func (o AuditVersion) DeepCopy() AuditVersion { return o } + +var AuditVersionMap = map[string]AuditVersion{ + "V0": 0, + "V1": 1, + "V2": 2, + "V3": 3, + "V4": 4, +} + +var AuditVersionRevMap = map[AuditVersion]string{ + 0: "V0", + 1: "V1", + 2: "V2", + 3: "V3", + 4: "V4", +} + +func (e AuditVersion) String() string { + if v, ok := AuditVersionRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +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"` +} + +func (o AuditHistory) DeepCopy() AuditHistory { + return AuditHistory{ + ID: o.ID.DeepCopy(), + Public: o.Public, + PriorMerkleSeqno: o.PriorMerkleSeqno.DeepCopy(), + Version: o.Version.DeepCopy(), + Audits: (func(x []Audit) []Audit { + if x == nil { + return nil + } + ret := make([]Audit, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Audits), + PreProbes: (func(x map[Seqno]Probe) map[Seqno]Probe { + if x == nil { + return nil + } + ret := make(map[Seqno]Probe, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.PreProbes), + PostProbes: (func(x map[Seqno]Probe) map[Seqno]Probe { + if x == nil { + return nil + } + ret := make(map[Seqno]Probe, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.PostProbes), + Tails: (func(x map[Seqno]LinkID) map[Seqno]LinkID { + if x == nil { + return nil + } + ret := make(map[Seqno]LinkID, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.Tails), + HiddenTails: (func(x map[Seqno]LinkID) map[Seqno]LinkID { + if x == nil { + return nil + } + ret := make(map[Seqno]LinkID, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.HiddenTails), + SkipUntil: o.SkipUntil.DeepCopy(), + } +} + +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 +) + +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, +} + +var TeamInviteCategoryRevMap = map[TeamInviteCategory]string{ + 0: "NONE", + 1: "UNKNOWN", + 2: "KEYBASE", + 3: "EMAIL", + 4: "SBS", + 5: "SEITAN", + 6: "PHONE", +} + +func (e TeamInviteCategory) String() string { + if v, ok := TeamInviteCategoryRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type TeamInviteType struct { + C__ TeamInviteCategory `codec:"c" json:"c"` + Unknown__ *string `codec:"unknown,omitempty" json:"unknown,omitempty"` + Sbs__ *TeamInviteSocialNetwork `codec:"sbs,omitempty" json:"sbs,omitempty"` +} + +func (o *TeamInviteType) C() (ret TeamInviteCategory, err error) { + switch o.C__ { + case TeamInviteCategory_UNKNOWN: + if o.Unknown__ == nil { + err = errors.New("unexpected nil value for Unknown__") + return ret, err + } + case TeamInviteCategory_SBS: + if o.Sbs__ == nil { + err = errors.New("unexpected nil value for Sbs__") + return ret, err + } + } + return o.C__, nil +} + +func (o TeamInviteType) Unknown() (res string) { + if o.C__ != TeamInviteCategory_UNKNOWN { + panic("wrong case accessed") + } + if o.Unknown__ == nil { + return + } + return *o.Unknown__ +} + +func (o TeamInviteType) Sbs() (res TeamInviteSocialNetwork) { + if o.C__ != TeamInviteCategory_SBS { + panic("wrong case accessed") + } + if o.Sbs__ == nil { + return + } + return *o.Sbs__ +} + +func NewTeamInviteTypeWithUnknown(v string) TeamInviteType { + return TeamInviteType{ + C__: TeamInviteCategory_UNKNOWN, + Unknown__: &v, + } +} + +func NewTeamInviteTypeWithSbs(v TeamInviteSocialNetwork) TeamInviteType { + return TeamInviteType{ + C__: TeamInviteCategory_SBS, + Sbs__: &v, + } +} + +func NewTeamInviteTypeDefault(c TeamInviteCategory) TeamInviteType { + return TeamInviteType{ + C__: c, + } +} + +func (o TeamInviteType) DeepCopy() TeamInviteType { + return TeamInviteType{ + C__: o.C__.DeepCopy(), + Unknown__: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Unknown__), + Sbs__: (func(x *TeamInviteSocialNetwork) *TeamInviteSocialNetwork { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Sbs__), + } +} + +type TeamInviteSocialNetwork string + +func (o TeamInviteSocialNetwork) DeepCopy() TeamInviteSocialNetwork { + return o +} + +type TeamInviteName string + +func (o TeamInviteName) DeepCopy() TeamInviteName { + 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"` +} + +func (o TeamInvite) DeepCopy() TeamInvite { + return TeamInvite{ + Role: o.Role.DeepCopy(), + Id: o.Id.DeepCopy(), + Type: o.Type.DeepCopy(), + Name: o.Name.DeepCopy(), + Inviter: o.Inviter.DeepCopy(), + } +} + +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"` +} + +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(), + InviterUsername: o.InviterUsername, + TeamName: o.TeamName, + Status: o.Status.DeepCopy(), + } +} + +type TeamEncryptedKBFSKeyset struct { + V int `codec:"v" json:"v"` + E []byte `codec:"e" json:"e"` + N []byte `codec:"n" json:"n"` +} + +func (o TeamEncryptedKBFSKeyset) DeepCopy() TeamEncryptedKBFSKeyset { + return TeamEncryptedKBFSKeyset{ + V: o.V, + E: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.E), + N: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.N), + } +} + +type TeamGetLegacyTLFUpgrade struct { + EncryptedKeyset string `codec:"encryptedKeyset" json:"encrypted_keyset"` + TeamGeneration PerTeamKeyGeneration `codec:"teamGeneration" json:"team_generation"` + LegacyGeneration int `codec:"legacyGeneration" json:"legacy_generation"` + AppType TeamApplication `codec:"appType" json:"app_type"` +} + +func (o TeamGetLegacyTLFUpgrade) DeepCopy() TeamGetLegacyTLFUpgrade { + return TeamGetLegacyTLFUpgrade{ + EncryptedKeyset: o.EncryptedKeyset, + TeamGeneration: o.TeamGeneration.DeepCopy(), + LegacyGeneration: o.LegacyGeneration, + AppType: o.AppType.DeepCopy(), + } +} + +type TeamEncryptedKBFSKeysetHash string + +func (o TeamEncryptedKBFSKeysetHash) DeepCopy() TeamEncryptedKBFSKeysetHash { + return o +} + +type TeamLegacyTLFUpgradeChainInfo struct { + KeysetHash TeamEncryptedKBFSKeysetHash `codec:"keysetHash" json:"keysetHash"` + TeamGeneration PerTeamKeyGeneration `codec:"teamGeneration" json:"teamGeneration"` + LegacyGeneration int `codec:"legacyGeneration" json:"legacyGeneration"` + AppType TeamApplication `codec:"appType" json:"appType"` +} + +func (o TeamLegacyTLFUpgradeChainInfo) DeepCopy() TeamLegacyTLFUpgradeChainInfo { + return TeamLegacyTLFUpgradeChainInfo{ + KeysetHash: o.KeysetHash.DeepCopy(), + TeamGeneration: o.TeamGeneration.DeepCopy(), + LegacyGeneration: o.LegacyGeneration, + AppType: o.AppType.DeepCopy(), + } +} + +type TeamSigChainState struct { + Reader UserVersion `codec:"reader" json:"reader"` + Id TeamID `codec:"id" json:"id"` + Implicit bool `codec:"implicit" json:"implicit"` + Public bool `codec:"public" json:"public"` + RootAncestor TeamName `codec:"rootAncestor" json:"rootAncestor"` + NameDepth int `codec:"nameDepth" json:"nameDepth"` + NameLog []TeamNameLogPoint `codec:"nameLog" json:"nameLog"` + LastSeqno Seqno `codec:"lastSeqno" json:"lastSeqno"` + LastLinkID LinkID `codec:"lastLinkID" json:"lastLinkID"` + LastHighSeqno Seqno `codec:"lastHighSeqno" json:"lastHighSeqno"` + LastHighLinkID LinkID `codec:"lastHighLinkID" json:"lastHighLinkID"` + ParentID *TeamID `codec:"parentID,omitempty" json:"parentID,omitempty"` + UserLog map[UserVersion][]UserLogPoint `codec:"userLog" json:"userLog"` + SubteamLog map[TeamID][]SubteamLogPoint `codec:"subteamLog" json:"subteamLog"` + PerTeamKeys map[PerTeamKeyGeneration]PerTeamKey `codec:"perTeamKeys" json:"perTeamKeys"` + MaxPerTeamKeyGeneration PerTeamKeyGeneration `codec:"maxPerTeamKeyGeneration" json:"maxPerTeamKeyGeneration"` + 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"` + Open bool `codec:"open" json:"open"` + OpenTeamJoinAs TeamRole `codec:"openTeamJoinAs" json:"openTeamJoinAs"` + Bots map[UserVersion]TeamBotSettings `codec:"bots" json:"bots"` + TlfIDs []TLFID `codec:"tlfIDs" json:"tlfIDs"` + TlfLegacyUpgrade map[TeamApplication]TeamLegacyTLFUpgradeChainInfo `codec:"tlfLegacyUpgrade" json:"tlfLegacyUpgrade"` + HeadMerkle *MerkleRootV2 `codec:"headMerkle,omitempty" json:"headMerkle,omitempty"` + MerkleRoots map[Seqno]MerkleRootV2 `codec:"merkleRoots" json:"merkleRoots"` +} + +func (o TeamSigChainState) DeepCopy() TeamSigChainState { + return TeamSigChainState{ + Reader: o.Reader.DeepCopy(), + Id: o.Id.DeepCopy(), + Implicit: o.Implicit, + Public: o.Public, + RootAncestor: o.RootAncestor.DeepCopy(), + NameDepth: o.NameDepth, + NameLog: (func(x []TeamNameLogPoint) []TeamNameLogPoint { + if x == nil { + return nil + } + ret := make([]TeamNameLogPoint, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.NameLog), + LastSeqno: o.LastSeqno.DeepCopy(), + LastLinkID: o.LastLinkID.DeepCopy(), + LastHighSeqno: o.LastHighSeqno.DeepCopy(), + LastHighLinkID: o.LastHighLinkID.DeepCopy(), + ParentID: (func(x *TeamID) *TeamID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ParentID), + UserLog: (func(x map[UserVersion][]UserLogPoint) map[UserVersion][]UserLogPoint { + if x == nil { + return nil + } + ret := make(map[UserVersion][]UserLogPoint, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := (func(x []UserLogPoint) []UserLogPoint { + if x == nil { + return nil + } + ret := make([]UserLogPoint, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(v) + ret[kCopy] = vCopy + } + return ret + })(o.UserLog), + SubteamLog: (func(x map[TeamID][]SubteamLogPoint) map[TeamID][]SubteamLogPoint { + if x == nil { + return nil + } + ret := make(map[TeamID][]SubteamLogPoint, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := (func(x []SubteamLogPoint) []SubteamLogPoint { + if x == nil { + return nil + } + ret := make([]SubteamLogPoint, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(v) + ret[kCopy] = vCopy + } + return ret + })(o.SubteamLog), + PerTeamKeys: (func(x map[PerTeamKeyGeneration]PerTeamKey) map[PerTeamKeyGeneration]PerTeamKey { + if x == nil { + return nil + } + ret := make(map[PerTeamKeyGeneration]PerTeamKey, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.PerTeamKeys), + MaxPerTeamKeyGeneration: o.MaxPerTeamKeyGeneration.DeepCopy(), + PerTeamKeyCTime: o.PerTeamKeyCTime.DeepCopy(), + LinkIDs: (func(x map[Seqno]LinkID) map[Seqno]LinkID { + if x == nil { + return nil + } + ret := make(map[Seqno]LinkID, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.LinkIDs), + StubbedLinks: (func(x map[Seqno]bool) map[Seqno]bool { + if x == nil { + return nil + } + ret := make(map[Seqno]bool, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v + ret[kCopy] = vCopy + } + 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 { + 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.ObsoleteInvites), + Open: o.Open, + OpenTeamJoinAs: o.OpenTeamJoinAs.DeepCopy(), + Bots: (func(x map[UserVersion]TeamBotSettings) map[UserVersion]TeamBotSettings { + if x == nil { + return nil + } + ret := make(map[UserVersion]TeamBotSettings, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.Bots), + TlfIDs: (func(x []TLFID) []TLFID { + if x == nil { + return nil + } + ret := make([]TLFID, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.TlfIDs), + TlfLegacyUpgrade: (func(x map[TeamApplication]TeamLegacyTLFUpgradeChainInfo) map[TeamApplication]TeamLegacyTLFUpgradeChainInfo { + if x == nil { + return nil + } + ret := make(map[TeamApplication]TeamLegacyTLFUpgradeChainInfo, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.TlfLegacyUpgrade), + HeadMerkle: (func(x *MerkleRootV2) *MerkleRootV2 { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.HeadMerkle), + MerkleRoots: (func(x map[Seqno]MerkleRootV2) map[Seqno]MerkleRootV2 { + if x == nil { + return nil + } + ret := make(map[Seqno]MerkleRootV2, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.MerkleRoots), + } +} + +type BoxSummaryHash string + +func (o BoxSummaryHash) DeepCopy() BoxSummaryHash { + return o +} + +type TeamNameLogPoint struct { + LastPart TeamNamePart `codec:"lastPart" json:"lastPart"` + Seqno Seqno `codec:"seqno" json:"seqno"` +} + +func (o TeamNameLogPoint) DeepCopy() TeamNameLogPoint { + return TeamNameLogPoint{ + LastPart: o.LastPart.DeepCopy(), + Seqno: o.Seqno.DeepCopy(), + } +} + +type UserLogPoint struct { + Role TeamRole `codec:"role" json:"role"` + SigMeta SignatureMetadata `codec:"sigMeta" json:"sigMeta"` +} + +func (o UserLogPoint) DeepCopy() UserLogPoint { + return UserLogPoint{ + Role: o.Role.DeepCopy(), + SigMeta: o.SigMeta.DeepCopy(), + } +} + +type SubteamLogPoint struct { + Name TeamName `codec:"name" json:"name"` + Seqno Seqno `codec:"seqno" json:"seqno"` +} + +func (o SubteamLogPoint) DeepCopy() SubteamLogPoint { + return SubteamLogPoint{ + Name: o.Name.DeepCopy(), + Seqno: o.Seqno.DeepCopy(), + } +} + +type TeamNamePart string + +func (o TeamNamePart) DeepCopy() TeamNamePart { + return o +} + +type TeamName struct { + Parts []TeamNamePart `codec:"parts" json:"parts"` +} + +func (o TeamName) DeepCopy() TeamName { + return TeamName{ + Parts: (func(x []TeamNamePart) []TeamNamePart { + if x == nil { + return nil + } + ret := make([]TeamNamePart, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Parts), + } +} + +type TeamCLKRResetUser struct { + Uid UID `codec:"uid" json:"uid"` + UserEldestSeqno Seqno `codec:"userEldestSeqno" json:"user_eldest"` + MemberEldestSeqno Seqno `codec:"memberEldestSeqno" json:"member_eldest"` +} + +func (o TeamCLKRResetUser) DeepCopy() TeamCLKRResetUser { + return TeamCLKRResetUser{ + Uid: o.Uid.DeepCopy(), + UserEldestSeqno: o.UserEldestSeqno.DeepCopy(), + MemberEldestSeqno: o.MemberEldestSeqno.DeepCopy(), + } +} + +type TeamCLKRMsg struct { + TeamID TeamID `codec:"teamID" json:"team_id"` + Generation PerTeamKeyGeneration `codec:"generation" json:"generation"` + Score int `codec:"score" json:"score"` + ResetUsersUntrusted []TeamCLKRResetUser `codec:"resetUsersUntrusted" json:"reset_users"` +} + +func (o TeamCLKRMsg) DeepCopy() TeamCLKRMsg { + return TeamCLKRMsg{ + TeamID: o.TeamID.DeepCopy(), + Generation: o.Generation.DeepCopy(), + Score: o.Score, + ResetUsersUntrusted: (func(x []TeamCLKRResetUser) []TeamCLKRResetUser { + if x == nil { + return nil + } + ret := make([]TeamCLKRResetUser, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.ResetUsersUntrusted), + } +} + +type TeamResetUser struct { + Username string `codec:"username" json:"username"` + Uid UID `codec:"uid" json:"uid"` + EldestSeqno Seqno `codec:"eldestSeqno" json:"eldest_seqno"` + IsDelete bool `codec:"isDelete" json:"is_delete"` +} + +func (o TeamResetUser) DeepCopy() TeamResetUser { + return TeamResetUser{ + Username: o.Username, + Uid: o.Uid.DeepCopy(), + EldestSeqno: o.EldestSeqno.DeepCopy(), + IsDelete: o.IsDelete, + } +} + +type TeamMemberOutFromReset struct { + TeamID TeamID `codec:"teamID" json:"team_id"` + TeamName string `codec:"teamName" json:"team_name"` + ResetUser TeamResetUser `codec:"resetUser" json:"reset_user"` +} + +func (o TeamMemberOutFromReset) DeepCopy() TeamMemberOutFromReset { + return TeamMemberOutFromReset{ + TeamID: o.TeamID.DeepCopy(), + TeamName: o.TeamName, + ResetUser: o.ResetUser.DeepCopy(), + } +} + +type TeamChangeRow struct { + Id TeamID `codec:"id" json:"id"` + Name string `codec:"name" json:"name"` + KeyRotated bool `codec:"keyRotated" json:"key_rotated"` + 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"` + ImplicitTeam bool `codec:"implicitTeam" json:"implicit_team"` + Misc bool `codec:"misc" json:"misc"` + RemovedResetUsers bool `codec:"removedResetUsers" json:"removed_reset_users"` +} + +func (o TeamChangeRow) DeepCopy() TeamChangeRow { + return TeamChangeRow{ + Id: o.Id.DeepCopy(), + Name: o.Name, + KeyRotated: o.KeyRotated, + MembershipChanged: o.MembershipChanged, + LatestSeqno: o.LatestSeqno.DeepCopy(), + LatestHiddenSeqno: o.LatestHiddenSeqno.DeepCopy(), + LatestOffchainSeqno: o.LatestOffchainSeqno.DeepCopy(), + ImplicitTeam: o.ImplicitTeam, + Misc: o.Misc, + RemovedResetUsers: o.RemovedResetUsers, + } +} + +type TeamExitRow struct { + Id TeamID `codec:"id" json:"id"` +} + +func (o TeamExitRow) DeepCopy() TeamExitRow { + return TeamExitRow{ + Id: o.Id.DeepCopy(), + } +} + +type TeamNewlyAddedRow struct { + Id TeamID `codec:"id" json:"id"` + Name string `codec:"name" json:"name"` +} + +func (o TeamNewlyAddedRow) DeepCopy() TeamNewlyAddedRow { + return TeamNewlyAddedRow{ + Id: o.Id.DeepCopy(), + Name: o.Name, + } +} + +type TeamInvitee struct { + InviteID TeamInviteID `codec:"inviteID" json:"invite_id"` + Uid UID `codec:"uid" json:"uid"` + EldestSeqno Seqno `codec:"eldestSeqno" json:"eldest_seqno"` + Role TeamRole `codec:"role" json:"role"` +} + +func (o TeamInvitee) DeepCopy() TeamInvitee { + return TeamInvitee{ + InviteID: o.InviteID.DeepCopy(), + Uid: o.Uid.DeepCopy(), + EldestSeqno: o.EldestSeqno.DeepCopy(), + Role: o.Role.DeepCopy(), + } +} + +type TeamSBSMsg struct { + TeamID TeamID `codec:"teamID" json:"team_id"` + Score int `codec:"score" json:"score"` + Invitees []TeamInvitee `codec:"invitees" json:"invitees"` +} + +func (o TeamSBSMsg) DeepCopy() TeamSBSMsg { + return TeamSBSMsg{ + TeamID: o.TeamID.DeepCopy(), + Score: o.Score, + Invitees: (func(x []TeamInvitee) []TeamInvitee { + if x == nil { + return nil + } + ret := make([]TeamInvitee, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Invitees), + } +} + +type TeamAccessRequest struct { + Uid UID `codec:"uid" json:"uid"` + EldestSeqno Seqno `codec:"eldestSeqno" json:"eldest_seqno"` +} + +func (o TeamAccessRequest) DeepCopy() TeamAccessRequest { + return TeamAccessRequest{ + Uid: o.Uid.DeepCopy(), + EldestSeqno: o.EldestSeqno.DeepCopy(), + } +} + +type TeamOpenReqMsg struct { + TeamID TeamID `codec:"teamID" json:"team_id"` + Tars []TeamAccessRequest `codec:"tars" json:"tars"` +} + +func (o TeamOpenReqMsg) DeepCopy() TeamOpenReqMsg { + return TeamOpenReqMsg{ + TeamID: o.TeamID.DeepCopy(), + Tars: (func(x []TeamAccessRequest) []TeamAccessRequest { + if x == nil { + return nil + } + ret := make([]TeamAccessRequest, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Tars), + } +} + +type SeitanAKey string + +func (o SeitanAKey) DeepCopy() SeitanAKey { + return o +} + +type SeitanIKey string + +func (o SeitanIKey) DeepCopy() SeitanIKey { + return o +} + +type SeitanPubKey string + +func (o SeitanPubKey) DeepCopy() SeitanPubKey { + return o +} + +type SeitanIKeyV2 string + +func (o SeitanIKeyV2) DeepCopy() SeitanIKeyV2 { + return o +} + +type SeitanKeyAndLabelVersion int + +const ( + SeitanKeyAndLabelVersion_V1 SeitanKeyAndLabelVersion = 1 + SeitanKeyAndLabelVersion_V2 SeitanKeyAndLabelVersion = 2 +) + +func (o SeitanKeyAndLabelVersion) DeepCopy() SeitanKeyAndLabelVersion { return o } + +var SeitanKeyAndLabelVersionMap = map[string]SeitanKeyAndLabelVersion{ + "V1": 1, + "V2": 2, +} + +var SeitanKeyAndLabelVersionRevMap = map[SeitanKeyAndLabelVersion]string{ + 1: "V1", + 2: "V2", +} + +func (e SeitanKeyAndLabelVersion) String() string { + if v, ok := SeitanKeyAndLabelVersionRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +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"` +} + +func (o *SeitanKeyAndLabel) V() (ret SeitanKeyAndLabelVersion, err error) { + switch o.V__ { + case SeitanKeyAndLabelVersion_V1: + if o.V1__ == nil { + err = errors.New("unexpected nil value for V1__") + return ret, err + } + case SeitanKeyAndLabelVersion_V2: + if o.V2__ == nil { + err = errors.New("unexpected nil value for V2__") + return ret, err + } + } + return o.V__, nil +} + +func (o SeitanKeyAndLabel) V1() (res SeitanKeyAndLabelVersion1) { + if o.V__ != SeitanKeyAndLabelVersion_V1 { + panic("wrong case accessed") + } + if o.V1__ == nil { + return + } + return *o.V1__ +} + +func (o SeitanKeyAndLabel) V2() (res SeitanKeyAndLabelVersion2) { + if o.V__ != SeitanKeyAndLabelVersion_V2 { + panic("wrong case accessed") + } + if o.V2__ == nil { + return + } + return *o.V2__ +} + +func NewSeitanKeyAndLabelWithV1(v SeitanKeyAndLabelVersion1) SeitanKeyAndLabel { + return SeitanKeyAndLabel{ + V__: SeitanKeyAndLabelVersion_V1, + V1__: &v, + } +} + +func NewSeitanKeyAndLabelWithV2(v SeitanKeyAndLabelVersion2) SeitanKeyAndLabel { + return SeitanKeyAndLabel{ + V__: SeitanKeyAndLabelVersion_V2, + V2__: &v, + } +} + +func NewSeitanKeyAndLabelDefault(v SeitanKeyAndLabelVersion) SeitanKeyAndLabel { + return SeitanKeyAndLabel{ + V__: v, + } +} + +func (o SeitanKeyAndLabel) DeepCopy() SeitanKeyAndLabel { + return SeitanKeyAndLabel{ + V__: o.V__.DeepCopy(), + V1__: (func(x *SeitanKeyAndLabelVersion1) *SeitanKeyAndLabelVersion1 { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V1__), + V2__: (func(x *SeitanKeyAndLabelVersion2) *SeitanKeyAndLabelVersion2 { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V2__), + } +} + +type SeitanKeyAndLabelVersion1 struct { + I SeitanIKey `codec:"i" json:"i"` + L SeitanKeyLabel `codec:"l" json:"l"` +} + +func (o SeitanKeyAndLabelVersion1) DeepCopy() SeitanKeyAndLabelVersion1 { + return SeitanKeyAndLabelVersion1{ + I: o.I.DeepCopy(), + L: o.L.DeepCopy(), + } +} + +type SeitanKeyAndLabelVersion2 struct { + K SeitanPubKey `codec:"k" json:"k"` + L SeitanKeyLabel `codec:"l" json:"l"` +} + +func (o SeitanKeyAndLabelVersion2) DeepCopy() SeitanKeyAndLabelVersion2 { + return SeitanKeyAndLabelVersion2{ + K: o.K.DeepCopy(), + L: o.L.DeepCopy(), + } +} + +type SeitanKeyLabelType int + +const ( + SeitanKeyLabelType_SMS SeitanKeyLabelType = 1 +) + +func (o SeitanKeyLabelType) DeepCopy() SeitanKeyLabelType { return o } + +var SeitanKeyLabelTypeMap = map[string]SeitanKeyLabelType{ + "SMS": 1, +} + +var SeitanKeyLabelTypeRevMap = map[SeitanKeyLabelType]string{ + 1: "SMS", +} + +func (e SeitanKeyLabelType) String() string { + if v, ok := SeitanKeyLabelTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type SeitanKeyLabel struct { + T__ SeitanKeyLabelType `codec:"t" json:"t"` + Sms__ *SeitanKeyLabelSms `codec:"sms,omitempty" json:"sms,omitempty"` +} + +func (o *SeitanKeyLabel) T() (ret SeitanKeyLabelType, err error) { + switch o.T__ { + case SeitanKeyLabelType_SMS: + if o.Sms__ == nil { + err = errors.New("unexpected nil value for Sms__") + return ret, err + } + } + return o.T__, nil +} + +func (o SeitanKeyLabel) Sms() (res SeitanKeyLabelSms) { + if o.T__ != SeitanKeyLabelType_SMS { + panic("wrong case accessed") + } + if o.Sms__ == nil { + return + } + return *o.Sms__ +} + +func NewSeitanKeyLabelWithSms(v SeitanKeyLabelSms) SeitanKeyLabel { + return SeitanKeyLabel{ + T__: SeitanKeyLabelType_SMS, + Sms__: &v, + } +} + +func NewSeitanKeyLabelDefault(t SeitanKeyLabelType) SeitanKeyLabel { + return SeitanKeyLabel{ + T__: t, + } +} + +func (o SeitanKeyLabel) DeepCopy() SeitanKeyLabel { + return SeitanKeyLabel{ + T__: o.T__.DeepCopy(), + Sms__: (func(x *SeitanKeyLabelSms) *SeitanKeyLabelSms { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Sms__), + } +} + +type SeitanKeyLabelSms struct { + F string `codec:"f" json:"f"` + N string `codec:"n" json:"n"` +} + +func (o SeitanKeyLabelSms) DeepCopy() SeitanKeyLabelSms { + return SeitanKeyLabelSms{ + F: o.F, + N: o.N, + } +} + +type TeamSeitanRequest struct { + InviteID TeamInviteID `codec:"inviteID" json:"invite_id"` + Uid UID `codec:"uid" json:"uid"` + EldestSeqno Seqno `codec:"eldestSeqno" json:"eldest_seqno"` + Akey SeitanAKey `codec:"akey" json:"akey"` + Role TeamRole `codec:"role" json:"role"` + UnixCTime int64 `codec:"unixCTime" json:"ctime"` +} + +func (o TeamSeitanRequest) DeepCopy() TeamSeitanRequest { + return TeamSeitanRequest{ + InviteID: o.InviteID.DeepCopy(), + Uid: o.Uid.DeepCopy(), + EldestSeqno: o.EldestSeqno.DeepCopy(), + Akey: o.Akey.DeepCopy(), + Role: o.Role.DeepCopy(), + UnixCTime: o.UnixCTime, + } +} + +type TeamSeitanMsg struct { + TeamID TeamID `codec:"teamID" json:"team_id"` + Seitans []TeamSeitanRequest `codec:"seitans" json:"seitans"` +} + +func (o TeamSeitanMsg) DeepCopy() TeamSeitanMsg { + return TeamSeitanMsg{ + TeamID: o.TeamID.DeepCopy(), + Seitans: (func(x []TeamSeitanRequest) []TeamSeitanRequest { + if x == nil { + return nil + } + ret := make([]TeamSeitanRequest, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Seitans), + } +} + +type TeamOpenSweepMsg struct { + TeamID TeamID `codec:"teamID" json:"team_id"` + ResetUsersUntrusted []TeamCLKRResetUser `codec:"resetUsersUntrusted" json:"reset_users"` +} + +func (o TeamOpenSweepMsg) DeepCopy() TeamOpenSweepMsg { + return TeamOpenSweepMsg{ + TeamID: o.TeamID.DeepCopy(), + ResetUsersUntrusted: (func(x []TeamCLKRResetUser) []TeamCLKRResetUser { + if x == nil { + return nil + } + ret := make([]TeamCLKRResetUser, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.ResetUsersUntrusted), + } +} + +type TeamKBFSKeyRefresher struct { + Generation int `codec:"generation" json:"generation"` + AppType TeamApplication `codec:"appType" json:"appType"` +} + +func (o TeamKBFSKeyRefresher) DeepCopy() TeamKBFSKeyRefresher { + return TeamKBFSKeyRefresher{ + Generation: o.Generation, + AppType: o.AppType.DeepCopy(), + } +} + +// * TeamRefreshData are needed or wanted data requirements that, if unmet, will cause +// * a refresh of the cache. +type TeamRefreshers struct { + NeedKeyGeneration PerTeamKeyGeneration `codec:"needKeyGeneration" json:"needKeyGeneration"` + NeedApplicationsAtGenerations map[PerTeamKeyGeneration][]TeamApplication `codec:"needApplicationsAtGenerations" json:"needApplicationsAtGenerations"` + NeedApplicationsAtGenerationsWithKBFS map[PerTeamKeyGeneration][]TeamApplication `codec:"needApplicationsAtGenerationsWithKBFS" json:"needApplicationsAtGenerationsWithKBFS"` + WantMembers []UserVersion `codec:"wantMembers" json:"wantMembers"` + WantMembersRole TeamRole `codec:"wantMembersRole" json:"wantMembersRole"` + NeedKBFSKeyGeneration TeamKBFSKeyRefresher `codec:"needKBFSKeyGeneration" json:"needKBFSKeyGeneration"` +} + +func (o TeamRefreshers) DeepCopy() TeamRefreshers { + return TeamRefreshers{ + NeedKeyGeneration: o.NeedKeyGeneration.DeepCopy(), + NeedApplicationsAtGenerations: (func(x map[PerTeamKeyGeneration][]TeamApplication) map[PerTeamKeyGeneration][]TeamApplication { + if x == nil { + return nil + } + ret := make(map[PerTeamKeyGeneration][]TeamApplication, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := (func(x []TeamApplication) []TeamApplication { + if x == nil { + return nil + } + ret := make([]TeamApplication, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(v) + ret[kCopy] = vCopy + } + return ret + })(o.NeedApplicationsAtGenerations), + NeedApplicationsAtGenerationsWithKBFS: (func(x map[PerTeamKeyGeneration][]TeamApplication) map[PerTeamKeyGeneration][]TeamApplication { + if x == nil { + return nil + } + ret := make(map[PerTeamKeyGeneration][]TeamApplication, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := (func(x []TeamApplication) []TeamApplication { + if x == nil { + return nil + } + ret := make([]TeamApplication, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(v) + ret[kCopy] = vCopy + } + return ret + })(o.NeedApplicationsAtGenerationsWithKBFS), + WantMembers: (func(x []UserVersion) []UserVersion { + if x == nil { + return nil + } + ret := make([]UserVersion, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.WantMembers), + WantMembersRole: o.WantMembersRole.DeepCopy(), + NeedKBFSKeyGeneration: o.NeedKBFSKeyGeneration.DeepCopy(), + } +} + +type LoadTeamArg struct { + ID TeamID `codec:"ID" json:"ID"` + Name string `codec:"name" json:"name"` + Public bool `codec:"public" json:"public"` + NeedAdmin bool `codec:"needAdmin" json:"needAdmin"` + RefreshUIDMapper bool `codec:"refreshUIDMapper" json:"refreshUIDMapper"` + Refreshers TeamRefreshers `codec:"refreshers" json:"refreshers"` + ForceFullReload bool `codec:"forceFullReload" json:"forceFullReload"` + ForceRepoll bool `codec:"forceRepoll" json:"forceRepoll"` + StaleOK bool `codec:"staleOK" json:"staleOK"` + AllowNameLookupBurstCache bool `codec:"allowNameLookupBurstCache" json:"allowNameLookupBurstCache"` + SkipNeedHiddenRotateCheck bool `codec:"skipNeedHiddenRotateCheck" json:"skipNeedHiddenRotateCheck"` + AuditMode AuditMode `codec:"auditMode" json:"auditMode"` +} + +func (o LoadTeamArg) DeepCopy() LoadTeamArg { + return LoadTeamArg{ + ID: o.ID.DeepCopy(), + Name: o.Name, + Public: o.Public, + NeedAdmin: o.NeedAdmin, + RefreshUIDMapper: o.RefreshUIDMapper, + Refreshers: o.Refreshers.DeepCopy(), + ForceFullReload: o.ForceFullReload, + ForceRepoll: o.ForceRepoll, + StaleOK: o.StaleOK, + AllowNameLookupBurstCache: o.AllowNameLookupBurstCache, + SkipNeedHiddenRotateCheck: o.SkipNeedHiddenRotateCheck, + AuditMode: o.AuditMode.DeepCopy(), + } +} + +type FastTeamLoadArg struct { + ID TeamID `codec:"ID" json:"ID"` + Public bool `codec:"public" json:"public"` + AssertTeamName *TeamName `codec:"assertTeamName,omitempty" json:"assertTeamName,omitempty"` + Applications []TeamApplication `codec:"applications" json:"applications"` + KeyGenerationsNeeded []PerTeamKeyGeneration `codec:"keyGenerationsNeeded" json:"keyGenerationsNeeded"` + NeedLatestKey bool `codec:"needLatestKey" json:"needLatestKey"` + ForceRefresh bool `codec:"forceRefresh" json:"forceRefresh"` + HiddenChainIsOptional bool `codec:"hiddenChainIsOptional" json:"hiddenChainIsOptional"` +} + +func (o FastTeamLoadArg) DeepCopy() FastTeamLoadArg { + return FastTeamLoadArg{ + ID: o.ID.DeepCopy(), + Public: o.Public, + AssertTeamName: (func(x *TeamName) *TeamName { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.AssertTeamName), + Applications: (func(x []TeamApplication) []TeamApplication { + if x == nil { + return nil + } + ret := make([]TeamApplication, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Applications), + KeyGenerationsNeeded: (func(x []PerTeamKeyGeneration) []PerTeamKeyGeneration { + if x == nil { + return nil + } + ret := make([]PerTeamKeyGeneration, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.KeyGenerationsNeeded), + NeedLatestKey: o.NeedLatestKey, + ForceRefresh: o.ForceRefresh, + HiddenChainIsOptional: o.HiddenChainIsOptional, + } +} + +type FastTeamLoadRes struct { + Name TeamName `codec:"name" json:"name"` + ApplicationKeys []TeamApplicationKey `codec:"applicationKeys" json:"applicationKeys"` +} + +func (o FastTeamLoadRes) DeepCopy() FastTeamLoadRes { + return FastTeamLoadRes{ + Name: o.Name.DeepCopy(), + ApplicationKeys: (func(x []TeamApplicationKey) []TeamApplicationKey { + if x == nil { + return nil + } + ret := make([]TeamApplicationKey, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.ApplicationKeys), + } +} + +type ImplicitRole struct { + Role TeamRole `codec:"role" json:"role"` + Ancestor TeamID `codec:"ancestor" json:"ancestor"` +} + +func (o ImplicitRole) DeepCopy() ImplicitRole { + return ImplicitRole{ + Role: o.Role.DeepCopy(), + Ancestor: o.Ancestor.DeepCopy(), + } +} + +type MemberInfo struct { + UserID UID `codec:"userID" json:"uid"` + TeamID TeamID `codec:"teamID" json:"team_id"` + FqName string `codec:"fqName" json:"fq_name"` + IsImplicitTeam bool `codec:"isImplicitTeam" json:"is_implicit_team"` + IsOpenTeam bool `codec:"isOpenTeam" json:"is_open_team"` + Role TeamRole `codec:"role" json:"role"` + Implicit *ImplicitRole `codec:"implicit,omitempty" json:"implicit,omitempty"` + MemberCount int `codec:"memberCount" json:"member_count"` + AllowProfilePromote bool `codec:"allowProfilePromote" json:"allow_profile_promote"` + IsMemberShowcased bool `codec:"isMemberShowcased" json:"is_member_showcased"` +} + +func (o MemberInfo) DeepCopy() MemberInfo { + return MemberInfo{ + UserID: o.UserID.DeepCopy(), + TeamID: o.TeamID.DeepCopy(), + FqName: o.FqName, + IsImplicitTeam: o.IsImplicitTeam, + IsOpenTeam: o.IsOpenTeam, + Role: o.Role.DeepCopy(), + Implicit: (func(x *ImplicitRole) *ImplicitRole { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Implicit), + MemberCount: o.MemberCount, + AllowProfilePromote: o.AllowProfilePromote, + IsMemberShowcased: o.IsMemberShowcased, + } +} + +type TeamList struct { + Teams []MemberInfo `codec:"teams" json:"teams"` +} + +func (o TeamList) DeepCopy() TeamList { + return TeamList{ + Teams: (func(x []MemberInfo) []MemberInfo { + if x == nil { + return nil + } + ret := make([]MemberInfo, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Teams), + } +} + +type AnnotatedMemberInfo struct { + UserID UID `codec:"userID" json:"uid"` + TeamID TeamID `codec:"teamID" json:"team_id"` + Username string `codec:"username" json:"username"` + FullName string `codec:"fullName" json:"full_name"` + FqName string `codec:"fqName" json:"fq_name"` + IsImplicitTeam bool `codec:"isImplicitTeam" json:"is_implicit_team"` + ImpTeamDisplayName string `codec:"impTeamDisplayName" json:"implicit_team_display_name"` + IsOpenTeam bool `codec:"isOpenTeam" json:"is_open_team"` + Role TeamRole `codec:"role" json:"role"` + Implicit *ImplicitRole `codec:"implicit,omitempty" json:"implicit,omitempty"` + NeedsPUK bool `codec:"needsPUK" json:"needsPUK"` + MemberCount int `codec:"memberCount" json:"member_count"` + EldestSeqno Seqno `codec:"eldestSeqno" json:"member_eldest_seqno"` + AllowProfilePromote bool `codec:"allowProfilePromote" json:"allow_profile_promote"` + IsMemberShowcased bool `codec:"isMemberShowcased" json:"is_member_showcased"` + Status TeamMemberStatus `codec:"status" json:"status"` +} + +func (o AnnotatedMemberInfo) DeepCopy() AnnotatedMemberInfo { + return AnnotatedMemberInfo{ + UserID: o.UserID.DeepCopy(), + TeamID: o.TeamID.DeepCopy(), + Username: o.Username, + FullName: o.FullName, + FqName: o.FqName, + IsImplicitTeam: o.IsImplicitTeam, + ImpTeamDisplayName: o.ImpTeamDisplayName, + IsOpenTeam: o.IsOpenTeam, + Role: o.Role.DeepCopy(), + Implicit: (func(x *ImplicitRole) *ImplicitRole { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Implicit), + NeedsPUK: o.NeedsPUK, + MemberCount: o.MemberCount, + EldestSeqno: o.EldestSeqno.DeepCopy(), + AllowProfilePromote: o.AllowProfilePromote, + IsMemberShowcased: o.IsMemberShowcased, + Status: o.Status.DeepCopy(), + } +} + +type AnnotatedTeamList struct { + Teams []AnnotatedMemberInfo `codec:"teams" json:"teams"` + AnnotatedActiveInvites map[TeamInviteID]AnnotatedTeamInvite `codec:"annotatedActiveInvites" json:"annotatedActiveInvites"` +} + +func (o AnnotatedTeamList) DeepCopy() AnnotatedTeamList { + return AnnotatedTeamList{ + Teams: (func(x []AnnotatedMemberInfo) []AnnotatedMemberInfo { + if x == nil { + return nil + } + ret := make([]AnnotatedMemberInfo, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Teams), + AnnotatedActiveInvites: (func(x map[TeamInviteID]AnnotatedTeamInvite) map[TeamInviteID]AnnotatedTeamInvite { + if x == nil { + return nil + } + ret := make(map[TeamInviteID]AnnotatedTeamInvite, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.AnnotatedActiveInvites), + } +} + +type TeamAddMemberResult struct { + Invited bool `codec:"invited" json:"invited"` + User *User `codec:"user,omitempty" json:"user,omitempty"` + ChatSending bool `codec:"chatSending" json:"chatSending"` +} + +func (o TeamAddMemberResult) DeepCopy() TeamAddMemberResult { + return TeamAddMemberResult{ + Invited: o.Invited, + User: (func(x *User) *User { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.User), + ChatSending: o.ChatSending, + } +} + +type TeamAddMembersResult struct { + NotAdded []User `codec:"notAdded" json:"notAdded"` +} + +func (o TeamAddMembersResult) DeepCopy() TeamAddMembersResult { + return TeamAddMembersResult{ + NotAdded: (func(x []User) []User { + if x == nil { + return nil + } + ret := make([]User, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.NotAdded), + } +} + +type TeamJoinRequest struct { + Name string `codec:"name" json:"name"` + Username string `codec:"username" json:"username"` +} + +func (o TeamJoinRequest) DeepCopy() TeamJoinRequest { + return TeamJoinRequest{ + Name: o.Name, + Username: o.Username, + } +} + +type TeamTreeResult struct { + Entries []TeamTreeEntry `codec:"entries" json:"entries"` +} + +func (o TeamTreeResult) DeepCopy() TeamTreeResult { + return TeamTreeResult{ + Entries: (func(x []TeamTreeEntry) []TeamTreeEntry { + if x == nil { + return nil + } + ret := make([]TeamTreeEntry, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Entries), + } +} + +type TeamTreeEntry struct { + Name TeamName `codec:"name" json:"name"` + Admin bool `codec:"admin" json:"admin"` +} + +func (o TeamTreeEntry) DeepCopy() TeamTreeEntry { + return TeamTreeEntry{ + Name: o.Name.DeepCopy(), + Admin: o.Admin, + } +} + +type SubteamListEntry struct { + Name TeamName `codec:"name" json:"name"` + TeamID TeamID `codec:"teamID" json:"teamID"` + MemberCount int `codec:"memberCount" json:"memberCount"` +} + +func (o SubteamListEntry) DeepCopy() SubteamListEntry { + return SubteamListEntry{ + Name: o.Name.DeepCopy(), + TeamID: o.TeamID.DeepCopy(), + MemberCount: o.MemberCount, + } +} + +type SubteamListResult struct { + Entries []SubteamListEntry `codec:"entries" json:"entries"` +} + +func (o SubteamListResult) DeepCopy() SubteamListResult { + return SubteamListResult{ + Entries: (func(x []SubteamListEntry) []SubteamListEntry { + if x == nil { + return nil + } + ret := make([]SubteamListEntry, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Entries), + } +} + +type TeamCreateResult struct { + TeamID TeamID `codec:"teamID" json:"teamID"` + ChatSent bool `codec:"chatSent" json:"chatSent"` + CreatorAdded bool `codec:"creatorAdded" json:"creatorAdded"` +} + +func (o TeamCreateResult) DeepCopy() TeamCreateResult { + return TeamCreateResult{ + TeamID: o.TeamID.DeepCopy(), + ChatSent: o.ChatSent, + CreatorAdded: o.CreatorAdded, + } +} + +type TeamSettings struct { + Open bool `codec:"open" json:"open"` + JoinAs TeamRole `codec:"joinAs" json:"joinAs"` +} + +func (o TeamSettings) DeepCopy() TeamSettings { + return TeamSettings{ + Open: o.Open, + JoinAs: o.JoinAs.DeepCopy(), + } +} + +type TeamBotSettings struct { + Cmds bool `codec:"cmds" json:"cmds"` + Mentions bool `codec:"mentions" json:"mentions"` + Triggers []string `codec:"triggers" json:"triggers"` + Convs []string `codec:"convs" json:"convs"` +} + +func (o TeamBotSettings) DeepCopy() TeamBotSettings { + return TeamBotSettings{ + Cmds: o.Cmds, + Mentions: o.Mentions, + Triggers: (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.Triggers), + Convs: (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.Convs), + } +} + +type TeamRequestAccessResult struct { + Open bool `codec:"open" json:"open"` +} + +func (o TeamRequestAccessResult) DeepCopy() TeamRequestAccessResult { + return TeamRequestAccessResult{ + Open: o.Open, + } +} + +type TeamAcceptOrRequestResult struct { + WasToken bool `codec:"wasToken" json:"wasToken"` + WasSeitan bool `codec:"wasSeitan" json:"wasSeitan"` + WasTeamName bool `codec:"wasTeamName" json:"wasTeamName"` + WasOpenTeam bool `codec:"wasOpenTeam" json:"wasOpenTeam"` +} + +func (o TeamAcceptOrRequestResult) DeepCopy() TeamAcceptOrRequestResult { + return TeamAcceptOrRequestResult{ + WasToken: o.WasToken, + WasSeitan: o.WasSeitan, + WasTeamName: o.WasTeamName, + WasOpenTeam: o.WasOpenTeam, + } +} + +type TeamShowcase struct { + IsShowcased bool `codec:"isShowcased" json:"is_showcased"` + Description *string `codec:"description,omitempty" json:"description,omitempty"` + SetByUID *UID `codec:"setByUID,omitempty" json:"set_by_uid,omitempty"` + AnyMemberShowcase bool `codec:"anyMemberShowcase" json:"any_member_showcase"` +} + +func (o TeamShowcase) DeepCopy() TeamShowcase { + return TeamShowcase{ + IsShowcased: o.IsShowcased, + Description: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Description), + SetByUID: (func(x *UID) *UID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.SetByUID), + AnyMemberShowcase: o.AnyMemberShowcase, + } +} + +type TeamAndMemberShowcase struct { + TeamShowcase TeamShowcase `codec:"teamShowcase" json:"teamShowcase"` + IsMemberShowcased bool `codec:"isMemberShowcased" json:"isMemberShowcased"` +} + +func (o TeamAndMemberShowcase) DeepCopy() TeamAndMemberShowcase { + return TeamAndMemberShowcase{ + TeamShowcase: o.TeamShowcase.DeepCopy(), + IsMemberShowcased: o.IsMemberShowcased, + } +} + +type UserRolePair struct { + AssertionOrEmail string `codec:"assertionOrEmail" json:"assertionOrEmail"` + 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(), + BotSettings: (func(x *TeamBotSettings) *TeamBotSettings { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.BotSettings), + } +} + +type BulkRes struct { + Invited []string `codec:"invited" json:"invited"` + AlreadyInvited []string `codec:"alreadyInvited" json:"alreadyInvited"` + Malformed []string `codec:"malformed" json:"malformed"` +} + +func (o BulkRes) DeepCopy() BulkRes { + return BulkRes{ + Invited: (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.Invited), + AlreadyInvited: (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.AlreadyInvited), + Malformed: (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.Malformed), + } +} + +type ImplicitTeamUserSet struct { + KeybaseUsers []string `codec:"keybaseUsers" json:"keybaseUsers"` + UnresolvedUsers []SocialAssertion `codec:"unresolvedUsers" json:"unresolvedUsers"` +} + +func (o ImplicitTeamUserSet) DeepCopy() ImplicitTeamUserSet { + return ImplicitTeamUserSet{ + KeybaseUsers: (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.KeybaseUsers), + UnresolvedUsers: (func(x []SocialAssertion) []SocialAssertion { + if x == nil { + return nil + } + ret := make([]SocialAssertion, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.UnresolvedUsers), + } +} + +// * iTeams +type ImplicitTeamDisplayName struct { + IsPublic bool `codec:"isPublic" json:"isPublic"` + Writers ImplicitTeamUserSet `codec:"writers" json:"writers"` + Readers ImplicitTeamUserSet `codec:"readers" json:"readers"` + ConflictInfo *ImplicitTeamConflictInfo `codec:"conflictInfo,omitempty" json:"conflictInfo,omitempty"` +} + +func (o ImplicitTeamDisplayName) DeepCopy() ImplicitTeamDisplayName { + return ImplicitTeamDisplayName{ + IsPublic: o.IsPublic, + Writers: o.Writers.DeepCopy(), + Readers: o.Readers.DeepCopy(), + ConflictInfo: (func(x *ImplicitTeamConflictInfo) *ImplicitTeamConflictInfo { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ConflictInfo), + } +} + +type ConflictGeneration int + +func (o ConflictGeneration) DeepCopy() ConflictGeneration { + return o +} + +type ImplicitTeamConflictInfo struct { + Generation ConflictGeneration `codec:"generation" json:"generation"` + Time Time `codec:"time" json:"time"` +} + +func (o ImplicitTeamConflictInfo) DeepCopy() ImplicitTeamConflictInfo { + return ImplicitTeamConflictInfo{ + Generation: o.Generation.DeepCopy(), + Time: o.Time.DeepCopy(), + } +} + +type LookupImplicitTeamRes struct { + TeamID TeamID `codec:"teamID" json:"teamID"` + Name TeamName `codec:"name" json:"name"` + DisplayName ImplicitTeamDisplayName `codec:"displayName" json:"displayName"` + TlfID TLFID `codec:"tlfID" json:"tlfID"` +} + +func (o LookupImplicitTeamRes) DeepCopy() LookupImplicitTeamRes { + return LookupImplicitTeamRes{ + TeamID: o.TeamID.DeepCopy(), + Name: o.Name.DeepCopy(), + DisplayName: o.DisplayName.DeepCopy(), + TlfID: o.TlfID.DeepCopy(), + } +} + +type TeamOperation struct { + ManageMembers bool `codec:"manageMembers" json:"manageMembers"` + ManageSubteams bool `codec:"manageSubteams" json:"manageSubteams"` + CreateChannel bool `codec:"createChannel" json:"createChannel"` + Chat bool `codec:"chat" json:"chat"` + DeleteChannel bool `codec:"deleteChannel" json:"deleteChannel"` + RenameChannel bool `codec:"renameChannel" json:"renameChannel"` + RenameTeam bool `codec:"renameTeam" json:"renameTeam"` + EditChannelDescription bool `codec:"editChannelDescription" json:"editChannelDescription"` + EditTeamDescription bool `codec:"editTeamDescription" json:"editTeamDescription"` + SetTeamShowcase bool `codec:"setTeamShowcase" json:"setTeamShowcase"` + SetMemberShowcase bool `codec:"setMemberShowcase" json:"setMemberShowcase"` + SetRetentionPolicy bool `codec:"setRetentionPolicy" json:"setRetentionPolicy"` + SetMinWriterRole bool `codec:"setMinWriterRole" json:"setMinWriterRole"` + ChangeOpenTeam bool `codec:"changeOpenTeam" json:"changeOpenTeam"` + LeaveTeam bool `codec:"leaveTeam" json:"leaveTeam"` + JoinTeam bool `codec:"joinTeam" json:"joinTeam"` + SetPublicityAny bool `codec:"setPublicityAny" json:"setPublicityAny"` + ListFirst bool `codec:"listFirst" json:"listFirst"` + ChangeTarsDisabled bool `codec:"changeTarsDisabled" json:"changeTarsDisabled"` + DeleteChatHistory bool `codec:"deleteChatHistory" json:"deleteChatHistory"` + DeleteOtherMessages bool `codec:"deleteOtherMessages" json:"deleteOtherMessages"` + DeleteTeam bool `codec:"deleteTeam" json:"deleteTeam"` + PinMessage bool `codec:"pinMessage" json:"pinMessage"` + ManageBots bool `codec:"manageBots" json:"manageBots"` +} + +func (o TeamOperation) DeepCopy() TeamOperation { + return TeamOperation{ + ManageMembers: o.ManageMembers, + ManageSubteams: o.ManageSubteams, + CreateChannel: o.CreateChannel, + Chat: o.Chat, + DeleteChannel: o.DeleteChannel, + RenameChannel: o.RenameChannel, + RenameTeam: o.RenameTeam, + EditChannelDescription: o.EditChannelDescription, + EditTeamDescription: o.EditTeamDescription, + SetTeamShowcase: o.SetTeamShowcase, + SetMemberShowcase: o.SetMemberShowcase, + SetRetentionPolicy: o.SetRetentionPolicy, + SetMinWriterRole: o.SetMinWriterRole, + ChangeOpenTeam: o.ChangeOpenTeam, + LeaveTeam: o.LeaveTeam, + JoinTeam: o.JoinTeam, + SetPublicityAny: o.SetPublicityAny, + ListFirst: o.ListFirst, + ChangeTarsDisabled: o.ChangeTarsDisabled, + DeleteChatHistory: o.DeleteChatHistory, + DeleteOtherMessages: o.DeleteOtherMessages, + DeleteTeam: o.DeleteTeam, + PinMessage: o.PinMessage, + ManageBots: o.ManageBots, + } +} + +type ProfileTeamLoadRes struct { + LoadTimeNsec int64 `codec:"loadTimeNsec" json:"loadTimeNsec"` +} + +func (o ProfileTeamLoadRes) DeepCopy() ProfileTeamLoadRes { + return ProfileTeamLoadRes{ + LoadTimeNsec: o.LoadTimeNsec, + } +} + +type RotationType int + +const ( + RotationType_VISIBLE RotationType = 0 + RotationType_HIDDEN RotationType = 1 + RotationType_CLKR RotationType = 2 +) + +func (o RotationType) DeepCopy() RotationType { return o } + +var RotationTypeMap = map[string]RotationType{ + "VISIBLE": 0, + "HIDDEN": 1, + "CLKR": 2, +} + +var RotationTypeRevMap = map[RotationType]string{ + 0: "VISIBLE", + 1: "HIDDEN", + 2: "CLKR", +} + +func (e RotationType) String() string { + if v, ok := RotationTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type TeamDebugRes struct { + Chain TeamSigChainState `codec:"chain" json:"chain"` +} + +func (o TeamDebugRes) DeepCopy() TeamDebugRes { + return TeamDebugRes{ + Chain: o.Chain.DeepCopy(), + } +} + +type TeamProfileAddEntry struct { + TeamID TeamID `codec:"teamID" json:"teamID"` + TeamName TeamName `codec:"teamName" json:"teamName"` + Open bool `codec:"open" json:"open"` + DisabledReason string `codec:"disabledReason" json:"disabledReason"` +} + +func (o TeamProfileAddEntry) DeepCopy() TeamProfileAddEntry { + return TeamProfileAddEntry{ + TeamID: o.TeamID.DeepCopy(), + TeamName: o.TeamName.DeepCopy(), + Open: o.Open, + DisabledReason: o.DisabledReason, + } +} + +type MemberEmail struct { + Email string `codec:"email" json:"email"` + Role string `codec:"role" json:"role"` +} + +func (o MemberEmail) DeepCopy() MemberEmail { + return MemberEmail{ + Email: o.Email, + Role: o.Role, + } +} + +type MemberUsername struct { + Username string `codec:"username" json:"username"` + Role string `codec:"role" json:"role"` +} + +func (o MemberUsername) DeepCopy() MemberUsername { + return MemberUsername{ + Username: o.Username, + Role: o.Role, + } +} + +type TeamRolePair struct { + Role TeamRole `codec:"role" json:"role"` + ImplicitRole TeamRole `codec:"implicitRole" json:"implicit_role"` +} + +func (o TeamRolePair) DeepCopy() TeamRolePair { + return TeamRolePair{ + Role: o.Role.DeepCopy(), + ImplicitRole: o.ImplicitRole.DeepCopy(), + } +} + +type TeamRoleMapAndVersion struct { + Teams map[TeamID]TeamRolePair `codec:"teams" json:"teams"` + Version UserTeamVersion `codec:"version" json:"user_team_version"` +} + +func (o TeamRoleMapAndVersion) DeepCopy() TeamRoleMapAndVersion { + return TeamRoleMapAndVersion{ + Teams: (func(x map[TeamID]TeamRolePair) map[TeamID]TeamRolePair { + if x == nil { + return nil + } + ret := make(map[TeamID]TeamRolePair, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.Teams), + Version: o.Version.DeepCopy(), + } +} + +type TeamRoleMapStored struct { + Data TeamRoleMapAndVersion `codec:"data" json:"data"` + CachedAt Time `codec:"cachedAt" json:"cachedAt"` +} + +func (o TeamRoleMapStored) DeepCopy() TeamRoleMapStored { + return TeamRoleMapStored{ + Data: o.Data.DeepCopy(), + CachedAt: o.CachedAt.DeepCopy(), + } +} + +type UserTeamVersion int + +func (o UserTeamVersion) DeepCopy() UserTeamVersion { + return o +} + +type UserTeamVersionUpdate struct { + Version UserTeamVersion `codec:"version" json:"version"` +} + +func (o UserTeamVersionUpdate) DeepCopy() UserTeamVersionUpdate { + return UserTeamVersionUpdate{ + Version: o.Version.DeepCopy(), + } +} + +type AnnotatedTeamMemberDetails struct { + Details TeamMemberDetails `codec:"details" json:"details"` + Role TeamRole `codec:"role" json:"role"` +} + +func (o AnnotatedTeamMemberDetails) DeepCopy() AnnotatedTeamMemberDetails { + return AnnotatedTeamMemberDetails{ + Details: o.Details.DeepCopy(), + Role: o.Role.DeepCopy(), + } +} + +type AnnotatedTeam struct { + TeamID TeamID `codec:"teamID" json:"teamID"` + Name string `codec:"name" json:"name"` + TransitiveSubteamsUnverified SubteamListResult `codec:"transitiveSubteamsUnverified" json:"transitiveSubteamsUnverified"` + 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"` +} + +func (o AnnotatedTeam) DeepCopy() AnnotatedTeam { + return AnnotatedTeam{ + TeamID: o.TeamID.DeepCopy(), + Name: o.Name, + TransitiveSubteamsUnverified: o.TransitiveSubteamsUnverified.DeepCopy(), + Members: (func(x []AnnotatedTeamMemberDetails) []AnnotatedTeamMemberDetails { + if x == nil { + return nil + } + ret := make([]AnnotatedTeamMemberDetails, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Members), + Invites: (func(x []AnnotatedTeamInvite) []AnnotatedTeamInvite { + if x == nil { + return nil + } + ret := make([]AnnotatedTeamInvite, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Invites), + JoinRequests: (func(x []TeamJoinRequest) []TeamJoinRequest { + if x == nil { + return nil + } + ret := make([]TeamJoinRequest, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.JoinRequests), + UserIsShowcasing: o.UserIsShowcasing, + TarsDisabled: o.TarsDisabled, + Settings: o.Settings.DeepCopy(), + Showcase: o.Showcase.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..2c713aa6 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/teams_ui.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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/test.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/test.go new file mode 100644 index 00000000..d8d6dd8a --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/test.go @@ -0,0 +1,64 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/test.avdl + +package keybase1 + +// Result from calling test(..). +type Test struct { + Reply string `codec:"reply" json:"reply"` +} + +func (o Test) DeepCopy() Test { + return Test{ + Reply: o.Reply, + } +} + +type Generic struct { + M map[string]Generic `codec:"m" json:"m"` + A []Generic `codec:"a" json:"a"` + S *string `codec:"s,omitempty" json:"s,omitempty"` + I *int `codec:"i,omitempty" json:"i,omitempty"` +} + +func (o Generic) DeepCopy() Generic { + return Generic{ + M: (func(x map[string]Generic) map[string]Generic { + if x == nil { + return nil + } + ret := make(map[string]Generic, len(x)) + for k, v := range x { + kCopy := k + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.M), + A: (func(x []Generic) []Generic { + if x == nil { + return nil + } + ret := make([]Generic, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.A), + S: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.S), + I: (func(x *int) *int { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.I), + } +} 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 new file mode 100644 index 00000000..ec803243 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/tlf.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..2aa0ee50 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/tlf_keys.go @@ -0,0 +1,180 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/tlf_keys.avdl + +package keybase1 + +import ( + "fmt" +) + +type TLFIdentifyBehavior int + +const ( + TLFIdentifyBehavior_UNSET TLFIdentifyBehavior = 0 + TLFIdentifyBehavior_CHAT_CLI TLFIdentifyBehavior = 1 + TLFIdentifyBehavior_CHAT_GUI TLFIdentifyBehavior = 2 + TLFIdentifyBehavior_REMOVED_AND_UNUSED TLFIdentifyBehavior = 3 + TLFIdentifyBehavior_KBFS_REKEY TLFIdentifyBehavior = 4 + TLFIdentifyBehavior_KBFS_QR TLFIdentifyBehavior = 5 + TLFIdentifyBehavior_CHAT_SKIP TLFIdentifyBehavior = 6 + TLFIdentifyBehavior_SALTPACK TLFIdentifyBehavior = 7 + TLFIdentifyBehavior_CLI TLFIdentifyBehavior = 8 + TLFIdentifyBehavior_GUI TLFIdentifyBehavior = 9 + TLFIdentifyBehavior_DEFAULT_KBFS TLFIdentifyBehavior = 10 + TLFIdentifyBehavior_KBFS_CHAT TLFIdentifyBehavior = 11 + TLFIdentifyBehavior_RESOLVE_AND_CHECK TLFIdentifyBehavior = 12 + TLFIdentifyBehavior_GUI_PROFILE TLFIdentifyBehavior = 13 + TLFIdentifyBehavior_KBFS_INIT TLFIdentifyBehavior = 14 + TLFIdentifyBehavior_FS_GUI TLFIdentifyBehavior = 15 +) + +func (o TLFIdentifyBehavior) DeepCopy() TLFIdentifyBehavior { return o } + +var TLFIdentifyBehaviorMap = map[string]TLFIdentifyBehavior{ + "UNSET": 0, + "CHAT_CLI": 1, + "CHAT_GUI": 2, + "REMOVED_AND_UNUSED": 3, + "KBFS_REKEY": 4, + "KBFS_QR": 5, + "CHAT_SKIP": 6, + "SALTPACK": 7, + "CLI": 8, + "GUI": 9, + "DEFAULT_KBFS": 10, + "KBFS_CHAT": 11, + "RESOLVE_AND_CHECK": 12, + "GUI_PROFILE": 13, + "KBFS_INIT": 14, + "FS_GUI": 15, +} + +var TLFIdentifyBehaviorRevMap = map[TLFIdentifyBehavior]string{ + 0: "UNSET", + 1: "CHAT_CLI", + 2: "CHAT_GUI", + 3: "REMOVED_AND_UNUSED", + 4: "KBFS_REKEY", + 5: "KBFS_QR", + 6: "CHAT_SKIP", + 7: "SALTPACK", + 8: "CLI", + 9: "GUI", + 10: "DEFAULT_KBFS", + 11: "KBFS_CHAT", + 12: "RESOLVE_AND_CHECK", + 13: "GUI_PROFILE", + 14: "KBFS_INIT", + 15: "FS_GUI", +} + +func (e TLFIdentifyBehavior) String() string { + if v, ok := TLFIdentifyBehaviorRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type CanonicalTlfName string + +func (o CanonicalTlfName) DeepCopy() CanonicalTlfName { + return o +} + +type CryptKey struct { + KeyGeneration int `codec:"KeyGeneration" json:"KeyGeneration"` + Key Bytes32 `codec:"Key" json:"Key"` +} + +func (o CryptKey) DeepCopy() CryptKey { + return CryptKey{ + KeyGeneration: o.KeyGeneration, + Key: o.Key.DeepCopy(), + } +} + +type TLFBreak struct { + Breaks []TLFIdentifyFailure `codec:"breaks" json:"breaks"` +} + +func (o TLFBreak) DeepCopy() TLFBreak { + return TLFBreak{ + Breaks: (func(x []TLFIdentifyFailure) []TLFIdentifyFailure { + if x == nil { + return nil + } + ret := make([]TLFIdentifyFailure, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Breaks), + } +} + +type TLFIdentifyFailure struct { + User User `codec:"user" json:"user"` + Breaks *IdentifyTrackBreaks `codec:"breaks,omitempty" json:"breaks,omitempty"` +} + +func (o TLFIdentifyFailure) DeepCopy() TLFIdentifyFailure { + return TLFIdentifyFailure{ + User: o.User.DeepCopy(), + Breaks: (func(x *IdentifyTrackBreaks) *IdentifyTrackBreaks { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Breaks), + } +} + +type CanonicalTLFNameAndIDWithBreaks struct { + TlfID TLFID `codec:"tlfID" json:"tlfID"` + CanonicalName CanonicalTlfName `codec:"CanonicalName" json:"CanonicalName"` + Breaks TLFBreak `codec:"breaks" json:"breaks"` +} + +func (o CanonicalTLFNameAndIDWithBreaks) DeepCopy() CanonicalTLFNameAndIDWithBreaks { + return CanonicalTLFNameAndIDWithBreaks{ + TlfID: o.TlfID.DeepCopy(), + CanonicalName: o.CanonicalName.DeepCopy(), + Breaks: o.Breaks.DeepCopy(), + } +} + +type GetTLFCryptKeysRes struct { + NameIDBreaks CanonicalTLFNameAndIDWithBreaks `codec:"nameIDBreaks" json:"nameIDBreaks"` + CryptKeys []CryptKey `codec:"CryptKeys" json:"CryptKeys"` +} + +func (o GetTLFCryptKeysRes) DeepCopy() GetTLFCryptKeysRes { + return GetTLFCryptKeysRes{ + NameIDBreaks: o.NameIDBreaks.DeepCopy(), + CryptKeys: (func(x []CryptKey) []CryptKey { + if x == nil { + return nil + } + ret := make([]CryptKey, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.CryptKeys), + } +} + +type TLFQuery struct { + TlfName string `codec:"tlfName" json:"tlfName"` + IdentifyBehavior TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` +} + +func (o TLFQuery) DeepCopy() TLFQuery { + return TLFQuery{ + TlfName: o.TlfName, + IdentifyBehavior: o.IdentifyBehavior.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..23ce1678 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/track.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..7eb6201c --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/ui.go @@ -0,0 +1,37 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/ui.avdl + +package keybase1 + +import ( + "fmt" +) + +type PromptDefault int + +const ( + PromptDefault_NONE PromptDefault = 0 + PromptDefault_YES PromptDefault = 1 + PromptDefault_NO PromptDefault = 2 +) + +func (o PromptDefault) DeepCopy() PromptDefault { return o } + +var PromptDefaultMap = map[string]PromptDefault{ + "NONE": 0, + "YES": 1, + "NO": 2, +} + +var PromptDefaultRevMap = map[PromptDefault]string{ + 0: "NONE", + 1: "YES", + 2: "NO", +} + +func (e PromptDefault) String() string { + if v, ok := PromptDefaultRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} 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 new file mode 100644 index 00000000..3148b115 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/upk.go @@ -0,0 +1,626 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/upk.avdl + +package keybase1 + +import ( + "errors" + "fmt" +) + +type KeyType int + +const ( + KeyType_NONE KeyType = 0 + KeyType_NACL KeyType = 1 + KeyType_PGP KeyType = 2 +) + +func (o KeyType) DeepCopy() KeyType { return o } + +var KeyTypeMap = map[string]KeyType{ + "NONE": 0, + "NACL": 1, + "PGP": 2, +} + +var KeyTypeRevMap = map[KeyType]string{ + 0: "NONE", + 1: "NACL", + 2: "PGP", +} + +func (e KeyType) String() string { + if v, ok := KeyTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type UPK2MinorVersion int + +const ( + UPK2MinorVersion_V0 UPK2MinorVersion = 0 + UPK2MinorVersion_V1 UPK2MinorVersion = 1 + UPK2MinorVersion_V2 UPK2MinorVersion = 2 + UPK2MinorVersion_V3 UPK2MinorVersion = 3 + UPK2MinorVersion_V4 UPK2MinorVersion = 4 + UPK2MinorVersion_V5 UPK2MinorVersion = 5 + UPK2MinorVersion_V6 UPK2MinorVersion = 6 +) + +func (o UPK2MinorVersion) DeepCopy() UPK2MinorVersion { return o } + +var UPK2MinorVersionMap = map[string]UPK2MinorVersion{ + "V0": 0, + "V1": 1, + "V2": 2, + "V3": 3, + "V4": 4, + "V5": 5, + "V6": 6, +} + +var UPK2MinorVersionRevMap = map[UPK2MinorVersion]string{ + 0: "V0", + 1: "V1", + 2: "V2", + 3: "V3", + 4: "V4", + 5: "V5", + 6: "V6", +} + +func (e UPK2MinorVersion) String() string { + if v, ok := UPK2MinorVersionRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type MerkleRootV2 struct { + Seqno Seqno `codec:"seqno" json:"seqno"` + HashMeta HashMeta `codec:"hashMeta" json:"hashMeta"` +} + +func (o MerkleRootV2) DeepCopy() MerkleRootV2 { + return MerkleRootV2{ + Seqno: o.Seqno.DeepCopy(), + HashMeta: o.HashMeta.DeepCopy(), + } +} + +type SigChainLocation struct { + Seqno Seqno `codec:"seqno" json:"seqno"` + SeqType SeqType `codec:"seqType" json:"seqType"` +} + +func (o SigChainLocation) DeepCopy() SigChainLocation { + return SigChainLocation{ + Seqno: o.Seqno.DeepCopy(), + SeqType: o.SeqType.DeepCopy(), + } +} + +type MerkleTreeLocation struct { + Leaf UserOrTeamID `codec:"leaf" json:"leaf"` + Loc SigChainLocation `codec:"loc" json:"loc"` +} + +func (o MerkleTreeLocation) DeepCopy() MerkleTreeLocation { + return MerkleTreeLocation{ + Leaf: o.Leaf.DeepCopy(), + Loc: o.Loc.DeepCopy(), + } +} + +type SignatureMetadata struct { + SigningKID KID `codec:"signingKID" json:"signingKID"` + PrevMerkleRootSigned MerkleRootV2 `codec:"prevMerkleRootSigned" json:"prevMerkleRootSigned"` + FirstAppearedUnverified Seqno `codec:"firstAppearedUnverified" json:"firstAppearedUnverified"` + Time Time `codec:"time" json:"time"` + SigChainLocation SigChainLocation `codec:"sigChainLocation" json:"sigChainLocation"` +} + +func (o SignatureMetadata) DeepCopy() SignatureMetadata { + return SignatureMetadata{ + SigningKID: o.SigningKID.DeepCopy(), + PrevMerkleRootSigned: o.PrevMerkleRootSigned.DeepCopy(), + FirstAppearedUnverified: o.FirstAppearedUnverified.DeepCopy(), + Time: o.Time.DeepCopy(), + SigChainLocation: o.SigChainLocation.DeepCopy(), + } +} + +type PublicKeyV2Base struct { + Kid KID `codec:"kid" json:"kid"` + IsSibkey bool `codec:"isSibkey" json:"isSibkey"` + IsEldest bool `codec:"isEldest" json:"isEldest"` + CTime Time `codec:"cTime" json:"cTime"` + ETime Time `codec:"eTime" json:"eTime"` + Provisioning SignatureMetadata `codec:"provisioning" json:"provisioning"` + Revocation *SignatureMetadata `codec:"revocation,omitempty" json:"revocation,omitempty"` +} + +func (o PublicKeyV2Base) DeepCopy() PublicKeyV2Base { + return PublicKeyV2Base{ + Kid: o.Kid.DeepCopy(), + IsSibkey: o.IsSibkey, + IsEldest: o.IsEldest, + CTime: o.CTime.DeepCopy(), + ETime: o.ETime.DeepCopy(), + Provisioning: o.Provisioning.DeepCopy(), + Revocation: (func(x *SignatureMetadata) *SignatureMetadata { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Revocation), + } +} + +type PublicKeyV2NaCl struct { + Base PublicKeyV2Base `codec:"base" json:"base"` + 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"` +} + +func (o PublicKeyV2NaCl) DeepCopy() PublicKeyV2NaCl { + return PublicKeyV2NaCl{ + Base: o.Base.DeepCopy(), + Parent: (func(x *KID) *KID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Parent), + DeviceID: o.DeviceID.DeepCopy(), + DeviceDescription: o.DeviceDescription, + DeviceType: o.DeviceType, + } +} + +type PGPFingerprint [20]byte + +func (o PGPFingerprint) DeepCopy() PGPFingerprint { + var ret PGPFingerprint + copy(ret[:], o[:]) + return ret +} + +type PublicKeyV2PGPSummary struct { + Base PublicKeyV2Base `codec:"base" json:"base"` + Fingerprint PGPFingerprint `codec:"fingerprint" json:"fingerprint"` + Identities []PGPIdentity `codec:"identities" json:"identities"` +} + +func (o PublicKeyV2PGPSummary) DeepCopy() PublicKeyV2PGPSummary { + return PublicKeyV2PGPSummary{ + Base: o.Base.DeepCopy(), + Fingerprint: o.Fingerprint.DeepCopy(), + Identities: (func(x []PGPIdentity) []PGPIdentity { + if x == nil { + return nil + } + ret := make([]PGPIdentity, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Identities), + } +} + +type PublicKeyV2 struct { + KeyType__ KeyType `codec:"keyType" json:"keyType"` + Nacl__ *PublicKeyV2NaCl `codec:"nacl,omitempty" json:"nacl,omitempty"` + PGP__ *PublicKeyV2PGPSummary `codec:"pgp,omitempty" json:"pgp,omitempty"` +} + +func (o *PublicKeyV2) KeyType() (ret KeyType, err error) { + switch o.KeyType__ { + case KeyType_NACL: + if o.Nacl__ == nil { + err = errors.New("unexpected nil value for Nacl__") + return ret, err + } + case KeyType_PGP: + if o.PGP__ == nil { + err = errors.New("unexpected nil value for PGP__") + return ret, err + } + } + return o.KeyType__, nil +} + +func (o PublicKeyV2) Nacl() (res PublicKeyV2NaCl) { + if o.KeyType__ != KeyType_NACL { + panic("wrong case accessed") + } + if o.Nacl__ == nil { + return + } + return *o.Nacl__ +} + +func (o PublicKeyV2) Pgp() (res PublicKeyV2PGPSummary) { + if o.KeyType__ != KeyType_PGP { + panic("wrong case accessed") + } + if o.PGP__ == nil { + return + } + return *o.PGP__ +} + +func NewPublicKeyV2WithNacl(v PublicKeyV2NaCl) PublicKeyV2 { + return PublicKeyV2{ + KeyType__: KeyType_NACL, + Nacl__: &v, + } +} + +func NewPublicKeyV2WithPgp(v PublicKeyV2PGPSummary) PublicKeyV2 { + return PublicKeyV2{ + KeyType__: KeyType_PGP, + PGP__: &v, + } +} + +func NewPublicKeyV2Default(keyType KeyType) PublicKeyV2 { + return PublicKeyV2{ + KeyType__: keyType, + } +} + +func (o PublicKeyV2) DeepCopy() PublicKeyV2 { + return PublicKeyV2{ + KeyType__: o.KeyType__.DeepCopy(), + Nacl__: (func(x *PublicKeyV2NaCl) *PublicKeyV2NaCl { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Nacl__), + PGP__: (func(x *PublicKeyV2PGPSummary) *PublicKeyV2PGPSummary { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.PGP__), + } +} + +type UserPlusKeysV2 struct { + Uid UID `codec:"uid" json:"uid"` + Username string `codec:"username" json:"username"` + EldestSeqno Seqno `codec:"eldestSeqno" json:"eldestSeqno"` + Status StatusCode `codec:"status" json:"status"` + PerUserKeys []PerUserKey `codec:"perUserKeys" json:"perUserKeys"` + DeviceKeys map[KID]PublicKeyV2NaCl `codec:"deviceKeys" json:"deviceKeys"` + PGPKeys map[KID]PublicKeyV2PGPSummary `codec:"pgpKeys" json:"pgpKeys"` + StellarAccountID *string `codec:"stellarAccountID,omitempty" json:"stellarAccountID,omitempty"` + RemoteTracks map[UID]RemoteTrack `codec:"remoteTracks" json:"remoteTracks"` + Reset *ResetSummary `codec:"reset,omitempty" json:"reset,omitempty"` + Unstubbed bool `codec:"unstubbed" json:"unstubbed"` +} + +func (o UserPlusKeysV2) DeepCopy() UserPlusKeysV2 { + return UserPlusKeysV2{ + Uid: o.Uid.DeepCopy(), + Username: o.Username, + EldestSeqno: o.EldestSeqno.DeepCopy(), + Status: o.Status.DeepCopy(), + PerUserKeys: (func(x []PerUserKey) []PerUserKey { + if x == nil { + return nil + } + ret := make([]PerUserKey, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.PerUserKeys), + DeviceKeys: (func(x map[KID]PublicKeyV2NaCl) map[KID]PublicKeyV2NaCl { + if x == nil { + return nil + } + ret := make(map[KID]PublicKeyV2NaCl, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.DeviceKeys), + PGPKeys: (func(x map[KID]PublicKeyV2PGPSummary) map[KID]PublicKeyV2PGPSummary { + if x == nil { + return nil + } + ret := make(map[KID]PublicKeyV2PGPSummary, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.PGPKeys), + StellarAccountID: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.StellarAccountID), + RemoteTracks: (func(x map[UID]RemoteTrack) map[UID]RemoteTrack { + if x == nil { + return nil + } + ret := make(map[UID]RemoteTrack, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.RemoteTracks), + Reset: (func(x *ResetSummary) *ResetSummary { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Reset), + Unstubbed: o.Unstubbed, + } +} + +type UserPlusKeysV2AllIncarnations struct { + Current UserPlusKeysV2 `codec:"current" json:"current"` + PastIncarnations []UserPlusKeysV2 `codec:"pastIncarnations" json:"pastIncarnations"` + Uvv UserVersionVector `codec:"uvv" json:"uvv"` + SeqnoLinkIDs map[Seqno]LinkID `codec:"seqnoLinkIDs" json:"seqnoLinkIDs"` + MinorVersion UPK2MinorVersion `codec:"minorVersion" json:"minorVersion"` + Stale bool `codec:"stale" json:"stale"` +} + +func (o UserPlusKeysV2AllIncarnations) DeepCopy() UserPlusKeysV2AllIncarnations { + return UserPlusKeysV2AllIncarnations{ + Current: o.Current.DeepCopy(), + PastIncarnations: (func(x []UserPlusKeysV2) []UserPlusKeysV2 { + if x == nil { + return nil + } + ret := make([]UserPlusKeysV2, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.PastIncarnations), + Uvv: o.Uvv.DeepCopy(), + SeqnoLinkIDs: (func(x map[Seqno]LinkID) map[Seqno]LinkID { + if x == nil { + return nil + } + ret := make(map[Seqno]LinkID, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.SeqnoLinkIDs), + MinorVersion: o.MinorVersion.DeepCopy(), + Stale: o.Stale, + } +} + +type UPAKVersion int + +const ( + UPAKVersion_V1 UPAKVersion = 1 + UPAKVersion_V2 UPAKVersion = 2 +) + +func (o UPAKVersion) DeepCopy() UPAKVersion { return o } + +var UPAKVersionMap = map[string]UPAKVersion{ + "V1": 1, + "V2": 2, +} + +var UPAKVersionRevMap = map[UPAKVersion]string{ + 1: "V1", + 2: "V2", +} + +func (e UPAKVersion) String() string { + if v, ok := UPAKVersionRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +// * What we're storing for each user. At first it was UPAKs, as defined +// * in common.avdl. But going forward, we're going to use UserPlusKeysV2AllIncarnations. +type UPAKVersioned struct { + V__ UPAKVersion `codec:"v" json:"v"` + V1__ *UserPlusAllKeys `codec:"v1,omitempty" json:"v1,omitempty"` + V2__ *UserPlusKeysV2AllIncarnations `codec:"v2,omitempty" json:"v2,omitempty"` +} + +func (o *UPAKVersioned) V() (ret UPAKVersion, err error) { + switch o.V__ { + case UPAKVersion_V1: + if o.V1__ == nil { + err = errors.New("unexpected nil value for V1__") + return ret, err + } + case UPAKVersion_V2: + if o.V2__ == nil { + err = errors.New("unexpected nil value for V2__") + return ret, err + } + } + return o.V__, nil +} + +func (o UPAKVersioned) V1() (res UserPlusAllKeys) { + if o.V__ != UPAKVersion_V1 { + panic("wrong case accessed") + } + if o.V1__ == nil { + return + } + return *o.V1__ +} + +func (o UPAKVersioned) V2() (res UserPlusKeysV2AllIncarnations) { + if o.V__ != UPAKVersion_V2 { + panic("wrong case accessed") + } + if o.V2__ == nil { + return + } + return *o.V2__ +} + +func NewUPAKVersionedWithV1(v UserPlusAllKeys) UPAKVersioned { + return UPAKVersioned{ + V__: UPAKVersion_V1, + V1__: &v, + } +} + +func NewUPAKVersionedWithV2(v UserPlusKeysV2AllIncarnations) UPAKVersioned { + return UPAKVersioned{ + V__: UPAKVersion_V2, + V2__: &v, + } +} + +func (o UPAKVersioned) DeepCopy() UPAKVersioned { + return UPAKVersioned{ + V__: o.V__.DeepCopy(), + V1__: (func(x *UserPlusAllKeys) *UserPlusAllKeys { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V1__), + V2__: (func(x *UserPlusKeysV2AllIncarnations) *UserPlusKeysV2AllIncarnations { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V2__), + } +} + +type UPKLiteMinorVersion int + +const ( + UPKLiteMinorVersion_V0 UPKLiteMinorVersion = 0 +) + +func (o UPKLiteMinorVersion) DeepCopy() UPKLiteMinorVersion { return o } + +var UPKLiteMinorVersionMap = map[string]UPKLiteMinorVersion{ + "V0": 0, +} + +var UPKLiteMinorVersionRevMap = map[UPKLiteMinorVersion]string{ + 0: "V0", +} + +func (e UPKLiteMinorVersion) String() string { + if v, ok := UPKLiteMinorVersionRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type UPKLiteV1 struct { + Uid UID `codec:"uid" json:"uid"` + Username string `codec:"username" json:"username"` + EldestSeqno Seqno `codec:"eldestSeqno" json:"eldestSeqno"` + Status StatusCode `codec:"status" json:"status"` + DeviceKeys map[KID]PublicKeyV2NaCl `codec:"deviceKeys" json:"deviceKeys"` + Reset *ResetSummary `codec:"reset,omitempty" json:"reset,omitempty"` +} + +func (o UPKLiteV1) DeepCopy() UPKLiteV1 { + return UPKLiteV1{ + Uid: o.Uid.DeepCopy(), + Username: o.Username, + EldestSeqno: o.EldestSeqno.DeepCopy(), + Status: o.Status.DeepCopy(), + DeviceKeys: (func(x map[KID]PublicKeyV2NaCl) map[KID]PublicKeyV2NaCl { + if x == nil { + return nil + } + ret := make(map[KID]PublicKeyV2NaCl, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.DeviceKeys), + Reset: (func(x *ResetSummary) *ResetSummary { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Reset), + } +} + +type UPKLiteV1AllIncarnations struct { + Current UPKLiteV1 `codec:"current" json:"current"` + PastIncarnations []UPKLiteV1 `codec:"pastIncarnations" json:"pastIncarnations"` + SeqnoLinkIDs map[Seqno]LinkID `codec:"seqnoLinkIDs" json:"seqnoLinkIDs"` + MinorVersion UPKLiteMinorVersion `codec:"minorVersion" json:"minorVersion"` +} + +func (o UPKLiteV1AllIncarnations) DeepCopy() UPKLiteV1AllIncarnations { + return UPKLiteV1AllIncarnations{ + Current: o.Current.DeepCopy(), + PastIncarnations: (func(x []UPKLiteV1) []UPKLiteV1 { + if x == nil { + return nil + } + ret := make([]UPKLiteV1, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.PastIncarnations), + SeqnoLinkIDs: (func(x map[Seqno]LinkID) map[Seqno]LinkID { + if x == nil { + return nil + } + ret := make(map[Seqno]LinkID, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.SeqnoLinkIDs), + MinorVersion: o.MinorVersion.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 new file mode 100644 index 00000000..47b3ab9b --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/user.go @@ -0,0 +1,587 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/user.avdl + +package keybase1 + +import ( + "fmt" +) + +type TrackProof struct { + ProofType string `codec:"proofType" json:"proofType"` + ProofName string `codec:"proofName" json:"proofName"` + IdString string `codec:"idString" json:"idString"` +} + +func (o TrackProof) DeepCopy() TrackProof { + return TrackProof{ + ProofType: o.ProofType, + ProofName: o.ProofName, + IdString: o.IdString, + } +} + +type WebProof struct { + Hostname string `codec:"hostname" json:"hostname"` + Protocols []string `codec:"protocols" json:"protocols"` +} + +func (o WebProof) DeepCopy() WebProof { + return WebProof{ + Hostname: o.Hostname, + Protocols: (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.Protocols), + } +} + +type Proofs struct { + Social []TrackProof `codec:"social" json:"social"` + Web []WebProof `codec:"web" json:"web"` + PublicKeys []PublicKey `codec:"publicKeys" json:"publicKeys"` +} + +func (o Proofs) DeepCopy() Proofs { + return Proofs{ + Social: (func(x []TrackProof) []TrackProof { + if x == nil { + return nil + } + ret := make([]TrackProof, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Social), + Web: (func(x []WebProof) []WebProof { + if x == nil { + return nil + } + ret := make([]WebProof, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Web), + PublicKeys: (func(x []PublicKey) []PublicKey { + if x == nil { + return nil + } + ret := make([]PublicKey, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.PublicKeys), + } +} + +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"` +} + +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(), + } +} + +type EmailAddress string + +func (o EmailAddress) DeepCopy() EmailAddress { + return o +} + +type Email struct { + Email EmailAddress `codec:"email" json:"email"` + IsVerified bool `codec:"isVerified" json:"isVerified"` + IsPrimary bool `codec:"isPrimary" json:"isPrimary"` + Visibility IdentityVisibility `codec:"visibility" json:"visibility"` + LastVerifyEmailDate UnixTime `codec:"lastVerifyEmailDate" json:"lastVerifyEmailDate"` +} + +func (o Email) DeepCopy() Email { + return Email{ + Email: o.Email.DeepCopy(), + IsVerified: o.IsVerified, + IsPrimary: o.IsPrimary, + Visibility: o.Visibility.DeepCopy(), + LastVerifyEmailDate: o.LastVerifyEmailDate.DeepCopy(), + } +} + +type UserSettings struct { + Emails []Email `codec:"emails" json:"emails"` + PhoneNumbers []UserPhoneNumber `codec:"phoneNumbers" json:"phoneNumbers"` +} + +func (o UserSettings) DeepCopy() UserSettings { + return UserSettings{ + Emails: (func(x []Email) []Email { + if x == nil { + return nil + } + ret := make([]Email, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Emails), + PhoneNumbers: (func(x []UserPhoneNumber) []UserPhoneNumber { + if x == nil { + return nil + } + ret := make([]UserPhoneNumber, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.PhoneNumbers), + } +} + +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"` + Fullname string `codec:"fullname" json:"fullname"` + ServiceMap map[string]string `codec:"serviceMap" json:"serviceMap"` +} + +func (o InterestingPerson) DeepCopy() InterestingPerson { + return InterestingPerson{ + Uid: o.Uid.DeepCopy(), + Username: o.Username, + Fullname: o.Fullname, + ServiceMap: (func(x map[string]string) map[string]string { + if x == nil { + return nil + } + ret := make(map[string]string, len(x)) + for k, v := range x { + kCopy := k + vCopy := v + ret[kCopy] = vCopy + } + return ret + })(o.ServiceMap), + } +} + +type ProofSuggestionsRes struct { + Suggestions []ProofSuggestion `codec:"suggestions" json:"suggestions"` + ShowMore bool `codec:"showMore" json:"showMore"` +} + +func (o ProofSuggestionsRes) DeepCopy() ProofSuggestionsRes { + return ProofSuggestionsRes{ + Suggestions: (func(x []ProofSuggestion) []ProofSuggestion { + if x == nil { + return nil + } + ret := make([]ProofSuggestion, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Suggestions), + ShowMore: o.ShowMore, + } +} + +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"` +} + +func (o ProofSuggestion) DeepCopy() ProofSuggestion { + return ProofSuggestion{ + Key: o.Key, + BelowFold: o.BelowFold, + ProfileText: o.ProfileText, + ProfileIcon: (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.ProfileIcon), + ProfileIconWhite: (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.ProfileIconWhite), + PickerText: o.PickerText, + PickerSubtext: o.PickerSubtext, + PickerIcon: (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.PickerIcon), + Metas: (func(x []Identify3RowMeta) []Identify3RowMeta { + if x == nil { + return nil + } + ret := make([]Identify3RowMeta, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Metas), + } +} + +type NextMerkleRootRes struct { + Res *MerkleRootV2 `codec:"res,omitempty" json:"res,omitempty"` +} + +func (o NextMerkleRootRes) DeepCopy() NextMerkleRootRes { + return NextMerkleRootRes{ + Res: (func(x *MerkleRootV2) *MerkleRootV2 { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Res), + } +} + +// PassphraseState values are used in .config.json, so should not be changed without a migration strategy +type PassphraseState int + +const ( + PassphraseState_KNOWN PassphraseState = 0 + PassphraseState_RANDOM PassphraseState = 1 +) + +func (o PassphraseState) DeepCopy() PassphraseState { return o } + +var PassphraseStateMap = map[string]PassphraseState{ + "KNOWN": 0, + "RANDOM": 1, +} + +var PassphraseStateRevMap = map[PassphraseState]string{ + 0: "KNOWN", + 1: "RANDOM", +} + +func (e PassphraseState) String() string { + if v, ok := PassphraseStateRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type CanLogoutRes struct { + CanLogout bool `codec:"canLogout" json:"canLogout"` + Reason string `codec:"reason" json:"reason"` + PassphraseState PassphraseState `codec:"passphraseState" json:"passphraseState"` +} + +func (o CanLogoutRes) DeepCopy() CanLogoutRes { + return CanLogoutRes{ + CanLogout: o.CanLogout, + Reason: o.Reason, + PassphraseState: o.PassphraseState.DeepCopy(), + } +} + +type UserPassphraseStateMsg struct { + PassphraseState PassphraseState `codec:"passphraseState" json:"state"` +} + +func (o UserPassphraseStateMsg) DeepCopy() UserPassphraseStateMsg { + return UserPassphraseStateMsg{ + PassphraseState: o.PassphraseState.DeepCopy(), + } +} + +type UserBlockedRow struct { + Uid UID `codec:"uid" json:"block_uid"` + Username string `codec:"username" json:"block_username"` + Chat *bool `codec:"chat,omitempty" json:"chat,omitempty"` + Follow *bool `codec:"follow,omitempty" json:"follow,omitempty"` +} + +func (o UserBlockedRow) DeepCopy() UserBlockedRow { + return UserBlockedRow{ + Uid: o.Uid.DeepCopy(), + Username: o.Username, + Chat: (func(x *bool) *bool { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Chat), + Follow: (func(x *bool) *bool { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Follow), + } +} + +type UserBlockType int + +const ( + UserBlockType_CHAT UserBlockType = 0 + UserBlockType_FOLLOW UserBlockType = 1 +) + +func (o UserBlockType) DeepCopy() UserBlockType { return o } + +var UserBlockTypeMap = map[string]UserBlockType{ + "CHAT": 0, + "FOLLOW": 1, +} + +var UserBlockTypeRevMap = map[UserBlockType]string{ + 0: "CHAT", + 1: "FOLLOW", +} + +func (e UserBlockType) String() string { + if v, ok := UserBlockTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type UserBlockedBody struct { + Blocks []UserBlockedRow `codec:"blocks" json:"blocks"` + Uid UID `codec:"uid" json:"blocker_uid"` + Username string `codec:"username" json:"blocker_username"` +} + +func (o UserBlockedBody) DeepCopy() UserBlockedBody { + return UserBlockedBody{ + Blocks: (func(x []UserBlockedRow) []UserBlockedRow { + if x == nil { + return nil + } + ret := make([]UserBlockedRow, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Blocks), + Uid: o.Uid.DeepCopy(), + Username: o.Username, + } +} + +type UserBlockState struct { + BlockType UserBlockType `codec:"blockType" json:"blockType"` + Blocked bool `codec:"blocked" json:"blocked"` +} + +func (o UserBlockState) DeepCopy() UserBlockState { + return UserBlockState{ + BlockType: o.BlockType.DeepCopy(), + Blocked: o.Blocked, + } +} + +type UserBlockedSummary struct { + Blocker string `codec:"blocker" json:"blocker"` + Blocks map[string][]UserBlockState `codec:"blocks" json:"blocks"` +} + +func (o UserBlockedSummary) DeepCopy() UserBlockedSummary { + return UserBlockedSummary{ + Blocker: o.Blocker, + Blocks: (func(x map[string][]UserBlockState) map[string][]UserBlockState { + if x == nil { + return nil + } + ret := make(map[string][]UserBlockState, len(x)) + for k, v := range x { + kCopy := k + vCopy := (func(x []UserBlockState) []UserBlockState { + if x == nil { + return nil + } + ret := make([]UserBlockState, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(v) + ret[kCopy] = vCopy + } + return ret + })(o.Blocks), + } +} + +type UserBlock struct { + Username string `codec:"username" json:"username"` + ChatBlocked bool `codec:"chatBlocked" json:"chatBlocked"` + FollowBlocked bool `codec:"followBlocked" json:"followBlocked"` + CreateTime *Time `codec:"createTime,omitempty" json:"createTime,omitempty"` + ModifyTime *Time `codec:"modifyTime,omitempty" json:"modifyTime,omitempty"` +} + +func (o UserBlock) DeepCopy() UserBlock { + return UserBlock{ + Username: o.Username, + ChatBlocked: o.ChatBlocked, + FollowBlocked: o.FollowBlocked, + CreateTime: (func(x *Time) *Time { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.CreateTime), + ModifyTime: (func(x *Time) *Time { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ModifyTime), + } +} + +type UserBlockArg struct { + Username string `codec:"username" json:"username"` + SetChatBlock *bool `codec:"setChatBlock,omitempty" json:"setChatBlock,omitempty"` + SetFollowBlock *bool `codec:"setFollowBlock,omitempty" json:"setFollowBlock,omitempty"` +} + +func (o UserBlockArg) DeepCopy() UserBlockArg { + return UserBlockArg{ + Username: o.Username, + SetChatBlock: (func(x *bool) *bool { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.SetChatBlock), + SetFollowBlock: (func(x *bool) *bool { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.SetFollowBlock), + } +} + +type TeamBlock struct { + TeamName string `codec:"teamName" json:"fq_name"` + CreateTime Time `codec:"createTime" json:"ctime"` +} + +func (o TeamBlock) DeepCopy() TeamBlock { + return TeamBlock{ + TeamName: o.TeamName, + CreateTime: o.CreateTime.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..3c66adf0 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/usersearch.go @@ -0,0 +1,235 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/keybase1/usersearch.avdl + +package keybase1 + +type APIUserServiceID string + +func (o APIUserServiceID) DeepCopy() APIUserServiceID { + return o +} + +type APIUserKeybaseResult struct { + Username string `codec:"username" json:"username"` + Uid UID `codec:"uid" json:"uid"` + PictureUrl *string `codec:"pictureUrl,omitempty" json:"picture_url,omitempty"` + FullName *string `codec:"fullName,omitempty" json:"full_name,omitempty"` + RawScore float64 `codec:"rawScore" json:"raw_score"` + Stellar *string `codec:"stellar,omitempty" json:"stellar,omitempty"` + IsFollowee bool `codec:"isFollowee" json:"is_followee"` +} + +func (o APIUserKeybaseResult) DeepCopy() APIUserKeybaseResult { + return APIUserKeybaseResult{ + Username: o.Username, + Uid: o.Uid.DeepCopy(), + PictureUrl: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.PictureUrl), + FullName: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.FullName), + RawScore: o.RawScore, + Stellar: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Stellar), + IsFollowee: o.IsFollowee, + } +} + +type APIUserServiceResult struct { + ServiceName APIUserServiceID `codec:"serviceName" json:"service_name"` + Username string `codec:"username" json:"username"` + PictureUrl string `codec:"pictureUrl" json:"picture_url"` + Bio string `codec:"bio" json:"bio"` + Location string `codec:"location" json:"location"` + FullName string `codec:"fullName" json:"full_name"` + Confirmed *bool `codec:"confirmed,omitempty" json:"confirmed,omitempty"` +} + +func (o APIUserServiceResult) DeepCopy() APIUserServiceResult { + return APIUserServiceResult{ + ServiceName: o.ServiceName.DeepCopy(), + Username: o.Username, + PictureUrl: o.PictureUrl, + Bio: o.Bio, + Location: o.Location, + FullName: o.FullName, + Confirmed: (func(x *bool) *bool { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Confirmed), + } +} + +type APIUserServiceSummary struct { + ServiceName APIUserServiceID `codec:"serviceName" json:"service_name"` + Username string `codec:"username" json:"username"` +} + +func (o APIUserServiceSummary) DeepCopy() APIUserServiceSummary { + return APIUserServiceSummary{ + ServiceName: o.ServiceName.DeepCopy(), + Username: o.Username, + } +} + +type ImpTofuSearchResult struct { + Assertion string `codec:"assertion" json:"assertion"` + AssertionValue string `codec:"assertionValue" json:"assertionValue"` + AssertionKey string `codec:"assertionKey" json:"assertionKey"` + Label string `codec:"label" json:"label"` + PrettyName string `codec:"prettyName" json:"prettyName"` + KeybaseUsername string `codec:"keybaseUsername" json:"keybaseUsername"` +} + +func (o ImpTofuSearchResult) DeepCopy() ImpTofuSearchResult { + return ImpTofuSearchResult{ + Assertion: o.Assertion, + AssertionValue: o.AssertionValue, + AssertionKey: o.AssertionKey, + Label: o.Label, + PrettyName: o.PrettyName, + KeybaseUsername: o.KeybaseUsername, + } +} + +type APIUserSearchResult struct { + Score float64 `codec:"score" json:"score"` + Keybase *APIUserKeybaseResult `codec:"keybase,omitempty" json:"keybase,omitempty"` + Service *APIUserServiceResult `codec:"service,omitempty" json:"service,omitempty"` + Contact *ProcessedContact `codec:"contact,omitempty" json:"contact,omitempty"` + Imptofu *ImpTofuSearchResult `codec:"imptofu,omitempty" json:"imptofu,omitempty"` + ServicesSummary map[APIUserServiceID]APIUserServiceSummary `codec:"servicesSummary" json:"services_summary"` + RawScore float64 `codec:"rawScore" json:"rawScore"` +} + +func (o APIUserSearchResult) DeepCopy() APIUserSearchResult { + return APIUserSearchResult{ + Score: o.Score, + Keybase: (func(x *APIUserKeybaseResult) *APIUserKeybaseResult { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Keybase), + Service: (func(x *APIUserServiceResult) *APIUserServiceResult { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Service), + Contact: (func(x *ProcessedContact) *ProcessedContact { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Contact), + Imptofu: (func(x *ImpTofuSearchResult) *ImpTofuSearchResult { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Imptofu), + ServicesSummary: (func(x map[APIUserServiceID]APIUserServiceSummary) map[APIUserServiceID]APIUserServiceSummary { + if x == nil { + return nil + } + ret := make(map[APIUserServiceID]APIUserServiceSummary, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.ServicesSummary), + RawScore: o.RawScore, + } +} + +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"` +} + +func (o NonUserDetails) DeepCopy() NonUserDetails { + return NonUserDetails{ + IsNonUser: o.IsNonUser, + AssertionValue: o.AssertionValue, + AssertionKey: o.AssertionKey, + Description: o.Description, + Contact: (func(x *ProcessedContact) *ProcessedContact { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Contact), + Service: (func(x *APIUserServiceResult) *APIUserServiceResult { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Service), + SiteIcon: (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.SiteIcon), + SiteIconFull: (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.SiteIconFull), + SiteIconWhite: (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.SiteIconWhite), + } +} 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 new file mode 100644 index 00000000..d5102ad9 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/bundle.go @@ -0,0 +1,988 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/stellar1/bundle.avdl + +package stellar1 + +import ( + "errors" + "fmt" + + keybase1 "github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1" +) + +type BundleRevision uint64 + +func (o BundleRevision) DeepCopy() BundleRevision { + return o +} + +type EncryptedBundle struct { + V int `codec:"v" json:"v"` + E []byte `codec:"e" json:"e"` + N keybase1.BoxNonce `codec:"n" json:"n"` + Gen keybase1.PerUserKeyGeneration `codec:"gen" json:"gen"` +} + +func (o EncryptedBundle) DeepCopy() EncryptedBundle { + return EncryptedBundle{ + V: o.V, + E: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.E), + N: o.N.DeepCopy(), + Gen: o.Gen.DeepCopy(), + } +} + +type BundleVersion int + +const ( + BundleVersion_V1 BundleVersion = 1 + BundleVersion_V2 BundleVersion = 2 + BundleVersion_V3 BundleVersion = 3 + BundleVersion_V4 BundleVersion = 4 + BundleVersion_V5 BundleVersion = 5 + BundleVersion_V6 BundleVersion = 6 + BundleVersion_V7 BundleVersion = 7 + BundleVersion_V8 BundleVersion = 8 + BundleVersion_V9 BundleVersion = 9 + BundleVersion_V10 BundleVersion = 10 +) + +func (o BundleVersion) DeepCopy() BundleVersion { return o } + +var BundleVersionMap = map[string]BundleVersion{ + "V1": 1, + "V2": 2, + "V3": 3, + "V4": 4, + "V5": 5, + "V6": 6, + "V7": 7, + "V8": 8, + "V9": 9, + "V10": 10, +} + +var BundleVersionRevMap = map[BundleVersion]string{ + 1: "V1", + 2: "V2", + 3: "V3", + 4: "V4", + 5: "V5", + 6: "V6", + 7: "V7", + 8: "V8", + 9: "V9", + 10: "V10", +} + +func (e BundleVersion) String() string { + if v, ok := BundleVersionRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type BundleSecretVersioned struct { + Version__ BundleVersion `codec:"version" json:"version"` + V1__ *BundleSecretUnsupported `codec:"v1,omitempty" json:"v1,omitempty"` + V2__ *BundleSecretV2 `codec:"v2,omitempty" json:"v2,omitempty"` + V3__ *BundleSecretUnsupported `codec:"v3,omitempty" json:"v3,omitempty"` + V4__ *BundleSecretUnsupported `codec:"v4,omitempty" json:"v4,omitempty"` + V5__ *BundleSecretUnsupported `codec:"v5,omitempty" json:"v5,omitempty"` + V6__ *BundleSecretUnsupported `codec:"v6,omitempty" json:"v6,omitempty"` + V7__ *BundleSecretUnsupported `codec:"v7,omitempty" json:"v7,omitempty"` + V8__ *BundleSecretUnsupported `codec:"v8,omitempty" json:"v8,omitempty"` + V9__ *BundleSecretUnsupported `codec:"v9,omitempty" json:"v9,omitempty"` + V10__ *BundleSecretUnsupported `codec:"v10,omitempty" json:"v10,omitempty"` +} + +func (o *BundleSecretVersioned) Version() (ret BundleVersion, err error) { + switch o.Version__ { + case BundleVersion_V1: + if o.V1__ == nil { + err = errors.New("unexpected nil value for V1__") + return ret, err + } + case BundleVersion_V2: + if o.V2__ == nil { + err = errors.New("unexpected nil value for V2__") + return ret, err + } + case BundleVersion_V3: + if o.V3__ == nil { + err = errors.New("unexpected nil value for V3__") + return ret, err + } + case BundleVersion_V4: + if o.V4__ == nil { + err = errors.New("unexpected nil value for V4__") + return ret, err + } + case BundleVersion_V5: + if o.V5__ == nil { + err = errors.New("unexpected nil value for V5__") + return ret, err + } + case BundleVersion_V6: + if o.V6__ == nil { + err = errors.New("unexpected nil value for V6__") + return ret, err + } + case BundleVersion_V7: + if o.V7__ == nil { + err = errors.New("unexpected nil value for V7__") + return ret, err + } + case BundleVersion_V8: + if o.V8__ == nil { + err = errors.New("unexpected nil value for V8__") + return ret, err + } + case BundleVersion_V9: + if o.V9__ == nil { + err = errors.New("unexpected nil value for V9__") + return ret, err + } + case BundleVersion_V10: + if o.V10__ == nil { + err = errors.New("unexpected nil value for V10__") + return ret, err + } + } + return o.Version__, nil +} + +func (o BundleSecretVersioned) V1() (res BundleSecretUnsupported) { + if o.Version__ != BundleVersion_V1 { + panic("wrong case accessed") + } + if o.V1__ == nil { + return + } + return *o.V1__ +} + +func (o BundleSecretVersioned) V2() (res BundleSecretV2) { + if o.Version__ != BundleVersion_V2 { + panic("wrong case accessed") + } + if o.V2__ == nil { + return + } + return *o.V2__ +} + +func (o BundleSecretVersioned) V3() (res BundleSecretUnsupported) { + if o.Version__ != BundleVersion_V3 { + panic("wrong case accessed") + } + if o.V3__ == nil { + return + } + return *o.V3__ +} + +func (o BundleSecretVersioned) V4() (res BundleSecretUnsupported) { + if o.Version__ != BundleVersion_V4 { + panic("wrong case accessed") + } + if o.V4__ == nil { + return + } + return *o.V4__ +} + +func (o BundleSecretVersioned) V5() (res BundleSecretUnsupported) { + if o.Version__ != BundleVersion_V5 { + panic("wrong case accessed") + } + if o.V5__ == nil { + return + } + return *o.V5__ +} + +func (o BundleSecretVersioned) V6() (res BundleSecretUnsupported) { + if o.Version__ != BundleVersion_V6 { + panic("wrong case accessed") + } + if o.V6__ == nil { + return + } + return *o.V6__ +} + +func (o BundleSecretVersioned) V7() (res BundleSecretUnsupported) { + if o.Version__ != BundleVersion_V7 { + panic("wrong case accessed") + } + if o.V7__ == nil { + return + } + return *o.V7__ +} + +func (o BundleSecretVersioned) V8() (res BundleSecretUnsupported) { + if o.Version__ != BundleVersion_V8 { + panic("wrong case accessed") + } + if o.V8__ == nil { + return + } + return *o.V8__ +} + +func (o BundleSecretVersioned) V9() (res BundleSecretUnsupported) { + if o.Version__ != BundleVersion_V9 { + panic("wrong case accessed") + } + if o.V9__ == nil { + return + } + return *o.V9__ +} + +func (o BundleSecretVersioned) V10() (res BundleSecretUnsupported) { + if o.Version__ != BundleVersion_V10 { + panic("wrong case accessed") + } + if o.V10__ == nil { + return + } + return *o.V10__ +} + +func NewBundleSecretVersionedWithV1(v BundleSecretUnsupported) BundleSecretVersioned { + return BundleSecretVersioned{ + Version__: BundleVersion_V1, + V1__: &v, + } +} + +func NewBundleSecretVersionedWithV2(v BundleSecretV2) BundleSecretVersioned { + return BundleSecretVersioned{ + Version__: BundleVersion_V2, + V2__: &v, + } +} + +func NewBundleSecretVersionedWithV3(v BundleSecretUnsupported) BundleSecretVersioned { + return BundleSecretVersioned{ + Version__: BundleVersion_V3, + V3__: &v, + } +} + +func NewBundleSecretVersionedWithV4(v BundleSecretUnsupported) BundleSecretVersioned { + return BundleSecretVersioned{ + Version__: BundleVersion_V4, + V4__: &v, + } +} + +func NewBundleSecretVersionedWithV5(v BundleSecretUnsupported) BundleSecretVersioned { + return BundleSecretVersioned{ + Version__: BundleVersion_V5, + V5__: &v, + } +} + +func NewBundleSecretVersionedWithV6(v BundleSecretUnsupported) BundleSecretVersioned { + return BundleSecretVersioned{ + Version__: BundleVersion_V6, + V6__: &v, + } +} + +func NewBundleSecretVersionedWithV7(v BundleSecretUnsupported) BundleSecretVersioned { + return BundleSecretVersioned{ + Version__: BundleVersion_V7, + V7__: &v, + } +} + +func NewBundleSecretVersionedWithV8(v BundleSecretUnsupported) BundleSecretVersioned { + return BundleSecretVersioned{ + Version__: BundleVersion_V8, + V8__: &v, + } +} + +func NewBundleSecretVersionedWithV9(v BundleSecretUnsupported) BundleSecretVersioned { + return BundleSecretVersioned{ + Version__: BundleVersion_V9, + V9__: &v, + } +} + +func NewBundleSecretVersionedWithV10(v BundleSecretUnsupported) BundleSecretVersioned { + return BundleSecretVersioned{ + Version__: BundleVersion_V10, + V10__: &v, + } +} + +func (o BundleSecretVersioned) DeepCopy() BundleSecretVersioned { + return BundleSecretVersioned{ + Version__: o.Version__.DeepCopy(), + V1__: (func(x *BundleSecretUnsupported) *BundleSecretUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V1__), + V2__: (func(x *BundleSecretV2) *BundleSecretV2 { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V2__), + V3__: (func(x *BundleSecretUnsupported) *BundleSecretUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V3__), + V4__: (func(x *BundleSecretUnsupported) *BundleSecretUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V4__), + V5__: (func(x *BundleSecretUnsupported) *BundleSecretUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V5__), + V6__: (func(x *BundleSecretUnsupported) *BundleSecretUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V6__), + V7__: (func(x *BundleSecretUnsupported) *BundleSecretUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V7__), + V8__: (func(x *BundleSecretUnsupported) *BundleSecretUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V8__), + V9__: (func(x *BundleSecretUnsupported) *BundleSecretUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V9__), + V10__: (func(x *BundleSecretUnsupported) *BundleSecretUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V10__), + } +} + +type BundleVisibleV2 struct { + Revision BundleRevision `codec:"revision" json:"revision"` + Prev Hash `codec:"prev" json:"prev"` + Accounts []BundleVisibleEntryV2 `codec:"accounts" json:"accounts"` +} + +func (o BundleVisibleV2) DeepCopy() BundleVisibleV2 { + return BundleVisibleV2{ + Revision: o.Revision.DeepCopy(), + Prev: o.Prev.DeepCopy(), + Accounts: (func(x []BundleVisibleEntryV2) []BundleVisibleEntryV2 { + if x == nil { + return nil + } + ret := make([]BundleVisibleEntryV2, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Accounts), + } +} + +type BundleSecretV2 struct { + VisibleHash Hash `codec:"visibleHash" json:"visibleHash"` + Accounts []BundleSecretEntryV2 `codec:"accounts" json:"accounts"` +} + +func (o BundleSecretV2) DeepCopy() BundleSecretV2 { + return BundleSecretV2{ + VisibleHash: o.VisibleHash.DeepCopy(), + Accounts: (func(x []BundleSecretEntryV2) []BundleSecretEntryV2 { + if x == nil { + return nil + } + ret := make([]BundleSecretEntryV2, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Accounts), + } +} + +type BundleVisibleEntryV2 struct { + AccountID AccountID `codec:"accountID" json:"accountID"` + Mode AccountMode `codec:"mode" json:"mode"` + IsPrimary bool `codec:"isPrimary" json:"isPrimary"` + AcctBundleRevision BundleRevision `codec:"acctBundleRevision" json:"acctBundleRevision"` + EncAcctBundleHash Hash `codec:"encAcctBundleHash" json:"encAcctBundleHash"` +} + +func (o BundleVisibleEntryV2) DeepCopy() BundleVisibleEntryV2 { + return BundleVisibleEntryV2{ + AccountID: o.AccountID.DeepCopy(), + Mode: o.Mode.DeepCopy(), + IsPrimary: o.IsPrimary, + AcctBundleRevision: o.AcctBundleRevision.DeepCopy(), + EncAcctBundleHash: o.EncAcctBundleHash.DeepCopy(), + } +} + +type BundleSecretEntryV2 struct { + AccountID AccountID `codec:"accountID" json:"accountID"` + Name string `codec:"name" json:"name"` +} + +func (o BundleSecretEntryV2) DeepCopy() BundleSecretEntryV2 { + return BundleSecretEntryV2{ + AccountID: o.AccountID.DeepCopy(), + Name: o.Name, + } +} + +type BundleSecretUnsupported struct { +} + +func (o BundleSecretUnsupported) DeepCopy() BundleSecretUnsupported { + return BundleSecretUnsupported{} +} + +type EncryptedAccountBundle struct { + V int `codec:"v" json:"v"` + E []byte `codec:"e" json:"e"` + N keybase1.BoxNonce `codec:"n" json:"n"` + Gen keybase1.PerUserKeyGeneration `codec:"gen" json:"gen"` +} + +func (o EncryptedAccountBundle) DeepCopy() EncryptedAccountBundle { + return EncryptedAccountBundle{ + V: o.V, + E: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.E), + N: o.N.DeepCopy(), + Gen: o.Gen.DeepCopy(), + } +} + +type AccountBundleVersion int + +const ( + AccountBundleVersion_V1 AccountBundleVersion = 1 + AccountBundleVersion_V2 AccountBundleVersion = 2 + AccountBundleVersion_V3 AccountBundleVersion = 3 + AccountBundleVersion_V4 AccountBundleVersion = 4 + AccountBundleVersion_V5 AccountBundleVersion = 5 + AccountBundleVersion_V6 AccountBundleVersion = 6 + AccountBundleVersion_V7 AccountBundleVersion = 7 + AccountBundleVersion_V8 AccountBundleVersion = 8 + AccountBundleVersion_V9 AccountBundleVersion = 9 + AccountBundleVersion_V10 AccountBundleVersion = 10 +) + +func (o AccountBundleVersion) DeepCopy() AccountBundleVersion { return o } + +var AccountBundleVersionMap = map[string]AccountBundleVersion{ + "V1": 1, + "V2": 2, + "V3": 3, + "V4": 4, + "V5": 5, + "V6": 6, + "V7": 7, + "V8": 8, + "V9": 9, + "V10": 10, +} + +var AccountBundleVersionRevMap = map[AccountBundleVersion]string{ + 1: "V1", + 2: "V2", + 3: "V3", + 4: "V4", + 5: "V5", + 6: "V6", + 7: "V7", + 8: "V8", + 9: "V9", + 10: "V10", +} + +func (e AccountBundleVersion) String() string { + if v, ok := AccountBundleVersionRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type AccountBundleSecretVersioned struct { + Version__ AccountBundleVersion `codec:"version" json:"version"` + V1__ *AccountBundleSecretV1 `codec:"v1,omitempty" json:"v1,omitempty"` + V2__ *AccountBundleSecretUnsupported `codec:"v2,omitempty" json:"v2,omitempty"` + V3__ *AccountBundleSecretUnsupported `codec:"v3,omitempty" json:"v3,omitempty"` + V4__ *AccountBundleSecretUnsupported `codec:"v4,omitempty" json:"v4,omitempty"` + V5__ *AccountBundleSecretUnsupported `codec:"v5,omitempty" json:"v5,omitempty"` + V6__ *AccountBundleSecretUnsupported `codec:"v6,omitempty" json:"v6,omitempty"` + V7__ *AccountBundleSecretUnsupported `codec:"v7,omitempty" json:"v7,omitempty"` + V8__ *AccountBundleSecretUnsupported `codec:"v8,omitempty" json:"v8,omitempty"` + V9__ *AccountBundleSecretUnsupported `codec:"v9,omitempty" json:"v9,omitempty"` + V10__ *AccountBundleSecretUnsupported `codec:"v10,omitempty" json:"v10,omitempty"` +} + +func (o *AccountBundleSecretVersioned) Version() (ret AccountBundleVersion, err error) { + switch o.Version__ { + case AccountBundleVersion_V1: + if o.V1__ == nil { + err = errors.New("unexpected nil value for V1__") + return ret, err + } + case AccountBundleVersion_V2: + if o.V2__ == nil { + err = errors.New("unexpected nil value for V2__") + return ret, err + } + case AccountBundleVersion_V3: + if o.V3__ == nil { + err = errors.New("unexpected nil value for V3__") + return ret, err + } + case AccountBundleVersion_V4: + if o.V4__ == nil { + err = errors.New("unexpected nil value for V4__") + return ret, err + } + case AccountBundleVersion_V5: + if o.V5__ == nil { + err = errors.New("unexpected nil value for V5__") + return ret, err + } + case AccountBundleVersion_V6: + if o.V6__ == nil { + err = errors.New("unexpected nil value for V6__") + return ret, err + } + case AccountBundleVersion_V7: + if o.V7__ == nil { + err = errors.New("unexpected nil value for V7__") + return ret, err + } + case AccountBundleVersion_V8: + if o.V8__ == nil { + err = errors.New("unexpected nil value for V8__") + return ret, err + } + case AccountBundleVersion_V9: + if o.V9__ == nil { + err = errors.New("unexpected nil value for V9__") + return ret, err + } + case AccountBundleVersion_V10: + if o.V10__ == nil { + err = errors.New("unexpected nil value for V10__") + return ret, err + } + } + return o.Version__, nil +} + +func (o AccountBundleSecretVersioned) V1() (res AccountBundleSecretV1) { + if o.Version__ != AccountBundleVersion_V1 { + panic("wrong case accessed") + } + if o.V1__ == nil { + return + } + return *o.V1__ +} + +func (o AccountBundleSecretVersioned) V2() (res AccountBundleSecretUnsupported) { + if o.Version__ != AccountBundleVersion_V2 { + panic("wrong case accessed") + } + if o.V2__ == nil { + return + } + return *o.V2__ +} + +func (o AccountBundleSecretVersioned) V3() (res AccountBundleSecretUnsupported) { + if o.Version__ != AccountBundleVersion_V3 { + panic("wrong case accessed") + } + if o.V3__ == nil { + return + } + return *o.V3__ +} + +func (o AccountBundleSecretVersioned) V4() (res AccountBundleSecretUnsupported) { + if o.Version__ != AccountBundleVersion_V4 { + panic("wrong case accessed") + } + if o.V4__ == nil { + return + } + return *o.V4__ +} + +func (o AccountBundleSecretVersioned) V5() (res AccountBundleSecretUnsupported) { + if o.Version__ != AccountBundleVersion_V5 { + panic("wrong case accessed") + } + if o.V5__ == nil { + return + } + return *o.V5__ +} + +func (o AccountBundleSecretVersioned) V6() (res AccountBundleSecretUnsupported) { + if o.Version__ != AccountBundleVersion_V6 { + panic("wrong case accessed") + } + if o.V6__ == nil { + return + } + return *o.V6__ +} + +func (o AccountBundleSecretVersioned) V7() (res AccountBundleSecretUnsupported) { + if o.Version__ != AccountBundleVersion_V7 { + panic("wrong case accessed") + } + if o.V7__ == nil { + return + } + return *o.V7__ +} + +func (o AccountBundleSecretVersioned) V8() (res AccountBundleSecretUnsupported) { + if o.Version__ != AccountBundleVersion_V8 { + panic("wrong case accessed") + } + if o.V8__ == nil { + return + } + return *o.V8__ +} + +func (o AccountBundleSecretVersioned) V9() (res AccountBundleSecretUnsupported) { + if o.Version__ != AccountBundleVersion_V9 { + panic("wrong case accessed") + } + if o.V9__ == nil { + return + } + return *o.V9__ +} + +func (o AccountBundleSecretVersioned) V10() (res AccountBundleSecretUnsupported) { + if o.Version__ != AccountBundleVersion_V10 { + panic("wrong case accessed") + } + if o.V10__ == nil { + return + } + return *o.V10__ +} + +func NewAccountBundleSecretVersionedWithV1(v AccountBundleSecretV1) AccountBundleSecretVersioned { + return AccountBundleSecretVersioned{ + Version__: AccountBundleVersion_V1, + V1__: &v, + } +} + +func NewAccountBundleSecretVersionedWithV2(v AccountBundleSecretUnsupported) AccountBundleSecretVersioned { + return AccountBundleSecretVersioned{ + Version__: AccountBundleVersion_V2, + V2__: &v, + } +} + +func NewAccountBundleSecretVersionedWithV3(v AccountBundleSecretUnsupported) AccountBundleSecretVersioned { + return AccountBundleSecretVersioned{ + Version__: AccountBundleVersion_V3, + V3__: &v, + } +} + +func NewAccountBundleSecretVersionedWithV4(v AccountBundleSecretUnsupported) AccountBundleSecretVersioned { + return AccountBundleSecretVersioned{ + Version__: AccountBundleVersion_V4, + V4__: &v, + } +} + +func NewAccountBundleSecretVersionedWithV5(v AccountBundleSecretUnsupported) AccountBundleSecretVersioned { + return AccountBundleSecretVersioned{ + Version__: AccountBundleVersion_V5, + V5__: &v, + } +} + +func NewAccountBundleSecretVersionedWithV6(v AccountBundleSecretUnsupported) AccountBundleSecretVersioned { + return AccountBundleSecretVersioned{ + Version__: AccountBundleVersion_V6, + V6__: &v, + } +} + +func NewAccountBundleSecretVersionedWithV7(v AccountBundleSecretUnsupported) AccountBundleSecretVersioned { + return AccountBundleSecretVersioned{ + Version__: AccountBundleVersion_V7, + V7__: &v, + } +} + +func NewAccountBundleSecretVersionedWithV8(v AccountBundleSecretUnsupported) AccountBundleSecretVersioned { + return AccountBundleSecretVersioned{ + Version__: AccountBundleVersion_V8, + V8__: &v, + } +} + +func NewAccountBundleSecretVersionedWithV9(v AccountBundleSecretUnsupported) AccountBundleSecretVersioned { + return AccountBundleSecretVersioned{ + Version__: AccountBundleVersion_V9, + V9__: &v, + } +} + +func NewAccountBundleSecretVersionedWithV10(v AccountBundleSecretUnsupported) AccountBundleSecretVersioned { + return AccountBundleSecretVersioned{ + Version__: AccountBundleVersion_V10, + V10__: &v, + } +} + +func (o AccountBundleSecretVersioned) DeepCopy() AccountBundleSecretVersioned { + return AccountBundleSecretVersioned{ + Version__: o.Version__.DeepCopy(), + V1__: (func(x *AccountBundleSecretV1) *AccountBundleSecretV1 { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V1__), + V2__: (func(x *AccountBundleSecretUnsupported) *AccountBundleSecretUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V2__), + V3__: (func(x *AccountBundleSecretUnsupported) *AccountBundleSecretUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V3__), + V4__: (func(x *AccountBundleSecretUnsupported) *AccountBundleSecretUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V4__), + V5__: (func(x *AccountBundleSecretUnsupported) *AccountBundleSecretUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V5__), + V6__: (func(x *AccountBundleSecretUnsupported) *AccountBundleSecretUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V6__), + V7__: (func(x *AccountBundleSecretUnsupported) *AccountBundleSecretUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V7__), + V8__: (func(x *AccountBundleSecretUnsupported) *AccountBundleSecretUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V8__), + V9__: (func(x *AccountBundleSecretUnsupported) *AccountBundleSecretUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V9__), + V10__: (func(x *AccountBundleSecretUnsupported) *AccountBundleSecretUnsupported { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.V10__), + } +} + +type AccountBundleSecretV1 struct { + AccountID AccountID `codec:"accountID" json:"accountID"` + Signers []SecretKey `codec:"signers" json:"signers"` +} + +func (o AccountBundleSecretV1) DeepCopy() AccountBundleSecretV1 { + return AccountBundleSecretV1{ + AccountID: o.AccountID.DeepCopy(), + Signers: (func(x []SecretKey) []SecretKey { + if x == nil { + return nil + } + ret := make([]SecretKey, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Signers), + } +} + +type AccountBundleSecretUnsupported struct { +} + +func (o AccountBundleSecretUnsupported) DeepCopy() AccountBundleSecretUnsupported { + return AccountBundleSecretUnsupported{} +} + +type Bundle struct { + Revision BundleRevision `codec:"revision" json:"revision"` + Prev Hash `codec:"prev" json:"prev"` + OwnHash Hash `codec:"ownHash" json:"ownHash"` + Accounts []BundleEntry `codec:"accounts" json:"accounts"` + AccountBundles map[AccountID]AccountBundle `codec:"accountBundles" json:"accountBundles"` +} + +func (o Bundle) DeepCopy() Bundle { + return Bundle{ + Revision: o.Revision.DeepCopy(), + Prev: o.Prev.DeepCopy(), + OwnHash: o.OwnHash.DeepCopy(), + Accounts: (func(x []BundleEntry) []BundleEntry { + if x == nil { + return nil + } + ret := make([]BundleEntry, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Accounts), + AccountBundles: (func(x map[AccountID]AccountBundle) map[AccountID]AccountBundle { + if x == nil { + return nil + } + ret := make(map[AccountID]AccountBundle, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.AccountBundles), + } +} + +type BundleEntry struct { + AccountID AccountID `codec:"accountID" json:"accountID"` + Mode AccountMode `codec:"mode" json:"mode"` + IsPrimary bool `codec:"isPrimary" json:"isPrimary"` + Name string `codec:"name" json:"name"` + AcctBundleRevision BundleRevision `codec:"acctBundleRevision" json:"acctBundleRevision"` + EncAcctBundleHash Hash `codec:"encAcctBundleHash" json:"encAcctBundleHash"` +} + +func (o BundleEntry) DeepCopy() BundleEntry { + return BundleEntry{ + AccountID: o.AccountID.DeepCopy(), + Mode: o.Mode.DeepCopy(), + IsPrimary: o.IsPrimary, + Name: o.Name, + AcctBundleRevision: o.AcctBundleRevision.DeepCopy(), + EncAcctBundleHash: o.EncAcctBundleHash.DeepCopy(), + } +} + +type AccountBundle struct { + Prev Hash `codec:"prev" json:"prev"` + OwnHash Hash `codec:"ownHash" json:"ownHash"` + AccountID AccountID `codec:"accountID" json:"accountID"` + Signers []SecretKey `codec:"signers" json:"signers"` +} + +func (o AccountBundle) DeepCopy() AccountBundle { + return AccountBundle{ + Prev: o.Prev.DeepCopy(), + OwnHash: o.OwnHash.DeepCopy(), + AccountID: o.AccountID.DeepCopy(), + Signers: (func(x []SecretKey) []SecretKey { + if x == nil { + return nil + } + ret := make([]SecretKey, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Signers), + } +} 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 new file mode 100644 index 00000000..cf49a1d8 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/common.go @@ -0,0 +1,548 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/stellar1/common.avdl + +package stellar1 + +import ( + "fmt" + + keybase1 "github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1" +) + +type AccountID string + +func (o AccountID) DeepCopy() AccountID { + return o +} + +type SecretKey string + +func (o SecretKey) DeepCopy() SecretKey { + return o +} + +type TransactionID string + +func (o TransactionID) DeepCopy() TransactionID { + return o +} + +type PaymentID string + +func (o PaymentID) DeepCopy() PaymentID { + return o +} + +type KeybaseTransactionID string + +func (o KeybaseTransactionID) DeepCopy() KeybaseTransactionID { + return o +} + +type TimeMs int64 + +func (o TimeMs) DeepCopy() TimeMs { + return o +} + +type Hash []byte + +func (o Hash) DeepCopy() Hash { + return (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o) +} + +type KeybaseRequestID string + +func (o KeybaseRequestID) DeepCopy() KeybaseRequestID { + return o +} + +type AssetCode string + +func (o AssetCode) DeepCopy() AssetCode { + return o +} + +type Asset struct { + Type string `codec:"type" json:"type"` + Code string `codec:"code" json:"code"` + Issuer string `codec:"issuer" json:"issuer"` + VerifiedDomain string `codec:"verifiedDomain" json:"verifiedDomain"` + IssuerName string `codec:"issuerName" json:"issuerName"` + Desc string `codec:"desc" json:"desc"` + InfoUrl string `codec:"infoUrl" json:"infoUrl"` + InfoUrlText string `codec:"infoUrlText" json:"infoUrlText"` + ShowDepositButton bool `codec:"showDepositButton" json:"showDepositButton"` + DepositButtonText string `codec:"depositButtonText" json:"depositButtonText"` + ShowWithdrawButton bool `codec:"showWithdrawButton" json:"showWithdrawButton"` + WithdrawButtonText string `codec:"withdrawButtonText" json:"withdrawButtonText"` + WithdrawType string `codec:"withdrawType" json:"withdrawType"` + TransferServer string `codec:"transferServer" json:"transferServer"` + AuthEndpoint string `codec:"authEndpoint" json:"authEndpoint"` + DepositReqAuth bool `codec:"depositReqAuth" json:"depositReqAuth"` + WithdrawReqAuth bool `codec:"withdrawReqAuth" json:"withdrawReqAuth"` +} + +func (o Asset) DeepCopy() Asset { + return Asset{ + Type: o.Type, + Code: o.Code, + Issuer: o.Issuer, + VerifiedDomain: o.VerifiedDomain, + IssuerName: o.IssuerName, + Desc: o.Desc, + InfoUrl: o.InfoUrl, + InfoUrlText: o.InfoUrlText, + ShowDepositButton: o.ShowDepositButton, + DepositButtonText: o.DepositButtonText, + ShowWithdrawButton: o.ShowWithdrawButton, + WithdrawButtonText: o.WithdrawButtonText, + WithdrawType: o.WithdrawType, + TransferServer: o.TransferServer, + AuthEndpoint: o.AuthEndpoint, + DepositReqAuth: o.DepositReqAuth, + WithdrawReqAuth: o.WithdrawReqAuth, + } +} + +type AssetListResult struct { + Assets []Asset `codec:"assets" json:"assets"` + TotalCount int `codec:"totalCount" json:"totalCount"` +} + +func (o AssetListResult) DeepCopy() AssetListResult { + return AssetListResult{ + Assets: (func(x []Asset) []Asset { + if x == nil { + return nil + } + ret := make([]Asset, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Assets), + TotalCount: o.TotalCount, + } +} + +type Balance struct { + Asset Asset `codec:"asset" json:"asset"` + Amount string `codec:"amount" json:"amount"` + Limit string `codec:"limit" json:"limit"` + IsAuthorized bool `codec:"isAuthorized" json:"isAuthorized"` +} + +func (o Balance) DeepCopy() Balance { + return Balance{ + Asset: o.Asset.DeepCopy(), + Amount: o.Amount, + Limit: o.Limit, + IsAuthorized: o.IsAuthorized, + } +} + +type AccountReserve struct { + Amount string `codec:"amount" json:"amount"` + Description string `codec:"description" json:"description"` +} + +func (o AccountReserve) DeepCopy() AccountReserve { + return AccountReserve{ + Amount: o.Amount, + Description: o.Description, + } +} + +type TransactionStatus int + +const ( + TransactionStatus_NONE TransactionStatus = 0 + TransactionStatus_PENDING TransactionStatus = 1 + TransactionStatus_SUCCESS TransactionStatus = 2 + TransactionStatus_ERROR_TRANSIENT TransactionStatus = 3 + TransactionStatus_ERROR_PERMANENT TransactionStatus = 4 +) + +func (o TransactionStatus) DeepCopy() TransactionStatus { return o } + +var TransactionStatusMap = map[string]TransactionStatus{ + "NONE": 0, + "PENDING": 1, + "SUCCESS": 2, + "ERROR_TRANSIENT": 3, + "ERROR_PERMANENT": 4, +} + +var TransactionStatusRevMap = map[TransactionStatus]string{ + 0: "NONE", + 1: "PENDING", + 2: "SUCCESS", + 3: "ERROR_TRANSIENT", + 4: "ERROR_PERMANENT", +} + +func (e TransactionStatus) String() string { + if v, ok := TransactionStatusRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type RequestStatus int + +const ( + RequestStatus_OK RequestStatus = 0 + RequestStatus_CANCELED RequestStatus = 1 + RequestStatus_DONE RequestStatus = 2 +) + +func (o RequestStatus) DeepCopy() RequestStatus { return o } + +var RequestStatusMap = map[string]RequestStatus{ + "OK": 0, + "CANCELED": 1, + "DONE": 2, +} + +var RequestStatusRevMap = map[RequestStatus]string{ + 0: "OK", + 1: "CANCELED", + 2: "DONE", +} + +func (e RequestStatus) String() string { + if v, ok := RequestStatusRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type PaymentStrategy int + +const ( + PaymentStrategy_NONE PaymentStrategy = 0 + PaymentStrategy_DIRECT PaymentStrategy = 1 + PaymentStrategy_RELAY PaymentStrategy = 2 +) + +func (o PaymentStrategy) DeepCopy() PaymentStrategy { return o } + +var PaymentStrategyMap = map[string]PaymentStrategy{ + "NONE": 0, + "DIRECT": 1, + "RELAY": 2, +} + +var PaymentStrategyRevMap = map[PaymentStrategy]string{ + 0: "NONE", + 1: "DIRECT", + 2: "RELAY", +} + +func (e PaymentStrategy) String() string { + if v, ok := PaymentStrategyRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type RelayDirection int + +const ( + RelayDirection_CLAIM RelayDirection = 0 + RelayDirection_YANK RelayDirection = 1 +) + +func (o RelayDirection) DeepCopy() RelayDirection { return o } + +var RelayDirectionMap = map[string]RelayDirection{ + "CLAIM": 0, + "YANK": 1, +} + +var RelayDirectionRevMap = map[RelayDirection]string{ + 0: "CLAIM", + 1: "YANK", +} + +func (e RelayDirection) String() string { + if v, ok := RelayDirectionRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type PaymentResult struct { + SenderAccountID AccountID `codec:"senderAccountID" json:"senderAccountID"` + KeybaseID KeybaseTransactionID `codec:"keybaseID" json:"keybaseID"` + StellarID TransactionID `codec:"stellarID" json:"stellarID"` + Pending bool `codec:"pending" json:"pending"` +} + +func (o PaymentResult) DeepCopy() PaymentResult { + return PaymentResult{ + SenderAccountID: o.SenderAccountID.DeepCopy(), + KeybaseID: o.KeybaseID.DeepCopy(), + StellarID: o.StellarID.DeepCopy(), + Pending: o.Pending, + } +} + +type RelayClaimResult struct { + ClaimStellarID TransactionID `codec:"claimStellarID" json:"claimStellarID"` +} + +func (o RelayClaimResult) DeepCopy() RelayClaimResult { + return RelayClaimResult{ + ClaimStellarID: o.ClaimStellarID.DeepCopy(), + } +} + +type EncryptedNote struct { + V int `codec:"v" json:"v"` + E []byte `codec:"e" json:"e"` + N keybase1.BoxNonce `codec:"n" json:"n"` + Sender NoteRecipient `codec:"sender" json:"sender"` + Recipient *NoteRecipient `codec:"recipient,omitempty" json:"recipient,omitempty"` +} + +func (o EncryptedNote) DeepCopy() EncryptedNote { + return EncryptedNote{ + V: o.V, + E: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.E), + N: o.N.DeepCopy(), + Sender: o.Sender.DeepCopy(), + Recipient: (func(x *NoteRecipient) *NoteRecipient { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Recipient), + } +} + +type NoteRecipient struct { + User keybase1.UserVersion `codec:"user" json:"user"` + PukGen keybase1.PerUserKeyGeneration `codec:"pukGen" json:"pukGen"` +} + +func (o NoteRecipient) DeepCopy() NoteRecipient { + return NoteRecipient{ + User: o.User.DeepCopy(), + PukGen: o.PukGen.DeepCopy(), + } +} + +type NoteContents struct { + Note string `codec:"note" json:"note"` + StellarID TransactionID `codec:"stellarID" json:"stellarID"` +} + +func (o NoteContents) DeepCopy() NoteContents { + return NoteContents{ + Note: o.Note, + StellarID: o.StellarID.DeepCopy(), + } +} + +type EncryptedRelaySecret struct { + V int `codec:"v" json:"v"` + E []byte `codec:"e" json:"e"` + N keybase1.BoxNonce `codec:"n" json:"n"` + Gen keybase1.PerTeamKeyGeneration `codec:"gen" json:"gen"` +} + +func (o EncryptedRelaySecret) DeepCopy() EncryptedRelaySecret { + return EncryptedRelaySecret{ + V: o.V, + E: (func(x []byte) []byte { + if x == nil { + return nil + } + return append([]byte{}, x...) + })(o.E), + N: o.N.DeepCopy(), + Gen: o.Gen.DeepCopy(), + } +} + +type RelayContents struct { + StellarID TransactionID `codec:"stellarID" json:"stellarID"` + Sk SecretKey `codec:"sk" json:"sk"` + Note string `codec:"note" json:"note"` +} + +func (o RelayContents) DeepCopy() RelayContents { + return RelayContents{ + StellarID: o.StellarID.DeepCopy(), + Sk: o.Sk.DeepCopy(), + Note: o.Note, + } +} + +type OutsideCurrencyCode string + +func (o OutsideCurrencyCode) DeepCopy() OutsideCurrencyCode { + return o +} + +type OutsideExchangeRate struct { + Currency OutsideCurrencyCode `codec:"currency" json:"currency"` + Rate string `codec:"rate" json:"rate"` +} + +func (o OutsideExchangeRate) DeepCopy() OutsideExchangeRate { + return OutsideExchangeRate{ + Currency: o.Currency.DeepCopy(), + Rate: o.Rate, + } +} + +type CurrencySymbol struct { + Symbol string `codec:"symbol" json:"str"` + Ambigious bool `codec:"ambigious" json:"ambigious"` + Postfix bool `codec:"postfix" json:"postfix"` +} + +func (o CurrencySymbol) DeepCopy() CurrencySymbol { + return CurrencySymbol{ + Symbol: o.Symbol, + Ambigious: o.Ambigious, + Postfix: o.Postfix, + } +} + +type OutsideCurrencyDefinition struct { + Name string `codec:"name" json:"name"` + Symbol CurrencySymbol `codec:"symbol" json:"symbol"` +} + +func (o OutsideCurrencyDefinition) DeepCopy() OutsideCurrencyDefinition { + return OutsideCurrencyDefinition{ + Name: o.Name, + Symbol: o.Symbol.DeepCopy(), + } +} + +type StellarServerDefinitions struct { + Revision int `codec:"revision" json:"revision"` + Currencies map[OutsideCurrencyCode]OutsideCurrencyDefinition `codec:"currencies" json:"currencies"` +} + +func (o StellarServerDefinitions) DeepCopy() StellarServerDefinitions { + return StellarServerDefinitions{ + Revision: o.Revision, + Currencies: (func(x map[OutsideCurrencyCode]OutsideCurrencyDefinition) map[OutsideCurrencyCode]OutsideCurrencyDefinition { + if x == nil { + return nil + } + ret := make(map[OutsideCurrencyCode]OutsideCurrencyDefinition, len(x)) + for k, v := range x { + kCopy := k.DeepCopy() + vCopy := v.DeepCopy() + ret[kCopy] = vCopy + } + return ret + })(o.Currencies), + } +} + +type PageCursor struct { + HorizonCursor string `codec:"horizonCursor" json:"horizonCursor"` + DirectCursor string `codec:"directCursor" json:"directCursor"` + RelayCursor string `codec:"relayCursor" json:"relayCursor"` +} + +func (o PageCursor) DeepCopy() PageCursor { + return PageCursor{ + HorizonCursor: o.HorizonCursor, + DirectCursor: o.DirectCursor, + RelayCursor: o.RelayCursor, + } +} + +type AccountMode int + +const ( + AccountMode_NONE AccountMode = 0 + AccountMode_USER AccountMode = 1 + AccountMode_MOBILE AccountMode = 2 +) + +func (o AccountMode) DeepCopy() AccountMode { return o } + +var AccountModeMap = map[string]AccountMode{ + "NONE": 0, + "USER": 1, + "MOBILE": 2, +} + +var AccountModeRevMap = map[AccountMode]string{ + 0: "NONE", + 1: "USER", + 2: "MOBILE", +} + +func (e AccountMode) String() string { + if v, ok := AccountModeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type Trustline struct { + AssetCode AssetCode `codec:"assetCode" json:"assetCode"` + Issuer AccountID `codec:"issuer" json:"issuer"` +} + +func (o Trustline) DeepCopy() Trustline { + return Trustline{ + AssetCode: o.AssetCode.DeepCopy(), + Issuer: o.Issuer.DeepCopy(), + } +} + +type PaymentPath struct { + SourceAmount string `codec:"sourceAmount" json:"sourceAmount"` + SourceAmountMax string `codec:"sourceAmountMax" json:"sourceAmountMax"` + SourceAsset Asset `codec:"sourceAsset" json:"sourceAsset"` + Path []Asset `codec:"path" json:"path"` + DestinationAmount string `codec:"destinationAmount" json:"destinationAmount"` + DestinationAsset Asset `codec:"destinationAsset" json:"destinationAsset"` + SourceInsufficientBalance string `codec:"sourceInsufficientBalance" json:"sourceInsufficientBalance"` +} + +func (o PaymentPath) DeepCopy() PaymentPath { + return PaymentPath{ + SourceAmount: o.SourceAmount, + SourceAmountMax: o.SourceAmountMax, + SourceAsset: o.SourceAsset.DeepCopy(), + Path: (func(x []Asset) []Asset { + if x == nil { + return nil + } + ret := make([]Asset, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Path), + DestinationAmount: o.DestinationAmount, + DestinationAsset: o.DestinationAsset.DeepCopy(), + SourceInsufficientBalance: o.SourceInsufficientBalance, + } +} 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 new file mode 100644 index 00000000..bcdf8592 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/gregor.go @@ -0,0 +1,40 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/stellar1/gregor.avdl + +package stellar1 + +type PaymentStatusMsg struct { + AccountID AccountID `codec:"accountID" json:"accountID"` + KbTxID KeybaseTransactionID `codec:"kbTxID" json:"kbTxID"` + TxID TransactionID `codec:"txID" json:"txID"` +} + +func (o PaymentStatusMsg) DeepCopy() PaymentStatusMsg { + return PaymentStatusMsg{ + AccountID: o.AccountID.DeepCopy(), + KbTxID: o.KbTxID.DeepCopy(), + TxID: o.TxID.DeepCopy(), + } +} + +type RequestStatusMsg struct { + ReqID KeybaseRequestID `codec:"reqID" json:"reqID"` +} + +func (o RequestStatusMsg) DeepCopy() RequestStatusMsg { + return RequestStatusMsg{ + ReqID: o.ReqID.DeepCopy(), + } +} + +type PaymentNotificationMsg struct { + AccountID AccountID `codec:"accountID" json:"accountID"` + PaymentID PaymentID `codec:"paymentID" json:"paymentID"` +} + +func (o PaymentNotificationMsg) DeepCopy() PaymentNotificationMsg { + return PaymentNotificationMsg{ + AccountID: o.AccountID.DeepCopy(), + PaymentID: o.PaymentID.DeepCopy(), + } +} 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 new file mode 100644 index 00000000..ec474d28 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/local.go @@ -0,0 +1,1311 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/stellar1/local.avdl + +package stellar1 + +import ( + "fmt" +) + +type WalletAccountLocal struct { + AccountID AccountID `codec:"accountID" json:"accountID"` + IsDefault bool `codec:"isDefault" json:"isDefault"` + Name string `codec:"name" json:"name"` + BalanceDescription string `codec:"balanceDescription" json:"balanceDescription"` + Seqno string `codec:"seqno" json:"seqno"` + CurrencyLocal CurrencyLocal `codec:"currencyLocal" json:"currencyLocal"` + AccountMode AccountMode `codec:"accountMode" json:"accountMode"` + AccountModeEditable bool `codec:"accountModeEditable" json:"accountModeEditable"` + DeviceReadOnly bool `codec:"deviceReadOnly" json:"deviceReadOnly"` + IsFunded bool `codec:"isFunded" json:"isFunded"` + CanSubmitTx bool `codec:"canSubmitTx" json:"canSubmitTx"` + CanAddTrustline bool `codec:"canAddTrustline" json:"canAddTrustline"` +} + +func (o WalletAccountLocal) DeepCopy() WalletAccountLocal { + return WalletAccountLocal{ + AccountID: o.AccountID.DeepCopy(), + IsDefault: o.IsDefault, + Name: o.Name, + BalanceDescription: o.BalanceDescription, + Seqno: o.Seqno, + CurrencyLocal: o.CurrencyLocal.DeepCopy(), + AccountMode: o.AccountMode.DeepCopy(), + AccountModeEditable: o.AccountModeEditable, + DeviceReadOnly: o.DeviceReadOnly, + IsFunded: o.IsFunded, + CanSubmitTx: o.CanSubmitTx, + CanAddTrustline: o.CanAddTrustline, + } +} + +type AccountAssetLocal struct { + Name string `codec:"name" json:"name"` + AssetCode string `codec:"assetCode" json:"assetCode"` + IssuerName string `codec:"issuerName" json:"issuerName"` + IssuerAccountID string `codec:"issuerAccountID" json:"issuerAccountID"` + IssuerVerifiedDomain string `codec:"issuerVerifiedDomain" json:"issuerVerifiedDomain"` + BalanceTotal string `codec:"balanceTotal" json:"balanceTotal"` + BalanceAvailableToSend string `codec:"balanceAvailableToSend" json:"balanceAvailableToSend"` + WorthCurrency string `codec:"worthCurrency" json:"worthCurrency"` + Worth string `codec:"worth" json:"worth"` + AvailableToSendWorth string `codec:"availableToSendWorth" json:"availableToSendWorth"` + Reserves []AccountReserve `codec:"reserves" json:"reserves"` + Desc string `codec:"desc" json:"desc"` + InfoUrl string `codec:"infoUrl" json:"infoUrl"` + InfoUrlText string `codec:"infoUrlText" json:"infoUrlText"` + ShowDepositButton bool `codec:"showDepositButton" json:"showDepositButton"` + DepositButtonText string `codec:"depositButtonText" json:"depositButtonText"` + ShowWithdrawButton bool `codec:"showWithdrawButton" json:"showWithdrawButton"` + WithdrawButtonText string `codec:"withdrawButtonText" json:"withdrawButtonText"` +} + +func (o AccountAssetLocal) DeepCopy() AccountAssetLocal { + return AccountAssetLocal{ + Name: o.Name, + AssetCode: o.AssetCode, + IssuerName: o.IssuerName, + IssuerAccountID: o.IssuerAccountID, + IssuerVerifiedDomain: o.IssuerVerifiedDomain, + BalanceTotal: o.BalanceTotal, + BalanceAvailableToSend: o.BalanceAvailableToSend, + WorthCurrency: o.WorthCurrency, + Worth: o.Worth, + AvailableToSendWorth: o.AvailableToSendWorth, + Reserves: (func(x []AccountReserve) []AccountReserve { + if x == nil { + return nil + } + ret := make([]AccountReserve, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Reserves), + Desc: o.Desc, + InfoUrl: o.InfoUrl, + InfoUrlText: o.InfoUrlText, + ShowDepositButton: o.ShowDepositButton, + DepositButtonText: o.DepositButtonText, + ShowWithdrawButton: o.ShowWithdrawButton, + WithdrawButtonText: o.WithdrawButtonText, + } +} + +type BalanceDelta int + +const ( + BalanceDelta_NONE BalanceDelta = 0 + BalanceDelta_INCREASE BalanceDelta = 1 + BalanceDelta_DECREASE BalanceDelta = 2 +) + +func (o BalanceDelta) DeepCopy() BalanceDelta { return o } + +var BalanceDeltaMap = map[string]BalanceDelta{ + "NONE": 0, + "INCREASE": 1, + "DECREASE": 2, +} + +var BalanceDeltaRevMap = map[BalanceDelta]string{ + 0: "NONE", + 1: "INCREASE", + 2: "DECREASE", +} + +func (e BalanceDelta) String() string { + if v, ok := BalanceDeltaRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type PaymentStatus int + +const ( + PaymentStatus_NONE PaymentStatus = 0 + PaymentStatus_PENDING PaymentStatus = 1 + PaymentStatus_CLAIMABLE PaymentStatus = 2 + PaymentStatus_COMPLETED PaymentStatus = 3 + PaymentStatus_ERROR PaymentStatus = 4 + PaymentStatus_UNKNOWN PaymentStatus = 5 + PaymentStatus_CANCELED PaymentStatus = 6 +) + +func (o PaymentStatus) DeepCopy() PaymentStatus { return o } + +var PaymentStatusMap = map[string]PaymentStatus{ + "NONE": 0, + "PENDING": 1, + "CLAIMABLE": 2, + "COMPLETED": 3, + "ERROR": 4, + "UNKNOWN": 5, + "CANCELED": 6, +} + +var PaymentStatusRevMap = map[PaymentStatus]string{ + 0: "NONE", + 1: "PENDING", + 2: "CLAIMABLE", + 3: "COMPLETED", + 4: "ERROR", + 5: "UNKNOWN", + 6: "CANCELED", +} + +func (e PaymentStatus) String() string { + if v, ok := PaymentStatusRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type ParticipantType int + +const ( + ParticipantType_NONE ParticipantType = 0 + ParticipantType_KEYBASE ParticipantType = 1 + ParticipantType_STELLAR ParticipantType = 2 + ParticipantType_SBS ParticipantType = 3 + ParticipantType_OWNACCOUNT ParticipantType = 4 +) + +func (o ParticipantType) DeepCopy() ParticipantType { return o } + +var ParticipantTypeMap = map[string]ParticipantType{ + "NONE": 0, + "KEYBASE": 1, + "STELLAR": 2, + "SBS": 3, + "OWNACCOUNT": 4, +} + +var ParticipantTypeRevMap = map[ParticipantType]string{ + 0: "NONE", + 1: "KEYBASE", + 2: "STELLAR", + 3: "SBS", + 4: "OWNACCOUNT", +} + +func (e ParticipantType) String() string { + if v, ok := ParticipantTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type PaymentOrErrorLocal struct { + Payment *PaymentLocal `codec:"payment,omitempty" json:"payment,omitempty"` + Err *string `codec:"err,omitempty" json:"err,omitempty"` +} + +func (o PaymentOrErrorLocal) DeepCopy() PaymentOrErrorLocal { + return PaymentOrErrorLocal{ + Payment: (func(x *PaymentLocal) *PaymentLocal { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Payment), + Err: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Err), + } +} + +type PaymentsPageLocal struct { + Payments []PaymentOrErrorLocal `codec:"payments" json:"payments"` + Cursor *PageCursor `codec:"cursor,omitempty" json:"cursor,omitempty"` + OldestUnread *PaymentID `codec:"oldestUnread,omitempty" json:"oldestUnread,omitempty"` +} + +func (o PaymentsPageLocal) DeepCopy() PaymentsPageLocal { + return PaymentsPageLocal{ + Payments: (func(x []PaymentOrErrorLocal) []PaymentOrErrorLocal { + if x == nil { + return nil + } + ret := make([]PaymentOrErrorLocal, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Payments), + Cursor: (func(x *PageCursor) *PageCursor { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Cursor), + OldestUnread: (func(x *PaymentID) *PaymentID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.OldestUnread), + } +} + +type PaymentLocal struct { + Id PaymentID `codec:"id" json:"id"` + TxID TransactionID `codec:"txID" json:"txID"` + Time TimeMs `codec:"time" json:"time"` + StatusSimplified PaymentStatus `codec:"statusSimplified" json:"statusSimplified"` + StatusDescription string `codec:"statusDescription" json:"statusDescription"` + StatusDetail string `codec:"statusDetail" json:"statusDetail"` + ShowCancel bool `codec:"showCancel" json:"showCancel"` + AmountDescription string `codec:"amountDescription" json:"amountDescription"` + Delta BalanceDelta `codec:"delta" json:"delta"` + Worth string `codec:"worth" json:"worth"` + WorthAtSendTime string `codec:"worthAtSendTime" json:"worthAtSendTime"` + IssuerDescription string `codec:"issuerDescription" json:"issuerDescription"` + IssuerAccountID *AccountID `codec:"issuerAccountID,omitempty" json:"issuerAccountID,omitempty"` + FromType ParticipantType `codec:"fromType" json:"fromType"` + ToType ParticipantType `codec:"toType" json:"toType"` + AssetCode string `codec:"assetCode" json:"assetCode"` + FromAccountID AccountID `codec:"fromAccountID" json:"fromAccountID"` + FromAccountName string `codec:"fromAccountName" json:"fromAccountName"` + FromUsername string `codec:"fromUsername" json:"fromUsername"` + ToAccountID *AccountID `codec:"toAccountID,omitempty" json:"toAccountID,omitempty"` + ToAccountName string `codec:"toAccountName" json:"toAccountName"` + ToUsername string `codec:"toUsername" json:"toUsername"` + ToAssertion string `codec:"toAssertion" json:"toAssertion"` + OriginalToAssertion string `codec:"originalToAssertion" json:"originalToAssertion"` + Note string `codec:"note" json:"note"` + NoteErr string `codec:"noteErr" json:"noteErr"` + SourceAmountMax string `codec:"sourceAmountMax" json:"sourceAmountMax"` + SourceAmountActual string `codec:"sourceAmountActual" json:"sourceAmountActual"` + SourceAsset Asset `codec:"sourceAsset" json:"sourceAsset"` + SourceConvRate string `codec:"sourceConvRate" json:"sourceConvRate"` + IsAdvanced bool `codec:"isAdvanced" json:"isAdvanced"` + SummaryAdvanced string `codec:"summaryAdvanced" json:"summaryAdvanced"` + Operations []string `codec:"operations" json:"operations"` + Unread bool `codec:"unread" json:"unread"` + BatchID string `codec:"batchID" json:"batchID"` + FromAirdrop bool `codec:"fromAirdrop" json:"fromAirdrop"` + IsInflation bool `codec:"isInflation" json:"isInflation"` + InflationSource *string `codec:"inflationSource,omitempty" json:"inflationSource,omitempty"` + Trustline *PaymentTrustlineLocal `codec:"trustline,omitempty" json:"trustline,omitempty"` +} + +func (o PaymentLocal) DeepCopy() PaymentLocal { + return PaymentLocal{ + Id: o.Id.DeepCopy(), + TxID: o.TxID.DeepCopy(), + Time: o.Time.DeepCopy(), + StatusSimplified: o.StatusSimplified.DeepCopy(), + StatusDescription: o.StatusDescription, + StatusDetail: o.StatusDetail, + ShowCancel: o.ShowCancel, + AmountDescription: o.AmountDescription, + Delta: o.Delta.DeepCopy(), + Worth: o.Worth, + WorthAtSendTime: o.WorthAtSendTime, + IssuerDescription: o.IssuerDescription, + IssuerAccountID: (func(x *AccountID) *AccountID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.IssuerAccountID), + FromType: o.FromType.DeepCopy(), + ToType: o.ToType.DeepCopy(), + AssetCode: o.AssetCode, + FromAccountID: o.FromAccountID.DeepCopy(), + FromAccountName: o.FromAccountName, + FromUsername: o.FromUsername, + ToAccountID: (func(x *AccountID) *AccountID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ToAccountID), + ToAccountName: o.ToAccountName, + ToUsername: o.ToUsername, + ToAssertion: o.ToAssertion, + OriginalToAssertion: o.OriginalToAssertion, + Note: o.Note, + NoteErr: o.NoteErr, + SourceAmountMax: o.SourceAmountMax, + SourceAmountActual: o.SourceAmountActual, + SourceAsset: o.SourceAsset.DeepCopy(), + SourceConvRate: o.SourceConvRate, + IsAdvanced: o.IsAdvanced, + SummaryAdvanced: o.SummaryAdvanced, + Operations: (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.Operations), + Unread: o.Unread, + BatchID: o.BatchID, + FromAirdrop: o.FromAirdrop, + IsInflation: o.IsInflation, + InflationSource: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.InflationSource), + Trustline: (func(x *PaymentTrustlineLocal) *PaymentTrustlineLocal { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Trustline), + } +} + +type PaymentDetailsLocal struct { + Summary PaymentLocal `codec:"summary" json:"summary"` + Details PaymentDetailsOnlyLocal `codec:"details" json:"details"` +} + +func (o PaymentDetailsLocal) DeepCopy() PaymentDetailsLocal { + return PaymentDetailsLocal{ + Summary: o.Summary.DeepCopy(), + Details: o.Details.DeepCopy(), + } +} + +type PaymentDetailsOnlyLocal struct { + PublicNote string `codec:"publicNote" json:"publicNote"` + PublicNoteType string `codec:"publicNoteType" json:"publicNoteType"` + ExternalTxURL string `codec:"externalTxURL" json:"externalTxURL"` + FeeChargedDescription string `codec:"feeChargedDescription" json:"feeChargedDescription"` + PathIntermediate []Asset `codec:"pathIntermediate" json:"pathIntermediate"` +} + +func (o PaymentDetailsOnlyLocal) DeepCopy() PaymentDetailsOnlyLocal { + return PaymentDetailsOnlyLocal{ + PublicNote: o.PublicNote, + PublicNoteType: o.PublicNoteType, + ExternalTxURL: o.ExternalTxURL, + FeeChargedDescription: o.FeeChargedDescription, + PathIntermediate: (func(x []Asset) []Asset { + if x == nil { + return nil + } + ret := make([]Asset, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.PathIntermediate), + } +} + +type PaymentTrustlineLocal struct { + Asset Asset `codec:"asset" json:"asset"` + Remove bool `codec:"remove" json:"remove"` +} + +func (o PaymentTrustlineLocal) DeepCopy() PaymentTrustlineLocal { + return PaymentTrustlineLocal{ + Asset: o.Asset.DeepCopy(), + Remove: o.Remove, + } +} + +type CurrencyLocal struct { + Description string `codec:"description" json:"description"` + Code OutsideCurrencyCode `codec:"code" json:"code"` + Symbol string `codec:"symbol" json:"symbol"` + Name string `codec:"name" json:"name"` +} + +func (o CurrencyLocal) DeepCopy() CurrencyLocal { + return CurrencyLocal{ + Description: o.Description, + Code: o.Code.DeepCopy(), + Symbol: o.Symbol, + Name: o.Name, + } +} + +type SendAssetChoiceLocal struct { + Asset Asset `codec:"asset" json:"asset"` + Enabled bool `codec:"enabled" json:"enabled"` + Left string `codec:"left" json:"left"` + Right string `codec:"right" json:"right"` + Subtext string `codec:"subtext" json:"subtext"` +} + +func (o SendAssetChoiceLocal) DeepCopy() SendAssetChoiceLocal { + return SendAssetChoiceLocal{ + Asset: o.Asset.DeepCopy(), + Enabled: o.Enabled, + Left: o.Left, + Right: o.Right, + Subtext: o.Subtext, + } +} + +type BuildPaymentID string + +func (o BuildPaymentID) DeepCopy() BuildPaymentID { + return o +} + +type BuildPaymentResLocal struct { + ReadyToReview bool `codec:"readyToReview" json:"readyToReview"` + From AccountID `codec:"from" json:"from"` + ToErrMsg string `codec:"toErrMsg" json:"toErrMsg"` + AmountErrMsg string `codec:"amountErrMsg" json:"amountErrMsg"` + SecretNoteErrMsg string `codec:"secretNoteErrMsg" json:"secretNoteErrMsg"` + PublicMemoErrMsg string `codec:"publicMemoErrMsg" json:"publicMemoErrMsg"` + PublicMemoOverride string `codec:"publicMemoOverride" json:"publicMemoOverride"` + WorthDescription string `codec:"worthDescription" json:"worthDescription"` + WorthInfo string `codec:"worthInfo" json:"worthInfo"` + WorthAmount string `codec:"worthAmount" json:"worthAmount"` + WorthCurrency string `codec:"worthCurrency" json:"worthCurrency"` + DisplayAmountXLM string `codec:"displayAmountXLM" json:"displayAmountXLM"` + DisplayAmountFiat string `codec:"displayAmountFiat" json:"displayAmountFiat"` + SendingIntentionXLM bool `codec:"sendingIntentionXLM" json:"sendingIntentionXLM"` + AmountAvailable string `codec:"amountAvailable" json:"amountAvailable"` + Banners []SendBannerLocal `codec:"banners" json:"banners"` +} + +func (o BuildPaymentResLocal) DeepCopy() BuildPaymentResLocal { + return BuildPaymentResLocal{ + ReadyToReview: o.ReadyToReview, + From: o.From.DeepCopy(), + ToErrMsg: o.ToErrMsg, + AmountErrMsg: o.AmountErrMsg, + SecretNoteErrMsg: o.SecretNoteErrMsg, + PublicMemoErrMsg: o.PublicMemoErrMsg, + PublicMemoOverride: o.PublicMemoOverride, + WorthDescription: o.WorthDescription, + WorthInfo: o.WorthInfo, + WorthAmount: o.WorthAmount, + WorthCurrency: o.WorthCurrency, + DisplayAmountXLM: o.DisplayAmountXLM, + DisplayAmountFiat: o.DisplayAmountFiat, + SendingIntentionXLM: o.SendingIntentionXLM, + AmountAvailable: o.AmountAvailable, + Banners: (func(x []SendBannerLocal) []SendBannerLocal { + if x == nil { + return nil + } + ret := make([]SendBannerLocal, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Banners), + } +} + +type AdvancedBanner int + +const ( + AdvancedBanner_NO_BANNER AdvancedBanner = 0 + AdvancedBanner_SENDER_BANNER AdvancedBanner = 1 + AdvancedBanner_RECEIVER_BANNER AdvancedBanner = 2 +) + +func (o AdvancedBanner) DeepCopy() AdvancedBanner { return o } + +var AdvancedBannerMap = map[string]AdvancedBanner{ + "NO_BANNER": 0, + "SENDER_BANNER": 1, + "RECEIVER_BANNER": 2, +} + +var AdvancedBannerRevMap = map[AdvancedBanner]string{ + 0: "NO_BANNER", + 1: "SENDER_BANNER", + 2: "RECEIVER_BANNER", +} + +func (e AdvancedBanner) String() string { + if v, ok := AdvancedBannerRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type SendBannerLocal struct { + Level string `codec:"level" json:"level"` + Message string `codec:"message" json:"message"` + ProofsChanged bool `codec:"proofsChanged" json:"proofsChanged"` + OfferAdvancedSendForm AdvancedBanner `codec:"offerAdvancedSendForm" json:"offerAdvancedSendForm"` +} + +func (o SendBannerLocal) DeepCopy() SendBannerLocal { + return SendBannerLocal{ + Level: o.Level, + Message: o.Message, + ProofsChanged: o.ProofsChanged, + OfferAdvancedSendForm: o.OfferAdvancedSendForm.DeepCopy(), + } +} + +type SendPaymentResLocal struct { + KbTxID KeybaseTransactionID `codec:"kbTxID" json:"kbTxID"` + Pending bool `codec:"pending" json:"pending"` + JumpToChat string `codec:"jumpToChat" json:"jumpToChat"` +} + +func (o SendPaymentResLocal) DeepCopy() SendPaymentResLocal { + return SendPaymentResLocal{ + KbTxID: o.KbTxID.DeepCopy(), + Pending: o.Pending, + JumpToChat: o.JumpToChat, + } +} + +type BuildRequestResLocal struct { + ReadyToRequest bool `codec:"readyToRequest" json:"readyToRequest"` + ToErrMsg string `codec:"toErrMsg" json:"toErrMsg"` + AmountErrMsg string `codec:"amountErrMsg" json:"amountErrMsg"` + SecretNoteErrMsg string `codec:"secretNoteErrMsg" json:"secretNoteErrMsg"` + WorthDescription string `codec:"worthDescription" json:"worthDescription"` + WorthInfo string `codec:"worthInfo" json:"worthInfo"` + DisplayAmountXLM string `codec:"displayAmountXLM" json:"displayAmountXLM"` + DisplayAmountFiat string `codec:"displayAmountFiat" json:"displayAmountFiat"` + SendingIntentionXLM bool `codec:"sendingIntentionXLM" json:"sendingIntentionXLM"` + Banners []SendBannerLocal `codec:"banners" json:"banners"` +} + +func (o BuildRequestResLocal) DeepCopy() BuildRequestResLocal { + return BuildRequestResLocal{ + ReadyToRequest: o.ReadyToRequest, + ToErrMsg: o.ToErrMsg, + AmountErrMsg: o.AmountErrMsg, + SecretNoteErrMsg: o.SecretNoteErrMsg, + WorthDescription: o.WorthDescription, + WorthInfo: o.WorthInfo, + DisplayAmountXLM: o.DisplayAmountXLM, + DisplayAmountFiat: o.DisplayAmountFiat, + SendingIntentionXLM: o.SendingIntentionXLM, + Banners: (func(x []SendBannerLocal) []SendBannerLocal { + if x == nil { + return nil + } + ret := make([]SendBannerLocal, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Banners), + } +} + +type RequestDetailsLocal struct { + Id KeybaseRequestID `codec:"id" json:"id"` + FromAssertion string `codec:"fromAssertion" json:"fromAssertion"` + FromCurrentUser bool `codec:"fromCurrentUser" json:"fromCurrentUser"` + ToUserType ParticipantType `codec:"toUserType" json:"toUserType"` + ToAssertion string `codec:"toAssertion" json:"toAssertion"` + Amount string `codec:"amount" json:"amount"` + Asset *Asset `codec:"asset,omitempty" json:"asset,omitempty"` + Currency *OutsideCurrencyCode `codec:"currency,omitempty" json:"currency,omitempty"` + AmountDescription string `codec:"amountDescription" json:"amountDescription"` + WorthAtRequestTime string `codec:"worthAtRequestTime" json:"worthAtRequestTime"` + Status RequestStatus `codec:"status" json:"status"` +} + +func (o RequestDetailsLocal) DeepCopy() RequestDetailsLocal { + return RequestDetailsLocal{ + Id: o.Id.DeepCopy(), + FromAssertion: o.FromAssertion, + FromCurrentUser: o.FromCurrentUser, + ToUserType: o.ToUserType.DeepCopy(), + ToAssertion: o.ToAssertion, + Amount: o.Amount, + Asset: (func(x *Asset) *Asset { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Asset), + Currency: (func(x *OutsideCurrencyCode) *OutsideCurrencyCode { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Currency), + AmountDescription: o.AmountDescription, + WorthAtRequestTime: o.WorthAtRequestTime, + Status: o.Status.DeepCopy(), + } +} + +type InflationDestinationTag string + +func (o InflationDestinationTag) DeepCopy() InflationDestinationTag { + return o +} + +type PredefinedInflationDestination struct { + Tag InflationDestinationTag `codec:"tag" json:"tag"` + Name string `codec:"name" json:"name"` + Recommended bool `codec:"recommended" json:"recommended"` + AccountID AccountID `codec:"accountID" json:"accountID"` + Url string `codec:"url" json:"url"` +} + +func (o PredefinedInflationDestination) DeepCopy() PredefinedInflationDestination { + return PredefinedInflationDestination{ + Tag: o.Tag.DeepCopy(), + Name: o.Name, + Recommended: o.Recommended, + AccountID: o.AccountID.DeepCopy(), + Url: o.Url, + } +} + +type InflationDestinationResultLocal struct { + Destination *AccountID `codec:"destination,omitempty" json:"destination,omitempty"` + KnownDestination *PredefinedInflationDestination `codec:"knownDestination,omitempty" json:"knownDestination,omitempty"` + Self bool `codec:"self" json:"self"` +} + +func (o InflationDestinationResultLocal) DeepCopy() InflationDestinationResultLocal { + return InflationDestinationResultLocal{ + Destination: (func(x *AccountID) *AccountID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Destination), + KnownDestination: (func(x *PredefinedInflationDestination) *PredefinedInflationDestination { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.KnownDestination), + Self: o.Self, + } +} + +type AirdropDetails struct { + IsPromoted bool `codec:"isPromoted" json:"isPromoted"` + Details string `codec:"details" json:"details"` + Disclaimer string `codec:"disclaimer" json:"disclaimer"` +} + +func (o AirdropDetails) DeepCopy() AirdropDetails { + return AirdropDetails{ + IsPromoted: o.IsPromoted, + Details: o.Details, + Disclaimer: o.Disclaimer, + } +} + +type AirdropState string + +func (o AirdropState) DeepCopy() AirdropState { + return o +} + +type AirdropQualification struct { + Title string `codec:"title" json:"title"` + Subtitle string `codec:"subtitle" json:"subtitle"` + Valid bool `codec:"valid" json:"valid"` +} + +func (o AirdropQualification) DeepCopy() AirdropQualification { + return AirdropQualification{ + Title: o.Title, + Subtitle: o.Subtitle, + Valid: o.Valid, + } +} + +type AirdropStatus struct { + State AirdropState `codec:"state" json:"state"` + Rows []AirdropQualification `codec:"rows" json:"rows"` +} + +func (o AirdropStatus) DeepCopy() AirdropStatus { + return AirdropStatus{ + State: o.State.DeepCopy(), + Rows: (func(x []AirdropQualification) []AirdropQualification { + if x == nil { + return nil + } + ret := make([]AirdropQualification, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Rows), + } +} + +type RecipientTrustlinesLocal struct { + Trustlines []Balance `codec:"trustlines" json:"trustlines"` + RecipientType ParticipantType `codec:"recipientType" json:"recipientType"` +} + +func (o RecipientTrustlinesLocal) DeepCopy() RecipientTrustlinesLocal { + return RecipientTrustlinesLocal{ + Trustlines: (func(x []Balance) []Balance { + if x == nil { + return nil + } + ret := make([]Balance, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Trustlines), + RecipientType: o.RecipientType.DeepCopy(), + } +} + +type PaymentPathLocal struct { + SourceDisplay string `codec:"sourceDisplay" json:"sourceDisplay"` + SourceMaxDisplay string `codec:"sourceMaxDisplay" json:"sourceMaxDisplay"` + DestinationDisplay string `codec:"destinationDisplay" json:"destinationDisplay"` + ExchangeRate string `codec:"exchangeRate" json:"exchangeRate"` + AmountError string `codec:"amountError" json:"amountError"` + DestinationAccount AccountID `codec:"destinationAccount" json:"destinationAccount"` + FullPath PaymentPath `codec:"fullPath" json:"fullPath"` +} + +func (o PaymentPathLocal) DeepCopy() PaymentPathLocal { + return PaymentPathLocal{ + SourceDisplay: o.SourceDisplay, + SourceMaxDisplay: o.SourceMaxDisplay, + DestinationDisplay: o.DestinationDisplay, + ExchangeRate: o.ExchangeRate, + AmountError: o.AmountError, + DestinationAccount: o.DestinationAccount.DeepCopy(), + FullPath: o.FullPath.DeepCopy(), + } +} + +type AssetActionResultLocal struct { + ExternalUrl *string `codec:"externalUrl,omitempty" json:"externalUrl,omitempty"` + MessageFromAnchor *string `codec:"messageFromAnchor,omitempty" json:"messageFromAnchor,omitempty"` +} + +func (o AssetActionResultLocal) DeepCopy() AssetActionResultLocal { + return AssetActionResultLocal{ + ExternalUrl: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.ExternalUrl), + MessageFromAnchor: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.MessageFromAnchor), + } +} + +type SendResultCLILocal struct { + KbTxID KeybaseTransactionID `codec:"kbTxID" json:"kbTxID"` + TxID TransactionID `codec:"txID" json:"txID"` +} + +func (o SendResultCLILocal) DeepCopy() SendResultCLILocal { + return SendResultCLILocal{ + KbTxID: o.KbTxID.DeepCopy(), + TxID: o.TxID.DeepCopy(), + } +} + +type PublicNoteType int + +const ( + PublicNoteType_NONE PublicNoteType = 0 + PublicNoteType_TEXT PublicNoteType = 1 + PublicNoteType_ID PublicNoteType = 2 + PublicNoteType_HASH PublicNoteType = 3 + PublicNoteType_RETURN PublicNoteType = 4 +) + +func (o PublicNoteType) DeepCopy() PublicNoteType { return o } + +var PublicNoteTypeMap = map[string]PublicNoteType{ + "NONE": 0, + "TEXT": 1, + "ID": 2, + "HASH": 3, + "RETURN": 4, +} + +var PublicNoteTypeRevMap = map[PublicNoteType]string{ + 0: "NONE", + 1: "TEXT", + 2: "ID", + 3: "HASH", + 4: "RETURN", +} + +func (e PublicNoteType) String() string { + if v, ok := PublicNoteTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type PaymentOrErrorCLILocal struct { + Payment *PaymentCLILocal `codec:"payment,omitempty" json:"payment,omitempty"` + Err *string `codec:"err,omitempty" json:"err,omitempty"` +} + +func (o PaymentOrErrorCLILocal) DeepCopy() PaymentOrErrorCLILocal { + return PaymentOrErrorCLILocal{ + Payment: (func(x *PaymentCLILocal) *PaymentCLILocal { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Payment), + Err: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Err), + } +} + +type PaymentCLILocal struct { + TxID TransactionID `codec:"txID" json:"txID"` + Time TimeMs `codec:"time" json:"time"` + Status string `codec:"status" json:"status"` + StatusDetail string `codec:"statusDetail" json:"statusDetail"` + Amount string `codec:"amount" json:"amount"` + Asset Asset `codec:"asset" json:"asset"` + DisplayAmount *string `codec:"displayAmount,omitempty" json:"displayAmount,omitempty"` + DisplayCurrency *string `codec:"displayCurrency,omitempty" json:"displayCurrency,omitempty"` + SourceAmountMax string `codec:"sourceAmountMax" json:"sourceAmountMax"` + SourceAmountActual string `codec:"sourceAmountActual" json:"sourceAmountActual"` + SourceAsset Asset `codec:"sourceAsset" json:"sourceAsset"` + IsAdvanced bool `codec:"isAdvanced" json:"isAdvanced"` + SummaryAdvanced string `codec:"summaryAdvanced" json:"summaryAdvanced"` + Operations []string `codec:"operations" json:"operations"` + FromStellar AccountID `codec:"fromStellar" json:"fromStellar"` + ToStellar *AccountID `codec:"toStellar,omitempty" json:"toStellar,omitempty"` + FromUsername *string `codec:"fromUsername,omitempty" json:"fromUsername,omitempty"` + ToUsername *string `codec:"toUsername,omitempty" json:"toUsername,omitempty"` + ToAssertion *string `codec:"toAssertion,omitempty" json:"toAssertion,omitempty"` + Note string `codec:"note" json:"note"` + NoteErr string `codec:"noteErr" json:"noteErr"` + Unread bool `codec:"unread" json:"unread"` + PublicNote string `codec:"publicNote" json:"publicNote"` + PublicNoteType string `codec:"publicNoteType" json:"publicNoteType"` + FeeChargedDescription string `codec:"feeChargedDescription" json:"feeChargedDescription"` +} + +func (o PaymentCLILocal) DeepCopy() PaymentCLILocal { + return PaymentCLILocal{ + TxID: o.TxID.DeepCopy(), + Time: o.Time.DeepCopy(), + Status: o.Status, + StatusDetail: o.StatusDetail, + Amount: o.Amount, + Asset: o.Asset.DeepCopy(), + DisplayAmount: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.DisplayAmount), + DisplayCurrency: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.DisplayCurrency), + SourceAmountMax: o.SourceAmountMax, + SourceAmountActual: o.SourceAmountActual, + SourceAsset: o.SourceAsset.DeepCopy(), + IsAdvanced: o.IsAdvanced, + SummaryAdvanced: o.SummaryAdvanced, + Operations: (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.Operations), + FromStellar: o.FromStellar.DeepCopy(), + ToStellar: (func(x *AccountID) *AccountID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ToStellar), + FromUsername: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.FromUsername), + ToUsername: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.ToUsername), + ToAssertion: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.ToAssertion), + Note: o.Note, + NoteErr: o.NoteErr, + Unread: o.Unread, + PublicNote: o.PublicNote, + PublicNoteType: o.PublicNoteType, + FeeChargedDescription: o.FeeChargedDescription, + } +} + +type OwnAccountCLILocal struct { + AccountID AccountID `codec:"accountID" json:"accountID"` + IsPrimary bool `codec:"isPrimary" json:"isPrimary"` + Name string `codec:"name" json:"name"` + Balance []Balance `codec:"balance" json:"balance"` + ExchangeRate *OutsideExchangeRate `codec:"exchangeRate,omitempty" json:"exchangeRate,omitempty"` + AccountMode AccountMode `codec:"accountMode" json:"accountMode"` +} + +func (o OwnAccountCLILocal) DeepCopy() OwnAccountCLILocal { + return OwnAccountCLILocal{ + AccountID: o.AccountID.DeepCopy(), + IsPrimary: o.IsPrimary, + Name: o.Name, + Balance: (func(x []Balance) []Balance { + if x == nil { + return nil + } + ret := make([]Balance, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Balance), + ExchangeRate: (func(x *OutsideExchangeRate) *OutsideExchangeRate { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ExchangeRate), + AccountMode: o.AccountMode.DeepCopy(), + } +} + +type LookupResultCLILocal struct { + AccountID AccountID `codec:"accountID" json:"accountID"` + Username *string `codec:"username,omitempty" json:"username,omitempty"` +} + +func (o LookupResultCLILocal) DeepCopy() LookupResultCLILocal { + return LookupResultCLILocal{ + AccountID: o.AccountID.DeepCopy(), + Username: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.Username), + } +} + +type BatchPaymentError struct { + Message string `codec:"message" json:"message"` + Code int `codec:"code" json:"code"` +} + +func (o BatchPaymentError) DeepCopy() BatchPaymentError { + return BatchPaymentError{ + Message: o.Message, + Code: o.Code, + } +} + +type BatchPaymentResult struct { + Username string `codec:"username" json:"username"` + StartTime TimeMs `codec:"startTime" json:"startTime"` + SubmittedTime TimeMs `codec:"submittedTime" json:"submittedTime"` + EndTime TimeMs `codec:"endTime" json:"endTime"` + TxID TransactionID `codec:"txID" json:"txID"` + Status PaymentStatus `codec:"status" json:"status"` + StatusDescription string `codec:"statusDescription" json:"statusDescription"` + Error *BatchPaymentError `codec:"error,omitempty" json:"error,omitempty"` +} + +func (o BatchPaymentResult) DeepCopy() BatchPaymentResult { + return BatchPaymentResult{ + Username: o.Username, + StartTime: o.StartTime.DeepCopy(), + SubmittedTime: o.SubmittedTime.DeepCopy(), + EndTime: o.EndTime.DeepCopy(), + TxID: o.TxID.DeepCopy(), + Status: o.Status.DeepCopy(), + StatusDescription: o.StatusDescription, + Error: (func(x *BatchPaymentError) *BatchPaymentError { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Error), + } +} + +type BatchResultLocal struct { + StartTime TimeMs `codec:"startTime" json:"startTime"` + PreparedTime TimeMs `codec:"preparedTime" json:"preparedTime"` + AllSubmittedTime TimeMs `codec:"allSubmittedTime" json:"allSubmittedTime"` + AllCompleteTime TimeMs `codec:"allCompleteTime" json:"allCompleteTime"` + EndTime TimeMs `codec:"endTime" json:"endTime"` + Payments []BatchPaymentResult `codec:"payments" json:"payments"` + OverallDurationMs TimeMs `codec:"overallDurationMs" json:"overallDurationMs"` + PrepareDurationMs TimeMs `codec:"prepareDurationMs" json:"prepareDurationMs"` + SubmitDurationMs TimeMs `codec:"submitDurationMs" json:"submitDurationMs"` + WaitPaymentsDurationMs TimeMs `codec:"waitPaymentsDurationMs" json:"waitPaymentsDurationMs"` + WaitChatDurationMs TimeMs `codec:"waitChatDurationMs" json:"waitChatDurationMs"` + CountSuccess int `codec:"countSuccess" json:"countSuccess"` + CountDirect int `codec:"countDirect" json:"countDirect"` + CountRelay int `codec:"countRelay" json:"countRelay"` + CountError int `codec:"countError" json:"countError"` + CountPending int `codec:"countPending" json:"countPending"` + AvgDurationMs TimeMs `codec:"avgDurationMs" json:"avgDurationMs"` + AvgSuccessDurationMs TimeMs `codec:"avgSuccessDurationMs" json:"avgSuccessDurationMs"` + AvgDirectDurationMs TimeMs `codec:"avgDirectDurationMs" json:"avgDirectDurationMs"` + AvgRelayDurationMs TimeMs `codec:"avgRelayDurationMs" json:"avgRelayDurationMs"` + AvgErrorDurationMs TimeMs `codec:"avgErrorDurationMs" json:"avgErrorDurationMs"` +} + +func (o BatchResultLocal) DeepCopy() BatchResultLocal { + return BatchResultLocal{ + StartTime: o.StartTime.DeepCopy(), + PreparedTime: o.PreparedTime.DeepCopy(), + AllSubmittedTime: o.AllSubmittedTime.DeepCopy(), + AllCompleteTime: o.AllCompleteTime.DeepCopy(), + EndTime: o.EndTime.DeepCopy(), + Payments: (func(x []BatchPaymentResult) []BatchPaymentResult { + if x == nil { + return nil + } + ret := make([]BatchPaymentResult, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Payments), + OverallDurationMs: o.OverallDurationMs.DeepCopy(), + PrepareDurationMs: o.PrepareDurationMs.DeepCopy(), + SubmitDurationMs: o.SubmitDurationMs.DeepCopy(), + WaitPaymentsDurationMs: o.WaitPaymentsDurationMs.DeepCopy(), + WaitChatDurationMs: o.WaitChatDurationMs.DeepCopy(), + CountSuccess: o.CountSuccess, + CountDirect: o.CountDirect, + CountRelay: o.CountRelay, + CountError: o.CountError, + CountPending: o.CountPending, + AvgDurationMs: o.AvgDurationMs.DeepCopy(), + AvgSuccessDurationMs: o.AvgSuccessDurationMs.DeepCopy(), + AvgDirectDurationMs: o.AvgDirectDurationMs.DeepCopy(), + AvgRelayDurationMs: o.AvgRelayDurationMs.DeepCopy(), + AvgErrorDurationMs: o.AvgErrorDurationMs.DeepCopy(), + } +} + +type BatchPaymentArg struct { + Recipient string `codec:"recipient" json:"recipient"` + Amount string `codec:"amount" json:"amount"` + Message string `codec:"message" json:"message"` +} + +func (o BatchPaymentArg) DeepCopy() BatchPaymentArg { + return BatchPaymentArg{ + Recipient: o.Recipient, + Amount: o.Amount, + Message: o.Message, + } +} + +type TxDisplaySummary struct { + Source AccountID `codec:"source" json:"source"` + Fee int `codec:"fee" json:"fee"` + Memo string `codec:"memo" json:"memo"` + MemoType string `codec:"memoType" json:"memoType"` + Operations []string `codec:"operations" json:"operations"` +} + +func (o TxDisplaySummary) DeepCopy() TxDisplaySummary { + return TxDisplaySummary{ + Source: o.Source.DeepCopy(), + Fee: o.Fee, + Memo: o.Memo, + MemoType: o.MemoType, + Operations: (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.Operations), + } +} + +type ValidateStellarURIResultLocal struct { + Operation string `codec:"operation" json:"operation"` + OriginDomain string `codec:"originDomain" json:"originDomain"` + Message string `codec:"message" json:"message"` + CallbackURL string `codec:"callbackURL" json:"callbackURL"` + Xdr string `codec:"xdr" json:"xdr"` + Summary TxDisplaySummary `codec:"summary" json:"summary"` + Recipient string `codec:"recipient" json:"recipient"` + Amount string `codec:"amount" json:"amount"` + AssetCode string `codec:"assetCode" json:"assetCode"` + AssetIssuer string `codec:"assetIssuer" json:"assetIssuer"` + Memo string `codec:"memo" json:"memo"` + MemoType string `codec:"memoType" json:"memoType"` + DisplayAmountFiat string `codec:"displayAmountFiat" json:"displayAmountFiat"` + AvailableToSendNative string `codec:"availableToSendNative" json:"availableToSendNative"` + AvailableToSendFiat string `codec:"availableToSendFiat" json:"availableToSendFiat"` + Signed bool `codec:"signed" json:"signed"` +} + +func (o ValidateStellarURIResultLocal) DeepCopy() ValidateStellarURIResultLocal { + return ValidateStellarURIResultLocal{ + Operation: o.Operation, + OriginDomain: o.OriginDomain, + Message: o.Message, + CallbackURL: o.CallbackURL, + Xdr: o.Xdr, + Summary: o.Summary.DeepCopy(), + Recipient: o.Recipient, + Amount: o.Amount, + AssetCode: o.AssetCode, + AssetIssuer: o.AssetIssuer, + Memo: o.Memo, + MemoType: o.MemoType, + DisplayAmountFiat: o.DisplayAmountFiat, + AvailableToSendNative: o.AvailableToSendNative, + AvailableToSendFiat: o.AvailableToSendFiat, + Signed: o.Signed, + } +} + +type PartnerUrl struct { + Url string `codec:"url" json:"url"` + Title string `codec:"title" json:"title"` + Description string `codec:"description" json:"description"` + IconFilename string `codec:"iconFilename" json:"icon_filename"` + AdminOnly bool `codec:"adminOnly" json:"admin_only"` + CanPurchase bool `codec:"canPurchase" json:"can_purchase"` + Extra string `codec:"extra" json:"extra"` +} + +func (o PartnerUrl) DeepCopy() PartnerUrl { + return PartnerUrl{ + Url: o.Url, + Title: o.Title, + Description: o.Description, + IconFilename: o.IconFilename, + AdminOnly: o.AdminOnly, + CanPurchase: o.CanPurchase, + Extra: o.Extra, + } +} + +type SignXdrResult struct { + SingedTx string `codec:"singedTx" json:"singedTx"` + AccountID AccountID `codec:"accountID" json:"accountID"` + SubmitErr *string `codec:"submitErr,omitempty" json:"submitErr,omitempty"` + SubmitTxID *TransactionID `codec:"submitTxID,omitempty" json:"submitTxID,omitempty"` +} + +func (o SignXdrResult) DeepCopy() SignXdrResult { + return SignXdrResult{ + SingedTx: o.SingedTx, + AccountID: o.AccountID.DeepCopy(), + SubmitErr: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.SubmitErr), + SubmitTxID: (func(x *TransactionID) *TransactionID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.SubmitTxID), + } +} + +type StaticConfig struct { + PaymentNoteMaxLength int `codec:"paymentNoteMaxLength" json:"paymentNoteMaxLength"` + RequestNoteMaxLength int `codec:"requestNoteMaxLength" json:"requestNoteMaxLength"` + PublicMemoMaxLength int `codec:"publicMemoMaxLength" json:"publicMemoMaxLength"` +} + +func (o StaticConfig) DeepCopy() StaticConfig { + return StaticConfig{ + PaymentNoteMaxLength: o.PaymentNoteMaxLength, + RequestNoteMaxLength: o.RequestNoteMaxLength, + PublicMemoMaxLength: o.PublicMemoMaxLength, + } +} 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 new file mode 100644 index 00000000..f095bf00 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/notify.go @@ -0,0 +1,4 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (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 new file mode 100644 index 00000000..798506a2 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/remote.go @@ -0,0 +1,913 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/stellar1/remote.avdl + +package stellar1 + +import ( + "errors" + "fmt" + + keybase1 "github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1" +) + +type ChatConversationID string + +func (o ChatConversationID) DeepCopy() ChatConversationID { + return o +} + +type PaymentDirectPost struct { + FromDeviceID keybase1.DeviceID `codec:"fromDeviceID" json:"fromDeviceID"` + To *keybase1.UserVersion `codec:"to,omitempty" json:"to,omitempty"` + DisplayAmount string `codec:"displayAmount" json:"displayAmount"` + DisplayCurrency string `codec:"displayCurrency" json:"displayCurrency"` + NoteB64 string `codec:"noteB64" json:"noteB64"` + SignedTransaction string `codec:"signedTransaction" json:"signedTransaction"` + QuickReturn bool `codec:"quickReturn" json:"quickReturn"` + ChatConversationID *ChatConversationID `codec:"chatConversationID,omitempty" json:"chatConversationID,omitempty"` + BatchID string `codec:"batchID" json:"batchID"` +} + +func (o PaymentDirectPost) DeepCopy() PaymentDirectPost { + return PaymentDirectPost{ + FromDeviceID: o.FromDeviceID.DeepCopy(), + To: (func(x *keybase1.UserVersion) *keybase1.UserVersion { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.To), + DisplayAmount: o.DisplayAmount, + DisplayCurrency: o.DisplayCurrency, + NoteB64: o.NoteB64, + SignedTransaction: o.SignedTransaction, + QuickReturn: o.QuickReturn, + ChatConversationID: (func(x *ChatConversationID) *ChatConversationID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ChatConversationID), + BatchID: o.BatchID, + } +} + +type PaymentRelayPost struct { + FromDeviceID keybase1.DeviceID `codec:"fromDeviceID" json:"fromDeviceID"` + To *keybase1.UserVersion `codec:"to,omitempty" json:"to,omitempty"` + ToAssertion string `codec:"toAssertion" json:"toAssertion"` + RelayAccount AccountID `codec:"relayAccount" json:"relayAccount"` + TeamID keybase1.TeamID `codec:"teamID" json:"teamID"` + DisplayAmount string `codec:"displayAmount" json:"displayAmount"` + DisplayCurrency string `codec:"displayCurrency" json:"displayCurrency"` + BoxB64 string `codec:"boxB64" json:"boxB64"` + SignedTransaction string `codec:"signedTransaction" json:"signedTransaction"` + QuickReturn bool `codec:"quickReturn" json:"quickReturn"` + ChatConversationID *ChatConversationID `codec:"chatConversationID,omitempty" json:"chatConversationID,omitempty"` + BatchID string `codec:"batchID" json:"batchID"` +} + +func (o PaymentRelayPost) DeepCopy() PaymentRelayPost { + return PaymentRelayPost{ + FromDeviceID: o.FromDeviceID.DeepCopy(), + To: (func(x *keybase1.UserVersion) *keybase1.UserVersion { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.To), + ToAssertion: o.ToAssertion, + RelayAccount: o.RelayAccount.DeepCopy(), + TeamID: o.TeamID.DeepCopy(), + DisplayAmount: o.DisplayAmount, + DisplayCurrency: o.DisplayCurrency, + BoxB64: o.BoxB64, + SignedTransaction: o.SignedTransaction, + QuickReturn: o.QuickReturn, + ChatConversationID: (func(x *ChatConversationID) *ChatConversationID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ChatConversationID), + BatchID: o.BatchID, + } +} + +type RelayClaimPost struct { + KeybaseID KeybaseTransactionID `codec:"keybaseID" json:"keybaseID"` + Dir RelayDirection `codec:"dir" json:"dir"` + SignedTransaction string `codec:"signedTransaction" json:"signedTransaction"` + AutoClaimToken *string `codec:"autoClaimToken,omitempty" json:"autoClaimToken,omitempty"` +} + +func (o RelayClaimPost) DeepCopy() RelayClaimPost { + return RelayClaimPost{ + KeybaseID: o.KeybaseID.DeepCopy(), + Dir: o.Dir.DeepCopy(), + SignedTransaction: o.SignedTransaction, + AutoClaimToken: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.AutoClaimToken), + } +} + +type PathPaymentPost struct { + FromDeviceID keybase1.DeviceID `codec:"fromDeviceID" json:"fromDeviceID"` + To *keybase1.UserVersion `codec:"to,omitempty" json:"to,omitempty"` + NoteB64 string `codec:"noteB64" json:"noteB64"` + SignedTransaction string `codec:"signedTransaction" json:"signedTransaction"` + QuickReturn bool `codec:"quickReturn" json:"quickReturn"` + ChatConversationID *ChatConversationID `codec:"chatConversationID,omitempty" json:"chatConversationID,omitempty"` +} + +func (o PathPaymentPost) DeepCopy() PathPaymentPost { + return PathPaymentPost{ + FromDeviceID: o.FromDeviceID.DeepCopy(), + To: (func(x *keybase1.UserVersion) *keybase1.UserVersion { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.To), + NoteB64: o.NoteB64, + SignedTransaction: o.SignedTransaction, + QuickReturn: o.QuickReturn, + ChatConversationID: (func(x *ChatConversationID) *ChatConversationID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ChatConversationID), + } +} + +type DirectOp struct { + NoteB64 string `codec:"noteB64" json:"noteB64"` +} + +func (o DirectOp) DeepCopy() DirectOp { + return DirectOp{ + NoteB64: o.NoteB64, + } +} + +type RelayOp struct { + ToAssertion string `codec:"toAssertion" json:"toAssertion"` + RelayAccount AccountID `codec:"relayAccount" json:"relayAccount"` + TeamID keybase1.TeamID `codec:"teamID" json:"teamID"` + BoxB64 string `codec:"boxB64" json:"boxB64"` +} + +func (o RelayOp) DeepCopy() RelayOp { + return RelayOp{ + ToAssertion: o.ToAssertion, + RelayAccount: o.RelayAccount.DeepCopy(), + TeamID: o.TeamID.DeepCopy(), + BoxB64: o.BoxB64, + } +} + +type PaymentOp struct { + To *keybase1.UserVersion `codec:"to,omitempty" json:"to,omitempty"` + Direct *DirectOp `codec:"direct,omitempty" json:"direct,omitempty"` + Relay *RelayOp `codec:"relay,omitempty" json:"relay,omitempty"` +} + +func (o PaymentOp) DeepCopy() PaymentOp { + return PaymentOp{ + To: (func(x *keybase1.UserVersion) *keybase1.UserVersion { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.To), + Direct: (func(x *DirectOp) *DirectOp { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Direct), + Relay: (func(x *RelayOp) *RelayOp { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Relay), + } +} + +type PaymentMultiPost struct { + FromDeviceID keybase1.DeviceID `codec:"fromDeviceID" json:"fromDeviceID"` + SignedTransaction string `codec:"signedTransaction" json:"signedTransaction"` + Operations []PaymentOp `codec:"operations" json:"operations"` + BatchID string `codec:"batchID" json:"batchID"` +} + +func (o PaymentMultiPost) DeepCopy() PaymentMultiPost { + return PaymentMultiPost{ + FromDeviceID: o.FromDeviceID.DeepCopy(), + SignedTransaction: o.SignedTransaction, + Operations: (func(x []PaymentOp) []PaymentOp { + if x == nil { + return nil + } + ret := make([]PaymentOp, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Operations), + BatchID: o.BatchID, + } +} + +type PaymentSummaryType int + +const ( + PaymentSummaryType_NONE PaymentSummaryType = 0 + PaymentSummaryType_STELLAR PaymentSummaryType = 1 + PaymentSummaryType_DIRECT PaymentSummaryType = 2 + PaymentSummaryType_RELAY PaymentSummaryType = 3 +) + +func (o PaymentSummaryType) DeepCopy() PaymentSummaryType { return o } + +var PaymentSummaryTypeMap = map[string]PaymentSummaryType{ + "NONE": 0, + "STELLAR": 1, + "DIRECT": 2, + "RELAY": 3, +} + +var PaymentSummaryTypeRevMap = map[PaymentSummaryType]string{ + 0: "NONE", + 1: "STELLAR", + 2: "DIRECT", + 3: "RELAY", +} + +func (e PaymentSummaryType) String() string { + if v, ok := PaymentSummaryTypeRevMap[e]; ok { + return v + } + return fmt.Sprintf("%v", int(e)) +} + +type PaymentSummary struct { + Typ__ PaymentSummaryType `codec:"typ" json:"typ"` + Stellar__ *PaymentSummaryStellar `codec:"stellar,omitempty" json:"stellar,omitempty"` + Direct__ *PaymentSummaryDirect `codec:"direct,omitempty" json:"direct,omitempty"` + Relay__ *PaymentSummaryRelay `codec:"relay,omitempty" json:"relay,omitempty"` +} + +func (o *PaymentSummary) Typ() (ret PaymentSummaryType, err error) { + switch o.Typ__ { + case PaymentSummaryType_STELLAR: + if o.Stellar__ == nil { + err = errors.New("unexpected nil value for Stellar__") + return ret, err + } + case PaymentSummaryType_DIRECT: + if o.Direct__ == nil { + err = errors.New("unexpected nil value for Direct__") + return ret, err + } + case PaymentSummaryType_RELAY: + if o.Relay__ == nil { + err = errors.New("unexpected nil value for Relay__") + return ret, err + } + } + return o.Typ__, nil +} + +func (o PaymentSummary) Stellar() (res PaymentSummaryStellar) { + if o.Typ__ != PaymentSummaryType_STELLAR { + panic("wrong case accessed") + } + if o.Stellar__ == nil { + return + } + return *o.Stellar__ +} + +func (o PaymentSummary) Direct() (res PaymentSummaryDirect) { + if o.Typ__ != PaymentSummaryType_DIRECT { + panic("wrong case accessed") + } + if o.Direct__ == nil { + return + } + return *o.Direct__ +} + +func (o PaymentSummary) Relay() (res PaymentSummaryRelay) { + if o.Typ__ != PaymentSummaryType_RELAY { + panic("wrong case accessed") + } + if o.Relay__ == nil { + return + } + return *o.Relay__ +} + +func NewPaymentSummaryWithStellar(v PaymentSummaryStellar) PaymentSummary { + return PaymentSummary{ + Typ__: PaymentSummaryType_STELLAR, + Stellar__: &v, + } +} + +func NewPaymentSummaryWithDirect(v PaymentSummaryDirect) PaymentSummary { + return PaymentSummary{ + Typ__: PaymentSummaryType_DIRECT, + Direct__: &v, + } +} + +func NewPaymentSummaryWithRelay(v PaymentSummaryRelay) PaymentSummary { + return PaymentSummary{ + Typ__: PaymentSummaryType_RELAY, + Relay__: &v, + } +} + +func (o PaymentSummary) DeepCopy() PaymentSummary { + return PaymentSummary{ + Typ__: o.Typ__.DeepCopy(), + Stellar__: (func(x *PaymentSummaryStellar) *PaymentSummaryStellar { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Stellar__), + Direct__: (func(x *PaymentSummaryDirect) *PaymentSummaryDirect { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Direct__), + Relay__: (func(x *PaymentSummaryRelay) *PaymentSummaryRelay { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Relay__), + } +} + +type PaymentSummaryStellar struct { + TxID TransactionID `codec:"txID" json:"txID"` + From AccountID `codec:"from" json:"from"` + To AccountID `codec:"to" json:"to"` + Amount string `codec:"amount" json:"amount"` + Asset Asset `codec:"asset" json:"asset"` + Ctime TimeMs `codec:"ctime" json:"ctime"` + CursorToken string `codec:"cursorToken" json:"cursorToken"` + Unread bool `codec:"unread" json:"unread"` + IsInflation bool `codec:"isInflation" json:"isInflation"` + InflationSource *string `codec:"inflationSource,omitempty" json:"inflationSource,omitempty"` + SourceAmountMax string `codec:"sourceAmountMax" json:"sourceAmountMax"` + SourceAmountActual string `codec:"sourceAmountActual" json:"sourceAmountActual"` + SourceAsset Asset `codec:"sourceAsset" json:"sourceAsset"` + IsAdvanced bool `codec:"isAdvanced" json:"isAdvanced"` + SummaryAdvanced string `codec:"summaryAdvanced" json:"summaryAdvanced"` + Operations []string `codec:"operations" json:"operations"` + Trustline *PaymentTrustlineLocal `codec:"trustline,omitempty" json:"trustline,omitempty"` +} + +func (o PaymentSummaryStellar) DeepCopy() PaymentSummaryStellar { + return PaymentSummaryStellar{ + TxID: o.TxID.DeepCopy(), + From: o.From.DeepCopy(), + To: o.To.DeepCopy(), + Amount: o.Amount, + Asset: o.Asset.DeepCopy(), + Ctime: o.Ctime.DeepCopy(), + CursorToken: o.CursorToken, + Unread: o.Unread, + IsInflation: o.IsInflation, + InflationSource: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.InflationSource), + SourceAmountMax: o.SourceAmountMax, + SourceAmountActual: o.SourceAmountActual, + SourceAsset: o.SourceAsset.DeepCopy(), + IsAdvanced: o.IsAdvanced, + SummaryAdvanced: o.SummaryAdvanced, + Operations: (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.Operations), + Trustline: (func(x *PaymentTrustlineLocal) *PaymentTrustlineLocal { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Trustline), + } +} + +type PaymentSummaryDirect struct { + KbTxID KeybaseTransactionID `codec:"kbTxID" json:"kbTxID"` + TxID TransactionID `codec:"txID" json:"txID"` + TxStatus TransactionStatus `codec:"txStatus" json:"txStatus"` + TxErrMsg string `codec:"txErrMsg" json:"txErrMsg"` + FromStellar AccountID `codec:"fromStellar" json:"fromStellar"` + From keybase1.UserVersion `codec:"from" json:"from"` + FromDeviceID keybase1.DeviceID `codec:"fromDeviceID" json:"fromDeviceID"` + ToStellar AccountID `codec:"toStellar" json:"toStellar"` + To *keybase1.UserVersion `codec:"to,omitempty" json:"to,omitempty"` + Amount string `codec:"amount" json:"amount"` + Asset Asset `codec:"asset" json:"asset"` + DisplayAmount *string `codec:"displayAmount,omitempty" json:"displayAmount,omitempty"` + DisplayCurrency *string `codec:"displayCurrency,omitempty" json:"displayCurrency,omitempty"` + NoteB64 string `codec:"noteB64" json:"noteB64"` + FromDisplayAmount string `codec:"fromDisplayAmount" json:"fromDisplayAmount"` + FromDisplayCurrency string `codec:"fromDisplayCurrency" json:"fromDisplayCurrency"` + ToDisplayAmount string `codec:"toDisplayAmount" json:"toDisplayAmount"` + ToDisplayCurrency string `codec:"toDisplayCurrency" json:"toDisplayCurrency"` + Ctime TimeMs `codec:"ctime" json:"ctime"` + Rtime TimeMs `codec:"rtime" json:"rtime"` + CursorToken string `codec:"cursorToken" json:"cursorToken"` + Unread bool `codec:"unread" json:"unread"` + FromPrimary bool `codec:"fromPrimary" json:"fromPrimary"` + BatchID string `codec:"batchID" json:"batchID"` + FromAirdrop bool `codec:"fromAirdrop" json:"fromAirdrop"` + SourceAmountMax string `codec:"sourceAmountMax" json:"sourceAmountMax"` + SourceAmountActual string `codec:"sourceAmountActual" json:"sourceAmountActual"` + SourceAsset Asset `codec:"sourceAsset" json:"sourceAsset"` +} + +func (o PaymentSummaryDirect) DeepCopy() PaymentSummaryDirect { + return PaymentSummaryDirect{ + KbTxID: o.KbTxID.DeepCopy(), + TxID: o.TxID.DeepCopy(), + TxStatus: o.TxStatus.DeepCopy(), + TxErrMsg: o.TxErrMsg, + FromStellar: o.FromStellar.DeepCopy(), + From: o.From.DeepCopy(), + FromDeviceID: o.FromDeviceID.DeepCopy(), + ToStellar: o.ToStellar.DeepCopy(), + To: (func(x *keybase1.UserVersion) *keybase1.UserVersion { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.To), + Amount: o.Amount, + Asset: o.Asset.DeepCopy(), + DisplayAmount: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.DisplayAmount), + DisplayCurrency: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.DisplayCurrency), + NoteB64: o.NoteB64, + FromDisplayAmount: o.FromDisplayAmount, + FromDisplayCurrency: o.FromDisplayCurrency, + ToDisplayAmount: o.ToDisplayAmount, + ToDisplayCurrency: o.ToDisplayCurrency, + Ctime: o.Ctime.DeepCopy(), + Rtime: o.Rtime.DeepCopy(), + CursorToken: o.CursorToken, + Unread: o.Unread, + FromPrimary: o.FromPrimary, + BatchID: o.BatchID, + FromAirdrop: o.FromAirdrop, + SourceAmountMax: o.SourceAmountMax, + SourceAmountActual: o.SourceAmountActual, + SourceAsset: o.SourceAsset.DeepCopy(), + } +} + +type PaymentSummaryRelay struct { + KbTxID KeybaseTransactionID `codec:"kbTxID" json:"kbTxID"` + TxID TransactionID `codec:"txID" json:"txID"` + TxStatus TransactionStatus `codec:"txStatus" json:"txStatus"` + TxErrMsg string `codec:"txErrMsg" json:"txErrMsg"` + FromStellar AccountID `codec:"fromStellar" json:"fromStellar"` + From keybase1.UserVersion `codec:"from" json:"from"` + FromDeviceID keybase1.DeviceID `codec:"fromDeviceID" json:"fromDeviceID"` + To *keybase1.UserVersion `codec:"to,omitempty" json:"to,omitempty"` + ToAssertion string `codec:"toAssertion" json:"toAssertion"` + RelayAccount AccountID `codec:"relayAccount" json:"relayAccount"` + Amount string `codec:"amount" json:"amount"` + DisplayAmount *string `codec:"displayAmount,omitempty" json:"displayAmount,omitempty"` + DisplayCurrency *string `codec:"displayCurrency,omitempty" json:"displayCurrency,omitempty"` + Ctime TimeMs `codec:"ctime" json:"ctime"` + Rtime TimeMs `codec:"rtime" json:"rtime"` + BoxB64 string `codec:"boxB64" json:"boxB64"` + TeamID keybase1.TeamID `codec:"teamID" json:"teamID"` + Claim *ClaimSummary `codec:"claim,omitempty" json:"claim,omitempty"` + CursorToken string `codec:"cursorToken" json:"cursorToken"` + BatchID string `codec:"batchID" json:"batchID"` + FromAirdrop bool `codec:"fromAirdrop" json:"fromAirdrop"` +} + +func (o PaymentSummaryRelay) DeepCopy() PaymentSummaryRelay { + return PaymentSummaryRelay{ + KbTxID: o.KbTxID.DeepCopy(), + TxID: o.TxID.DeepCopy(), + TxStatus: o.TxStatus.DeepCopy(), + TxErrMsg: o.TxErrMsg, + FromStellar: o.FromStellar.DeepCopy(), + From: o.From.DeepCopy(), + FromDeviceID: o.FromDeviceID.DeepCopy(), + To: (func(x *keybase1.UserVersion) *keybase1.UserVersion { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.To), + ToAssertion: o.ToAssertion, + RelayAccount: o.RelayAccount.DeepCopy(), + Amount: o.Amount, + DisplayAmount: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.DisplayAmount), + DisplayCurrency: (func(x *string) *string { + if x == nil { + return nil + } + tmp := (*x) + return &tmp + })(o.DisplayCurrency), + Ctime: o.Ctime.DeepCopy(), + Rtime: o.Rtime.DeepCopy(), + BoxB64: o.BoxB64, + TeamID: o.TeamID.DeepCopy(), + Claim: (func(x *ClaimSummary) *ClaimSummary { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Claim), + CursorToken: o.CursorToken, + BatchID: o.BatchID, + FromAirdrop: o.FromAirdrop, + } +} + +type ClaimSummary struct { + TxID TransactionID `codec:"txID" json:"txID"` + TxStatus TransactionStatus `codec:"txStatus" json:"txStatus"` + TxErrMsg string `codec:"txErrMsg" json:"txErrMsg"` + Dir RelayDirection `codec:"dir" json:"dir"` + ToStellar AccountID `codec:"toStellar" json:"toStellar"` + To keybase1.UserVersion `codec:"to" json:"to"` +} + +func (o ClaimSummary) DeepCopy() ClaimSummary { + return ClaimSummary{ + TxID: o.TxID.DeepCopy(), + TxStatus: o.TxStatus.DeepCopy(), + TxErrMsg: o.TxErrMsg, + Dir: o.Dir.DeepCopy(), + ToStellar: o.ToStellar.DeepCopy(), + To: o.To.DeepCopy(), + } +} + +type PaymentDetails struct { + Summary PaymentSummary `codec:"summary" json:"summary"` + Memo string `codec:"memo" json:"memo"` + MemoType string `codec:"memoType" json:"memoType"` + ExternalTxURL string `codec:"externalTxURL" json:"externalTxURL"` + FeeCharged string `codec:"feeCharged" json:"feeCharged"` + PathIntermediate []Asset `codec:"pathIntermediate" json:"pathIntermediate"` +} + +func (o PaymentDetails) DeepCopy() PaymentDetails { + return PaymentDetails{ + Summary: o.Summary.DeepCopy(), + Memo: o.Memo, + MemoType: o.MemoType, + ExternalTxURL: o.ExternalTxURL, + FeeCharged: o.FeeCharged, + PathIntermediate: (func(x []Asset) []Asset { + if x == nil { + return nil + } + ret := make([]Asset, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.PathIntermediate), + } +} + +type AccountDetails struct { + AccountID AccountID `codec:"accountID" json:"accountID"` + Seqno string `codec:"seqno" json:"seqno"` + Balances []Balance `codec:"balances" json:"balances"` + SubentryCount int `codec:"subentryCount" json:"subentryCount"` + Available string `codec:"available" json:"available"` + Reserves []AccountReserve `codec:"reserves" json:"reserves"` + ReadTransactionID *TransactionID `codec:"readTransactionID,omitempty" json:"readTransactionID,omitempty"` + UnreadPayments int `codec:"unreadPayments" json:"unreadPayments"` + DisplayCurrency string `codec:"displayCurrency" json:"displayCurrency"` + InflationDestination *AccountID `codec:"inflationDestination,omitempty" json:"inflationDestination,omitempty"` +} + +func (o AccountDetails) DeepCopy() AccountDetails { + return AccountDetails{ + AccountID: o.AccountID.DeepCopy(), + Seqno: o.Seqno, + Balances: (func(x []Balance) []Balance { + if x == nil { + return nil + } + ret := make([]Balance, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Balances), + SubentryCount: o.SubentryCount, + Available: o.Available, + Reserves: (func(x []AccountReserve) []AccountReserve { + if x == nil { + return nil + } + ret := make([]AccountReserve, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Reserves), + ReadTransactionID: (func(x *TransactionID) *TransactionID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ReadTransactionID), + UnreadPayments: o.UnreadPayments, + DisplayCurrency: o.DisplayCurrency, + InflationDestination: (func(x *AccountID) *AccountID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.InflationDestination), + } +} + +type PaymentsPage struct { + Payments []PaymentSummary `codec:"payments" json:"payments"` + Cursor *PageCursor `codec:"cursor,omitempty" json:"cursor,omitempty"` + OldestUnread *TransactionID `codec:"oldestUnread,omitempty" json:"oldestUnread,omitempty"` +} + +func (o PaymentsPage) DeepCopy() PaymentsPage { + return PaymentsPage{ + Payments: (func(x []PaymentSummary) []PaymentSummary { + if x == nil { + return nil + } + ret := make([]PaymentSummary, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Payments), + Cursor: (func(x *PageCursor) *PageCursor { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Cursor), + OldestUnread: (func(x *TransactionID) *TransactionID { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.OldestUnread), + } +} + +type SubmitMultiRes struct { + TxID TransactionID `codec:"txID" json:"txID"` +} + +func (o SubmitMultiRes) DeepCopy() SubmitMultiRes { + return SubmitMultiRes{ + TxID: o.TxID.DeepCopy(), + } +} + +type AutoClaim struct { + KbTxID KeybaseTransactionID `codec:"kbTxID" json:"kbTxID"` +} + +func (o AutoClaim) DeepCopy() AutoClaim { + return AutoClaim{ + KbTxID: o.KbTxID.DeepCopy(), + } +} + +type RequestPost struct { + ToUser *keybase1.UserVersion `codec:"toUser,omitempty" json:"toUser,omitempty"` + ToAssertion string `codec:"toAssertion" json:"toAssertion"` + Amount string `codec:"amount" json:"amount"` + Asset *Asset `codec:"asset,omitempty" json:"asset,omitempty"` + Currency *OutsideCurrencyCode `codec:"currency,omitempty" json:"currency,omitempty"` +} + +func (o RequestPost) DeepCopy() RequestPost { + return RequestPost{ + ToUser: (func(x *keybase1.UserVersion) *keybase1.UserVersion { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ToUser), + ToAssertion: o.ToAssertion, + Amount: o.Amount, + Asset: (func(x *Asset) *Asset { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Asset), + Currency: (func(x *OutsideCurrencyCode) *OutsideCurrencyCode { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Currency), + } +} + +type RequestDetails struct { + Id KeybaseRequestID `codec:"id" json:"id"` + FromUser keybase1.UserVersion `codec:"fromUser" json:"fromUser"` + ToUser *keybase1.UserVersion `codec:"toUser,omitempty" json:"toUser,omitempty"` + ToAssertion string `codec:"toAssertion" json:"toAssertion"` + Amount string `codec:"amount" json:"amount"` + Asset *Asset `codec:"asset,omitempty" json:"asset,omitempty"` + Currency *OutsideCurrencyCode `codec:"currency,omitempty" json:"currency,omitempty"` + FromDisplayAmount string `codec:"fromDisplayAmount" json:"fromDisplayAmount"` + FromDisplayCurrency string `codec:"fromDisplayCurrency" json:"fromDisplayCurrency"` + ToDisplayAmount string `codec:"toDisplayAmount" json:"toDisplayAmount"` + ToDisplayCurrency string `codec:"toDisplayCurrency" json:"toDisplayCurrency"` + FundingKbTxID KeybaseTransactionID `codec:"fundingKbTxID" json:"fundingKbTxID"` + Status RequestStatus `codec:"status" json:"status"` +} + +func (o RequestDetails) DeepCopy() RequestDetails { + return RequestDetails{ + Id: o.Id.DeepCopy(), + FromUser: o.FromUser.DeepCopy(), + ToUser: (func(x *keybase1.UserVersion) *keybase1.UserVersion { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.ToUser), + ToAssertion: o.ToAssertion, + Amount: o.Amount, + Asset: (func(x *Asset) *Asset { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Asset), + Currency: (func(x *OutsideCurrencyCode) *OutsideCurrencyCode { + if x == nil { + return nil + } + tmp := (*x).DeepCopy() + return &tmp + })(o.Currency), + FromDisplayAmount: o.FromDisplayAmount, + FromDisplayCurrency: o.FromDisplayCurrency, + ToDisplayAmount: o.ToDisplayAmount, + ToDisplayCurrency: o.ToDisplayCurrency, + FundingKbTxID: o.FundingKbTxID.DeepCopy(), + Status: o.Status.DeepCopy(), + } +} + +type TimeboundsRecommendation struct { + TimeNow keybase1.UnixTime `codec:"timeNow" json:"time_now"` + Timeout int64 `codec:"timeout" json:"timeout"` +} + +func (o TimeboundsRecommendation) DeepCopy() TimeboundsRecommendation { + return TimeboundsRecommendation{ + TimeNow: o.TimeNow.DeepCopy(), + Timeout: o.Timeout, + } +} + +type NetworkOptions struct { + BaseFee uint64 `codec:"baseFee" json:"baseFee"` +} + +func (o NetworkOptions) DeepCopy() NetworkOptions { + return NetworkOptions{ + BaseFee: o.BaseFee, + } +} + +type DetailsPlusPayments struct { + Details AccountDetails `codec:"details" json:"details"` + RecentPayments PaymentsPage `codec:"recentPayments" json:"recentPayments"` + PendingPayments []PaymentSummary `codec:"pendingPayments" json:"pendingPayments"` +} + +func (o DetailsPlusPayments) DeepCopy() DetailsPlusPayments { + return DetailsPlusPayments{ + Details: o.Details.DeepCopy(), + RecentPayments: o.RecentPayments.DeepCopy(), + PendingPayments: (func(x []PaymentSummary) []PaymentSummary { + if x == nil { + return nil + } + ret := make([]PaymentSummary, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.PendingPayments), + } +} + +type PaymentPathQuery struct { + Source AccountID `codec:"source" json:"source"` + Destination AccountID `codec:"destination" json:"destination"` + SourceAsset Asset `codec:"sourceAsset" json:"sourceAsset"` + DestinationAsset Asset `codec:"destinationAsset" json:"destinationAsset"` + Amount string `codec:"amount" json:"amount"` +} + +func (o PaymentPathQuery) DeepCopy() PaymentPathQuery { + return PaymentPathQuery{ + Source: o.Source.DeepCopy(), + Destination: o.Destination.DeepCopy(), + SourceAsset: o.SourceAsset.DeepCopy(), + DestinationAsset: o.DestinationAsset.DeepCopy(), + Amount: o.Amount, + } +} 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 new file mode 100644 index 00000000..8decce76 --- /dev/null +++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/ui.go @@ -0,0 +1,32 @@ +// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) +// Input file: ../client/protocol/avdl/stellar1/ui.avdl + +package stellar1 + +type UIPaymentReviewed struct { + Bid BuildPaymentID `codec:"bid" json:"bid"` + ReviewID int `codec:"reviewID" json:"reviewID"` + Seqno int `codec:"seqno" json:"seqno"` + Banners []SendBannerLocal `codec:"banners" json:"banners"` + NextButton string `codec:"nextButton" json:"nextButton"` +} + +func (o UIPaymentReviewed) DeepCopy() UIPaymentReviewed { + return UIPaymentReviewed{ + Bid: o.Bid.DeepCopy(), + ReviewID: o.ReviewID, + Seqno: o.Seqno, + Banners: (func(x []SendBannerLocal) []SendBannerLocal { + if x == nil { + return nil + } + ret := make([]SendBannerLocal, len(x)) + for i, v := range x { + vCopy := v.DeepCopy() + ret[i] = vCopy + } + return ret + })(o.Banners), + NextButton: o.NextButton, + } +} 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 7dfdab68..fb9cfb31 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 @@ -5,25 +5,12 @@ import ( "encoding/json" "fmt" "strings" + + "github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1" ) type WalletOutput struct { - Result WalletResult `json:"result"` -} - -type WalletResult struct { - TxID string `json:"txID"` - Status string `json:"status"` - Amount string `json:"amount"` - Asset WalletAsset `json:"asset"` - FromUsername string `json:"fromUsername"` - ToUsername string `json:"toUsername"` -} - -type WalletAsset struct { - Type string `json:"type"` - Code string `json:"code"` - Issuer string `json:"issuer"` + Result stellar1.PaymentCLILocal `json:"result"` } func (a *API) GetWalletTxDetails(txID string) (wOut WalletOutput, err error) { |