1// Auto-generated to Go types and interfaces using avdl-compiler v1.4.9 (https://github.com/keybase/node-avdl-compiler)
2//   Input file: avdl/chat1/remote.avdl
3
4package chat1
5
6import (
7	"errors"
8	"fmt"
9	gregor1 "github.com/keybase/client/go/protocol/gregor1"
10	keybase1 "github.com/keybase/client/go/protocol/keybase1"
11	"github.com/keybase/go-framed-msgpack-rpc/rpc"
12	context "golang.org/x/net/context"
13	"time"
14)
15
16type MessageBoxed struct {
17	Version          MessageBoxedVersion  `codec:"version" json:"version"`
18	ServerHeader     *MessageServerHeader `codec:"serverHeader,omitempty" json:"serverHeader,omitempty"`
19	ClientHeader     MessageClientHeader  `codec:"clientHeader" json:"clientHeader"`
20	HeaderCiphertext SealedData           `codec:"headerCiphertext" json:"headerCiphertext"`
21	BodyCiphertext   EncryptedData        `codec:"bodyCiphertext" json:"bodyCiphertext"`
22	VerifyKey        []byte               `codec:"verifyKey" json:"verifyKey"`
23	KeyGeneration    int                  `codec:"keyGeneration" json:"keyGeneration"`
24}
25
26func (o MessageBoxed) DeepCopy() MessageBoxed {
27	return MessageBoxed{
28		Version: o.Version.DeepCopy(),
29		ServerHeader: (func(x *MessageServerHeader) *MessageServerHeader {
30			if x == nil {
31				return nil
32			}
33			tmp := (*x).DeepCopy()
34			return &tmp
35		})(o.ServerHeader),
36		ClientHeader:     o.ClientHeader.DeepCopy(),
37		HeaderCiphertext: o.HeaderCiphertext.DeepCopy(),
38		BodyCiphertext:   o.BodyCiphertext.DeepCopy(),
39		VerifyKey: (func(x []byte) []byte {
40			if x == nil {
41				return nil
42			}
43			return append([]byte{}, x...)
44		})(o.VerifyKey),
45		KeyGeneration: o.KeyGeneration,
46	}
47}
48
49type MessageBoxedVersion int
50
51const (
52	MessageBoxedVersion_VNONE MessageBoxedVersion = 0
53	MessageBoxedVersion_V1    MessageBoxedVersion = 1
54	MessageBoxedVersion_V2    MessageBoxedVersion = 2
55	MessageBoxedVersion_V3    MessageBoxedVersion = 3
56	MessageBoxedVersion_V4    MessageBoxedVersion = 4
57)
58
59func (o MessageBoxedVersion) DeepCopy() MessageBoxedVersion { return o }
60
61var MessageBoxedVersionMap = map[string]MessageBoxedVersion{
62	"VNONE": 0,
63	"V1":    1,
64	"V2":    2,
65	"V3":    3,
66	"V4":    4,
67}
68
69var MessageBoxedVersionRevMap = map[MessageBoxedVersion]string{
70	0: "VNONE",
71	1: "V1",
72	2: "V2",
73	3: "V3",
74	4: "V4",
75}
76
77func (e MessageBoxedVersion) String() string {
78	if v, ok := MessageBoxedVersionRevMap[e]; ok {
79		return v
80	}
81	return fmt.Sprintf("%v", int(e))
82}
83
84type ThreadViewBoxed struct {
85	Messages   []MessageBoxed `codec:"messages" json:"messages"`
86	Pagination *Pagination    `codec:"pagination,omitempty" json:"pagination,omitempty"`
87}
88
89func (o ThreadViewBoxed) DeepCopy() ThreadViewBoxed {
90	return ThreadViewBoxed{
91		Messages: (func(x []MessageBoxed) []MessageBoxed {
92			if x == nil {
93				return nil
94			}
95			ret := make([]MessageBoxed, len(x))
96			for i, v := range x {
97				vCopy := v.DeepCopy()
98				ret[i] = vCopy
99			}
100			return ret
101		})(o.Messages),
102		Pagination: (func(x *Pagination) *Pagination {
103			if x == nil {
104				return nil
105			}
106			tmp := (*x).DeepCopy()
107			return &tmp
108		})(o.Pagination),
109	}
110}
111
112type GetInboxRemoteRes struct {
113	Inbox     InboxView  `codec:"inbox" json:"inbox"`
114	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
115}
116
117func (o GetInboxRemoteRes) DeepCopy() GetInboxRemoteRes {
118	return GetInboxRemoteRes{
119		Inbox: o.Inbox.DeepCopy(),
120		RateLimit: (func(x *RateLimit) *RateLimit {
121			if x == nil {
122				return nil
123			}
124			tmp := (*x).DeepCopy()
125			return &tmp
126		})(o.RateLimit),
127	}
128}
129
130type GetInboxByTLFIDRemoteRes struct {
131	Convs     []Conversation `codec:"convs" json:"convs"`
132	RateLimit *RateLimit     `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
133}
134
135func (o GetInboxByTLFIDRemoteRes) DeepCopy() GetInboxByTLFIDRemoteRes {
136	return GetInboxByTLFIDRemoteRes{
137		Convs: (func(x []Conversation) []Conversation {
138			if x == nil {
139				return nil
140			}
141			ret := make([]Conversation, len(x))
142			for i, v := range x {
143				vCopy := v.DeepCopy()
144				ret[i] = vCopy
145			}
146			return ret
147		})(o.Convs),
148		RateLimit: (func(x *RateLimit) *RateLimit {
149			if x == nil {
150				return nil
151			}
152			tmp := (*x).DeepCopy()
153			return &tmp
154		})(o.RateLimit),
155	}
156}
157
158type GetThreadRemoteRes struct {
159	Thread      ThreadViewBoxed         `codec:"thread" json:"thread"`
160	MembersType ConversationMembersType `codec:"membersType" json:"membersType"`
161	Visibility  keybase1.TLFVisibility  `codec:"visibility" json:"visibility"`
162	RateLimit   *RateLimit              `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
163}
164
165func (o GetThreadRemoteRes) DeepCopy() GetThreadRemoteRes {
166	return GetThreadRemoteRes{
167		Thread:      o.Thread.DeepCopy(),
168		MembersType: o.MembersType.DeepCopy(),
169		Visibility:  o.Visibility.DeepCopy(),
170		RateLimit: (func(x *RateLimit) *RateLimit {
171			if x == nil {
172				return nil
173			}
174			tmp := (*x).DeepCopy()
175			return &tmp
176		})(o.RateLimit),
177	}
178}
179
180type GetConversationMetadataRemoteRes struct {
181	Conv      Conversation `codec:"conv" json:"conv"`
182	RateLimit *RateLimit   `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
183}
184
185func (o GetConversationMetadataRemoteRes) DeepCopy() GetConversationMetadataRemoteRes {
186	return GetConversationMetadataRemoteRes{
187		Conv: o.Conv.DeepCopy(),
188		RateLimit: (func(x *RateLimit) *RateLimit {
189			if x == nil {
190				return nil
191			}
192			tmp := (*x).DeepCopy()
193			return &tmp
194		})(o.RateLimit),
195	}
196}
197
198type PostRemoteRes struct {
199	MsgHeader MessageServerHeader `codec:"msgHeader" json:"msgHeader"`
200	RateLimit *RateLimit          `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
201}
202
203func (o PostRemoteRes) DeepCopy() PostRemoteRes {
204	return PostRemoteRes{
205		MsgHeader: o.MsgHeader.DeepCopy(),
206		RateLimit: (func(x *RateLimit) *RateLimit {
207			if x == nil {
208				return nil
209			}
210			tmp := (*x).DeepCopy()
211			return &tmp
212		})(o.RateLimit),
213	}
214}
215
216type NewConversationRemoteRes struct {
217	ConvID             ConversationID `codec:"convID" json:"convID"`
218	CreatedComplexTeam bool           `codec:"createdComplexTeam" json:"createdComplexTeam"`
219	RateLimit          *RateLimit     `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
220}
221
222func (o NewConversationRemoteRes) DeepCopy() NewConversationRemoteRes {
223	return NewConversationRemoteRes{
224		ConvID:             o.ConvID.DeepCopy(),
225		CreatedComplexTeam: o.CreatedComplexTeam,
226		RateLimit: (func(x *RateLimit) *RateLimit {
227			if x == nil {
228				return nil
229			}
230			tmp := (*x).DeepCopy()
231			return &tmp
232		})(o.RateLimit),
233	}
234}
235
236type GetMessagesRemoteRes struct {
237	Msgs        []MessageBoxed          `codec:"msgs" json:"msgs"`
238	MembersType ConversationMembersType `codec:"membersType" json:"membersType"`
239	Visibility  keybase1.TLFVisibility  `codec:"visibility" json:"visibility"`
240	RateLimit   *RateLimit              `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
241}
242
243func (o GetMessagesRemoteRes) DeepCopy() GetMessagesRemoteRes {
244	return GetMessagesRemoteRes{
245		Msgs: (func(x []MessageBoxed) []MessageBoxed {
246			if x == nil {
247				return nil
248			}
249			ret := make([]MessageBoxed, len(x))
250			for i, v := range x {
251				vCopy := v.DeepCopy()
252				ret[i] = vCopy
253			}
254			return ret
255		})(o.Msgs),
256		MembersType: o.MembersType.DeepCopy(),
257		Visibility:  o.Visibility.DeepCopy(),
258		RateLimit: (func(x *RateLimit) *RateLimit {
259			if x == nil {
260				return nil
261			}
262			tmp := (*x).DeepCopy()
263			return &tmp
264		})(o.RateLimit),
265	}
266}
267
268type MarkAsReadRes struct {
269	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
270}
271
272func (o MarkAsReadRes) DeepCopy() MarkAsReadRes {
273	return MarkAsReadRes{
274		RateLimit: (func(x *RateLimit) *RateLimit {
275			if x == nil {
276				return nil
277			}
278			tmp := (*x).DeepCopy()
279			return &tmp
280		})(o.RateLimit),
281	}
282}
283
284type SetConversationStatusRes struct {
285	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
286}
287
288func (o SetConversationStatusRes) DeepCopy() SetConversationStatusRes {
289	return SetConversationStatusRes{
290		RateLimit: (func(x *RateLimit) *RateLimit {
291			if x == nil {
292				return nil
293			}
294			tmp := (*x).DeepCopy()
295			return &tmp
296		})(o.RateLimit),
297	}
298}
299
300type GetPublicConversationsRes struct {
301	Conversations []Conversation `codec:"conversations" json:"conversations"`
302	RateLimit     *RateLimit     `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
303}
304
305func (o GetPublicConversationsRes) DeepCopy() GetPublicConversationsRes {
306	return GetPublicConversationsRes{
307		Conversations: (func(x []Conversation) []Conversation {
308			if x == nil {
309				return nil
310			}
311			ret := make([]Conversation, len(x))
312			for i, v := range x {
313				vCopy := v.DeepCopy()
314				ret[i] = vCopy
315			}
316			return ret
317		})(o.Conversations),
318		RateLimit: (func(x *RateLimit) *RateLimit {
319			if x == nil {
320				return nil
321			}
322			tmp := (*x).DeepCopy()
323			return &tmp
324		})(o.RateLimit),
325	}
326}
327
328type GetUnreadlineRemoteRes struct {
329	UnreadlineID *MessageID `codec:"unreadlineID,omitempty" json:"unreadlineID,omitempty"`
330	RateLimit    *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
331}
332
333func (o GetUnreadlineRemoteRes) DeepCopy() GetUnreadlineRemoteRes {
334	return GetUnreadlineRemoteRes{
335		UnreadlineID: (func(x *MessageID) *MessageID {
336			if x == nil {
337				return nil
338			}
339			tmp := (*x).DeepCopy()
340			return &tmp
341		})(o.UnreadlineID),
342		RateLimit: (func(x *RateLimit) *RateLimit {
343			if x == nil {
344				return nil
345			}
346			tmp := (*x).DeepCopy()
347			return &tmp
348		})(o.RateLimit),
349	}
350}
351
352type ChannelMention int
353
354const (
355	ChannelMention_NONE ChannelMention = 0
356	ChannelMention_ALL  ChannelMention = 1
357	ChannelMention_HERE ChannelMention = 2
358)
359
360func (o ChannelMention) DeepCopy() ChannelMention { return o }
361
362var ChannelMentionMap = map[string]ChannelMention{
363	"NONE": 0,
364	"ALL":  1,
365	"HERE": 2,
366}
367
368var ChannelMentionRevMap = map[ChannelMention]string{
369	0: "NONE",
370	1: "ALL",
371	2: "HERE",
372}
373
374func (e ChannelMention) String() string {
375	if v, ok := ChannelMentionRevMap[e]; ok {
376		return v
377	}
378	return fmt.Sprintf("%v", int(e))
379}
380
381type UnreadUpdateFull struct {
382	Ignore          bool             `codec:"ignore" json:"ignore"`
383	InboxVers       InboxVers        `codec:"inboxVers" json:"inboxVers"`
384	InboxSyncStatus SyncInboxResType `codec:"inboxSyncStatus" json:"inboxSyncStatus"`
385	Updates         []UnreadUpdate   `codec:"updates" json:"updates"`
386}
387
388func (o UnreadUpdateFull) DeepCopy() UnreadUpdateFull {
389	return UnreadUpdateFull{
390		Ignore:          o.Ignore,
391		InboxVers:       o.InboxVers.DeepCopy(),
392		InboxSyncStatus: o.InboxSyncStatus.DeepCopy(),
393		Updates: (func(x []UnreadUpdate) []UnreadUpdate {
394			if x == nil {
395				return nil
396			}
397			ret := make([]UnreadUpdate, len(x))
398			for i, v := range x {
399				vCopy := v.DeepCopy()
400				ret[i] = vCopy
401			}
402			return ret
403		})(o.Updates),
404	}
405}
406
407type S3Params struct {
408	Bucket               string `codec:"bucket" json:"bucket"`
409	ObjectKey            string `codec:"objectKey" json:"objectKey"`
410	AccessKey            string `codec:"accessKey" json:"accessKey"`
411	Acl                  string `codec:"acl" json:"acl"`
412	RegionName           string `codec:"regionName" json:"regionName"`
413	RegionEndpoint       string `codec:"regionEndpoint" json:"regionEndpoint"`
414	RegionBucketEndpoint string `codec:"regionBucketEndpoint" json:"regionBucketEndpoint"`
415}
416
417func (o S3Params) DeepCopy() S3Params {
418	return S3Params{
419		Bucket:               o.Bucket,
420		ObjectKey:            o.ObjectKey,
421		AccessKey:            o.AccessKey,
422		Acl:                  o.Acl,
423		RegionName:           o.RegionName,
424		RegionEndpoint:       o.RegionEndpoint,
425		RegionBucketEndpoint: o.RegionBucketEndpoint,
426	}
427}
428
429type SyncIncrementalRes struct {
430	Vers  InboxVers      `codec:"vers" json:"vers"`
431	Convs []Conversation `codec:"convs" json:"convs"`
432}
433
434func (o SyncIncrementalRes) DeepCopy() SyncIncrementalRes {
435	return SyncIncrementalRes{
436		Vers: o.Vers.DeepCopy(),
437		Convs: (func(x []Conversation) []Conversation {
438			if x == nil {
439				return nil
440			}
441			ret := make([]Conversation, len(x))
442			for i, v := range x {
443				vCopy := v.DeepCopy()
444				ret[i] = vCopy
445			}
446			return ret
447		})(o.Convs),
448	}
449}
450
451type ServerCacheVers struct {
452	InboxVers  int `codec:"inboxVers" json:"inboxVers"`
453	BodiesVers int `codec:"bodiesVers" json:"bodiesVers"`
454}
455
456func (o ServerCacheVers) DeepCopy() ServerCacheVers {
457	return ServerCacheVers{
458		InboxVers:  o.InboxVers,
459		BodiesVers: o.BodiesVers,
460	}
461}
462
463type SyncInboxRes struct {
464	Typ__         SyncInboxResType    `codec:"typ" json:"typ"`
465	Incremental__ *SyncIncrementalRes `codec:"incremental,omitempty" json:"incremental,omitempty"`
466}
467
468func (o *SyncInboxRes) Typ() (ret SyncInboxResType, err error) {
469	switch o.Typ__ {
470	case SyncInboxResType_INCREMENTAL:
471		if o.Incremental__ == nil {
472			err = errors.New("unexpected nil value for Incremental__")
473			return ret, err
474		}
475	}
476	return o.Typ__, nil
477}
478
479func (o SyncInboxRes) Incremental() (res SyncIncrementalRes) {
480	if o.Typ__ != SyncInboxResType_INCREMENTAL {
481		panic("wrong case accessed")
482	}
483	if o.Incremental__ == nil {
484		return
485	}
486	return *o.Incremental__
487}
488
489func NewSyncInboxResWithCurrent() SyncInboxRes {
490	return SyncInboxRes{
491		Typ__: SyncInboxResType_CURRENT,
492	}
493}
494
495func NewSyncInboxResWithIncremental(v SyncIncrementalRes) SyncInboxRes {
496	return SyncInboxRes{
497		Typ__:         SyncInboxResType_INCREMENTAL,
498		Incremental__: &v,
499	}
500}
501
502func NewSyncInboxResWithClear() SyncInboxRes {
503	return SyncInboxRes{
504		Typ__: SyncInboxResType_CLEAR,
505	}
506}
507
508func (o SyncInboxRes) DeepCopy() SyncInboxRes {
509	return SyncInboxRes{
510		Typ__: o.Typ__.DeepCopy(),
511		Incremental__: (func(x *SyncIncrementalRes) *SyncIncrementalRes {
512			if x == nil {
513				return nil
514			}
515			tmp := (*x).DeepCopy()
516			return &tmp
517		})(o.Incremental__),
518	}
519}
520
521type SyncChatRes struct {
522	CacheVers ServerCacheVers `codec:"cacheVers" json:"cacheVers"`
523	InboxRes  SyncInboxRes    `codec:"inboxRes" json:"inboxRes"`
524}
525
526func (o SyncChatRes) DeepCopy() SyncChatRes {
527	return SyncChatRes{
528		CacheVers: o.CacheVers.DeepCopy(),
529		InboxRes:  o.InboxRes.DeepCopy(),
530	}
531}
532
533type SyncAllProtVers int
534
535const (
536	SyncAllProtVers_V0 SyncAllProtVers = 0
537	SyncAllProtVers_V1 SyncAllProtVers = 1
538)
539
540func (o SyncAllProtVers) DeepCopy() SyncAllProtVers { return o }
541
542var SyncAllProtVersMap = map[string]SyncAllProtVers{
543	"V0": 0,
544	"V1": 1,
545}
546
547var SyncAllProtVersRevMap = map[SyncAllProtVers]string{
548	0: "V0",
549	1: "V1",
550}
551
552func (e SyncAllProtVers) String() string {
553	if v, ok := SyncAllProtVersRevMap[e]; ok {
554		return v
555	}
556	return fmt.Sprintf("%v", int(e))
557}
558
559type SyncAllNotificationType int
560
561const (
562	SyncAllNotificationType_STATE       SyncAllNotificationType = 0
563	SyncAllNotificationType_INCREMENTAL SyncAllNotificationType = 1
564)
565
566func (o SyncAllNotificationType) DeepCopy() SyncAllNotificationType { return o }
567
568var SyncAllNotificationTypeMap = map[string]SyncAllNotificationType{
569	"STATE":       0,
570	"INCREMENTAL": 1,
571}
572
573var SyncAllNotificationTypeRevMap = map[SyncAllNotificationType]string{
574	0: "STATE",
575	1: "INCREMENTAL",
576}
577
578func (e SyncAllNotificationType) String() string {
579	if v, ok := SyncAllNotificationTypeRevMap[e]; ok {
580		return v
581	}
582	return fmt.Sprintf("%v", int(e))
583}
584
585type SyncAllNotificationRes struct {
586	Typ__         SyncAllNotificationType `codec:"typ" json:"typ"`
587	State__       *gregor1.State          `codec:"state,omitempty" json:"state,omitempty"`
588	Incremental__ *gregor1.SyncResult     `codec:"incremental,omitempty" json:"incremental,omitempty"`
589}
590
591func (o *SyncAllNotificationRes) Typ() (ret SyncAllNotificationType, err error) {
592	switch o.Typ__ {
593	case SyncAllNotificationType_STATE:
594		if o.State__ == nil {
595			err = errors.New("unexpected nil value for State__")
596			return ret, err
597		}
598	case SyncAllNotificationType_INCREMENTAL:
599		if o.Incremental__ == nil {
600			err = errors.New("unexpected nil value for Incremental__")
601			return ret, err
602		}
603	}
604	return o.Typ__, nil
605}
606
607func (o SyncAllNotificationRes) State() (res gregor1.State) {
608	if o.Typ__ != SyncAllNotificationType_STATE {
609		panic("wrong case accessed")
610	}
611	if o.State__ == nil {
612		return
613	}
614	return *o.State__
615}
616
617func (o SyncAllNotificationRes) Incremental() (res gregor1.SyncResult) {
618	if o.Typ__ != SyncAllNotificationType_INCREMENTAL {
619		panic("wrong case accessed")
620	}
621	if o.Incremental__ == nil {
622		return
623	}
624	return *o.Incremental__
625}
626
627func NewSyncAllNotificationResWithState(v gregor1.State) SyncAllNotificationRes {
628	return SyncAllNotificationRes{
629		Typ__:   SyncAllNotificationType_STATE,
630		State__: &v,
631	}
632}
633
634func NewSyncAllNotificationResWithIncremental(v gregor1.SyncResult) SyncAllNotificationRes {
635	return SyncAllNotificationRes{
636		Typ__:         SyncAllNotificationType_INCREMENTAL,
637		Incremental__: &v,
638	}
639}
640
641func (o SyncAllNotificationRes) DeepCopy() SyncAllNotificationRes {
642	return SyncAllNotificationRes{
643		Typ__: o.Typ__.DeepCopy(),
644		State__: (func(x *gregor1.State) *gregor1.State {
645			if x == nil {
646				return nil
647			}
648			tmp := (*x).DeepCopy()
649			return &tmp
650		})(o.State__),
651		Incremental__: (func(x *gregor1.SyncResult) *gregor1.SyncResult {
652			if x == nil {
653				return nil
654			}
655			tmp := (*x).DeepCopy()
656			return &tmp
657		})(o.Incremental__),
658	}
659}
660
661type SyncAllResult struct {
662	Auth         gregor1.AuthResult     `codec:"auth" json:"auth"`
663	Chat         SyncChatRes            `codec:"chat" json:"chat"`
664	Notification SyncAllNotificationRes `codec:"notification" json:"notification"`
665	Badge        UnreadUpdateFull       `codec:"badge" json:"badge"`
666}
667
668func (o SyncAllResult) DeepCopy() SyncAllResult {
669	return SyncAllResult{
670		Auth:         o.Auth.DeepCopy(),
671		Chat:         o.Chat.DeepCopy(),
672		Notification: o.Notification.DeepCopy(),
673		Badge:        o.Badge.DeepCopy(),
674	}
675}
676
677type JoinLeaveConversationRemoteRes struct {
678	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
679}
680
681func (o JoinLeaveConversationRemoteRes) DeepCopy() JoinLeaveConversationRemoteRes {
682	return JoinLeaveConversationRemoteRes{
683		RateLimit: (func(x *RateLimit) *RateLimit {
684			if x == nil {
685				return nil
686			}
687			tmp := (*x).DeepCopy()
688			return &tmp
689		})(o.RateLimit),
690	}
691}
692
693type DeleteConversationRemoteRes struct {
694	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
695}
696
697func (o DeleteConversationRemoteRes) DeepCopy() DeleteConversationRemoteRes {
698	return DeleteConversationRemoteRes{
699		RateLimit: (func(x *RateLimit) *RateLimit {
700			if x == nil {
701				return nil
702			}
703			tmp := (*x).DeepCopy()
704			return &tmp
705		})(o.RateLimit),
706	}
707}
708
709type RemoveFromConversationRemoteRes struct {
710	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
711}
712
713func (o RemoveFromConversationRemoteRes) DeepCopy() RemoveFromConversationRemoteRes {
714	return RemoveFromConversationRemoteRes{
715		RateLimit: (func(x *RateLimit) *RateLimit {
716			if x == nil {
717				return nil
718			}
719			tmp := (*x).DeepCopy()
720			return &tmp
721		})(o.RateLimit),
722	}
723}
724
725type GetMessageBeforeRes struct {
726	MsgID     MessageID  `codec:"msgID" json:"msgID"`
727	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
728}
729
730func (o GetMessageBeforeRes) DeepCopy() GetMessageBeforeRes {
731	return GetMessageBeforeRes{
732		MsgID: o.MsgID.DeepCopy(),
733		RateLimit: (func(x *RateLimit) *RateLimit {
734			if x == nil {
735				return nil
736			}
737			tmp := (*x).DeepCopy()
738			return &tmp
739		})(o.RateLimit),
740	}
741}
742
743type GetTLFConversationsRes struct {
744	Conversations []Conversation `codec:"conversations" json:"conversations"`
745	RateLimit     *RateLimit     `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
746}
747
748func (o GetTLFConversationsRes) DeepCopy() GetTLFConversationsRes {
749	return GetTLFConversationsRes{
750		Conversations: (func(x []Conversation) []Conversation {
751			if x == nil {
752				return nil
753			}
754			ret := make([]Conversation, len(x))
755			for i, v := range x {
756				vCopy := v.DeepCopy()
757				ret[i] = vCopy
758			}
759			return ret
760		})(o.Conversations),
761		RateLimit: (func(x *RateLimit) *RateLimit {
762			if x == nil {
763				return nil
764			}
765			tmp := (*x).DeepCopy()
766			return &tmp
767		})(o.RateLimit),
768	}
769}
770
771type SetAppNotificationSettingsRes struct {
772	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
773}
774
775func (o SetAppNotificationSettingsRes) DeepCopy() SetAppNotificationSettingsRes {
776	return SetAppNotificationSettingsRes{
777		RateLimit: (func(x *RateLimit) *RateLimit {
778			if x == nil {
779				return nil
780			}
781			tmp := (*x).DeepCopy()
782			return &tmp
783		})(o.RateLimit),
784	}
785}
786
787type SetRetentionRes struct {
788	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
789}
790
791func (o SetRetentionRes) DeepCopy() SetRetentionRes {
792	return SetRetentionRes{
793		RateLimit: (func(x *RateLimit) *RateLimit {
794			if x == nil {
795				return nil
796			}
797			tmp := (*x).DeepCopy()
798			return &tmp
799		})(o.RateLimit),
800	}
801}
802
803type SetConvMinWriterRoleRes struct {
804	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
805}
806
807func (o SetConvMinWriterRoleRes) DeepCopy() SetConvMinWriterRoleRes {
808	return SetConvMinWriterRoleRes{
809		RateLimit: (func(x *RateLimit) *RateLimit {
810			if x == nil {
811				return nil
812			}
813			tmp := (*x).DeepCopy()
814			return &tmp
815		})(o.RateLimit),
816	}
817}
818
819type SweepRes struct {
820	FoundTask       bool    `codec:"foundTask" json:"foundTask"`
821	DeletedMessages bool    `codec:"deletedMessages" json:"deletedMessages"`
822	Expunge         Expunge `codec:"expunge" json:"expunge"`
823}
824
825func (o SweepRes) DeepCopy() SweepRes {
826	return SweepRes{
827		FoundTask:       o.FoundTask,
828		DeletedMessages: o.DeletedMessages,
829		Expunge:         o.Expunge.DeepCopy(),
830	}
831}
832
833type ServerNowRes struct {
834	RateLimit *RateLimit   `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
835	Now       gregor1.Time `codec:"now" json:"now"`
836}
837
838func (o ServerNowRes) DeepCopy() ServerNowRes {
839	return ServerNowRes{
840		RateLimit: (func(x *RateLimit) *RateLimit {
841			if x == nil {
842				return nil
843			}
844			tmp := (*x).DeepCopy()
845			return &tmp
846		})(o.RateLimit),
847		Now: o.Now.DeepCopy(),
848	}
849}
850
851type ExternalAPIKeyTyp int
852
853const (
854	ExternalAPIKeyTyp_GOOGLEMAPS ExternalAPIKeyTyp = 0
855	ExternalAPIKeyTyp_GIPHY      ExternalAPIKeyTyp = 1
856)
857
858func (o ExternalAPIKeyTyp) DeepCopy() ExternalAPIKeyTyp { return o }
859
860var ExternalAPIKeyTypMap = map[string]ExternalAPIKeyTyp{
861	"GOOGLEMAPS": 0,
862	"GIPHY":      1,
863}
864
865var ExternalAPIKeyTypRevMap = map[ExternalAPIKeyTyp]string{
866	0: "GOOGLEMAPS",
867	1: "GIPHY",
868}
869
870func (e ExternalAPIKeyTyp) String() string {
871	if v, ok := ExternalAPIKeyTypRevMap[e]; ok {
872		return v
873	}
874	return fmt.Sprintf("%v", int(e))
875}
876
877type ExternalAPIKey struct {
878	Typ__        ExternalAPIKeyTyp `codec:"typ" json:"typ"`
879	Googlemaps__ *string           `codec:"googlemaps,omitempty" json:"googlemaps,omitempty"`
880	Giphy__      *string           `codec:"giphy,omitempty" json:"giphy,omitempty"`
881}
882
883func (o *ExternalAPIKey) Typ() (ret ExternalAPIKeyTyp, err error) {
884	switch o.Typ__ {
885	case ExternalAPIKeyTyp_GOOGLEMAPS:
886		if o.Googlemaps__ == nil {
887			err = errors.New("unexpected nil value for Googlemaps__")
888			return ret, err
889		}
890	case ExternalAPIKeyTyp_GIPHY:
891		if o.Giphy__ == nil {
892			err = errors.New("unexpected nil value for Giphy__")
893			return ret, err
894		}
895	}
896	return o.Typ__, nil
897}
898
899func (o ExternalAPIKey) Googlemaps() (res string) {
900	if o.Typ__ != ExternalAPIKeyTyp_GOOGLEMAPS {
901		panic("wrong case accessed")
902	}
903	if o.Googlemaps__ == nil {
904		return
905	}
906	return *o.Googlemaps__
907}
908
909func (o ExternalAPIKey) Giphy() (res string) {
910	if o.Typ__ != ExternalAPIKeyTyp_GIPHY {
911		panic("wrong case accessed")
912	}
913	if o.Giphy__ == nil {
914		return
915	}
916	return *o.Giphy__
917}
918
919func NewExternalAPIKeyWithGooglemaps(v string) ExternalAPIKey {
920	return ExternalAPIKey{
921		Typ__:        ExternalAPIKeyTyp_GOOGLEMAPS,
922		Googlemaps__: &v,
923	}
924}
925
926func NewExternalAPIKeyWithGiphy(v string) ExternalAPIKey {
927	return ExternalAPIKey{
928		Typ__:   ExternalAPIKeyTyp_GIPHY,
929		Giphy__: &v,
930	}
931}
932
933func (o ExternalAPIKey) DeepCopy() ExternalAPIKey {
934	return ExternalAPIKey{
935		Typ__: o.Typ__.DeepCopy(),
936		Googlemaps__: (func(x *string) *string {
937			if x == nil {
938				return nil
939			}
940			tmp := (*x)
941			return &tmp
942		})(o.Googlemaps__),
943		Giphy__: (func(x *string) *string {
944			if x == nil {
945				return nil
946			}
947			tmp := (*x)
948			return &tmp
949		})(o.Giphy__),
950	}
951}
952
953type BotInfoHashVers uint64
954
955func (o BotInfoHashVers) DeepCopy() BotInfoHashVers {
956	return o
957}
958
959type CommandConvVers uint64
960
961func (o CommandConvVers) DeepCopy() CommandConvVers {
962	return o
963}
964
965type RemoteBotCommandsAdvertisementPublic struct {
966	ConvID ConversationID `codec:"convID" json:"convID"`
967}
968
969func (o RemoteBotCommandsAdvertisementPublic) DeepCopy() RemoteBotCommandsAdvertisementPublic {
970	return RemoteBotCommandsAdvertisementPublic{
971		ConvID: o.ConvID.DeepCopy(),
972	}
973}
974
975type RemoteBotCommandsAdvertisementTLFID struct {
976	ConvID ConversationID `codec:"convID" json:"convID"`
977	TlfID  TLFID          `codec:"tlfID" json:"tlfID"`
978}
979
980func (o RemoteBotCommandsAdvertisementTLFID) DeepCopy() RemoteBotCommandsAdvertisementTLFID {
981	return RemoteBotCommandsAdvertisementTLFID{
982		ConvID: o.ConvID.DeepCopy(),
983		TlfID:  o.TlfID.DeepCopy(),
984	}
985}
986
987type RemoteBotCommandsAdvertisementConv struct {
988	ConvID          ConversationID `codec:"convID" json:"convID"`
989	AdvertiseConvID ConversationID `codec:"advertiseConvID" json:"advertiseConvID"`
990}
991
992func (o RemoteBotCommandsAdvertisementConv) DeepCopy() RemoteBotCommandsAdvertisementConv {
993	return RemoteBotCommandsAdvertisementConv{
994		ConvID:          o.ConvID.DeepCopy(),
995		AdvertiseConvID: o.AdvertiseConvID.DeepCopy(),
996	}
997}
998
999type RemoteBotCommandsAdvertisement struct {
1000	Typ__          BotCommandsAdvertisementTyp           `codec:"typ" json:"typ"`
1001	Public__       *RemoteBotCommandsAdvertisementPublic `codec:"public,omitempty" json:"public,omitempty"`
1002	TlfidMembers__ *RemoteBotCommandsAdvertisementTLFID  `codec:"tlfidMembers,omitempty" json:"tlfidMembers,omitempty"`
1003	TlfidConvs__   *RemoteBotCommandsAdvertisementTLFID  `codec:"tlfidConvs,omitempty" json:"tlfidConvs,omitempty"`
1004	Conv__         *RemoteBotCommandsAdvertisementConv   `codec:"conv,omitempty" json:"conv,omitempty"`
1005}
1006
1007func (o *RemoteBotCommandsAdvertisement) Typ() (ret BotCommandsAdvertisementTyp, err error) {
1008	switch o.Typ__ {
1009	case BotCommandsAdvertisementTyp_PUBLIC:
1010		if o.Public__ == nil {
1011			err = errors.New("unexpected nil value for Public__")
1012			return ret, err
1013		}
1014	case BotCommandsAdvertisementTyp_TLFID_MEMBERS:
1015		if o.TlfidMembers__ == nil {
1016			err = errors.New("unexpected nil value for TlfidMembers__")
1017			return ret, err
1018		}
1019	case BotCommandsAdvertisementTyp_TLFID_CONVS:
1020		if o.TlfidConvs__ == nil {
1021			err = errors.New("unexpected nil value for TlfidConvs__")
1022			return ret, err
1023		}
1024	case BotCommandsAdvertisementTyp_CONV:
1025		if o.Conv__ == nil {
1026			err = errors.New("unexpected nil value for Conv__")
1027			return ret, err
1028		}
1029	}
1030	return o.Typ__, nil
1031}
1032
1033func (o RemoteBotCommandsAdvertisement) Public() (res RemoteBotCommandsAdvertisementPublic) {
1034	if o.Typ__ != BotCommandsAdvertisementTyp_PUBLIC {
1035		panic("wrong case accessed")
1036	}
1037	if o.Public__ == nil {
1038		return
1039	}
1040	return *o.Public__
1041}
1042
1043func (o RemoteBotCommandsAdvertisement) TlfidMembers() (res RemoteBotCommandsAdvertisementTLFID) {
1044	if o.Typ__ != BotCommandsAdvertisementTyp_TLFID_MEMBERS {
1045		panic("wrong case accessed")
1046	}
1047	if o.TlfidMembers__ == nil {
1048		return
1049	}
1050	return *o.TlfidMembers__
1051}
1052
1053func (o RemoteBotCommandsAdvertisement) TlfidConvs() (res RemoteBotCommandsAdvertisementTLFID) {
1054	if o.Typ__ != BotCommandsAdvertisementTyp_TLFID_CONVS {
1055		panic("wrong case accessed")
1056	}
1057	if o.TlfidConvs__ == nil {
1058		return
1059	}
1060	return *o.TlfidConvs__
1061}
1062
1063func (o RemoteBotCommandsAdvertisement) Conv() (res RemoteBotCommandsAdvertisementConv) {
1064	if o.Typ__ != BotCommandsAdvertisementTyp_CONV {
1065		panic("wrong case accessed")
1066	}
1067	if o.Conv__ == nil {
1068		return
1069	}
1070	return *o.Conv__
1071}
1072
1073func NewRemoteBotCommandsAdvertisementWithPublic(v RemoteBotCommandsAdvertisementPublic) RemoteBotCommandsAdvertisement {
1074	return RemoteBotCommandsAdvertisement{
1075		Typ__:    BotCommandsAdvertisementTyp_PUBLIC,
1076		Public__: &v,
1077	}
1078}
1079
1080func NewRemoteBotCommandsAdvertisementWithTlfidMembers(v RemoteBotCommandsAdvertisementTLFID) RemoteBotCommandsAdvertisement {
1081	return RemoteBotCommandsAdvertisement{
1082		Typ__:          BotCommandsAdvertisementTyp_TLFID_MEMBERS,
1083		TlfidMembers__: &v,
1084	}
1085}
1086
1087func NewRemoteBotCommandsAdvertisementWithTlfidConvs(v RemoteBotCommandsAdvertisementTLFID) RemoteBotCommandsAdvertisement {
1088	return RemoteBotCommandsAdvertisement{
1089		Typ__:        BotCommandsAdvertisementTyp_TLFID_CONVS,
1090		TlfidConvs__: &v,
1091	}
1092}
1093
1094func NewRemoteBotCommandsAdvertisementWithConv(v RemoteBotCommandsAdvertisementConv) RemoteBotCommandsAdvertisement {
1095	return RemoteBotCommandsAdvertisement{
1096		Typ__:  BotCommandsAdvertisementTyp_CONV,
1097		Conv__: &v,
1098	}
1099}
1100
1101func (o RemoteBotCommandsAdvertisement) DeepCopy() RemoteBotCommandsAdvertisement {
1102	return RemoteBotCommandsAdvertisement{
1103		Typ__: o.Typ__.DeepCopy(),
1104		Public__: (func(x *RemoteBotCommandsAdvertisementPublic) *RemoteBotCommandsAdvertisementPublic {
1105			if x == nil {
1106				return nil
1107			}
1108			tmp := (*x).DeepCopy()
1109			return &tmp
1110		})(o.Public__),
1111		TlfidMembers__: (func(x *RemoteBotCommandsAdvertisementTLFID) *RemoteBotCommandsAdvertisementTLFID {
1112			if x == nil {
1113				return nil
1114			}
1115			tmp := (*x).DeepCopy()
1116			return &tmp
1117		})(o.TlfidMembers__),
1118		TlfidConvs__: (func(x *RemoteBotCommandsAdvertisementTLFID) *RemoteBotCommandsAdvertisementTLFID {
1119			if x == nil {
1120				return nil
1121			}
1122			tmp := (*x).DeepCopy()
1123			return &tmp
1124		})(o.TlfidConvs__),
1125		Conv__: (func(x *RemoteBotCommandsAdvertisementConv) *RemoteBotCommandsAdvertisementConv {
1126			if x == nil {
1127				return nil
1128			}
1129			tmp := (*x).DeepCopy()
1130			return &tmp
1131		})(o.Conv__),
1132	}
1133}
1134
1135type BotCommandConv struct {
1136	Uid               gregor1.UID                 `codec:"uid" json:"uid"`
1137	UntrustedTeamRole keybase1.TeamRole           `codec:"untrustedTeamRole" json:"untrustedTeamRole"`
1138	ConvID            ConversationID              `codec:"convID" json:"convID"`
1139	Vers              CommandConvVers             `codec:"vers" json:"vers"`
1140	Mtime             gregor1.Time                `codec:"mtime" json:"mtime"`
1141	Typ               BotCommandsAdvertisementTyp `codec:"typ" json:"typ"`
1142}
1143
1144func (o BotCommandConv) DeepCopy() BotCommandConv {
1145	return BotCommandConv{
1146		Uid:               o.Uid.DeepCopy(),
1147		UntrustedTeamRole: o.UntrustedTeamRole.DeepCopy(),
1148		ConvID:            o.ConvID.DeepCopy(),
1149		Vers:              o.Vers.DeepCopy(),
1150		Mtime:             o.Mtime.DeepCopy(),
1151		Typ:               o.Typ.DeepCopy(),
1152	}
1153}
1154
1155type BotInfo struct {
1156	ServerHashVers BotInfoHashVers  `codec:"serverHashVers" json:"serverHashVers"`
1157	ClientHashVers BotInfoHashVers  `codec:"clientHashVers" json:"clientHashVers"`
1158	CommandConvs   []BotCommandConv `codec:"commandConvs" json:"commandConvs"`
1159}
1160
1161func (o BotInfo) DeepCopy() BotInfo {
1162	return BotInfo{
1163		ServerHashVers: o.ServerHashVers.DeepCopy(),
1164		ClientHashVers: o.ClientHashVers.DeepCopy(),
1165		CommandConvs: (func(x []BotCommandConv) []BotCommandConv {
1166			if x == nil {
1167				return nil
1168			}
1169			ret := make([]BotCommandConv, len(x))
1170			for i, v := range x {
1171				vCopy := v.DeepCopy()
1172				ret[i] = vCopy
1173			}
1174			return ret
1175		})(o.CommandConvs),
1176	}
1177}
1178
1179type AdvertiseBotCommandsRes struct {
1180	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
1181}
1182
1183func (o AdvertiseBotCommandsRes) DeepCopy() AdvertiseBotCommandsRes {
1184	return AdvertiseBotCommandsRes{
1185		RateLimit: (func(x *RateLimit) *RateLimit {
1186			if x == nil {
1187				return nil
1188			}
1189			tmp := (*x).DeepCopy()
1190			return &tmp
1191		})(o.RateLimit),
1192	}
1193}
1194
1195type RemoteClearBotCommandsFilterPublic struct {
1196}
1197
1198func (o RemoteClearBotCommandsFilterPublic) DeepCopy() RemoteClearBotCommandsFilterPublic {
1199	return RemoteClearBotCommandsFilterPublic{}
1200}
1201
1202type RemoteClearBotCommandsFilterTLFID struct {
1203	TlfID TLFID `codec:"tlfID" json:"tlfID"`
1204}
1205
1206func (o RemoteClearBotCommandsFilterTLFID) DeepCopy() RemoteClearBotCommandsFilterTLFID {
1207	return RemoteClearBotCommandsFilterTLFID{
1208		TlfID: o.TlfID.DeepCopy(),
1209	}
1210}
1211
1212type RemoteClearBotCommandsFilterConv struct {
1213	ConvID ConversationID `codec:"convID" json:"convID"`
1214}
1215
1216func (o RemoteClearBotCommandsFilterConv) DeepCopy() RemoteClearBotCommandsFilterConv {
1217	return RemoteClearBotCommandsFilterConv{
1218		ConvID: o.ConvID.DeepCopy(),
1219	}
1220}
1221
1222type RemoteClearBotCommandsFilter struct {
1223	Typ__          BotCommandsAdvertisementTyp         `codec:"typ" json:"typ"`
1224	Public__       *RemoteClearBotCommandsFilterPublic `codec:"public,omitempty" json:"public,omitempty"`
1225	TlfidMembers__ *RemoteClearBotCommandsFilterTLFID  `codec:"tlfidMembers,omitempty" json:"tlfidMembers,omitempty"`
1226	TlfidConvs__   *RemoteClearBotCommandsFilterTLFID  `codec:"tlfidConvs,omitempty" json:"tlfidConvs,omitempty"`
1227	Conv__         *RemoteClearBotCommandsFilterConv   `codec:"conv,omitempty" json:"conv,omitempty"`
1228}
1229
1230func (o *RemoteClearBotCommandsFilter) Typ() (ret BotCommandsAdvertisementTyp, err error) {
1231	switch o.Typ__ {
1232	case BotCommandsAdvertisementTyp_PUBLIC:
1233		if o.Public__ == nil {
1234			err = errors.New("unexpected nil value for Public__")
1235			return ret, err
1236		}
1237	case BotCommandsAdvertisementTyp_TLFID_MEMBERS:
1238		if o.TlfidMembers__ == nil {
1239			err = errors.New("unexpected nil value for TlfidMembers__")
1240			return ret, err
1241		}
1242	case BotCommandsAdvertisementTyp_TLFID_CONVS:
1243		if o.TlfidConvs__ == nil {
1244			err = errors.New("unexpected nil value for TlfidConvs__")
1245			return ret, err
1246		}
1247	case BotCommandsAdvertisementTyp_CONV:
1248		if o.Conv__ == nil {
1249			err = errors.New("unexpected nil value for Conv__")
1250			return ret, err
1251		}
1252	}
1253	return o.Typ__, nil
1254}
1255
1256func (o RemoteClearBotCommandsFilter) Public() (res RemoteClearBotCommandsFilterPublic) {
1257	if o.Typ__ != BotCommandsAdvertisementTyp_PUBLIC {
1258		panic("wrong case accessed")
1259	}
1260	if o.Public__ == nil {
1261		return
1262	}
1263	return *o.Public__
1264}
1265
1266func (o RemoteClearBotCommandsFilter) TlfidMembers() (res RemoteClearBotCommandsFilterTLFID) {
1267	if o.Typ__ != BotCommandsAdvertisementTyp_TLFID_MEMBERS {
1268		panic("wrong case accessed")
1269	}
1270	if o.TlfidMembers__ == nil {
1271		return
1272	}
1273	return *o.TlfidMembers__
1274}
1275
1276func (o RemoteClearBotCommandsFilter) TlfidConvs() (res RemoteClearBotCommandsFilterTLFID) {
1277	if o.Typ__ != BotCommandsAdvertisementTyp_TLFID_CONVS {
1278		panic("wrong case accessed")
1279	}
1280	if o.TlfidConvs__ == nil {
1281		return
1282	}
1283	return *o.TlfidConvs__
1284}
1285
1286func (o RemoteClearBotCommandsFilter) Conv() (res RemoteClearBotCommandsFilterConv) {
1287	if o.Typ__ != BotCommandsAdvertisementTyp_CONV {
1288		panic("wrong case accessed")
1289	}
1290	if o.Conv__ == nil {
1291		return
1292	}
1293	return *o.Conv__
1294}
1295
1296func NewRemoteClearBotCommandsFilterWithPublic(v RemoteClearBotCommandsFilterPublic) RemoteClearBotCommandsFilter {
1297	return RemoteClearBotCommandsFilter{
1298		Typ__:    BotCommandsAdvertisementTyp_PUBLIC,
1299		Public__: &v,
1300	}
1301}
1302
1303func NewRemoteClearBotCommandsFilterWithTlfidMembers(v RemoteClearBotCommandsFilterTLFID) RemoteClearBotCommandsFilter {
1304	return RemoteClearBotCommandsFilter{
1305		Typ__:          BotCommandsAdvertisementTyp_TLFID_MEMBERS,
1306		TlfidMembers__: &v,
1307	}
1308}
1309
1310func NewRemoteClearBotCommandsFilterWithTlfidConvs(v RemoteClearBotCommandsFilterTLFID) RemoteClearBotCommandsFilter {
1311	return RemoteClearBotCommandsFilter{
1312		Typ__:        BotCommandsAdvertisementTyp_TLFID_CONVS,
1313		TlfidConvs__: &v,
1314	}
1315}
1316
1317func NewRemoteClearBotCommandsFilterWithConv(v RemoteClearBotCommandsFilterConv) RemoteClearBotCommandsFilter {
1318	return RemoteClearBotCommandsFilter{
1319		Typ__:  BotCommandsAdvertisementTyp_CONV,
1320		Conv__: &v,
1321	}
1322}
1323
1324func (o RemoteClearBotCommandsFilter) DeepCopy() RemoteClearBotCommandsFilter {
1325	return RemoteClearBotCommandsFilter{
1326		Typ__: o.Typ__.DeepCopy(),
1327		Public__: (func(x *RemoteClearBotCommandsFilterPublic) *RemoteClearBotCommandsFilterPublic {
1328			if x == nil {
1329				return nil
1330			}
1331			tmp := (*x).DeepCopy()
1332			return &tmp
1333		})(o.Public__),
1334		TlfidMembers__: (func(x *RemoteClearBotCommandsFilterTLFID) *RemoteClearBotCommandsFilterTLFID {
1335			if x == nil {
1336				return nil
1337			}
1338			tmp := (*x).DeepCopy()
1339			return &tmp
1340		})(o.TlfidMembers__),
1341		TlfidConvs__: (func(x *RemoteClearBotCommandsFilterTLFID) *RemoteClearBotCommandsFilterTLFID {
1342			if x == nil {
1343				return nil
1344			}
1345			tmp := (*x).DeepCopy()
1346			return &tmp
1347		})(o.TlfidConvs__),
1348		Conv__: (func(x *RemoteClearBotCommandsFilterConv) *RemoteClearBotCommandsFilterConv {
1349			if x == nil {
1350				return nil
1351			}
1352			tmp := (*x).DeepCopy()
1353			return &tmp
1354		})(o.Conv__),
1355	}
1356}
1357
1358type ClearBotCommandsRes struct {
1359	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
1360}
1361
1362func (o ClearBotCommandsRes) DeepCopy() ClearBotCommandsRes {
1363	return ClearBotCommandsRes{
1364		RateLimit: (func(x *RateLimit) *RateLimit {
1365			if x == nil {
1366				return nil
1367			}
1368			tmp := (*x).DeepCopy()
1369			return &tmp
1370		})(o.RateLimit),
1371	}
1372}
1373
1374type BotInfoResponseTyp int
1375
1376const (
1377	BotInfoResponseTyp_UPTODATE BotInfoResponseTyp = 0
1378	BotInfoResponseTyp_INFO     BotInfoResponseTyp = 1
1379)
1380
1381func (o BotInfoResponseTyp) DeepCopy() BotInfoResponseTyp { return o }
1382
1383var BotInfoResponseTypMap = map[string]BotInfoResponseTyp{
1384	"UPTODATE": 0,
1385	"INFO":     1,
1386}
1387
1388var BotInfoResponseTypRevMap = map[BotInfoResponseTyp]string{
1389	0: "UPTODATE",
1390	1: "INFO",
1391}
1392
1393func (e BotInfoResponseTyp) String() string {
1394	if v, ok := BotInfoResponseTypRevMap[e]; ok {
1395		return v
1396	}
1397	return fmt.Sprintf("%v", int(e))
1398}
1399
1400type BotInfoResponse struct {
1401	Typ__  BotInfoResponseTyp `codec:"typ" json:"typ"`
1402	Info__ *BotInfo           `codec:"info,omitempty" json:"info,omitempty"`
1403}
1404
1405func (o *BotInfoResponse) Typ() (ret BotInfoResponseTyp, err error) {
1406	switch o.Typ__ {
1407	case BotInfoResponseTyp_INFO:
1408		if o.Info__ == nil {
1409			err = errors.New("unexpected nil value for Info__")
1410			return ret, err
1411		}
1412	}
1413	return o.Typ__, nil
1414}
1415
1416func (o BotInfoResponse) Info() (res BotInfo) {
1417	if o.Typ__ != BotInfoResponseTyp_INFO {
1418		panic("wrong case accessed")
1419	}
1420	if o.Info__ == nil {
1421		return
1422	}
1423	return *o.Info__
1424}
1425
1426func NewBotInfoResponseWithUptodate() BotInfoResponse {
1427	return BotInfoResponse{
1428		Typ__: BotInfoResponseTyp_UPTODATE,
1429	}
1430}
1431
1432func NewBotInfoResponseWithInfo(v BotInfo) BotInfoResponse {
1433	return BotInfoResponse{
1434		Typ__:  BotInfoResponseTyp_INFO,
1435		Info__: &v,
1436	}
1437}
1438
1439func (o BotInfoResponse) DeepCopy() BotInfoResponse {
1440	return BotInfoResponse{
1441		Typ__: o.Typ__.DeepCopy(),
1442		Info__: (func(x *BotInfo) *BotInfo {
1443			if x == nil {
1444				return nil
1445			}
1446			tmp := (*x).DeepCopy()
1447			return &tmp
1448		})(o.Info__),
1449	}
1450}
1451
1452type GetBotInfoRes struct {
1453	Response  BotInfoResponse `codec:"response" json:"response"`
1454	RateLimit *RateLimit      `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
1455}
1456
1457func (o GetBotInfoRes) DeepCopy() GetBotInfoRes {
1458	return GetBotInfoRes{
1459		Response: o.Response.DeepCopy(),
1460		RateLimit: (func(x *RateLimit) *RateLimit {
1461			if x == nil {
1462				return nil
1463			}
1464			tmp := (*x).DeepCopy()
1465			return &tmp
1466		})(o.RateLimit),
1467	}
1468}
1469
1470type BotInfoHash []byte
1471
1472func (o BotInfoHash) DeepCopy() BotInfoHash {
1473	return (func(x []byte) []byte {
1474		if x == nil {
1475			return nil
1476		}
1477		return append([]byte{}, x...)
1478	})(o)
1479}
1480
1481type GetDefaultTeamChannelsRes struct {
1482	Convs     []ConversationID `codec:"convs" json:"convs"`
1483	RateLimit *RateLimit       `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
1484}
1485
1486func (o GetDefaultTeamChannelsRes) DeepCopy() GetDefaultTeamChannelsRes {
1487	return GetDefaultTeamChannelsRes{
1488		Convs: (func(x []ConversationID) []ConversationID {
1489			if x == nil {
1490				return nil
1491			}
1492			ret := make([]ConversationID, len(x))
1493			for i, v := range x {
1494				vCopy := v.DeepCopy()
1495				ret[i] = vCopy
1496			}
1497			return ret
1498		})(o.Convs),
1499		RateLimit: (func(x *RateLimit) *RateLimit {
1500			if x == nil {
1501				return nil
1502			}
1503			tmp := (*x).DeepCopy()
1504			return &tmp
1505		})(o.RateLimit),
1506	}
1507}
1508
1509type SetDefaultTeamChannelsRes struct {
1510	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
1511}
1512
1513func (o SetDefaultTeamChannelsRes) DeepCopy() SetDefaultTeamChannelsRes {
1514	return SetDefaultTeamChannelsRes{
1515		RateLimit: (func(x *RateLimit) *RateLimit {
1516			if x == nil {
1517				return nil
1518			}
1519			tmp := (*x).DeepCopy()
1520			return &tmp
1521		})(o.RateLimit),
1522	}
1523}
1524
1525type GetRecentJoinsRes struct {
1526	NumJoins  int        `codec:"numJoins" json:"numJoins"`
1527	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
1528}
1529
1530func (o GetRecentJoinsRes) DeepCopy() GetRecentJoinsRes {
1531	return GetRecentJoinsRes{
1532		NumJoins: o.NumJoins,
1533		RateLimit: (func(x *RateLimit) *RateLimit {
1534			if x == nil {
1535				return nil
1536			}
1537			tmp := (*x).DeepCopy()
1538			return &tmp
1539		})(o.RateLimit),
1540	}
1541}
1542
1543type RefreshParticipantsRemoteRes struct {
1544	HashMatch bool          `codec:"hashMatch" json:"hashMatch"`
1545	Uids      []gregor1.UID `codec:"uids" json:"uids"`
1546	Hash      string        `codec:"hash" json:"hash"`
1547	RateLimit *RateLimit    `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
1548}
1549
1550func (o RefreshParticipantsRemoteRes) DeepCopy() RefreshParticipantsRemoteRes {
1551	return RefreshParticipantsRemoteRes{
1552		HashMatch: o.HashMatch,
1553		Uids: (func(x []gregor1.UID) []gregor1.UID {
1554			if x == nil {
1555				return nil
1556			}
1557			ret := make([]gregor1.UID, len(x))
1558			for i, v := range x {
1559				vCopy := v.DeepCopy()
1560				ret[i] = vCopy
1561			}
1562			return ret
1563		})(o.Uids),
1564		Hash: o.Hash,
1565		RateLimit: (func(x *RateLimit) *RateLimit {
1566			if x == nil {
1567				return nil
1568			}
1569			tmp := (*x).DeepCopy()
1570			return &tmp
1571		})(o.RateLimit),
1572	}
1573}
1574
1575type GetLastActiveAtRes struct {
1576	LastActiveAt gregor1.Time `codec:"lastActiveAt" json:"lastActiveAt"`
1577	RateLimit    *RateLimit   `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
1578}
1579
1580func (o GetLastActiveAtRes) DeepCopy() GetLastActiveAtRes {
1581	return GetLastActiveAtRes{
1582		LastActiveAt: o.LastActiveAt.DeepCopy(),
1583		RateLimit: (func(x *RateLimit) *RateLimit {
1584			if x == nil {
1585				return nil
1586			}
1587			tmp := (*x).DeepCopy()
1588			return &tmp
1589		})(o.RateLimit),
1590	}
1591}
1592
1593type ResetConversationMember struct {
1594	ConvID ConversationID `codec:"convID" json:"convID"`
1595	Uid    gregor1.UID    `codec:"uid" json:"uid"`
1596}
1597
1598func (o ResetConversationMember) DeepCopy() ResetConversationMember {
1599	return ResetConversationMember{
1600		ConvID: o.ConvID.DeepCopy(),
1601		Uid:    o.Uid.DeepCopy(),
1602	}
1603}
1604
1605type GetResetConversationsRes struct {
1606	ResetConvs []ResetConversationMember `codec:"resetConvs" json:"resetConvs"`
1607	RateLimit  *RateLimit                `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
1608}
1609
1610func (o GetResetConversationsRes) DeepCopy() GetResetConversationsRes {
1611	return GetResetConversationsRes{
1612		ResetConvs: (func(x []ResetConversationMember) []ResetConversationMember {
1613			if x == nil {
1614				return nil
1615			}
1616			ret := make([]ResetConversationMember, len(x))
1617			for i, v := range x {
1618				vCopy := v.DeepCopy()
1619				ret[i] = vCopy
1620			}
1621			return ret
1622		})(o.ResetConvs),
1623		RateLimit: (func(x *RateLimit) *RateLimit {
1624			if x == nil {
1625				return nil
1626			}
1627			tmp := (*x).DeepCopy()
1628			return &tmp
1629		})(o.RateLimit),
1630	}
1631}
1632
1633type GetInboxRemoteArg struct {
1634	Vers       InboxVers      `codec:"vers" json:"vers"`
1635	Query      *GetInboxQuery `codec:"query,omitempty" json:"query,omitempty"`
1636	Pagination *Pagination    `codec:"pagination,omitempty" json:"pagination,omitempty"`
1637}
1638
1639type GetThreadRemoteArg struct {
1640	ConversationID ConversationID  `codec:"conversationID" json:"conversationID"`
1641	Reason         GetThreadReason `codec:"reason" json:"reason"`
1642	Query          *GetThreadQuery `codec:"query,omitempty" json:"query,omitempty"`
1643	Pagination     *Pagination     `codec:"pagination,omitempty" json:"pagination,omitempty"`
1644}
1645
1646type GetUnreadlineRemoteArg struct {
1647	ConvID    ConversationID `codec:"convID" json:"convID"`
1648	ReadMsgID MessageID      `codec:"readMsgID" json:"readMsgID"`
1649}
1650
1651type GetPublicConversationsArg struct {
1652	TlfID            TLFID     `codec:"tlfID" json:"tlfID"`
1653	TopicType        TopicType `codec:"topicType" json:"topicType"`
1654	SummarizeMaxMsgs bool      `codec:"summarizeMaxMsgs" json:"summarizeMaxMsgs"`
1655}
1656
1657type PostRemoteArg struct {
1658	ConversationID ConversationID            `codec:"conversationID" json:"conversationID"`
1659	MessageBoxed   MessageBoxed              `codec:"messageBoxed" json:"messageBoxed"`
1660	AtMentions     []gregor1.UID             `codec:"atMentions" json:"atMentions"`
1661	ChannelMention ChannelMention            `codec:"channelMention" json:"channelMention"`
1662	TopicNameState *TopicNameState           `codec:"topicNameState,omitempty" json:"topicNameState,omitempty"`
1663	JoinMentionsAs *ConversationMemberStatus `codec:"joinMentionsAs,omitempty" json:"joinMentionsAs,omitempty"`
1664}
1665
1666type NewConversationRemoteArg struct {
1667	IdTriple ConversationIDTriple `codec:"idTriple" json:"idTriple"`
1668}
1669
1670type NewConversationRemote2Arg struct {
1671	IdTriple         ConversationIDTriple    `codec:"idTriple" json:"idTriple"`
1672	TLFMessage       MessageBoxed            `codec:"TLFMessage" json:"TLFMessage"`
1673	MembersType      ConversationMembersType `codec:"membersType" json:"membersType"`
1674	TopicNameState   *TopicNameState         `codec:"topicNameState,omitempty" json:"topicNameState,omitempty"`
1675	MemberSourceConv *ConversationID         `codec:"memberSourceConv,omitempty" json:"memberSourceConv,omitempty"`
1676	RetentionPolicy  *RetentionPolicy        `codec:"retentionPolicy,omitempty" json:"retentionPolicy,omitempty"`
1677}
1678
1679type GetMessagesRemoteArg struct {
1680	ConversationID ConversationID   `codec:"conversationID" json:"conversationID"`
1681	ThreadReason   *GetThreadReason `codec:"threadReason,omitempty" json:"threadReason,omitempty"`
1682	MessageIDs     []MessageID      `codec:"messageIDs" json:"messageIDs"`
1683}
1684
1685type MarkAsReadArg struct {
1686	ConversationID ConversationID `codec:"conversationID" json:"conversationID"`
1687	MsgID          MessageID      `codec:"msgID" json:"msgID"`
1688}
1689
1690type SetConversationStatusArg struct {
1691	ConversationID ConversationID     `codec:"conversationID" json:"conversationID"`
1692	Status         ConversationStatus `codec:"status" json:"status"`
1693}
1694
1695type GetUnreadUpdateFullArg struct {
1696	InboxVers InboxVers `codec:"inboxVers" json:"inboxVers"`
1697}
1698
1699type GetS3ParamsArg struct {
1700	ConversationID ConversationID `codec:"conversationID" json:"conversationID"`
1701}
1702
1703type S3SignArg struct {
1704	Version int    `codec:"version" json:"version"`
1705	Payload []byte `codec:"payload" json:"payload"`
1706}
1707
1708type GetInboxVersionArg struct {
1709	Uid gregor1.UID `codec:"uid" json:"uid"`
1710}
1711
1712type SyncInboxArg struct {
1713	Vers InboxVers `codec:"vers" json:"vers"`
1714}
1715
1716type SyncChatArg struct {
1717	Vers             InboxVers             `codec:"vers" json:"vers"`
1718	SummarizeMaxMsgs bool                  `codec:"summarizeMaxMsgs" json:"summarizeMaxMsgs"`
1719	ParticipantsMode InboxParticipantsMode `codec:"participantsMode" json:"participantsMode"`
1720}
1721
1722type SyncAllArg struct {
1723	Uid              gregor1.UID           `codec:"uid" json:"uid"`
1724	DeviceID         gregor1.DeviceID      `codec:"deviceID" json:"deviceID"`
1725	Session          gregor1.SessionToken  `codec:"session" json:"session"`
1726	InboxVers        InboxVers             `codec:"inboxVers" json:"inboxVers"`
1727	Ctime            gregor1.Time          `codec:"ctime" json:"ctime"`
1728	Fresh            bool                  `codec:"fresh" json:"fresh"`
1729	ProtVers         SyncAllProtVers       `codec:"protVers" json:"protVers"`
1730	HostName         string                `codec:"hostName" json:"hostName"`
1731	SummarizeMaxMsgs bool                  `codec:"summarizeMaxMsgs" json:"summarizeMaxMsgs"`
1732	ParticipantsMode InboxParticipantsMode `codec:"participantsMode" json:"participantsMode"`
1733}
1734
1735type TlfFinalizeArg struct {
1736	TlfID          TLFID         `codec:"tlfID" json:"tlfID"`
1737	ResetUser      string        `codec:"resetUser" json:"resetUser"`
1738	ResetDate      string        `codec:"resetDate" json:"resetDate"`
1739	ResetTimestamp gregor1.Time  `codec:"resetTimestamp" json:"resetTimestamp"`
1740	ResetFull      string        `codec:"resetFull" json:"resetFull"`
1741	ResetUID       *keybase1.UID `codec:"resetUID,omitempty" json:"resetUID,omitempty"`
1742}
1743
1744type TlfResolveArg struct {
1745	TlfID           TLFID         `codec:"tlfID" json:"tlfID"`
1746	ResolvedWriters []gregor1.UID `codec:"resolvedWriters" json:"resolvedWriters"`
1747	ResolvedReaders []gregor1.UID `codec:"resolvedReaders" json:"resolvedReaders"`
1748}
1749
1750type UpdateTypingRemoteArg struct {
1751	Uid      gregor1.UID      `codec:"uid" json:"uid"`
1752	DeviceID gregor1.DeviceID `codec:"deviceID" json:"deviceID"`
1753	ConvID   ConversationID   `codec:"convID" json:"convID"`
1754	Typing   bool             `codec:"typing" json:"typing"`
1755}
1756
1757type JoinConversationArg struct {
1758	ConvID ConversationID `codec:"convID" json:"convID"`
1759}
1760
1761type LeaveConversationArg struct {
1762	ConvID ConversationID `codec:"convID" json:"convID"`
1763}
1764
1765type PreviewConversationArg struct {
1766	ConvID ConversationID `codec:"convID" json:"convID"`
1767}
1768
1769type DeleteConversationArg struct {
1770	ConvID ConversationID `codec:"convID" json:"convID"`
1771}
1772
1773type RemoveFromConversationArg struct {
1774	ConvID ConversationID `codec:"convID" json:"convID"`
1775	Users  []gregor1.UID  `codec:"users" json:"users"`
1776}
1777
1778type GetMessageBeforeArg struct {
1779	ConvID ConversationID      `codec:"convID" json:"convID"`
1780	Age    gregor1.DurationSec `codec:"age" json:"age"`
1781}
1782
1783type GetTLFConversationsArg struct {
1784	TlfID            TLFID     `codec:"tlfID" json:"tlfID"`
1785	TopicType        TopicType `codec:"topicType" json:"topicType"`
1786	SummarizeMaxMsgs bool      `codec:"summarizeMaxMsgs" json:"summarizeMaxMsgs"`
1787}
1788
1789type SetAppNotificationSettingsArg struct {
1790	ConvID   ConversationID               `codec:"convID" json:"convID"`
1791	Settings ConversationNotificationInfo `codec:"settings" json:"settings"`
1792}
1793
1794type SetGlobalAppNotificationSettingsArg struct {
1795	Settings GlobalAppNotificationSettings `codec:"settings" json:"settings"`
1796}
1797
1798type GetGlobalAppNotificationSettingsArg struct {
1799}
1800
1801type RemoteNotificationSuccessfulArg struct {
1802	AuthToken        gregor1.SessionToken `codec:"authToken" json:"authToken"`
1803	CompanionPushIDs []string             `codec:"companionPushIDs" json:"companionPushIDs"`
1804}
1805
1806type SetConvRetentionArg struct {
1807	ConvID       ConversationID  `codec:"convID" json:"convID"`
1808	Policy       RetentionPolicy `codec:"policy" json:"policy"`
1809	SweepChannel uint64          `codec:"sweepChannel" json:"sweepChannel"`
1810}
1811
1812type SetTeamRetentionArg struct {
1813	TeamID       keybase1.TeamID `codec:"teamID" json:"teamID"`
1814	Policy       RetentionPolicy `codec:"policy" json:"policy"`
1815	SweepChannel uint64          `codec:"sweepChannel" json:"sweepChannel"`
1816}
1817
1818type SetConvMinWriterRoleArg struct {
1819	ConvID ConversationID    `codec:"convID" json:"convID"`
1820	Role   keybase1.TeamRole `codec:"role" json:"role"`
1821}
1822
1823type RetentionSweepConvArg struct {
1824	ConvID ConversationID `codec:"convID" json:"convID"`
1825}
1826
1827type UpgradeKBFSToImpteamArg struct {
1828	TlfID  TLFID           `codec:"tlfID" json:"tlfID"`
1829	TeamID keybase1.TeamID `codec:"teamID" json:"teamID"`
1830}
1831
1832type RegisterSharePostArg struct {
1833	ConvID   ConversationID   `codec:"convID" json:"convID"`
1834	DeviceID gregor1.DeviceID `codec:"deviceID" json:"deviceID"`
1835	OutboxID OutboxID         `codec:"outboxID" json:"outboxID"`
1836}
1837
1838type FailSharePostArg struct {
1839	ConvID   ConversationID   `codec:"convID" json:"convID"`
1840	DeviceID gregor1.DeviceID `codec:"deviceID" json:"deviceID"`
1841	OutboxID OutboxID         `codec:"outboxID" json:"outboxID"`
1842}
1843
1844type BroadcastGregorMessageToConvArg struct {
1845	ConvID ConversationID  `codec:"convID" json:"convID"`
1846	Msg    gregor1.Message `codec:"msg" json:"msg"`
1847}
1848
1849type TeamIDOfConvArg struct {
1850	ConvID ConversationID `codec:"convID" json:"convID"`
1851}
1852
1853type ServerNowArg struct {
1854}
1855
1856type GetExternalAPIKeysArg struct {
1857	Typs []ExternalAPIKeyTyp `codec:"typs" json:"typs"`
1858}
1859
1860type AdvertiseBotCommandsArg struct {
1861	Ads []RemoteBotCommandsAdvertisement `codec:"ads" json:"ads"`
1862}
1863
1864type ClearBotCommandsArg struct {
1865	Filter *RemoteClearBotCommandsFilter `codec:"filter,omitempty" json:"filter,omitempty"`
1866}
1867
1868type GetBotInfoArg struct {
1869	ConvID         ConversationID  `codec:"convID" json:"convID"`
1870	InfoHash       BotInfoHash     `codec:"infoHash" json:"infoHash"`
1871	ClientHashVers BotInfoHashVers `codec:"clientHashVers" json:"clientHashVers"`
1872}
1873
1874type GetDefaultTeamChannelsArg struct {
1875	TeamID keybase1.TeamID `codec:"teamID" json:"teamID"`
1876}
1877
1878type SetDefaultTeamChannelsArg struct {
1879	TeamID keybase1.TeamID  `codec:"teamID" json:"teamID"`
1880	Convs  []ConversationID `codec:"convs" json:"convs"`
1881}
1882
1883type GetRecentJoinsArg struct {
1884	ConvID ConversationID `codec:"convID" json:"convID"`
1885}
1886
1887type RefreshParticipantsRemoteArg struct {
1888	ConvID ConversationID `codec:"convID" json:"convID"`
1889	Hash   string         `codec:"hash" json:"hash"`
1890}
1891
1892type GetLastActiveAtArg struct {
1893	TeamID keybase1.TeamID `codec:"teamID" json:"teamID"`
1894	Uid    gregor1.UID     `codec:"uid" json:"uid"`
1895}
1896
1897type GetResetConversationsArg struct {
1898}
1899
1900type RemoteInterface interface {
1901	GetInboxRemote(context.Context, GetInboxRemoteArg) (GetInboxRemoteRes, error)
1902	GetThreadRemote(context.Context, GetThreadRemoteArg) (GetThreadRemoteRes, error)
1903	GetUnreadlineRemote(context.Context, GetUnreadlineRemoteArg) (GetUnreadlineRemoteRes, error)
1904	GetPublicConversations(context.Context, GetPublicConversationsArg) (GetPublicConversationsRes, error)
1905	PostRemote(context.Context, PostRemoteArg) (PostRemoteRes, error)
1906	NewConversationRemote(context.Context, ConversationIDTriple) (NewConversationRemoteRes, error)
1907	NewConversationRemote2(context.Context, NewConversationRemote2Arg) (NewConversationRemoteRes, error)
1908	GetMessagesRemote(context.Context, GetMessagesRemoteArg) (GetMessagesRemoteRes, error)
1909	MarkAsRead(context.Context, MarkAsReadArg) (MarkAsReadRes, error)
1910	SetConversationStatus(context.Context, SetConversationStatusArg) (SetConversationStatusRes, error)
1911	GetUnreadUpdateFull(context.Context, InboxVers) (UnreadUpdateFull, error)
1912	GetS3Params(context.Context, ConversationID) (S3Params, error)
1913	S3Sign(context.Context, S3SignArg) ([]byte, error)
1914	GetInboxVersion(context.Context, gregor1.UID) (InboxVers, error)
1915	SyncInbox(context.Context, InboxVers) (SyncInboxRes, error)
1916	SyncChat(context.Context, SyncChatArg) (SyncChatRes, error)
1917	SyncAll(context.Context, SyncAllArg) (SyncAllResult, error)
1918	TlfFinalize(context.Context, TlfFinalizeArg) error
1919	TlfResolve(context.Context, TlfResolveArg) error
1920	UpdateTypingRemote(context.Context, UpdateTypingRemoteArg) error
1921	JoinConversation(context.Context, ConversationID) (JoinLeaveConversationRemoteRes, error)
1922	LeaveConversation(context.Context, ConversationID) (JoinLeaveConversationRemoteRes, error)
1923	PreviewConversation(context.Context, ConversationID) (JoinLeaveConversationRemoteRes, error)
1924	DeleteConversation(context.Context, ConversationID) (DeleteConversationRemoteRes, error)
1925	RemoveFromConversation(context.Context, RemoveFromConversationArg) (RemoveFromConversationRemoteRes, error)
1926	GetMessageBefore(context.Context, GetMessageBeforeArg) (GetMessageBeforeRes, error)
1927	GetTLFConversations(context.Context, GetTLFConversationsArg) (GetTLFConversationsRes, error)
1928	SetAppNotificationSettings(context.Context, SetAppNotificationSettingsArg) (SetAppNotificationSettingsRes, error)
1929	SetGlobalAppNotificationSettings(context.Context, GlobalAppNotificationSettings) error
1930	GetGlobalAppNotificationSettings(context.Context) (GlobalAppNotificationSettings, error)
1931	RemoteNotificationSuccessful(context.Context, RemoteNotificationSuccessfulArg) error
1932	SetConvRetention(context.Context, SetConvRetentionArg) (SetRetentionRes, error)
1933	SetTeamRetention(context.Context, SetTeamRetentionArg) (SetRetentionRes, error)
1934	SetConvMinWriterRole(context.Context, SetConvMinWriterRoleArg) (SetConvMinWriterRoleRes, error)
1935	RetentionSweepConv(context.Context, ConversationID) (SweepRes, error)
1936	UpgradeKBFSToImpteam(context.Context, UpgradeKBFSToImpteamArg) error
1937	RegisterSharePost(context.Context, RegisterSharePostArg) error
1938	FailSharePost(context.Context, FailSharePostArg) error
1939	BroadcastGregorMessageToConv(context.Context, BroadcastGregorMessageToConvArg) error
1940	TeamIDOfConv(context.Context, ConversationID) (*keybase1.TeamID, error)
1941	ServerNow(context.Context) (ServerNowRes, error)
1942	GetExternalAPIKeys(context.Context, []ExternalAPIKeyTyp) ([]ExternalAPIKey, error)
1943	AdvertiseBotCommands(context.Context, []RemoteBotCommandsAdvertisement) (AdvertiseBotCommandsRes, error)
1944	ClearBotCommands(context.Context, *RemoteClearBotCommandsFilter) (ClearBotCommandsRes, error)
1945	GetBotInfo(context.Context, GetBotInfoArg) (GetBotInfoRes, error)
1946	GetDefaultTeamChannels(context.Context, keybase1.TeamID) (GetDefaultTeamChannelsRes, error)
1947	SetDefaultTeamChannels(context.Context, SetDefaultTeamChannelsArg) (SetDefaultTeamChannelsRes, error)
1948	GetRecentJoins(context.Context, ConversationID) (GetRecentJoinsRes, error)
1949	RefreshParticipantsRemote(context.Context, RefreshParticipantsRemoteArg) (RefreshParticipantsRemoteRes, error)
1950	GetLastActiveAt(context.Context, GetLastActiveAtArg) (GetLastActiveAtRes, error)
1951	GetResetConversations(context.Context) (GetResetConversationsRes, error)
1952}
1953
1954func RemoteProtocol(i RemoteInterface) rpc.Protocol {
1955	return rpc.Protocol{
1956		Name: "chat.1.remote",
1957		Methods: map[string]rpc.ServeHandlerDescription{
1958			"getInboxRemote": {
1959				MakeArg: func() interface{} {
1960					var ret [1]GetInboxRemoteArg
1961					return &ret
1962				},
1963				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
1964					typedArgs, ok := args.(*[1]GetInboxRemoteArg)
1965					if !ok {
1966						err = rpc.NewTypeError((*[1]GetInboxRemoteArg)(nil), args)
1967						return
1968					}
1969					ret, err = i.GetInboxRemote(ctx, typedArgs[0])
1970					return
1971				},
1972			},
1973			"getThreadRemote": {
1974				MakeArg: func() interface{} {
1975					var ret [1]GetThreadRemoteArg
1976					return &ret
1977				},
1978				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
1979					typedArgs, ok := args.(*[1]GetThreadRemoteArg)
1980					if !ok {
1981						err = rpc.NewTypeError((*[1]GetThreadRemoteArg)(nil), args)
1982						return
1983					}
1984					ret, err = i.GetThreadRemote(ctx, typedArgs[0])
1985					return
1986				},
1987			},
1988			"getUnreadlineRemote": {
1989				MakeArg: func() interface{} {
1990					var ret [1]GetUnreadlineRemoteArg
1991					return &ret
1992				},
1993				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
1994					typedArgs, ok := args.(*[1]GetUnreadlineRemoteArg)
1995					if !ok {
1996						err = rpc.NewTypeError((*[1]GetUnreadlineRemoteArg)(nil), args)
1997						return
1998					}
1999					ret, err = i.GetUnreadlineRemote(ctx, typedArgs[0])
2000					return
2001				},
2002			},
2003			"getPublicConversations": {
2004				MakeArg: func() interface{} {
2005					var ret [1]GetPublicConversationsArg
2006					return &ret
2007				},
2008				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2009					typedArgs, ok := args.(*[1]GetPublicConversationsArg)
2010					if !ok {
2011						err = rpc.NewTypeError((*[1]GetPublicConversationsArg)(nil), args)
2012						return
2013					}
2014					ret, err = i.GetPublicConversations(ctx, typedArgs[0])
2015					return
2016				},
2017			},
2018			"postRemote": {
2019				MakeArg: func() interface{} {
2020					var ret [1]PostRemoteArg
2021					return &ret
2022				},
2023				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2024					typedArgs, ok := args.(*[1]PostRemoteArg)
2025					if !ok {
2026						err = rpc.NewTypeError((*[1]PostRemoteArg)(nil), args)
2027						return
2028					}
2029					ret, err = i.PostRemote(ctx, typedArgs[0])
2030					return
2031				},
2032			},
2033			"newConversationRemote": {
2034				MakeArg: func() interface{} {
2035					var ret [1]NewConversationRemoteArg
2036					return &ret
2037				},
2038				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2039					typedArgs, ok := args.(*[1]NewConversationRemoteArg)
2040					if !ok {
2041						err = rpc.NewTypeError((*[1]NewConversationRemoteArg)(nil), args)
2042						return
2043					}
2044					ret, err = i.NewConversationRemote(ctx, typedArgs[0].IdTriple)
2045					return
2046				},
2047			},
2048			"newConversationRemote2": {
2049				MakeArg: func() interface{} {
2050					var ret [1]NewConversationRemote2Arg
2051					return &ret
2052				},
2053				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2054					typedArgs, ok := args.(*[1]NewConversationRemote2Arg)
2055					if !ok {
2056						err = rpc.NewTypeError((*[1]NewConversationRemote2Arg)(nil), args)
2057						return
2058					}
2059					ret, err = i.NewConversationRemote2(ctx, typedArgs[0])
2060					return
2061				},
2062			},
2063			"getMessagesRemote": {
2064				MakeArg: func() interface{} {
2065					var ret [1]GetMessagesRemoteArg
2066					return &ret
2067				},
2068				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2069					typedArgs, ok := args.(*[1]GetMessagesRemoteArg)
2070					if !ok {
2071						err = rpc.NewTypeError((*[1]GetMessagesRemoteArg)(nil), args)
2072						return
2073					}
2074					ret, err = i.GetMessagesRemote(ctx, typedArgs[0])
2075					return
2076				},
2077			},
2078			"markAsRead": {
2079				MakeArg: func() interface{} {
2080					var ret [1]MarkAsReadArg
2081					return &ret
2082				},
2083				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2084					typedArgs, ok := args.(*[1]MarkAsReadArg)
2085					if !ok {
2086						err = rpc.NewTypeError((*[1]MarkAsReadArg)(nil), args)
2087						return
2088					}
2089					ret, err = i.MarkAsRead(ctx, typedArgs[0])
2090					return
2091				},
2092			},
2093			"SetConversationStatus": {
2094				MakeArg: func() interface{} {
2095					var ret [1]SetConversationStatusArg
2096					return &ret
2097				},
2098				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2099					typedArgs, ok := args.(*[1]SetConversationStatusArg)
2100					if !ok {
2101						err = rpc.NewTypeError((*[1]SetConversationStatusArg)(nil), args)
2102						return
2103					}
2104					ret, err = i.SetConversationStatus(ctx, typedArgs[0])
2105					return
2106				},
2107			},
2108			"GetUnreadUpdateFull": {
2109				MakeArg: func() interface{} {
2110					var ret [1]GetUnreadUpdateFullArg
2111					return &ret
2112				},
2113				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2114					typedArgs, ok := args.(*[1]GetUnreadUpdateFullArg)
2115					if !ok {
2116						err = rpc.NewTypeError((*[1]GetUnreadUpdateFullArg)(nil), args)
2117						return
2118					}
2119					ret, err = i.GetUnreadUpdateFull(ctx, typedArgs[0].InboxVers)
2120					return
2121				},
2122			},
2123			"getS3Params": {
2124				MakeArg: func() interface{} {
2125					var ret [1]GetS3ParamsArg
2126					return &ret
2127				},
2128				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2129					typedArgs, ok := args.(*[1]GetS3ParamsArg)
2130					if !ok {
2131						err = rpc.NewTypeError((*[1]GetS3ParamsArg)(nil), args)
2132						return
2133					}
2134					ret, err = i.GetS3Params(ctx, typedArgs[0].ConversationID)
2135					return
2136				},
2137			},
2138			"s3Sign": {
2139				MakeArg: func() interface{} {
2140					var ret [1]S3SignArg
2141					return &ret
2142				},
2143				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2144					typedArgs, ok := args.(*[1]S3SignArg)
2145					if !ok {
2146						err = rpc.NewTypeError((*[1]S3SignArg)(nil), args)
2147						return
2148					}
2149					ret, err = i.S3Sign(ctx, typedArgs[0])
2150					return
2151				},
2152			},
2153			"getInboxVersion": {
2154				MakeArg: func() interface{} {
2155					var ret [1]GetInboxVersionArg
2156					return &ret
2157				},
2158				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2159					typedArgs, ok := args.(*[1]GetInboxVersionArg)
2160					if !ok {
2161						err = rpc.NewTypeError((*[1]GetInboxVersionArg)(nil), args)
2162						return
2163					}
2164					ret, err = i.GetInboxVersion(ctx, typedArgs[0].Uid)
2165					return
2166				},
2167			},
2168			"syncInbox": {
2169				MakeArg: func() interface{} {
2170					var ret [1]SyncInboxArg
2171					return &ret
2172				},
2173				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2174					typedArgs, ok := args.(*[1]SyncInboxArg)
2175					if !ok {
2176						err = rpc.NewTypeError((*[1]SyncInboxArg)(nil), args)
2177						return
2178					}
2179					ret, err = i.SyncInbox(ctx, typedArgs[0].Vers)
2180					return
2181				},
2182			},
2183			"syncChat": {
2184				MakeArg: func() interface{} {
2185					var ret [1]SyncChatArg
2186					return &ret
2187				},
2188				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2189					typedArgs, ok := args.(*[1]SyncChatArg)
2190					if !ok {
2191						err = rpc.NewTypeError((*[1]SyncChatArg)(nil), args)
2192						return
2193					}
2194					ret, err = i.SyncChat(ctx, typedArgs[0])
2195					return
2196				},
2197			},
2198			"syncAll": {
2199				MakeArg: func() interface{} {
2200					var ret [1]SyncAllArg
2201					return &ret
2202				},
2203				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2204					typedArgs, ok := args.(*[1]SyncAllArg)
2205					if !ok {
2206						err = rpc.NewTypeError((*[1]SyncAllArg)(nil), args)
2207						return
2208					}
2209					ret, err = i.SyncAll(ctx, typedArgs[0])
2210					return
2211				},
2212			},
2213			"tlfFinalize": {
2214				MakeArg: func() interface{} {
2215					var ret [1]TlfFinalizeArg
2216					return &ret
2217				},
2218				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2219					typedArgs, ok := args.(*[1]TlfFinalizeArg)
2220					if !ok {
2221						err = rpc.NewTypeError((*[1]TlfFinalizeArg)(nil), args)
2222						return
2223					}
2224					err = i.TlfFinalize(ctx, typedArgs[0])
2225					return
2226				},
2227			},
2228			"tlfResolve": {
2229				MakeArg: func() interface{} {
2230					var ret [1]TlfResolveArg
2231					return &ret
2232				},
2233				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2234					typedArgs, ok := args.(*[1]TlfResolveArg)
2235					if !ok {
2236						err = rpc.NewTypeError((*[1]TlfResolveArg)(nil), args)
2237						return
2238					}
2239					err = i.TlfResolve(ctx, typedArgs[0])
2240					return
2241				},
2242			},
2243			"updateTypingRemote": {
2244				MakeArg: func() interface{} {
2245					var ret [1]UpdateTypingRemoteArg
2246					return &ret
2247				},
2248				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2249					typedArgs, ok := args.(*[1]UpdateTypingRemoteArg)
2250					if !ok {
2251						err = rpc.NewTypeError((*[1]UpdateTypingRemoteArg)(nil), args)
2252						return
2253					}
2254					err = i.UpdateTypingRemote(ctx, typedArgs[0])
2255					return
2256				},
2257			},
2258			"joinConversation": {
2259				MakeArg: func() interface{} {
2260					var ret [1]JoinConversationArg
2261					return &ret
2262				},
2263				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2264					typedArgs, ok := args.(*[1]JoinConversationArg)
2265					if !ok {
2266						err = rpc.NewTypeError((*[1]JoinConversationArg)(nil), args)
2267						return
2268					}
2269					ret, err = i.JoinConversation(ctx, typedArgs[0].ConvID)
2270					return
2271				},
2272			},
2273			"leaveConversation": {
2274				MakeArg: func() interface{} {
2275					var ret [1]LeaveConversationArg
2276					return &ret
2277				},
2278				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2279					typedArgs, ok := args.(*[1]LeaveConversationArg)
2280					if !ok {
2281						err = rpc.NewTypeError((*[1]LeaveConversationArg)(nil), args)
2282						return
2283					}
2284					ret, err = i.LeaveConversation(ctx, typedArgs[0].ConvID)
2285					return
2286				},
2287			},
2288			"previewConversation": {
2289				MakeArg: func() interface{} {
2290					var ret [1]PreviewConversationArg
2291					return &ret
2292				},
2293				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2294					typedArgs, ok := args.(*[1]PreviewConversationArg)
2295					if !ok {
2296						err = rpc.NewTypeError((*[1]PreviewConversationArg)(nil), args)
2297						return
2298					}
2299					ret, err = i.PreviewConversation(ctx, typedArgs[0].ConvID)
2300					return
2301				},
2302			},
2303			"deleteConversation": {
2304				MakeArg: func() interface{} {
2305					var ret [1]DeleteConversationArg
2306					return &ret
2307				},
2308				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2309					typedArgs, ok := args.(*[1]DeleteConversationArg)
2310					if !ok {
2311						err = rpc.NewTypeError((*[1]DeleteConversationArg)(nil), args)
2312						return
2313					}
2314					ret, err = i.DeleteConversation(ctx, typedArgs[0].ConvID)
2315					return
2316				},
2317			},
2318			"removeFromConversation": {
2319				MakeArg: func() interface{} {
2320					var ret [1]RemoveFromConversationArg
2321					return &ret
2322				},
2323				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2324					typedArgs, ok := args.(*[1]RemoveFromConversationArg)
2325					if !ok {
2326						err = rpc.NewTypeError((*[1]RemoveFromConversationArg)(nil), args)
2327						return
2328					}
2329					ret, err = i.RemoveFromConversation(ctx, typedArgs[0])
2330					return
2331				},
2332			},
2333			"getMessageBefore": {
2334				MakeArg: func() interface{} {
2335					var ret [1]GetMessageBeforeArg
2336					return &ret
2337				},
2338				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2339					typedArgs, ok := args.(*[1]GetMessageBeforeArg)
2340					if !ok {
2341						err = rpc.NewTypeError((*[1]GetMessageBeforeArg)(nil), args)
2342						return
2343					}
2344					ret, err = i.GetMessageBefore(ctx, typedArgs[0])
2345					return
2346				},
2347			},
2348			"getTLFConversations": {
2349				MakeArg: func() interface{} {
2350					var ret [1]GetTLFConversationsArg
2351					return &ret
2352				},
2353				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2354					typedArgs, ok := args.(*[1]GetTLFConversationsArg)
2355					if !ok {
2356						err = rpc.NewTypeError((*[1]GetTLFConversationsArg)(nil), args)
2357						return
2358					}
2359					ret, err = i.GetTLFConversations(ctx, typedArgs[0])
2360					return
2361				},
2362			},
2363			"setAppNotificationSettings": {
2364				MakeArg: func() interface{} {
2365					var ret [1]SetAppNotificationSettingsArg
2366					return &ret
2367				},
2368				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2369					typedArgs, ok := args.(*[1]SetAppNotificationSettingsArg)
2370					if !ok {
2371						err = rpc.NewTypeError((*[1]SetAppNotificationSettingsArg)(nil), args)
2372						return
2373					}
2374					ret, err = i.SetAppNotificationSettings(ctx, typedArgs[0])
2375					return
2376				},
2377			},
2378			"setGlobalAppNotificationSettings": {
2379				MakeArg: func() interface{} {
2380					var ret [1]SetGlobalAppNotificationSettingsArg
2381					return &ret
2382				},
2383				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2384					typedArgs, ok := args.(*[1]SetGlobalAppNotificationSettingsArg)
2385					if !ok {
2386						err = rpc.NewTypeError((*[1]SetGlobalAppNotificationSettingsArg)(nil), args)
2387						return
2388					}
2389					err = i.SetGlobalAppNotificationSettings(ctx, typedArgs[0].Settings)
2390					return
2391				},
2392			},
2393			"getGlobalAppNotificationSettings": {
2394				MakeArg: func() interface{} {
2395					var ret [1]GetGlobalAppNotificationSettingsArg
2396					return &ret
2397				},
2398				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2399					ret, err = i.GetGlobalAppNotificationSettings(ctx)
2400					return
2401				},
2402			},
2403			"remoteNotificationSuccessful": {
2404				MakeArg: func() interface{} {
2405					var ret [1]RemoteNotificationSuccessfulArg
2406					return &ret
2407				},
2408				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2409					typedArgs, ok := args.(*[1]RemoteNotificationSuccessfulArg)
2410					if !ok {
2411						err = rpc.NewTypeError((*[1]RemoteNotificationSuccessfulArg)(nil), args)
2412						return
2413					}
2414					err = i.RemoteNotificationSuccessful(ctx, typedArgs[0])
2415					return
2416				},
2417			},
2418			"setConvRetention": {
2419				MakeArg: func() interface{} {
2420					var ret [1]SetConvRetentionArg
2421					return &ret
2422				},
2423				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2424					typedArgs, ok := args.(*[1]SetConvRetentionArg)
2425					if !ok {
2426						err = rpc.NewTypeError((*[1]SetConvRetentionArg)(nil), args)
2427						return
2428					}
2429					ret, err = i.SetConvRetention(ctx, typedArgs[0])
2430					return
2431				},
2432			},
2433			"setTeamRetention": {
2434				MakeArg: func() interface{} {
2435					var ret [1]SetTeamRetentionArg
2436					return &ret
2437				},
2438				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2439					typedArgs, ok := args.(*[1]SetTeamRetentionArg)
2440					if !ok {
2441						err = rpc.NewTypeError((*[1]SetTeamRetentionArg)(nil), args)
2442						return
2443					}
2444					ret, err = i.SetTeamRetention(ctx, typedArgs[0])
2445					return
2446				},
2447			},
2448			"setConvMinWriterRole": {
2449				MakeArg: func() interface{} {
2450					var ret [1]SetConvMinWriterRoleArg
2451					return &ret
2452				},
2453				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2454					typedArgs, ok := args.(*[1]SetConvMinWriterRoleArg)
2455					if !ok {
2456						err = rpc.NewTypeError((*[1]SetConvMinWriterRoleArg)(nil), args)
2457						return
2458					}
2459					ret, err = i.SetConvMinWriterRole(ctx, typedArgs[0])
2460					return
2461				},
2462			},
2463			"retentionSweepConv": {
2464				MakeArg: func() interface{} {
2465					var ret [1]RetentionSweepConvArg
2466					return &ret
2467				},
2468				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2469					typedArgs, ok := args.(*[1]RetentionSweepConvArg)
2470					if !ok {
2471						err = rpc.NewTypeError((*[1]RetentionSweepConvArg)(nil), args)
2472						return
2473					}
2474					ret, err = i.RetentionSweepConv(ctx, typedArgs[0].ConvID)
2475					return
2476				},
2477			},
2478			"upgradeKBFSToImpteam": {
2479				MakeArg: func() interface{} {
2480					var ret [1]UpgradeKBFSToImpteamArg
2481					return &ret
2482				},
2483				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2484					typedArgs, ok := args.(*[1]UpgradeKBFSToImpteamArg)
2485					if !ok {
2486						err = rpc.NewTypeError((*[1]UpgradeKBFSToImpteamArg)(nil), args)
2487						return
2488					}
2489					err = i.UpgradeKBFSToImpteam(ctx, typedArgs[0])
2490					return
2491				},
2492			},
2493			"registerSharePost": {
2494				MakeArg: func() interface{} {
2495					var ret [1]RegisterSharePostArg
2496					return &ret
2497				},
2498				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2499					typedArgs, ok := args.(*[1]RegisterSharePostArg)
2500					if !ok {
2501						err = rpc.NewTypeError((*[1]RegisterSharePostArg)(nil), args)
2502						return
2503					}
2504					err = i.RegisterSharePost(ctx, typedArgs[0])
2505					return
2506				},
2507			},
2508			"failSharePost": {
2509				MakeArg: func() interface{} {
2510					var ret [1]FailSharePostArg
2511					return &ret
2512				},
2513				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2514					typedArgs, ok := args.(*[1]FailSharePostArg)
2515					if !ok {
2516						err = rpc.NewTypeError((*[1]FailSharePostArg)(nil), args)
2517						return
2518					}
2519					err = i.FailSharePost(ctx, typedArgs[0])
2520					return
2521				},
2522			},
2523			"broadcastGregorMessageToConv": {
2524				MakeArg: func() interface{} {
2525					var ret [1]BroadcastGregorMessageToConvArg
2526					return &ret
2527				},
2528				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2529					typedArgs, ok := args.(*[1]BroadcastGregorMessageToConvArg)
2530					if !ok {
2531						err = rpc.NewTypeError((*[1]BroadcastGregorMessageToConvArg)(nil), args)
2532						return
2533					}
2534					err = i.BroadcastGregorMessageToConv(ctx, typedArgs[0])
2535					return
2536				},
2537			},
2538			"teamIDOfConv": {
2539				MakeArg: func() interface{} {
2540					var ret [1]TeamIDOfConvArg
2541					return &ret
2542				},
2543				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2544					typedArgs, ok := args.(*[1]TeamIDOfConvArg)
2545					if !ok {
2546						err = rpc.NewTypeError((*[1]TeamIDOfConvArg)(nil), args)
2547						return
2548					}
2549					ret, err = i.TeamIDOfConv(ctx, typedArgs[0].ConvID)
2550					return
2551				},
2552			},
2553			"serverNow": {
2554				MakeArg: func() interface{} {
2555					var ret [1]ServerNowArg
2556					return &ret
2557				},
2558				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2559					ret, err = i.ServerNow(ctx)
2560					return
2561				},
2562			},
2563			"getExternalAPIKeys": {
2564				MakeArg: func() interface{} {
2565					var ret [1]GetExternalAPIKeysArg
2566					return &ret
2567				},
2568				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2569					typedArgs, ok := args.(*[1]GetExternalAPIKeysArg)
2570					if !ok {
2571						err = rpc.NewTypeError((*[1]GetExternalAPIKeysArg)(nil), args)
2572						return
2573					}
2574					ret, err = i.GetExternalAPIKeys(ctx, typedArgs[0].Typs)
2575					return
2576				},
2577			},
2578			"advertiseBotCommands": {
2579				MakeArg: func() interface{} {
2580					var ret [1]AdvertiseBotCommandsArg
2581					return &ret
2582				},
2583				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2584					typedArgs, ok := args.(*[1]AdvertiseBotCommandsArg)
2585					if !ok {
2586						err = rpc.NewTypeError((*[1]AdvertiseBotCommandsArg)(nil), args)
2587						return
2588					}
2589					ret, err = i.AdvertiseBotCommands(ctx, typedArgs[0].Ads)
2590					return
2591				},
2592			},
2593			"clearBotCommands": {
2594				MakeArg: func() interface{} {
2595					var ret [1]ClearBotCommandsArg
2596					return &ret
2597				},
2598				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2599					typedArgs, ok := args.(*[1]ClearBotCommandsArg)
2600					if !ok {
2601						err = rpc.NewTypeError((*[1]ClearBotCommandsArg)(nil), args)
2602						return
2603					}
2604					ret, err = i.ClearBotCommands(ctx, typedArgs[0].Filter)
2605					return
2606				},
2607			},
2608			"getBotInfo": {
2609				MakeArg: func() interface{} {
2610					var ret [1]GetBotInfoArg
2611					return &ret
2612				},
2613				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2614					typedArgs, ok := args.(*[1]GetBotInfoArg)
2615					if !ok {
2616						err = rpc.NewTypeError((*[1]GetBotInfoArg)(nil), args)
2617						return
2618					}
2619					ret, err = i.GetBotInfo(ctx, typedArgs[0])
2620					return
2621				},
2622			},
2623			"getDefaultTeamChannels": {
2624				MakeArg: func() interface{} {
2625					var ret [1]GetDefaultTeamChannelsArg
2626					return &ret
2627				},
2628				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2629					typedArgs, ok := args.(*[1]GetDefaultTeamChannelsArg)
2630					if !ok {
2631						err = rpc.NewTypeError((*[1]GetDefaultTeamChannelsArg)(nil), args)
2632						return
2633					}
2634					ret, err = i.GetDefaultTeamChannels(ctx, typedArgs[0].TeamID)
2635					return
2636				},
2637			},
2638			"setDefaultTeamChannels": {
2639				MakeArg: func() interface{} {
2640					var ret [1]SetDefaultTeamChannelsArg
2641					return &ret
2642				},
2643				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2644					typedArgs, ok := args.(*[1]SetDefaultTeamChannelsArg)
2645					if !ok {
2646						err = rpc.NewTypeError((*[1]SetDefaultTeamChannelsArg)(nil), args)
2647						return
2648					}
2649					ret, err = i.SetDefaultTeamChannels(ctx, typedArgs[0])
2650					return
2651				},
2652			},
2653			"getRecentJoins": {
2654				MakeArg: func() interface{} {
2655					var ret [1]GetRecentJoinsArg
2656					return &ret
2657				},
2658				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2659					typedArgs, ok := args.(*[1]GetRecentJoinsArg)
2660					if !ok {
2661						err = rpc.NewTypeError((*[1]GetRecentJoinsArg)(nil), args)
2662						return
2663					}
2664					ret, err = i.GetRecentJoins(ctx, typedArgs[0].ConvID)
2665					return
2666				},
2667			},
2668			"refreshParticipantsRemote": {
2669				MakeArg: func() interface{} {
2670					var ret [1]RefreshParticipantsRemoteArg
2671					return &ret
2672				},
2673				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2674					typedArgs, ok := args.(*[1]RefreshParticipantsRemoteArg)
2675					if !ok {
2676						err = rpc.NewTypeError((*[1]RefreshParticipantsRemoteArg)(nil), args)
2677						return
2678					}
2679					ret, err = i.RefreshParticipantsRemote(ctx, typedArgs[0])
2680					return
2681				},
2682			},
2683			"getLastActiveAt": {
2684				MakeArg: func() interface{} {
2685					var ret [1]GetLastActiveAtArg
2686					return &ret
2687				},
2688				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2689					typedArgs, ok := args.(*[1]GetLastActiveAtArg)
2690					if !ok {
2691						err = rpc.NewTypeError((*[1]GetLastActiveAtArg)(nil), args)
2692						return
2693					}
2694					ret, err = i.GetLastActiveAt(ctx, typedArgs[0])
2695					return
2696				},
2697			},
2698			"getResetConversations": {
2699				MakeArg: func() interface{} {
2700					var ret [1]GetResetConversationsArg
2701					return &ret
2702				},
2703				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
2704					ret, err = i.GetResetConversations(ctx)
2705					return
2706				},
2707			},
2708		},
2709	}
2710}
2711
2712type RemoteClient struct {
2713	Cli rpc.GenericClient
2714}
2715
2716func (c RemoteClient) GetInboxRemote(ctx context.Context, __arg GetInboxRemoteArg) (res GetInboxRemoteRes, err error) {
2717	err = c.Cli.CallCompressed(ctx, "chat.1.remote.getInboxRemote", []interface{}{__arg}, &res, rpc.CompressionGzip, 1200000*time.Millisecond)
2718	return
2719}
2720
2721func (c RemoteClient) GetThreadRemote(ctx context.Context, __arg GetThreadRemoteArg) (res GetThreadRemoteRes, err error) {
2722	err = c.Cli.CallCompressed(ctx, "chat.1.remote.getThreadRemote", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2723	return
2724}
2725
2726func (c RemoteClient) GetUnreadlineRemote(ctx context.Context, __arg GetUnreadlineRemoteArg) (res GetUnreadlineRemoteRes, err error) {
2727	err = c.Cli.CallCompressed(ctx, "chat.1.remote.getUnreadlineRemote", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2728	return
2729}
2730
2731func (c RemoteClient) GetPublicConversations(ctx context.Context, __arg GetPublicConversationsArg) (res GetPublicConversationsRes, err error) {
2732	err = c.Cli.CallCompressed(ctx, "chat.1.remote.getPublicConversations", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2733	return
2734}
2735
2736func (c RemoteClient) PostRemote(ctx context.Context, __arg PostRemoteArg) (res PostRemoteRes, err error) {
2737	err = c.Cli.CallCompressed(ctx, "chat.1.remote.postRemote", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2738	return
2739}
2740
2741func (c RemoteClient) NewConversationRemote(ctx context.Context, idTriple ConversationIDTriple) (res NewConversationRemoteRes, err error) {
2742	__arg := NewConversationRemoteArg{IdTriple: idTriple}
2743	err = c.Cli.CallCompressed(ctx, "chat.1.remote.newConversationRemote", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2744	return
2745}
2746
2747func (c RemoteClient) NewConversationRemote2(ctx context.Context, __arg NewConversationRemote2Arg) (res NewConversationRemoteRes, err error) {
2748	err = c.Cli.CallCompressed(ctx, "chat.1.remote.newConversationRemote2", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2749	return
2750}
2751
2752func (c RemoteClient) GetMessagesRemote(ctx context.Context, __arg GetMessagesRemoteArg) (res GetMessagesRemoteRes, err error) {
2753	err = c.Cli.CallCompressed(ctx, "chat.1.remote.getMessagesRemote", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2754	return
2755}
2756
2757func (c RemoteClient) MarkAsRead(ctx context.Context, __arg MarkAsReadArg) (res MarkAsReadRes, err error) {
2758	err = c.Cli.CallCompressed(ctx, "chat.1.remote.markAsRead", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2759	return
2760}
2761
2762func (c RemoteClient) SetConversationStatus(ctx context.Context, __arg SetConversationStatusArg) (res SetConversationStatusRes, err error) {
2763	err = c.Cli.CallCompressed(ctx, "chat.1.remote.SetConversationStatus", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2764	return
2765}
2766
2767func (c RemoteClient) GetUnreadUpdateFull(ctx context.Context, inboxVers InboxVers) (res UnreadUpdateFull, err error) {
2768	__arg := GetUnreadUpdateFullArg{InboxVers: inboxVers}
2769	err = c.Cli.CallCompressed(ctx, "chat.1.remote.GetUnreadUpdateFull", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2770	return
2771}
2772
2773func (c RemoteClient) GetS3Params(ctx context.Context, conversationID ConversationID) (res S3Params, err error) {
2774	__arg := GetS3ParamsArg{ConversationID: conversationID}
2775	err = c.Cli.CallCompressed(ctx, "chat.1.remote.getS3Params", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2776	return
2777}
2778
2779func (c RemoteClient) S3Sign(ctx context.Context, __arg S3SignArg) (res []byte, err error) {
2780	err = c.Cli.CallCompressed(ctx, "chat.1.remote.s3Sign", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2781	return
2782}
2783
2784func (c RemoteClient) GetInboxVersion(ctx context.Context, uid gregor1.UID) (res InboxVers, err error) {
2785	__arg := GetInboxVersionArg{Uid: uid}
2786	err = c.Cli.CallCompressed(ctx, "chat.1.remote.getInboxVersion", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2787	return
2788}
2789
2790func (c RemoteClient) SyncInbox(ctx context.Context, vers InboxVers) (res SyncInboxRes, err error) {
2791	__arg := SyncInboxArg{Vers: vers}
2792	err = c.Cli.CallCompressed(ctx, "chat.1.remote.syncInbox", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2793	return
2794}
2795
2796func (c RemoteClient) SyncChat(ctx context.Context, __arg SyncChatArg) (res SyncChatRes, err error) {
2797	err = c.Cli.CallCompressed(ctx, "chat.1.remote.syncChat", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2798	return
2799}
2800
2801func (c RemoteClient) SyncAll(ctx context.Context, __arg SyncAllArg) (res SyncAllResult, err error) {
2802	err = c.Cli.CallCompressed(ctx, "chat.1.remote.syncAll", []interface{}{__arg}, &res, rpc.CompressionMsgpackzip, 0*time.Millisecond)
2803	return
2804}
2805
2806func (c RemoteClient) TlfFinalize(ctx context.Context, __arg TlfFinalizeArg) (err error) {
2807	err = c.Cli.CallCompressed(ctx, "chat.1.remote.tlfFinalize", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
2808	return
2809}
2810
2811func (c RemoteClient) TlfResolve(ctx context.Context, __arg TlfResolveArg) (err error) {
2812	err = c.Cli.CallCompressed(ctx, "chat.1.remote.tlfResolve", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
2813	return
2814}
2815
2816func (c RemoteClient) UpdateTypingRemote(ctx context.Context, __arg UpdateTypingRemoteArg) (err error) {
2817	err = c.Cli.CallCompressed(ctx, "chat.1.remote.updateTypingRemote", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
2818	return
2819}
2820
2821func (c RemoteClient) JoinConversation(ctx context.Context, convID ConversationID) (res JoinLeaveConversationRemoteRes, err error) {
2822	__arg := JoinConversationArg{ConvID: convID}
2823	err = c.Cli.CallCompressed(ctx, "chat.1.remote.joinConversation", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2824	return
2825}
2826
2827func (c RemoteClient) LeaveConversation(ctx context.Context, convID ConversationID) (res JoinLeaveConversationRemoteRes, err error) {
2828	__arg := LeaveConversationArg{ConvID: convID}
2829	err = c.Cli.CallCompressed(ctx, "chat.1.remote.leaveConversation", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2830	return
2831}
2832
2833func (c RemoteClient) PreviewConversation(ctx context.Context, convID ConversationID) (res JoinLeaveConversationRemoteRes, err error) {
2834	__arg := PreviewConversationArg{ConvID: convID}
2835	err = c.Cli.CallCompressed(ctx, "chat.1.remote.previewConversation", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2836	return
2837}
2838
2839func (c RemoteClient) DeleteConversation(ctx context.Context, convID ConversationID) (res DeleteConversationRemoteRes, err error) {
2840	__arg := DeleteConversationArg{ConvID: convID}
2841	err = c.Cli.CallCompressed(ctx, "chat.1.remote.deleteConversation", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2842	return
2843}
2844
2845func (c RemoteClient) RemoveFromConversation(ctx context.Context, __arg RemoveFromConversationArg) (res RemoveFromConversationRemoteRes, err error) {
2846	err = c.Cli.CallCompressed(ctx, "chat.1.remote.removeFromConversation", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2847	return
2848}
2849
2850func (c RemoteClient) GetMessageBefore(ctx context.Context, __arg GetMessageBeforeArg) (res GetMessageBeforeRes, err error) {
2851	err = c.Cli.CallCompressed(ctx, "chat.1.remote.getMessageBefore", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2852	return
2853}
2854
2855func (c RemoteClient) GetTLFConversations(ctx context.Context, __arg GetTLFConversationsArg) (res GetTLFConversationsRes, err error) {
2856	err = c.Cli.CallCompressed(ctx, "chat.1.remote.getTLFConversations", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2857	return
2858}
2859
2860func (c RemoteClient) SetAppNotificationSettings(ctx context.Context, __arg SetAppNotificationSettingsArg) (res SetAppNotificationSettingsRes, err error) {
2861	err = c.Cli.CallCompressed(ctx, "chat.1.remote.setAppNotificationSettings", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2862	return
2863}
2864
2865func (c RemoteClient) SetGlobalAppNotificationSettings(ctx context.Context, settings GlobalAppNotificationSettings) (err error) {
2866	__arg := SetGlobalAppNotificationSettingsArg{Settings: settings}
2867	err = c.Cli.CallCompressed(ctx, "chat.1.remote.setGlobalAppNotificationSettings", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
2868	return
2869}
2870
2871func (c RemoteClient) GetGlobalAppNotificationSettings(ctx context.Context) (res GlobalAppNotificationSettings, err error) {
2872	err = c.Cli.CallCompressed(ctx, "chat.1.remote.getGlobalAppNotificationSettings", []interface{}{GetGlobalAppNotificationSettingsArg{}}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2873	return
2874}
2875
2876func (c RemoteClient) RemoteNotificationSuccessful(ctx context.Context, __arg RemoteNotificationSuccessfulArg) (err error) {
2877	err = c.Cli.Call(ctx, "chat.1.remote.remoteNotificationSuccessful", []interface{}{__arg}, nil, 0*time.Millisecond)
2878	return
2879}
2880
2881func (c RemoteClient) SetConvRetention(ctx context.Context, __arg SetConvRetentionArg) (res SetRetentionRes, err error) {
2882	err = c.Cli.CallCompressed(ctx, "chat.1.remote.setConvRetention", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2883	return
2884}
2885
2886func (c RemoteClient) SetTeamRetention(ctx context.Context, __arg SetTeamRetentionArg) (res SetRetentionRes, err error) {
2887	err = c.Cli.CallCompressed(ctx, "chat.1.remote.setTeamRetention", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2888	return
2889}
2890
2891func (c RemoteClient) SetConvMinWriterRole(ctx context.Context, __arg SetConvMinWriterRoleArg) (res SetConvMinWriterRoleRes, err error) {
2892	err = c.Cli.CallCompressed(ctx, "chat.1.remote.setConvMinWriterRole", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2893	return
2894}
2895
2896func (c RemoteClient) RetentionSweepConv(ctx context.Context, convID ConversationID) (res SweepRes, err error) {
2897	__arg := RetentionSweepConvArg{ConvID: convID}
2898	err = c.Cli.CallCompressed(ctx, "chat.1.remote.retentionSweepConv", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2899	return
2900}
2901
2902func (c RemoteClient) UpgradeKBFSToImpteam(ctx context.Context, __arg UpgradeKBFSToImpteamArg) (err error) {
2903	err = c.Cli.CallCompressed(ctx, "chat.1.remote.upgradeKBFSToImpteam", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
2904	return
2905}
2906
2907func (c RemoteClient) RegisterSharePost(ctx context.Context, __arg RegisterSharePostArg) (err error) {
2908	err = c.Cli.CallCompressed(ctx, "chat.1.remote.registerSharePost", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
2909	return
2910}
2911
2912func (c RemoteClient) FailSharePost(ctx context.Context, __arg FailSharePostArg) (err error) {
2913	err = c.Cli.CallCompressed(ctx, "chat.1.remote.failSharePost", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
2914	return
2915}
2916
2917func (c RemoteClient) BroadcastGregorMessageToConv(ctx context.Context, __arg BroadcastGregorMessageToConvArg) (err error) {
2918	err = c.Cli.CallCompressed(ctx, "chat.1.remote.broadcastGregorMessageToConv", []interface{}{__arg}, nil, rpc.CompressionGzip, 0*time.Millisecond)
2919	return
2920}
2921
2922func (c RemoteClient) TeamIDOfConv(ctx context.Context, convID ConversationID) (res *keybase1.TeamID, err error) {
2923	__arg := TeamIDOfConvArg{ConvID: convID}
2924	err = c.Cli.CallCompressed(ctx, "chat.1.remote.teamIDOfConv", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2925	return
2926}
2927
2928func (c RemoteClient) ServerNow(ctx context.Context) (res ServerNowRes, err error) {
2929	err = c.Cli.CallCompressed(ctx, "chat.1.remote.serverNow", []interface{}{ServerNowArg{}}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2930	return
2931}
2932
2933func (c RemoteClient) GetExternalAPIKeys(ctx context.Context, typs []ExternalAPIKeyTyp) (res []ExternalAPIKey, err error) {
2934	__arg := GetExternalAPIKeysArg{Typs: typs}
2935	err = c.Cli.CallCompressed(ctx, "chat.1.remote.getExternalAPIKeys", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2936	return
2937}
2938
2939func (c RemoteClient) AdvertiseBotCommands(ctx context.Context, ads []RemoteBotCommandsAdvertisement) (res AdvertiseBotCommandsRes, err error) {
2940	__arg := AdvertiseBotCommandsArg{Ads: ads}
2941	err = c.Cli.CallCompressed(ctx, "chat.1.remote.advertiseBotCommands", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2942	return
2943}
2944
2945func (c RemoteClient) ClearBotCommands(ctx context.Context, filter *RemoteClearBotCommandsFilter) (res ClearBotCommandsRes, err error) {
2946	__arg := ClearBotCommandsArg{Filter: filter}
2947	err = c.Cli.CallCompressed(ctx, "chat.1.remote.clearBotCommands", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2948	return
2949}
2950
2951func (c RemoteClient) GetBotInfo(ctx context.Context, __arg GetBotInfoArg) (res GetBotInfoRes, err error) {
2952	err = c.Cli.CallCompressed(ctx, "chat.1.remote.getBotInfo", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2953	return
2954}
2955
2956func (c RemoteClient) GetDefaultTeamChannels(ctx context.Context, teamID keybase1.TeamID) (res GetDefaultTeamChannelsRes, err error) {
2957	__arg := GetDefaultTeamChannelsArg{TeamID: teamID}
2958	err = c.Cli.CallCompressed(ctx, "chat.1.remote.getDefaultTeamChannels", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2959	return
2960}
2961
2962func (c RemoteClient) SetDefaultTeamChannels(ctx context.Context, __arg SetDefaultTeamChannelsArg) (res SetDefaultTeamChannelsRes, err error) {
2963	err = c.Cli.CallCompressed(ctx, "chat.1.remote.setDefaultTeamChannels", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2964	return
2965}
2966
2967func (c RemoteClient) GetRecentJoins(ctx context.Context, convID ConversationID) (res GetRecentJoinsRes, err error) {
2968	__arg := GetRecentJoinsArg{ConvID: convID}
2969	err = c.Cli.CallCompressed(ctx, "chat.1.remote.getRecentJoins", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2970	return
2971}
2972
2973func (c RemoteClient) RefreshParticipantsRemote(ctx context.Context, __arg RefreshParticipantsRemoteArg) (res RefreshParticipantsRemoteRes, err error) {
2974	err = c.Cli.CallCompressed(ctx, "chat.1.remote.refreshParticipantsRemote", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2975	return
2976}
2977
2978func (c RemoteClient) GetLastActiveAt(ctx context.Context, __arg GetLastActiveAtArg) (res GetLastActiveAtRes, err error) {
2979	err = c.Cli.CallCompressed(ctx, "chat.1.remote.getLastActiveAt", []interface{}{__arg}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2980	return
2981}
2982
2983func (c RemoteClient) GetResetConversations(ctx context.Context) (res GetResetConversationsRes, err error) {
2984	err = c.Cli.CallCompressed(ctx, "chat.1.remote.getResetConversations", []interface{}{GetResetConversationsArg{}}, &res, rpc.CompressionGzip, 0*time.Millisecond)
2985	return
2986}
2987