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/local.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 stellar1 "github.com/keybase/client/go/protocol/stellar1" 12 "github.com/keybase/go-framed-msgpack-rpc/rpc" 13 context "golang.org/x/net/context" 14 "time" 15) 16 17type VersionKind string 18 19func (o VersionKind) DeepCopy() VersionKind { 20 return o 21} 22 23type TextPaymentResultTyp int 24 25const ( 26 TextPaymentResultTyp_SENT TextPaymentResultTyp = 0 27 TextPaymentResultTyp_ERROR TextPaymentResultTyp = 1 28) 29 30func (o TextPaymentResultTyp) DeepCopy() TextPaymentResultTyp { return o } 31 32var TextPaymentResultTypMap = map[string]TextPaymentResultTyp{ 33 "SENT": 0, 34 "ERROR": 1, 35} 36 37var TextPaymentResultTypRevMap = map[TextPaymentResultTyp]string{ 38 0: "SENT", 39 1: "ERROR", 40} 41 42func (e TextPaymentResultTyp) String() string { 43 if v, ok := TextPaymentResultTypRevMap[e]; ok { 44 return v 45 } 46 return fmt.Sprintf("%v", int(e)) 47} 48 49type TextPaymentResult struct { 50 ResultTyp__ TextPaymentResultTyp `codec:"resultTyp" json:"resultTyp"` 51 Error__ *string `codec:"error,omitempty" json:"error,omitempty"` 52 Sent__ *stellar1.PaymentID `codec:"sent,omitempty" json:"sent,omitempty"` 53} 54 55func (o *TextPaymentResult) ResultTyp() (ret TextPaymentResultTyp, err error) { 56 switch o.ResultTyp__ { 57 case TextPaymentResultTyp_ERROR: 58 if o.Error__ == nil { 59 err = errors.New("unexpected nil value for Error__") 60 return ret, err 61 } 62 case TextPaymentResultTyp_SENT: 63 if o.Sent__ == nil { 64 err = errors.New("unexpected nil value for Sent__") 65 return ret, err 66 } 67 } 68 return o.ResultTyp__, nil 69} 70 71func (o TextPaymentResult) Error() (res string) { 72 if o.ResultTyp__ != TextPaymentResultTyp_ERROR { 73 panic("wrong case accessed") 74 } 75 if o.Error__ == nil { 76 return 77 } 78 return *o.Error__ 79} 80 81func (o TextPaymentResult) Sent() (res stellar1.PaymentID) { 82 if o.ResultTyp__ != TextPaymentResultTyp_SENT { 83 panic("wrong case accessed") 84 } 85 if o.Sent__ == nil { 86 return 87 } 88 return *o.Sent__ 89} 90 91func NewTextPaymentResultWithError(v string) TextPaymentResult { 92 return TextPaymentResult{ 93 ResultTyp__: TextPaymentResultTyp_ERROR, 94 Error__: &v, 95 } 96} 97 98func NewTextPaymentResultWithSent(v stellar1.PaymentID) TextPaymentResult { 99 return TextPaymentResult{ 100 ResultTyp__: TextPaymentResultTyp_SENT, 101 Sent__: &v, 102 } 103} 104 105func (o TextPaymentResult) DeepCopy() TextPaymentResult { 106 return TextPaymentResult{ 107 ResultTyp__: o.ResultTyp__.DeepCopy(), 108 Error__: (func(x *string) *string { 109 if x == nil { 110 return nil 111 } 112 tmp := (*x) 113 return &tmp 114 })(o.Error__), 115 Sent__: (func(x *stellar1.PaymentID) *stellar1.PaymentID { 116 if x == nil { 117 return nil 118 } 119 tmp := (*x).DeepCopy() 120 return &tmp 121 })(o.Sent__), 122 } 123} 124 125type TextPayment struct { 126 Username string `codec:"username" json:"username"` 127 PaymentText string `codec:"paymentText" json:"paymentText"` 128 Result TextPaymentResult `codec:"result" json:"result"` 129} 130 131func (o TextPayment) DeepCopy() TextPayment { 132 return TextPayment{ 133 Username: o.Username, 134 PaymentText: o.PaymentText, 135 Result: o.Result.DeepCopy(), 136 } 137} 138 139type KnownUserMention struct { 140 Text string `codec:"text" json:"text"` 141 Uid gregor1.UID `codec:"uid" json:"uid"` 142} 143 144func (o KnownUserMention) DeepCopy() KnownUserMention { 145 return KnownUserMention{ 146 Text: o.Text, 147 Uid: o.Uid.DeepCopy(), 148 } 149} 150 151type KnownTeamMention struct { 152 Name string `codec:"name" json:"name"` 153 Channel string `codec:"channel" json:"channel"` 154} 155 156func (o KnownTeamMention) DeepCopy() KnownTeamMention { 157 return KnownTeamMention{ 158 Name: o.Name, 159 Channel: o.Channel, 160 } 161} 162 163type MaybeMention struct { 164 Name string `codec:"name" json:"name"` 165 Channel string `codec:"channel" json:"channel"` 166} 167 168func (o MaybeMention) DeepCopy() MaybeMention { 169 return MaybeMention{ 170 Name: o.Name, 171 Channel: o.Channel, 172 } 173} 174 175type Coordinate struct { 176 Lat float64 `codec:"lat" json:"lat"` 177 Lon float64 `codec:"lon" json:"lon"` 178 Accuracy float64 `codec:"accuracy" json:"accuracy"` 179} 180 181func (o Coordinate) DeepCopy() Coordinate { 182 return Coordinate{ 183 Lat: o.Lat, 184 Lon: o.Lon, 185 Accuracy: o.Accuracy, 186 } 187} 188 189type LiveLocation struct { 190 EndTime gregor1.Time `codec:"endTime" json:"endTime"` 191} 192 193func (o LiveLocation) DeepCopy() LiveLocation { 194 return LiveLocation{ 195 EndTime: o.EndTime.DeepCopy(), 196 } 197} 198 199type MessageText struct { 200 Body string `codec:"body" json:"body"` 201 Payments []TextPayment `codec:"payments" json:"payments"` 202 ReplyTo *MessageID `codec:"replyTo,omitempty" json:"replyTo,omitempty"` 203 ReplyToUID *gregor1.UID `codec:"replyToUID,omitempty" json:"replyToUID,omitempty"` 204 UserMentions []KnownUserMention `codec:"userMentions" json:"userMentions"` 205 TeamMentions []KnownTeamMention `codec:"teamMentions" json:"teamMentions"` 206 LiveLocation *LiveLocation `codec:"liveLocation,omitempty" json:"liveLocation,omitempty"` 207 Emojis map[string]HarvestedEmoji `codec:"emojis" json:"emojis"` 208} 209 210func (o MessageText) DeepCopy() MessageText { 211 return MessageText{ 212 Body: o.Body, 213 Payments: (func(x []TextPayment) []TextPayment { 214 if x == nil { 215 return nil 216 } 217 ret := make([]TextPayment, len(x)) 218 for i, v := range x { 219 vCopy := v.DeepCopy() 220 ret[i] = vCopy 221 } 222 return ret 223 })(o.Payments), 224 ReplyTo: (func(x *MessageID) *MessageID { 225 if x == nil { 226 return nil 227 } 228 tmp := (*x).DeepCopy() 229 return &tmp 230 })(o.ReplyTo), 231 ReplyToUID: (func(x *gregor1.UID) *gregor1.UID { 232 if x == nil { 233 return nil 234 } 235 tmp := (*x).DeepCopy() 236 return &tmp 237 })(o.ReplyToUID), 238 UserMentions: (func(x []KnownUserMention) []KnownUserMention { 239 if x == nil { 240 return nil 241 } 242 ret := make([]KnownUserMention, len(x)) 243 for i, v := range x { 244 vCopy := v.DeepCopy() 245 ret[i] = vCopy 246 } 247 return ret 248 })(o.UserMentions), 249 TeamMentions: (func(x []KnownTeamMention) []KnownTeamMention { 250 if x == nil { 251 return nil 252 } 253 ret := make([]KnownTeamMention, len(x)) 254 for i, v := range x { 255 vCopy := v.DeepCopy() 256 ret[i] = vCopy 257 } 258 return ret 259 })(o.TeamMentions), 260 LiveLocation: (func(x *LiveLocation) *LiveLocation { 261 if x == nil { 262 return nil 263 } 264 tmp := (*x).DeepCopy() 265 return &tmp 266 })(o.LiveLocation), 267 Emojis: (func(x map[string]HarvestedEmoji) map[string]HarvestedEmoji { 268 if x == nil { 269 return nil 270 } 271 ret := make(map[string]HarvestedEmoji, len(x)) 272 for k, v := range x { 273 kCopy := k 274 vCopy := v.DeepCopy() 275 ret[kCopy] = vCopy 276 } 277 return ret 278 })(o.Emojis), 279 } 280} 281 282type MessageConversationMetadata struct { 283 ConversationTitle string `codec:"conversationTitle" json:"conversationTitle"` 284} 285 286func (o MessageConversationMetadata) DeepCopy() MessageConversationMetadata { 287 return MessageConversationMetadata{ 288 ConversationTitle: o.ConversationTitle, 289 } 290} 291 292type MessageEdit struct { 293 MessageID MessageID `codec:"messageID" json:"messageID"` 294 Body string `codec:"body" json:"body"` 295 UserMentions []KnownUserMention `codec:"userMentions" json:"userMentions"` 296 TeamMentions []KnownTeamMention `codec:"teamMentions" json:"teamMentions"` 297 Emojis map[string]HarvestedEmoji `codec:"emojis" json:"emojis"` 298} 299 300func (o MessageEdit) DeepCopy() MessageEdit { 301 return MessageEdit{ 302 MessageID: o.MessageID.DeepCopy(), 303 Body: o.Body, 304 UserMentions: (func(x []KnownUserMention) []KnownUserMention { 305 if x == nil { 306 return nil 307 } 308 ret := make([]KnownUserMention, len(x)) 309 for i, v := range x { 310 vCopy := v.DeepCopy() 311 ret[i] = vCopy 312 } 313 return ret 314 })(o.UserMentions), 315 TeamMentions: (func(x []KnownTeamMention) []KnownTeamMention { 316 if x == nil { 317 return nil 318 } 319 ret := make([]KnownTeamMention, len(x)) 320 for i, v := range x { 321 vCopy := v.DeepCopy() 322 ret[i] = vCopy 323 } 324 return ret 325 })(o.TeamMentions), 326 Emojis: (func(x map[string]HarvestedEmoji) map[string]HarvestedEmoji { 327 if x == nil { 328 return nil 329 } 330 ret := make(map[string]HarvestedEmoji, len(x)) 331 for k, v := range x { 332 kCopy := k 333 vCopy := v.DeepCopy() 334 ret[kCopy] = vCopy 335 } 336 return ret 337 })(o.Emojis), 338 } 339} 340 341type MessageDelete struct { 342 MessageIDs []MessageID `codec:"messageIDs" json:"messageIDs"` 343} 344 345func (o MessageDelete) DeepCopy() MessageDelete { 346 return MessageDelete{ 347 MessageIDs: (func(x []MessageID) []MessageID { 348 if x == nil { 349 return nil 350 } 351 ret := make([]MessageID, len(x)) 352 for i, v := range x { 353 vCopy := v.DeepCopy() 354 ret[i] = vCopy 355 } 356 return ret 357 })(o.MessageIDs), 358 } 359} 360 361type MessageHeadline struct { 362 Headline string `codec:"headline" json:"headline"` 363 Emojis map[string]HarvestedEmoji `codec:"emojis" json:"emojis"` 364} 365 366func (o MessageHeadline) DeepCopy() MessageHeadline { 367 return MessageHeadline{ 368 Headline: o.Headline, 369 Emojis: (func(x map[string]HarvestedEmoji) map[string]HarvestedEmoji { 370 if x == nil { 371 return nil 372 } 373 ret := make(map[string]HarvestedEmoji, len(x)) 374 for k, v := range x { 375 kCopy := k 376 vCopy := v.DeepCopy() 377 ret[kCopy] = vCopy 378 } 379 return ret 380 })(o.Emojis), 381 } 382} 383 384type MessageFlip struct { 385 Text string `codec:"text" json:"text"` 386 GameID FlipGameID `codec:"gameID" json:"gameID"` 387 FlipConvID ConversationID `codec:"flipConvID" json:"flipConvID"` 388 UserMentions []KnownUserMention `codec:"userMentions" json:"userMentions"` 389 TeamMentions []KnownTeamMention `codec:"teamMentions" json:"teamMentions"` 390} 391 392func (o MessageFlip) DeepCopy() MessageFlip { 393 return MessageFlip{ 394 Text: o.Text, 395 GameID: o.GameID.DeepCopy(), 396 FlipConvID: o.FlipConvID.DeepCopy(), 397 UserMentions: (func(x []KnownUserMention) []KnownUserMention { 398 if x == nil { 399 return nil 400 } 401 ret := make([]KnownUserMention, len(x)) 402 for i, v := range x { 403 vCopy := v.DeepCopy() 404 ret[i] = vCopy 405 } 406 return ret 407 })(o.UserMentions), 408 TeamMentions: (func(x []KnownTeamMention) []KnownTeamMention { 409 if x == nil { 410 return nil 411 } 412 ret := make([]KnownTeamMention, len(x)) 413 for i, v := range x { 414 vCopy := v.DeepCopy() 415 ret[i] = vCopy 416 } 417 return ret 418 })(o.TeamMentions), 419 } 420} 421 422type MessagePin struct { 423 MsgID MessageID `codec:"msgID" json:"msgID"` 424} 425 426func (o MessagePin) DeepCopy() MessagePin { 427 return MessagePin{ 428 MsgID: o.MsgID.DeepCopy(), 429 } 430} 431 432type MessageSystemType int 433 434const ( 435 MessageSystemType_ADDEDTOTEAM MessageSystemType = 0 436 MessageSystemType_INVITEADDEDTOTEAM MessageSystemType = 1 437 MessageSystemType_COMPLEXTEAM MessageSystemType = 2 438 MessageSystemType_CREATETEAM MessageSystemType = 3 439 MessageSystemType_GITPUSH MessageSystemType = 4 440 MessageSystemType_CHANGEAVATAR MessageSystemType = 5 441 MessageSystemType_CHANGERETENTION MessageSystemType = 6 442 MessageSystemType_BULKADDTOCONV MessageSystemType = 7 443 MessageSystemType_SBSRESOLVE MessageSystemType = 8 444 MessageSystemType_NEWCHANNEL MessageSystemType = 9 445) 446 447func (o MessageSystemType) DeepCopy() MessageSystemType { return o } 448 449var MessageSystemTypeMap = map[string]MessageSystemType{ 450 "ADDEDTOTEAM": 0, 451 "INVITEADDEDTOTEAM": 1, 452 "COMPLEXTEAM": 2, 453 "CREATETEAM": 3, 454 "GITPUSH": 4, 455 "CHANGEAVATAR": 5, 456 "CHANGERETENTION": 6, 457 "BULKADDTOCONV": 7, 458 "SBSRESOLVE": 8, 459 "NEWCHANNEL": 9, 460} 461 462var MessageSystemTypeRevMap = map[MessageSystemType]string{ 463 0: "ADDEDTOTEAM", 464 1: "INVITEADDEDTOTEAM", 465 2: "COMPLEXTEAM", 466 3: "CREATETEAM", 467 4: "GITPUSH", 468 5: "CHANGEAVATAR", 469 6: "CHANGERETENTION", 470 7: "BULKADDTOCONV", 471 8: "SBSRESOLVE", 472 9: "NEWCHANNEL", 473} 474 475func (e MessageSystemType) String() string { 476 if v, ok := MessageSystemTypeRevMap[e]; ok { 477 return v 478 } 479 return fmt.Sprintf("%v", int(e)) 480} 481 482type MessageSystemAddedToTeam struct { 483 Team string `codec:"team" json:"team"` 484 Adder string `codec:"adder" json:"adder"` 485 Addee string `codec:"addee" json:"addee"` 486 Role keybase1.TeamRole `codec:"role" json:"role"` 487 BulkAdds []string `codec:"bulkAdds" json:"bulkAdds"` 488} 489 490func (o MessageSystemAddedToTeam) DeepCopy() MessageSystemAddedToTeam { 491 return MessageSystemAddedToTeam{ 492 Team: o.Team, 493 Adder: o.Adder, 494 Addee: o.Addee, 495 Role: o.Role.DeepCopy(), 496 BulkAdds: (func(x []string) []string { 497 if x == nil { 498 return nil 499 } 500 ret := make([]string, len(x)) 501 for i, v := range x { 502 vCopy := v 503 ret[i] = vCopy 504 } 505 return ret 506 })(o.BulkAdds), 507 } 508} 509 510type MessageSystemInviteAddedToTeam struct { 511 Team string `codec:"team" json:"team"` 512 Inviter string `codec:"inviter" json:"inviter"` 513 Invitee string `codec:"invitee" json:"invitee"` 514 Adder string `codec:"adder" json:"adder"` 515 InviteType keybase1.TeamInviteCategory `codec:"inviteType" json:"inviteType"` 516 Role keybase1.TeamRole `codec:"role" json:"role"` 517} 518 519func (o MessageSystemInviteAddedToTeam) DeepCopy() MessageSystemInviteAddedToTeam { 520 return MessageSystemInviteAddedToTeam{ 521 Team: o.Team, 522 Inviter: o.Inviter, 523 Invitee: o.Invitee, 524 Adder: o.Adder, 525 InviteType: o.InviteType.DeepCopy(), 526 Role: o.Role.DeepCopy(), 527 } 528} 529 530type MessageSystemComplexTeam struct { 531 Team string `codec:"team" json:"team"` 532} 533 534func (o MessageSystemComplexTeam) DeepCopy() MessageSystemComplexTeam { 535 return MessageSystemComplexTeam{ 536 Team: o.Team, 537 } 538} 539 540type MessageSystemCreateTeam struct { 541 Team string `codec:"team" json:"team"` 542 Creator string `codec:"creator" json:"creator"` 543} 544 545func (o MessageSystemCreateTeam) DeepCopy() MessageSystemCreateTeam { 546 return MessageSystemCreateTeam{ 547 Team: o.Team, 548 Creator: o.Creator, 549 } 550} 551 552type MessageSystemGitPush struct { 553 Team string `codec:"team" json:"team"` 554 Pusher string `codec:"pusher" json:"pusher"` 555 RepoName string `codec:"repoName" json:"repoName"` 556 RepoID keybase1.RepoID `codec:"repoID" json:"repoID"` 557 Refs []keybase1.GitRefMetadata `codec:"refs" json:"refs"` 558 PushType keybase1.GitPushType `codec:"pushType" json:"pushType"` 559 PreviousRepoName string `codec:"previousRepoName" json:"previousRepoName"` 560} 561 562func (o MessageSystemGitPush) DeepCopy() MessageSystemGitPush { 563 return MessageSystemGitPush{ 564 Team: o.Team, 565 Pusher: o.Pusher, 566 RepoName: o.RepoName, 567 RepoID: o.RepoID.DeepCopy(), 568 Refs: (func(x []keybase1.GitRefMetadata) []keybase1.GitRefMetadata { 569 if x == nil { 570 return nil 571 } 572 ret := make([]keybase1.GitRefMetadata, len(x)) 573 for i, v := range x { 574 vCopy := v.DeepCopy() 575 ret[i] = vCopy 576 } 577 return ret 578 })(o.Refs), 579 PushType: o.PushType.DeepCopy(), 580 PreviousRepoName: o.PreviousRepoName, 581 } 582} 583 584type MessageSystemChangeAvatar struct { 585 Team string `codec:"team" json:"team"` 586 User string `codec:"user" json:"user"` 587} 588 589func (o MessageSystemChangeAvatar) DeepCopy() MessageSystemChangeAvatar { 590 return MessageSystemChangeAvatar{ 591 Team: o.Team, 592 User: o.User, 593 } 594} 595 596type MessageSystemChangeRetention struct { 597 IsTeam bool `codec:"isTeam" json:"isTeam"` 598 IsInherit bool `codec:"isInherit" json:"isInherit"` 599 MembersType ConversationMembersType `codec:"membersType" json:"membersType"` 600 Policy RetentionPolicy `codec:"policy" json:"policy"` 601 User string `codec:"user" json:"user"` 602} 603 604func (o MessageSystemChangeRetention) DeepCopy() MessageSystemChangeRetention { 605 return MessageSystemChangeRetention{ 606 IsTeam: o.IsTeam, 607 IsInherit: o.IsInherit, 608 MembersType: o.MembersType.DeepCopy(), 609 Policy: o.Policy.DeepCopy(), 610 User: o.User, 611 } 612} 613 614type MessageSystemBulkAddToConv struct { 615 Usernames []string `codec:"usernames" json:"usernames"` 616} 617 618func (o MessageSystemBulkAddToConv) DeepCopy() MessageSystemBulkAddToConv { 619 return MessageSystemBulkAddToConv{ 620 Usernames: (func(x []string) []string { 621 if x == nil { 622 return nil 623 } 624 ret := make([]string, len(x)) 625 for i, v := range x { 626 vCopy := v 627 ret[i] = vCopy 628 } 629 return ret 630 })(o.Usernames), 631 } 632} 633 634type MessageSystemSbsResolve struct { 635 AssertionService string `codec:"assertionService" json:"assertionService"` 636 AssertionUsername string `codec:"assertionUsername" json:"assertionUsername"` 637 Prover string `codec:"prover" json:"prover"` 638} 639 640func (o MessageSystemSbsResolve) DeepCopy() MessageSystemSbsResolve { 641 return MessageSystemSbsResolve{ 642 AssertionService: o.AssertionService, 643 AssertionUsername: o.AssertionUsername, 644 Prover: o.Prover, 645 } 646} 647 648type MessageSystemNewChannel struct { 649 Creator string `codec:"creator" json:"creator"` 650 NameAtCreation string `codec:"nameAtCreation" json:"nameAtCreation"` 651 ConvID ConversationID `codec:"convID" json:"convID"` 652 ConvIDs []ConversationID `codec:"convIDs" json:"convIDs"` 653} 654 655func (o MessageSystemNewChannel) DeepCopy() MessageSystemNewChannel { 656 return MessageSystemNewChannel{ 657 Creator: o.Creator, 658 NameAtCreation: o.NameAtCreation, 659 ConvID: o.ConvID.DeepCopy(), 660 ConvIDs: (func(x []ConversationID) []ConversationID { 661 if x == nil { 662 return nil 663 } 664 ret := make([]ConversationID, len(x)) 665 for i, v := range x { 666 vCopy := v.DeepCopy() 667 ret[i] = vCopy 668 } 669 return ret 670 })(o.ConvIDs), 671 } 672} 673 674type MessageSystem struct { 675 SystemType__ MessageSystemType `codec:"systemType" json:"systemType"` 676 Addedtoteam__ *MessageSystemAddedToTeam `codec:"addedtoteam,omitempty" json:"addedtoteam,omitempty"` 677 Inviteaddedtoteam__ *MessageSystemInviteAddedToTeam `codec:"inviteaddedtoteam,omitempty" json:"inviteaddedtoteam,omitempty"` 678 Complexteam__ *MessageSystemComplexTeam `codec:"complexteam,omitempty" json:"complexteam,omitempty"` 679 Createteam__ *MessageSystemCreateTeam `codec:"createteam,omitempty" json:"createteam,omitempty"` 680 Gitpush__ *MessageSystemGitPush `codec:"gitpush,omitempty" json:"gitpush,omitempty"` 681 Changeavatar__ *MessageSystemChangeAvatar `codec:"changeavatar,omitempty" json:"changeavatar,omitempty"` 682 Changeretention__ *MessageSystemChangeRetention `codec:"changeretention,omitempty" json:"changeretention,omitempty"` 683 Bulkaddtoconv__ *MessageSystemBulkAddToConv `codec:"bulkaddtoconv,omitempty" json:"bulkaddtoconv,omitempty"` 684 Sbsresolve__ *MessageSystemSbsResolve `codec:"sbsresolve,omitempty" json:"sbsresolve,omitempty"` 685 Newchannel__ *MessageSystemNewChannel `codec:"newchannel,omitempty" json:"newchannel,omitempty"` 686} 687 688func (o *MessageSystem) SystemType() (ret MessageSystemType, err error) { 689 switch o.SystemType__ { 690 case MessageSystemType_ADDEDTOTEAM: 691 if o.Addedtoteam__ == nil { 692 err = errors.New("unexpected nil value for Addedtoteam__") 693 return ret, err 694 } 695 case MessageSystemType_INVITEADDEDTOTEAM: 696 if o.Inviteaddedtoteam__ == nil { 697 err = errors.New("unexpected nil value for Inviteaddedtoteam__") 698 return ret, err 699 } 700 case MessageSystemType_COMPLEXTEAM: 701 if o.Complexteam__ == nil { 702 err = errors.New("unexpected nil value for Complexteam__") 703 return ret, err 704 } 705 case MessageSystemType_CREATETEAM: 706 if o.Createteam__ == nil { 707 err = errors.New("unexpected nil value for Createteam__") 708 return ret, err 709 } 710 case MessageSystemType_GITPUSH: 711 if o.Gitpush__ == nil { 712 err = errors.New("unexpected nil value for Gitpush__") 713 return ret, err 714 } 715 case MessageSystemType_CHANGEAVATAR: 716 if o.Changeavatar__ == nil { 717 err = errors.New("unexpected nil value for Changeavatar__") 718 return ret, err 719 } 720 case MessageSystemType_CHANGERETENTION: 721 if o.Changeretention__ == nil { 722 err = errors.New("unexpected nil value for Changeretention__") 723 return ret, err 724 } 725 case MessageSystemType_BULKADDTOCONV: 726 if o.Bulkaddtoconv__ == nil { 727 err = errors.New("unexpected nil value for Bulkaddtoconv__") 728 return ret, err 729 } 730 case MessageSystemType_SBSRESOLVE: 731 if o.Sbsresolve__ == nil { 732 err = errors.New("unexpected nil value for Sbsresolve__") 733 return ret, err 734 } 735 case MessageSystemType_NEWCHANNEL: 736 if o.Newchannel__ == nil { 737 err = errors.New("unexpected nil value for Newchannel__") 738 return ret, err 739 } 740 } 741 return o.SystemType__, nil 742} 743 744func (o MessageSystem) Addedtoteam() (res MessageSystemAddedToTeam) { 745 if o.SystemType__ != MessageSystemType_ADDEDTOTEAM { 746 panic("wrong case accessed") 747 } 748 if o.Addedtoteam__ == nil { 749 return 750 } 751 return *o.Addedtoteam__ 752} 753 754func (o MessageSystem) Inviteaddedtoteam() (res MessageSystemInviteAddedToTeam) { 755 if o.SystemType__ != MessageSystemType_INVITEADDEDTOTEAM { 756 panic("wrong case accessed") 757 } 758 if o.Inviteaddedtoteam__ == nil { 759 return 760 } 761 return *o.Inviteaddedtoteam__ 762} 763 764func (o MessageSystem) Complexteam() (res MessageSystemComplexTeam) { 765 if o.SystemType__ != MessageSystemType_COMPLEXTEAM { 766 panic("wrong case accessed") 767 } 768 if o.Complexteam__ == nil { 769 return 770 } 771 return *o.Complexteam__ 772} 773 774func (o MessageSystem) Createteam() (res MessageSystemCreateTeam) { 775 if o.SystemType__ != MessageSystemType_CREATETEAM { 776 panic("wrong case accessed") 777 } 778 if o.Createteam__ == nil { 779 return 780 } 781 return *o.Createteam__ 782} 783 784func (o MessageSystem) Gitpush() (res MessageSystemGitPush) { 785 if o.SystemType__ != MessageSystemType_GITPUSH { 786 panic("wrong case accessed") 787 } 788 if o.Gitpush__ == nil { 789 return 790 } 791 return *o.Gitpush__ 792} 793 794func (o MessageSystem) Changeavatar() (res MessageSystemChangeAvatar) { 795 if o.SystemType__ != MessageSystemType_CHANGEAVATAR { 796 panic("wrong case accessed") 797 } 798 if o.Changeavatar__ == nil { 799 return 800 } 801 return *o.Changeavatar__ 802} 803 804func (o MessageSystem) Changeretention() (res MessageSystemChangeRetention) { 805 if o.SystemType__ != MessageSystemType_CHANGERETENTION { 806 panic("wrong case accessed") 807 } 808 if o.Changeretention__ == nil { 809 return 810 } 811 return *o.Changeretention__ 812} 813 814func (o MessageSystem) Bulkaddtoconv() (res MessageSystemBulkAddToConv) { 815 if o.SystemType__ != MessageSystemType_BULKADDTOCONV { 816 panic("wrong case accessed") 817 } 818 if o.Bulkaddtoconv__ == nil { 819 return 820 } 821 return *o.Bulkaddtoconv__ 822} 823 824func (o MessageSystem) Sbsresolve() (res MessageSystemSbsResolve) { 825 if o.SystemType__ != MessageSystemType_SBSRESOLVE { 826 panic("wrong case accessed") 827 } 828 if o.Sbsresolve__ == nil { 829 return 830 } 831 return *o.Sbsresolve__ 832} 833 834func (o MessageSystem) Newchannel() (res MessageSystemNewChannel) { 835 if o.SystemType__ != MessageSystemType_NEWCHANNEL { 836 panic("wrong case accessed") 837 } 838 if o.Newchannel__ == nil { 839 return 840 } 841 return *o.Newchannel__ 842} 843 844func NewMessageSystemWithAddedtoteam(v MessageSystemAddedToTeam) MessageSystem { 845 return MessageSystem{ 846 SystemType__: MessageSystemType_ADDEDTOTEAM, 847 Addedtoteam__: &v, 848 } 849} 850 851func NewMessageSystemWithInviteaddedtoteam(v MessageSystemInviteAddedToTeam) MessageSystem { 852 return MessageSystem{ 853 SystemType__: MessageSystemType_INVITEADDEDTOTEAM, 854 Inviteaddedtoteam__: &v, 855 } 856} 857 858func NewMessageSystemWithComplexteam(v MessageSystemComplexTeam) MessageSystem { 859 return MessageSystem{ 860 SystemType__: MessageSystemType_COMPLEXTEAM, 861 Complexteam__: &v, 862 } 863} 864 865func NewMessageSystemWithCreateteam(v MessageSystemCreateTeam) MessageSystem { 866 return MessageSystem{ 867 SystemType__: MessageSystemType_CREATETEAM, 868 Createteam__: &v, 869 } 870} 871 872func NewMessageSystemWithGitpush(v MessageSystemGitPush) MessageSystem { 873 return MessageSystem{ 874 SystemType__: MessageSystemType_GITPUSH, 875 Gitpush__: &v, 876 } 877} 878 879func NewMessageSystemWithChangeavatar(v MessageSystemChangeAvatar) MessageSystem { 880 return MessageSystem{ 881 SystemType__: MessageSystemType_CHANGEAVATAR, 882 Changeavatar__: &v, 883 } 884} 885 886func NewMessageSystemWithChangeretention(v MessageSystemChangeRetention) MessageSystem { 887 return MessageSystem{ 888 SystemType__: MessageSystemType_CHANGERETENTION, 889 Changeretention__: &v, 890 } 891} 892 893func NewMessageSystemWithBulkaddtoconv(v MessageSystemBulkAddToConv) MessageSystem { 894 return MessageSystem{ 895 SystemType__: MessageSystemType_BULKADDTOCONV, 896 Bulkaddtoconv__: &v, 897 } 898} 899 900func NewMessageSystemWithSbsresolve(v MessageSystemSbsResolve) MessageSystem { 901 return MessageSystem{ 902 SystemType__: MessageSystemType_SBSRESOLVE, 903 Sbsresolve__: &v, 904 } 905} 906 907func NewMessageSystemWithNewchannel(v MessageSystemNewChannel) MessageSystem { 908 return MessageSystem{ 909 SystemType__: MessageSystemType_NEWCHANNEL, 910 Newchannel__: &v, 911 } 912} 913 914func (o MessageSystem) DeepCopy() MessageSystem { 915 return MessageSystem{ 916 SystemType__: o.SystemType__.DeepCopy(), 917 Addedtoteam__: (func(x *MessageSystemAddedToTeam) *MessageSystemAddedToTeam { 918 if x == nil { 919 return nil 920 } 921 tmp := (*x).DeepCopy() 922 return &tmp 923 })(o.Addedtoteam__), 924 Inviteaddedtoteam__: (func(x *MessageSystemInviteAddedToTeam) *MessageSystemInviteAddedToTeam { 925 if x == nil { 926 return nil 927 } 928 tmp := (*x).DeepCopy() 929 return &tmp 930 })(o.Inviteaddedtoteam__), 931 Complexteam__: (func(x *MessageSystemComplexTeam) *MessageSystemComplexTeam { 932 if x == nil { 933 return nil 934 } 935 tmp := (*x).DeepCopy() 936 return &tmp 937 })(o.Complexteam__), 938 Createteam__: (func(x *MessageSystemCreateTeam) *MessageSystemCreateTeam { 939 if x == nil { 940 return nil 941 } 942 tmp := (*x).DeepCopy() 943 return &tmp 944 })(o.Createteam__), 945 Gitpush__: (func(x *MessageSystemGitPush) *MessageSystemGitPush { 946 if x == nil { 947 return nil 948 } 949 tmp := (*x).DeepCopy() 950 return &tmp 951 })(o.Gitpush__), 952 Changeavatar__: (func(x *MessageSystemChangeAvatar) *MessageSystemChangeAvatar { 953 if x == nil { 954 return nil 955 } 956 tmp := (*x).DeepCopy() 957 return &tmp 958 })(o.Changeavatar__), 959 Changeretention__: (func(x *MessageSystemChangeRetention) *MessageSystemChangeRetention { 960 if x == nil { 961 return nil 962 } 963 tmp := (*x).DeepCopy() 964 return &tmp 965 })(o.Changeretention__), 966 Bulkaddtoconv__: (func(x *MessageSystemBulkAddToConv) *MessageSystemBulkAddToConv { 967 if x == nil { 968 return nil 969 } 970 tmp := (*x).DeepCopy() 971 return &tmp 972 })(o.Bulkaddtoconv__), 973 Sbsresolve__: (func(x *MessageSystemSbsResolve) *MessageSystemSbsResolve { 974 if x == nil { 975 return nil 976 } 977 tmp := (*x).DeepCopy() 978 return &tmp 979 })(o.Sbsresolve__), 980 Newchannel__: (func(x *MessageSystemNewChannel) *MessageSystemNewChannel { 981 if x == nil { 982 return nil 983 } 984 tmp := (*x).DeepCopy() 985 return &tmp 986 })(o.Newchannel__), 987 } 988} 989 990type MessageDeleteHistory struct { 991 Upto MessageID `codec:"upto" json:"upto"` 992} 993 994func (o MessageDeleteHistory) DeepCopy() MessageDeleteHistory { 995 return MessageDeleteHistory{ 996 Upto: o.Upto.DeepCopy(), 997 } 998} 999 1000type MessageAttachment struct { 1001 Object Asset `codec:"object" json:"object"` 1002 Preview *Asset `codec:"preview,omitempty" json:"preview,omitempty"` 1003 Previews []Asset `codec:"previews" json:"previews"` 1004 Metadata []byte `codec:"metadata" json:"metadata"` 1005 Uploaded bool `codec:"uploaded" json:"uploaded"` 1006 UserMentions []KnownUserMention `codec:"userMentions" json:"userMentions"` 1007 TeamMentions []KnownTeamMention `codec:"teamMentions" json:"teamMentions"` 1008 Emojis map[string]HarvestedEmoji `codec:"emojis" json:"emojis"` 1009} 1010 1011func (o MessageAttachment) DeepCopy() MessageAttachment { 1012 return MessageAttachment{ 1013 Object: o.Object.DeepCopy(), 1014 Preview: (func(x *Asset) *Asset { 1015 if x == nil { 1016 return nil 1017 } 1018 tmp := (*x).DeepCopy() 1019 return &tmp 1020 })(o.Preview), 1021 Previews: (func(x []Asset) []Asset { 1022 if x == nil { 1023 return nil 1024 } 1025 ret := make([]Asset, len(x)) 1026 for i, v := range x { 1027 vCopy := v.DeepCopy() 1028 ret[i] = vCopy 1029 } 1030 return ret 1031 })(o.Previews), 1032 Metadata: (func(x []byte) []byte { 1033 if x == nil { 1034 return nil 1035 } 1036 return append([]byte{}, x...) 1037 })(o.Metadata), 1038 Uploaded: o.Uploaded, 1039 UserMentions: (func(x []KnownUserMention) []KnownUserMention { 1040 if x == nil { 1041 return nil 1042 } 1043 ret := make([]KnownUserMention, len(x)) 1044 for i, v := range x { 1045 vCopy := v.DeepCopy() 1046 ret[i] = vCopy 1047 } 1048 return ret 1049 })(o.UserMentions), 1050 TeamMentions: (func(x []KnownTeamMention) []KnownTeamMention { 1051 if x == nil { 1052 return nil 1053 } 1054 ret := make([]KnownTeamMention, len(x)) 1055 for i, v := range x { 1056 vCopy := v.DeepCopy() 1057 ret[i] = vCopy 1058 } 1059 return ret 1060 })(o.TeamMentions), 1061 Emojis: (func(x map[string]HarvestedEmoji) map[string]HarvestedEmoji { 1062 if x == nil { 1063 return nil 1064 } 1065 ret := make(map[string]HarvestedEmoji, len(x)) 1066 for k, v := range x { 1067 kCopy := k 1068 vCopy := v.DeepCopy() 1069 ret[kCopy] = vCopy 1070 } 1071 return ret 1072 })(o.Emojis), 1073 } 1074} 1075 1076type MessageAttachmentUploaded struct { 1077 MessageID MessageID `codec:"messageID" json:"messageID"` 1078 Object Asset `codec:"object" json:"object"` 1079 Previews []Asset `codec:"previews" json:"previews"` 1080 Metadata []byte `codec:"metadata" json:"metadata"` 1081} 1082 1083func (o MessageAttachmentUploaded) DeepCopy() MessageAttachmentUploaded { 1084 return MessageAttachmentUploaded{ 1085 MessageID: o.MessageID.DeepCopy(), 1086 Object: o.Object.DeepCopy(), 1087 Previews: (func(x []Asset) []Asset { 1088 if x == nil { 1089 return nil 1090 } 1091 ret := make([]Asset, len(x)) 1092 for i, v := range x { 1093 vCopy := v.DeepCopy() 1094 ret[i] = vCopy 1095 } 1096 return ret 1097 })(o.Previews), 1098 Metadata: (func(x []byte) []byte { 1099 if x == nil { 1100 return nil 1101 } 1102 return append([]byte{}, x...) 1103 })(o.Metadata), 1104 } 1105} 1106 1107type MessageJoin struct { 1108 Joiners []string `codec:"joiners" json:"joiners"` 1109 Leavers []string `codec:"leavers" json:"leavers"` 1110} 1111 1112func (o MessageJoin) DeepCopy() MessageJoin { 1113 return MessageJoin{ 1114 Joiners: (func(x []string) []string { 1115 if x == nil { 1116 return nil 1117 } 1118 ret := make([]string, len(x)) 1119 for i, v := range x { 1120 vCopy := v 1121 ret[i] = vCopy 1122 } 1123 return ret 1124 })(o.Joiners), 1125 Leavers: (func(x []string) []string { 1126 if x == nil { 1127 return nil 1128 } 1129 ret := make([]string, len(x)) 1130 for i, v := range x { 1131 vCopy := v 1132 ret[i] = vCopy 1133 } 1134 return ret 1135 })(o.Leavers), 1136 } 1137} 1138 1139type MessageLeave struct { 1140} 1141 1142func (o MessageLeave) DeepCopy() MessageLeave { 1143 return MessageLeave{} 1144} 1145 1146type MessageReaction struct { 1147 MessageID MessageID `codec:"m" json:"m"` 1148 Body string `codec:"b" json:"b"` 1149 TargetUID *gregor1.UID `codec:"t,omitempty" json:"t,omitempty"` 1150 Emojis map[string]HarvestedEmoji `codec:"e" json:"e"` 1151} 1152 1153func (o MessageReaction) DeepCopy() MessageReaction { 1154 return MessageReaction{ 1155 MessageID: o.MessageID.DeepCopy(), 1156 Body: o.Body, 1157 TargetUID: (func(x *gregor1.UID) *gregor1.UID { 1158 if x == nil { 1159 return nil 1160 } 1161 tmp := (*x).DeepCopy() 1162 return &tmp 1163 })(o.TargetUID), 1164 Emojis: (func(x map[string]HarvestedEmoji) map[string]HarvestedEmoji { 1165 if x == nil { 1166 return nil 1167 } 1168 ret := make(map[string]HarvestedEmoji, len(x)) 1169 for k, v := range x { 1170 kCopy := k 1171 vCopy := v.DeepCopy() 1172 ret[kCopy] = vCopy 1173 } 1174 return ret 1175 })(o.Emojis), 1176 } 1177} 1178 1179type MessageSendPayment struct { 1180 PaymentID stellar1.PaymentID `codec:"paymentID" json:"paymentID"` 1181} 1182 1183func (o MessageSendPayment) DeepCopy() MessageSendPayment { 1184 return MessageSendPayment{ 1185 PaymentID: o.PaymentID.DeepCopy(), 1186 } 1187} 1188 1189type MessageRequestPayment struct { 1190 RequestID stellar1.KeybaseRequestID `codec:"requestID" json:"requestID"` 1191 Note string `codec:"note" json:"note"` 1192} 1193 1194func (o MessageRequestPayment) DeepCopy() MessageRequestPayment { 1195 return MessageRequestPayment{ 1196 RequestID: o.RequestID.DeepCopy(), 1197 Note: o.Note, 1198 } 1199} 1200 1201type MessageUnfurl struct { 1202 Unfurl UnfurlResult `codec:"unfurl" json:"unfurl"` 1203 MessageID MessageID `codec:"messageID" json:"messageID"` 1204} 1205 1206func (o MessageUnfurl) DeepCopy() MessageUnfurl { 1207 return MessageUnfurl{ 1208 Unfurl: o.Unfurl.DeepCopy(), 1209 MessageID: o.MessageID.DeepCopy(), 1210 } 1211} 1212 1213type MessageBody struct { 1214 MessageType__ MessageType `codec:"messageType" json:"messageType"` 1215 Text__ *MessageText `codec:"text,omitempty" json:"text,omitempty"` 1216 Attachment__ *MessageAttachment `codec:"attachment,omitempty" json:"attachment,omitempty"` 1217 Edit__ *MessageEdit `codec:"edit,omitempty" json:"edit,omitempty"` 1218 Delete__ *MessageDelete `codec:"delete,omitempty" json:"delete,omitempty"` 1219 Metadata__ *MessageConversationMetadata `codec:"metadata,omitempty" json:"metadata,omitempty"` 1220 Headline__ *MessageHeadline `codec:"headline,omitempty" json:"headline,omitempty"` 1221 Attachmentuploaded__ *MessageAttachmentUploaded `codec:"attachmentuploaded,omitempty" json:"attachmentuploaded,omitempty"` 1222 Join__ *MessageJoin `codec:"join,omitempty" json:"join,omitempty"` 1223 Leave__ *MessageLeave `codec:"leave,omitempty" json:"leave,omitempty"` 1224 System__ *MessageSystem `codec:"system,omitempty" json:"system,omitempty"` 1225 Deletehistory__ *MessageDeleteHistory `codec:"deletehistory,omitempty" json:"deletehistory,omitempty"` 1226 Reaction__ *MessageReaction `codec:"reaction,omitempty" json:"reaction,omitempty"` 1227 Sendpayment__ *MessageSendPayment `codec:"sendpayment,omitempty" json:"sendpayment,omitempty"` 1228 Requestpayment__ *MessageRequestPayment `codec:"requestpayment,omitempty" json:"requestpayment,omitempty"` 1229 Unfurl__ *MessageUnfurl `codec:"unfurl,omitempty" json:"unfurl,omitempty"` 1230 Flip__ *MessageFlip `codec:"flip,omitempty" json:"flip,omitempty"` 1231 Pin__ *MessagePin `codec:"pin,omitempty" json:"pin,omitempty"` 1232} 1233 1234func (o *MessageBody) MessageType() (ret MessageType, err error) { 1235 switch o.MessageType__ { 1236 case MessageType_TEXT: 1237 if o.Text__ == nil { 1238 err = errors.New("unexpected nil value for Text__") 1239 return ret, err 1240 } 1241 case MessageType_ATTACHMENT: 1242 if o.Attachment__ == nil { 1243 err = errors.New("unexpected nil value for Attachment__") 1244 return ret, err 1245 } 1246 case MessageType_EDIT: 1247 if o.Edit__ == nil { 1248 err = errors.New("unexpected nil value for Edit__") 1249 return ret, err 1250 } 1251 case MessageType_DELETE: 1252 if o.Delete__ == nil { 1253 err = errors.New("unexpected nil value for Delete__") 1254 return ret, err 1255 } 1256 case MessageType_METADATA: 1257 if o.Metadata__ == nil { 1258 err = errors.New("unexpected nil value for Metadata__") 1259 return ret, err 1260 } 1261 case MessageType_HEADLINE: 1262 if o.Headline__ == nil { 1263 err = errors.New("unexpected nil value for Headline__") 1264 return ret, err 1265 } 1266 case MessageType_ATTACHMENTUPLOADED: 1267 if o.Attachmentuploaded__ == nil { 1268 err = errors.New("unexpected nil value for Attachmentuploaded__") 1269 return ret, err 1270 } 1271 case MessageType_JOIN: 1272 if o.Join__ == nil { 1273 err = errors.New("unexpected nil value for Join__") 1274 return ret, err 1275 } 1276 case MessageType_LEAVE: 1277 if o.Leave__ == nil { 1278 err = errors.New("unexpected nil value for Leave__") 1279 return ret, err 1280 } 1281 case MessageType_SYSTEM: 1282 if o.System__ == nil { 1283 err = errors.New("unexpected nil value for System__") 1284 return ret, err 1285 } 1286 case MessageType_DELETEHISTORY: 1287 if o.Deletehistory__ == nil { 1288 err = errors.New("unexpected nil value for Deletehistory__") 1289 return ret, err 1290 } 1291 case MessageType_REACTION: 1292 if o.Reaction__ == nil { 1293 err = errors.New("unexpected nil value for Reaction__") 1294 return ret, err 1295 } 1296 case MessageType_SENDPAYMENT: 1297 if o.Sendpayment__ == nil { 1298 err = errors.New("unexpected nil value for Sendpayment__") 1299 return ret, err 1300 } 1301 case MessageType_REQUESTPAYMENT: 1302 if o.Requestpayment__ == nil { 1303 err = errors.New("unexpected nil value for Requestpayment__") 1304 return ret, err 1305 } 1306 case MessageType_UNFURL: 1307 if o.Unfurl__ == nil { 1308 err = errors.New("unexpected nil value for Unfurl__") 1309 return ret, err 1310 } 1311 case MessageType_FLIP: 1312 if o.Flip__ == nil { 1313 err = errors.New("unexpected nil value for Flip__") 1314 return ret, err 1315 } 1316 case MessageType_PIN: 1317 if o.Pin__ == nil { 1318 err = errors.New("unexpected nil value for Pin__") 1319 return ret, err 1320 } 1321 } 1322 return o.MessageType__, nil 1323} 1324 1325func (o MessageBody) Text() (res MessageText) { 1326 if o.MessageType__ != MessageType_TEXT { 1327 panic("wrong case accessed") 1328 } 1329 if o.Text__ == nil { 1330 return 1331 } 1332 return *o.Text__ 1333} 1334 1335func (o MessageBody) Attachment() (res MessageAttachment) { 1336 if o.MessageType__ != MessageType_ATTACHMENT { 1337 panic("wrong case accessed") 1338 } 1339 if o.Attachment__ == nil { 1340 return 1341 } 1342 return *o.Attachment__ 1343} 1344 1345func (o MessageBody) Edit() (res MessageEdit) { 1346 if o.MessageType__ != MessageType_EDIT { 1347 panic("wrong case accessed") 1348 } 1349 if o.Edit__ == nil { 1350 return 1351 } 1352 return *o.Edit__ 1353} 1354 1355func (o MessageBody) Delete() (res MessageDelete) { 1356 if o.MessageType__ != MessageType_DELETE { 1357 panic("wrong case accessed") 1358 } 1359 if o.Delete__ == nil { 1360 return 1361 } 1362 return *o.Delete__ 1363} 1364 1365func (o MessageBody) Metadata() (res MessageConversationMetadata) { 1366 if o.MessageType__ != MessageType_METADATA { 1367 panic("wrong case accessed") 1368 } 1369 if o.Metadata__ == nil { 1370 return 1371 } 1372 return *o.Metadata__ 1373} 1374 1375func (o MessageBody) Headline() (res MessageHeadline) { 1376 if o.MessageType__ != MessageType_HEADLINE { 1377 panic("wrong case accessed") 1378 } 1379 if o.Headline__ == nil { 1380 return 1381 } 1382 return *o.Headline__ 1383} 1384 1385func (o MessageBody) Attachmentuploaded() (res MessageAttachmentUploaded) { 1386 if o.MessageType__ != MessageType_ATTACHMENTUPLOADED { 1387 panic("wrong case accessed") 1388 } 1389 if o.Attachmentuploaded__ == nil { 1390 return 1391 } 1392 return *o.Attachmentuploaded__ 1393} 1394 1395func (o MessageBody) Join() (res MessageJoin) { 1396 if o.MessageType__ != MessageType_JOIN { 1397 panic("wrong case accessed") 1398 } 1399 if o.Join__ == nil { 1400 return 1401 } 1402 return *o.Join__ 1403} 1404 1405func (o MessageBody) Leave() (res MessageLeave) { 1406 if o.MessageType__ != MessageType_LEAVE { 1407 panic("wrong case accessed") 1408 } 1409 if o.Leave__ == nil { 1410 return 1411 } 1412 return *o.Leave__ 1413} 1414 1415func (o MessageBody) System() (res MessageSystem) { 1416 if o.MessageType__ != MessageType_SYSTEM { 1417 panic("wrong case accessed") 1418 } 1419 if o.System__ == nil { 1420 return 1421 } 1422 return *o.System__ 1423} 1424 1425func (o MessageBody) Deletehistory() (res MessageDeleteHistory) { 1426 if o.MessageType__ != MessageType_DELETEHISTORY { 1427 panic("wrong case accessed") 1428 } 1429 if o.Deletehistory__ == nil { 1430 return 1431 } 1432 return *o.Deletehistory__ 1433} 1434 1435func (o MessageBody) Reaction() (res MessageReaction) { 1436 if o.MessageType__ != MessageType_REACTION { 1437 panic("wrong case accessed") 1438 } 1439 if o.Reaction__ == nil { 1440 return 1441 } 1442 return *o.Reaction__ 1443} 1444 1445func (o MessageBody) Sendpayment() (res MessageSendPayment) { 1446 if o.MessageType__ != MessageType_SENDPAYMENT { 1447 panic("wrong case accessed") 1448 } 1449 if o.Sendpayment__ == nil { 1450 return 1451 } 1452 return *o.Sendpayment__ 1453} 1454 1455func (o MessageBody) Requestpayment() (res MessageRequestPayment) { 1456 if o.MessageType__ != MessageType_REQUESTPAYMENT { 1457 panic("wrong case accessed") 1458 } 1459 if o.Requestpayment__ == nil { 1460 return 1461 } 1462 return *o.Requestpayment__ 1463} 1464 1465func (o MessageBody) Unfurl() (res MessageUnfurl) { 1466 if o.MessageType__ != MessageType_UNFURL { 1467 panic("wrong case accessed") 1468 } 1469 if o.Unfurl__ == nil { 1470 return 1471 } 1472 return *o.Unfurl__ 1473} 1474 1475func (o MessageBody) Flip() (res MessageFlip) { 1476 if o.MessageType__ != MessageType_FLIP { 1477 panic("wrong case accessed") 1478 } 1479 if o.Flip__ == nil { 1480 return 1481 } 1482 return *o.Flip__ 1483} 1484 1485func (o MessageBody) Pin() (res MessagePin) { 1486 if o.MessageType__ != MessageType_PIN { 1487 panic("wrong case accessed") 1488 } 1489 if o.Pin__ == nil { 1490 return 1491 } 1492 return *o.Pin__ 1493} 1494 1495func NewMessageBodyWithText(v MessageText) MessageBody { 1496 return MessageBody{ 1497 MessageType__: MessageType_TEXT, 1498 Text__: &v, 1499 } 1500} 1501 1502func NewMessageBodyWithAttachment(v MessageAttachment) MessageBody { 1503 return MessageBody{ 1504 MessageType__: MessageType_ATTACHMENT, 1505 Attachment__: &v, 1506 } 1507} 1508 1509func NewMessageBodyWithEdit(v MessageEdit) MessageBody { 1510 return MessageBody{ 1511 MessageType__: MessageType_EDIT, 1512 Edit__: &v, 1513 } 1514} 1515 1516func NewMessageBodyWithDelete(v MessageDelete) MessageBody { 1517 return MessageBody{ 1518 MessageType__: MessageType_DELETE, 1519 Delete__: &v, 1520 } 1521} 1522 1523func NewMessageBodyWithMetadata(v MessageConversationMetadata) MessageBody { 1524 return MessageBody{ 1525 MessageType__: MessageType_METADATA, 1526 Metadata__: &v, 1527 } 1528} 1529 1530func NewMessageBodyWithHeadline(v MessageHeadline) MessageBody { 1531 return MessageBody{ 1532 MessageType__: MessageType_HEADLINE, 1533 Headline__: &v, 1534 } 1535} 1536 1537func NewMessageBodyWithAttachmentuploaded(v MessageAttachmentUploaded) MessageBody { 1538 return MessageBody{ 1539 MessageType__: MessageType_ATTACHMENTUPLOADED, 1540 Attachmentuploaded__: &v, 1541 } 1542} 1543 1544func NewMessageBodyWithJoin(v MessageJoin) MessageBody { 1545 return MessageBody{ 1546 MessageType__: MessageType_JOIN, 1547 Join__: &v, 1548 } 1549} 1550 1551func NewMessageBodyWithLeave(v MessageLeave) MessageBody { 1552 return MessageBody{ 1553 MessageType__: MessageType_LEAVE, 1554 Leave__: &v, 1555 } 1556} 1557 1558func NewMessageBodyWithSystem(v MessageSystem) MessageBody { 1559 return MessageBody{ 1560 MessageType__: MessageType_SYSTEM, 1561 System__: &v, 1562 } 1563} 1564 1565func NewMessageBodyWithDeletehistory(v MessageDeleteHistory) MessageBody { 1566 return MessageBody{ 1567 MessageType__: MessageType_DELETEHISTORY, 1568 Deletehistory__: &v, 1569 } 1570} 1571 1572func NewMessageBodyWithReaction(v MessageReaction) MessageBody { 1573 return MessageBody{ 1574 MessageType__: MessageType_REACTION, 1575 Reaction__: &v, 1576 } 1577} 1578 1579func NewMessageBodyWithSendpayment(v MessageSendPayment) MessageBody { 1580 return MessageBody{ 1581 MessageType__: MessageType_SENDPAYMENT, 1582 Sendpayment__: &v, 1583 } 1584} 1585 1586func NewMessageBodyWithRequestpayment(v MessageRequestPayment) MessageBody { 1587 return MessageBody{ 1588 MessageType__: MessageType_REQUESTPAYMENT, 1589 Requestpayment__: &v, 1590 } 1591} 1592 1593func NewMessageBodyWithUnfurl(v MessageUnfurl) MessageBody { 1594 return MessageBody{ 1595 MessageType__: MessageType_UNFURL, 1596 Unfurl__: &v, 1597 } 1598} 1599 1600func NewMessageBodyWithFlip(v MessageFlip) MessageBody { 1601 return MessageBody{ 1602 MessageType__: MessageType_FLIP, 1603 Flip__: &v, 1604 } 1605} 1606 1607func NewMessageBodyWithPin(v MessagePin) MessageBody { 1608 return MessageBody{ 1609 MessageType__: MessageType_PIN, 1610 Pin__: &v, 1611 } 1612} 1613 1614func (o MessageBody) DeepCopy() MessageBody { 1615 return MessageBody{ 1616 MessageType__: o.MessageType__.DeepCopy(), 1617 Text__: (func(x *MessageText) *MessageText { 1618 if x == nil { 1619 return nil 1620 } 1621 tmp := (*x).DeepCopy() 1622 return &tmp 1623 })(o.Text__), 1624 Attachment__: (func(x *MessageAttachment) *MessageAttachment { 1625 if x == nil { 1626 return nil 1627 } 1628 tmp := (*x).DeepCopy() 1629 return &tmp 1630 })(o.Attachment__), 1631 Edit__: (func(x *MessageEdit) *MessageEdit { 1632 if x == nil { 1633 return nil 1634 } 1635 tmp := (*x).DeepCopy() 1636 return &tmp 1637 })(o.Edit__), 1638 Delete__: (func(x *MessageDelete) *MessageDelete { 1639 if x == nil { 1640 return nil 1641 } 1642 tmp := (*x).DeepCopy() 1643 return &tmp 1644 })(o.Delete__), 1645 Metadata__: (func(x *MessageConversationMetadata) *MessageConversationMetadata { 1646 if x == nil { 1647 return nil 1648 } 1649 tmp := (*x).DeepCopy() 1650 return &tmp 1651 })(o.Metadata__), 1652 Headline__: (func(x *MessageHeadline) *MessageHeadline { 1653 if x == nil { 1654 return nil 1655 } 1656 tmp := (*x).DeepCopy() 1657 return &tmp 1658 })(o.Headline__), 1659 Attachmentuploaded__: (func(x *MessageAttachmentUploaded) *MessageAttachmentUploaded { 1660 if x == nil { 1661 return nil 1662 } 1663 tmp := (*x).DeepCopy() 1664 return &tmp 1665 })(o.Attachmentuploaded__), 1666 Join__: (func(x *MessageJoin) *MessageJoin { 1667 if x == nil { 1668 return nil 1669 } 1670 tmp := (*x).DeepCopy() 1671 return &tmp 1672 })(o.Join__), 1673 Leave__: (func(x *MessageLeave) *MessageLeave { 1674 if x == nil { 1675 return nil 1676 } 1677 tmp := (*x).DeepCopy() 1678 return &tmp 1679 })(o.Leave__), 1680 System__: (func(x *MessageSystem) *MessageSystem { 1681 if x == nil { 1682 return nil 1683 } 1684 tmp := (*x).DeepCopy() 1685 return &tmp 1686 })(o.System__), 1687 Deletehistory__: (func(x *MessageDeleteHistory) *MessageDeleteHistory { 1688 if x == nil { 1689 return nil 1690 } 1691 tmp := (*x).DeepCopy() 1692 return &tmp 1693 })(o.Deletehistory__), 1694 Reaction__: (func(x *MessageReaction) *MessageReaction { 1695 if x == nil { 1696 return nil 1697 } 1698 tmp := (*x).DeepCopy() 1699 return &tmp 1700 })(o.Reaction__), 1701 Sendpayment__: (func(x *MessageSendPayment) *MessageSendPayment { 1702 if x == nil { 1703 return nil 1704 } 1705 tmp := (*x).DeepCopy() 1706 return &tmp 1707 })(o.Sendpayment__), 1708 Requestpayment__: (func(x *MessageRequestPayment) *MessageRequestPayment { 1709 if x == nil { 1710 return nil 1711 } 1712 tmp := (*x).DeepCopy() 1713 return &tmp 1714 })(o.Requestpayment__), 1715 Unfurl__: (func(x *MessageUnfurl) *MessageUnfurl { 1716 if x == nil { 1717 return nil 1718 } 1719 tmp := (*x).DeepCopy() 1720 return &tmp 1721 })(o.Unfurl__), 1722 Flip__: (func(x *MessageFlip) *MessageFlip { 1723 if x == nil { 1724 return nil 1725 } 1726 tmp := (*x).DeepCopy() 1727 return &tmp 1728 })(o.Flip__), 1729 Pin__: (func(x *MessagePin) *MessagePin { 1730 if x == nil { 1731 return nil 1732 } 1733 tmp := (*x).DeepCopy() 1734 return &tmp 1735 })(o.Pin__), 1736 } 1737} 1738 1739type SenderPrepareOptions struct { 1740 SkipTopicNameState bool `codec:"skipTopicNameState" json:"skipTopicNameState"` 1741 ReplyTo *MessageID `codec:"replyTo,omitempty" json:"replyTo,omitempty"` 1742} 1743 1744func (o SenderPrepareOptions) DeepCopy() SenderPrepareOptions { 1745 return SenderPrepareOptions{ 1746 SkipTopicNameState: o.SkipTopicNameState, 1747 ReplyTo: (func(x *MessageID) *MessageID { 1748 if x == nil { 1749 return nil 1750 } 1751 tmp := (*x).DeepCopy() 1752 return &tmp 1753 })(o.ReplyTo), 1754 } 1755} 1756 1757type SenderSendOptions struct { 1758 JoinMentionsAs *ConversationMemberStatus `codec:"joinMentionsAs,omitempty" json:"joinMentionsAs,omitempty"` 1759} 1760 1761func (o SenderSendOptions) DeepCopy() SenderSendOptions { 1762 return SenderSendOptions{ 1763 JoinMentionsAs: (func(x *ConversationMemberStatus) *ConversationMemberStatus { 1764 if x == nil { 1765 return nil 1766 } 1767 tmp := (*x).DeepCopy() 1768 return &tmp 1769 })(o.JoinMentionsAs), 1770 } 1771} 1772 1773type OutboxStateType int 1774 1775const ( 1776 OutboxStateType_SENDING OutboxStateType = 0 1777 OutboxStateType_ERROR OutboxStateType = 1 1778) 1779 1780func (o OutboxStateType) DeepCopy() OutboxStateType { return o } 1781 1782var OutboxStateTypeMap = map[string]OutboxStateType{ 1783 "SENDING": 0, 1784 "ERROR": 1, 1785} 1786 1787var OutboxStateTypeRevMap = map[OutboxStateType]string{ 1788 0: "SENDING", 1789 1: "ERROR", 1790} 1791 1792func (e OutboxStateType) String() string { 1793 if v, ok := OutboxStateTypeRevMap[e]; ok { 1794 return v 1795 } 1796 return fmt.Sprintf("%v", int(e)) 1797} 1798 1799type OutboxErrorType int 1800 1801const ( 1802 OutboxErrorType_MISC OutboxErrorType = 0 1803 OutboxErrorType_OFFLINE OutboxErrorType = 1 1804 OutboxErrorType_IDENTIFY OutboxErrorType = 2 1805 OutboxErrorType_TOOLONG OutboxErrorType = 3 1806 OutboxErrorType_DUPLICATE OutboxErrorType = 4 1807 OutboxErrorType_EXPIRED OutboxErrorType = 5 1808 OutboxErrorType_TOOMANYATTEMPTS OutboxErrorType = 6 1809 OutboxErrorType_ALREADY_DELETED OutboxErrorType = 7 1810 OutboxErrorType_UPLOADFAILED OutboxErrorType = 8 1811 OutboxErrorType_RESTRICTEDBOT OutboxErrorType = 9 1812 OutboxErrorType_MINWRITER OutboxErrorType = 10 1813) 1814 1815func (o OutboxErrorType) DeepCopy() OutboxErrorType { return o } 1816 1817var OutboxErrorTypeMap = map[string]OutboxErrorType{ 1818 "MISC": 0, 1819 "OFFLINE": 1, 1820 "IDENTIFY": 2, 1821 "TOOLONG": 3, 1822 "DUPLICATE": 4, 1823 "EXPIRED": 5, 1824 "TOOMANYATTEMPTS": 6, 1825 "ALREADY_DELETED": 7, 1826 "UPLOADFAILED": 8, 1827 "RESTRICTEDBOT": 9, 1828 "MINWRITER": 10, 1829} 1830 1831var OutboxErrorTypeRevMap = map[OutboxErrorType]string{ 1832 0: "MISC", 1833 1: "OFFLINE", 1834 2: "IDENTIFY", 1835 3: "TOOLONG", 1836 4: "DUPLICATE", 1837 5: "EXPIRED", 1838 6: "TOOMANYATTEMPTS", 1839 7: "ALREADY_DELETED", 1840 8: "UPLOADFAILED", 1841 9: "RESTRICTEDBOT", 1842 10: "MINWRITER", 1843} 1844 1845func (e OutboxErrorType) String() string { 1846 if v, ok := OutboxErrorTypeRevMap[e]; ok { 1847 return v 1848 } 1849 return fmt.Sprintf("%v", int(e)) 1850} 1851 1852type OutboxStateError struct { 1853 Message string `codec:"message" json:"message"` 1854 Typ OutboxErrorType `codec:"typ" json:"typ"` 1855} 1856 1857func (o OutboxStateError) DeepCopy() OutboxStateError { 1858 return OutboxStateError{ 1859 Message: o.Message, 1860 Typ: o.Typ.DeepCopy(), 1861 } 1862} 1863 1864type OutboxState struct { 1865 State__ OutboxStateType `codec:"state" json:"state"` 1866 Sending__ *int `codec:"sending,omitempty" json:"sending,omitempty"` 1867 Error__ *OutboxStateError `codec:"error,omitempty" json:"error,omitempty"` 1868} 1869 1870func (o *OutboxState) State() (ret OutboxStateType, err error) { 1871 switch o.State__ { 1872 case OutboxStateType_SENDING: 1873 if o.Sending__ == nil { 1874 err = errors.New("unexpected nil value for Sending__") 1875 return ret, err 1876 } 1877 case OutboxStateType_ERROR: 1878 if o.Error__ == nil { 1879 err = errors.New("unexpected nil value for Error__") 1880 return ret, err 1881 } 1882 } 1883 return o.State__, nil 1884} 1885 1886func (o OutboxState) Sending() (res int) { 1887 if o.State__ != OutboxStateType_SENDING { 1888 panic("wrong case accessed") 1889 } 1890 if o.Sending__ == nil { 1891 return 1892 } 1893 return *o.Sending__ 1894} 1895 1896func (o OutboxState) Error() (res OutboxStateError) { 1897 if o.State__ != OutboxStateType_ERROR { 1898 panic("wrong case accessed") 1899 } 1900 if o.Error__ == nil { 1901 return 1902 } 1903 return *o.Error__ 1904} 1905 1906func NewOutboxStateWithSending(v int) OutboxState { 1907 return OutboxState{ 1908 State__: OutboxStateType_SENDING, 1909 Sending__: &v, 1910 } 1911} 1912 1913func NewOutboxStateWithError(v OutboxStateError) OutboxState { 1914 return OutboxState{ 1915 State__: OutboxStateType_ERROR, 1916 Error__: &v, 1917 } 1918} 1919 1920func (o OutboxState) DeepCopy() OutboxState { 1921 return OutboxState{ 1922 State__: o.State__.DeepCopy(), 1923 Sending__: (func(x *int) *int { 1924 if x == nil { 1925 return nil 1926 } 1927 tmp := (*x) 1928 return &tmp 1929 })(o.Sending__), 1930 Error__: (func(x *OutboxStateError) *OutboxStateError { 1931 if x == nil { 1932 return nil 1933 } 1934 tmp := (*x).DeepCopy() 1935 return &tmp 1936 })(o.Error__), 1937 } 1938} 1939 1940type OutboxRecord struct { 1941 State OutboxState `codec:"state" json:"state"` 1942 OutboxID OutboxID `codec:"outboxID" json:"outboxID"` 1943 ConvID ConversationID `codec:"convID" json:"convID"` 1944 Ctime gregor1.Time `codec:"ctime" json:"ctime"` 1945 Msg MessagePlaintext `codec:"Msg" json:"Msg"` 1946 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 1947 PrepareOpts *SenderPrepareOptions `codec:"prepareOpts,omitempty" json:"prepareOpts,omitempty"` 1948 SendOpts *SenderSendOptions `codec:"sendOpts,omitempty" json:"sendOpts,omitempty"` 1949 Ordinal int `codec:"ordinal" json:"ordinal"` 1950 Preview *MakePreviewRes `codec:"preview,omitempty" json:"preview,omitempty"` 1951 ReplyTo *MessageUnboxed `codec:"replyTo,omitempty" json:"replyTo,omitempty"` 1952} 1953 1954func (o OutboxRecord) DeepCopy() OutboxRecord { 1955 return OutboxRecord{ 1956 State: o.State.DeepCopy(), 1957 OutboxID: o.OutboxID.DeepCopy(), 1958 ConvID: o.ConvID.DeepCopy(), 1959 Ctime: o.Ctime.DeepCopy(), 1960 Msg: o.Msg.DeepCopy(), 1961 IdentifyBehavior: o.IdentifyBehavior.DeepCopy(), 1962 PrepareOpts: (func(x *SenderPrepareOptions) *SenderPrepareOptions { 1963 if x == nil { 1964 return nil 1965 } 1966 tmp := (*x).DeepCopy() 1967 return &tmp 1968 })(o.PrepareOpts), 1969 SendOpts: (func(x *SenderSendOptions) *SenderSendOptions { 1970 if x == nil { 1971 return nil 1972 } 1973 tmp := (*x).DeepCopy() 1974 return &tmp 1975 })(o.SendOpts), 1976 Ordinal: o.Ordinal, 1977 Preview: (func(x *MakePreviewRes) *MakePreviewRes { 1978 if x == nil { 1979 return nil 1980 } 1981 tmp := (*x).DeepCopy() 1982 return &tmp 1983 })(o.Preview), 1984 ReplyTo: (func(x *MessageUnboxed) *MessageUnboxed { 1985 if x == nil { 1986 return nil 1987 } 1988 tmp := (*x).DeepCopy() 1989 return &tmp 1990 })(o.ReplyTo), 1991 } 1992} 1993 1994type HeaderPlaintextVersion int 1995 1996const ( 1997 HeaderPlaintextVersion_V1 HeaderPlaintextVersion = 1 1998 HeaderPlaintextVersion_V2 HeaderPlaintextVersion = 2 1999 HeaderPlaintextVersion_V3 HeaderPlaintextVersion = 3 2000 HeaderPlaintextVersion_V4 HeaderPlaintextVersion = 4 2001 HeaderPlaintextVersion_V5 HeaderPlaintextVersion = 5 2002 HeaderPlaintextVersion_V6 HeaderPlaintextVersion = 6 2003 HeaderPlaintextVersion_V7 HeaderPlaintextVersion = 7 2004 HeaderPlaintextVersion_V8 HeaderPlaintextVersion = 8 2005 HeaderPlaintextVersion_V9 HeaderPlaintextVersion = 9 2006 HeaderPlaintextVersion_V10 HeaderPlaintextVersion = 10 2007) 2008 2009func (o HeaderPlaintextVersion) DeepCopy() HeaderPlaintextVersion { return o } 2010 2011var HeaderPlaintextVersionMap = map[string]HeaderPlaintextVersion{ 2012 "V1": 1, 2013 "V2": 2, 2014 "V3": 3, 2015 "V4": 4, 2016 "V5": 5, 2017 "V6": 6, 2018 "V7": 7, 2019 "V8": 8, 2020 "V9": 9, 2021 "V10": 10, 2022} 2023 2024var HeaderPlaintextVersionRevMap = map[HeaderPlaintextVersion]string{ 2025 1: "V1", 2026 2: "V2", 2027 3: "V3", 2028 4: "V4", 2029 5: "V5", 2030 6: "V6", 2031 7: "V7", 2032 8: "V8", 2033 9: "V9", 2034 10: "V10", 2035} 2036 2037func (e HeaderPlaintextVersion) String() string { 2038 if v, ok := HeaderPlaintextVersionRevMap[e]; ok { 2039 return v 2040 } 2041 return fmt.Sprintf("%v", int(e)) 2042} 2043 2044type HeaderPlaintextMetaInfo struct { 2045 Crit bool `codec:"crit" json:"crit"` 2046} 2047 2048func (o HeaderPlaintextMetaInfo) DeepCopy() HeaderPlaintextMetaInfo { 2049 return HeaderPlaintextMetaInfo{ 2050 Crit: o.Crit, 2051 } 2052} 2053 2054type HeaderPlaintextUnsupported struct { 2055 Mi HeaderPlaintextMetaInfo `codec:"mi" json:"mi"` 2056} 2057 2058func (o HeaderPlaintextUnsupported) DeepCopy() HeaderPlaintextUnsupported { 2059 return HeaderPlaintextUnsupported{ 2060 Mi: o.Mi.DeepCopy(), 2061 } 2062} 2063 2064type HeaderPlaintextV1 struct { 2065 Conv ConversationIDTriple `codec:"conv" json:"conv"` 2066 TlfName string `codec:"tlfName" json:"tlfName"` 2067 TlfPublic bool `codec:"tlfPublic" json:"tlfPublic"` 2068 MessageType MessageType `codec:"messageType" json:"messageType"` 2069 Prev []MessagePreviousPointer `codec:"prev" json:"prev"` 2070 Sender gregor1.UID `codec:"sender" json:"sender"` 2071 SenderDevice gregor1.DeviceID `codec:"senderDevice" json:"senderDevice"` 2072 KbfsCryptKeysUsed *bool `codec:"kbfsCryptKeysUsed,omitempty" json:"kbfsCryptKeysUsed,omitempty"` 2073 BodyHash Hash `codec:"bodyHash" json:"bodyHash"` 2074 OutboxInfo *OutboxInfo `codec:"outboxInfo,omitempty" json:"outboxInfo,omitempty"` 2075 OutboxID *OutboxID `codec:"outboxID,omitempty" json:"outboxID,omitempty"` 2076 HeaderSignature *SignatureInfo `codec:"headerSignature,omitempty" json:"headerSignature,omitempty"` 2077 MerkleRoot *MerkleRoot `codec:"merkleRoot,omitempty" json:"merkleRoot,omitempty"` 2078 EphemeralMetadata *MsgEphemeralMetadata `codec:"em,omitempty" json:"em,omitempty"` 2079 BotUID *gregor1.UID `codec:"b,omitempty" json:"b,omitempty"` 2080} 2081 2082func (o HeaderPlaintextV1) DeepCopy() HeaderPlaintextV1 { 2083 return HeaderPlaintextV1{ 2084 Conv: o.Conv.DeepCopy(), 2085 TlfName: o.TlfName, 2086 TlfPublic: o.TlfPublic, 2087 MessageType: o.MessageType.DeepCopy(), 2088 Prev: (func(x []MessagePreviousPointer) []MessagePreviousPointer { 2089 if x == nil { 2090 return nil 2091 } 2092 ret := make([]MessagePreviousPointer, len(x)) 2093 for i, v := range x { 2094 vCopy := v.DeepCopy() 2095 ret[i] = vCopy 2096 } 2097 return ret 2098 })(o.Prev), 2099 Sender: o.Sender.DeepCopy(), 2100 SenderDevice: o.SenderDevice.DeepCopy(), 2101 KbfsCryptKeysUsed: (func(x *bool) *bool { 2102 if x == nil { 2103 return nil 2104 } 2105 tmp := (*x) 2106 return &tmp 2107 })(o.KbfsCryptKeysUsed), 2108 BodyHash: o.BodyHash.DeepCopy(), 2109 OutboxInfo: (func(x *OutboxInfo) *OutboxInfo { 2110 if x == nil { 2111 return nil 2112 } 2113 tmp := (*x).DeepCopy() 2114 return &tmp 2115 })(o.OutboxInfo), 2116 OutboxID: (func(x *OutboxID) *OutboxID { 2117 if x == nil { 2118 return nil 2119 } 2120 tmp := (*x).DeepCopy() 2121 return &tmp 2122 })(o.OutboxID), 2123 HeaderSignature: (func(x *SignatureInfo) *SignatureInfo { 2124 if x == nil { 2125 return nil 2126 } 2127 tmp := (*x).DeepCopy() 2128 return &tmp 2129 })(o.HeaderSignature), 2130 MerkleRoot: (func(x *MerkleRoot) *MerkleRoot { 2131 if x == nil { 2132 return nil 2133 } 2134 tmp := (*x).DeepCopy() 2135 return &tmp 2136 })(o.MerkleRoot), 2137 EphemeralMetadata: (func(x *MsgEphemeralMetadata) *MsgEphemeralMetadata { 2138 if x == nil { 2139 return nil 2140 } 2141 tmp := (*x).DeepCopy() 2142 return &tmp 2143 })(o.EphemeralMetadata), 2144 BotUID: (func(x *gregor1.UID) *gregor1.UID { 2145 if x == nil { 2146 return nil 2147 } 2148 tmp := (*x).DeepCopy() 2149 return &tmp 2150 })(o.BotUID), 2151 } 2152} 2153 2154type HeaderPlaintext struct { 2155 Version__ HeaderPlaintextVersion `codec:"version" json:"version"` 2156 V1__ *HeaderPlaintextV1 `codec:"v1,omitempty" json:"v1,omitempty"` 2157 V2__ *HeaderPlaintextUnsupported `codec:"v2,omitempty" json:"v2,omitempty"` 2158 V3__ *HeaderPlaintextUnsupported `codec:"v3,omitempty" json:"v3,omitempty"` 2159 V4__ *HeaderPlaintextUnsupported `codec:"v4,omitempty" json:"v4,omitempty"` 2160 V5__ *HeaderPlaintextUnsupported `codec:"v5,omitempty" json:"v5,omitempty"` 2161 V6__ *HeaderPlaintextUnsupported `codec:"v6,omitempty" json:"v6,omitempty"` 2162 V7__ *HeaderPlaintextUnsupported `codec:"v7,omitempty" json:"v7,omitempty"` 2163 V8__ *HeaderPlaintextUnsupported `codec:"v8,omitempty" json:"v8,omitempty"` 2164 V9__ *HeaderPlaintextUnsupported `codec:"v9,omitempty" json:"v9,omitempty"` 2165 V10__ *HeaderPlaintextUnsupported `codec:"v10,omitempty" json:"v10,omitempty"` 2166} 2167 2168func (o *HeaderPlaintext) Version() (ret HeaderPlaintextVersion, err error) { 2169 switch o.Version__ { 2170 case HeaderPlaintextVersion_V1: 2171 if o.V1__ == nil { 2172 err = errors.New("unexpected nil value for V1__") 2173 return ret, err 2174 } 2175 case HeaderPlaintextVersion_V2: 2176 if o.V2__ == nil { 2177 err = errors.New("unexpected nil value for V2__") 2178 return ret, err 2179 } 2180 case HeaderPlaintextVersion_V3: 2181 if o.V3__ == nil { 2182 err = errors.New("unexpected nil value for V3__") 2183 return ret, err 2184 } 2185 case HeaderPlaintextVersion_V4: 2186 if o.V4__ == nil { 2187 err = errors.New("unexpected nil value for V4__") 2188 return ret, err 2189 } 2190 case HeaderPlaintextVersion_V5: 2191 if o.V5__ == nil { 2192 err = errors.New("unexpected nil value for V5__") 2193 return ret, err 2194 } 2195 case HeaderPlaintextVersion_V6: 2196 if o.V6__ == nil { 2197 err = errors.New("unexpected nil value for V6__") 2198 return ret, err 2199 } 2200 case HeaderPlaintextVersion_V7: 2201 if o.V7__ == nil { 2202 err = errors.New("unexpected nil value for V7__") 2203 return ret, err 2204 } 2205 case HeaderPlaintextVersion_V8: 2206 if o.V8__ == nil { 2207 err = errors.New("unexpected nil value for V8__") 2208 return ret, err 2209 } 2210 case HeaderPlaintextVersion_V9: 2211 if o.V9__ == nil { 2212 err = errors.New("unexpected nil value for V9__") 2213 return ret, err 2214 } 2215 case HeaderPlaintextVersion_V10: 2216 if o.V10__ == nil { 2217 err = errors.New("unexpected nil value for V10__") 2218 return ret, err 2219 } 2220 } 2221 return o.Version__, nil 2222} 2223 2224func (o HeaderPlaintext) V1() (res HeaderPlaintextV1) { 2225 if o.Version__ != HeaderPlaintextVersion_V1 { 2226 panic("wrong case accessed") 2227 } 2228 if o.V1__ == nil { 2229 return 2230 } 2231 return *o.V1__ 2232} 2233 2234func (o HeaderPlaintext) V2() (res HeaderPlaintextUnsupported) { 2235 if o.Version__ != HeaderPlaintextVersion_V2 { 2236 panic("wrong case accessed") 2237 } 2238 if o.V2__ == nil { 2239 return 2240 } 2241 return *o.V2__ 2242} 2243 2244func (o HeaderPlaintext) V3() (res HeaderPlaintextUnsupported) { 2245 if o.Version__ != HeaderPlaintextVersion_V3 { 2246 panic("wrong case accessed") 2247 } 2248 if o.V3__ == nil { 2249 return 2250 } 2251 return *o.V3__ 2252} 2253 2254func (o HeaderPlaintext) V4() (res HeaderPlaintextUnsupported) { 2255 if o.Version__ != HeaderPlaintextVersion_V4 { 2256 panic("wrong case accessed") 2257 } 2258 if o.V4__ == nil { 2259 return 2260 } 2261 return *o.V4__ 2262} 2263 2264func (o HeaderPlaintext) V5() (res HeaderPlaintextUnsupported) { 2265 if o.Version__ != HeaderPlaintextVersion_V5 { 2266 panic("wrong case accessed") 2267 } 2268 if o.V5__ == nil { 2269 return 2270 } 2271 return *o.V5__ 2272} 2273 2274func (o HeaderPlaintext) V6() (res HeaderPlaintextUnsupported) { 2275 if o.Version__ != HeaderPlaintextVersion_V6 { 2276 panic("wrong case accessed") 2277 } 2278 if o.V6__ == nil { 2279 return 2280 } 2281 return *o.V6__ 2282} 2283 2284func (o HeaderPlaintext) V7() (res HeaderPlaintextUnsupported) { 2285 if o.Version__ != HeaderPlaintextVersion_V7 { 2286 panic("wrong case accessed") 2287 } 2288 if o.V7__ == nil { 2289 return 2290 } 2291 return *o.V7__ 2292} 2293 2294func (o HeaderPlaintext) V8() (res HeaderPlaintextUnsupported) { 2295 if o.Version__ != HeaderPlaintextVersion_V8 { 2296 panic("wrong case accessed") 2297 } 2298 if o.V8__ == nil { 2299 return 2300 } 2301 return *o.V8__ 2302} 2303 2304func (o HeaderPlaintext) V9() (res HeaderPlaintextUnsupported) { 2305 if o.Version__ != HeaderPlaintextVersion_V9 { 2306 panic("wrong case accessed") 2307 } 2308 if o.V9__ == nil { 2309 return 2310 } 2311 return *o.V9__ 2312} 2313 2314func (o HeaderPlaintext) V10() (res HeaderPlaintextUnsupported) { 2315 if o.Version__ != HeaderPlaintextVersion_V10 { 2316 panic("wrong case accessed") 2317 } 2318 if o.V10__ == nil { 2319 return 2320 } 2321 return *o.V10__ 2322} 2323 2324func NewHeaderPlaintextWithV1(v HeaderPlaintextV1) HeaderPlaintext { 2325 return HeaderPlaintext{ 2326 Version__: HeaderPlaintextVersion_V1, 2327 V1__: &v, 2328 } 2329} 2330 2331func NewHeaderPlaintextWithV2(v HeaderPlaintextUnsupported) HeaderPlaintext { 2332 return HeaderPlaintext{ 2333 Version__: HeaderPlaintextVersion_V2, 2334 V2__: &v, 2335 } 2336} 2337 2338func NewHeaderPlaintextWithV3(v HeaderPlaintextUnsupported) HeaderPlaintext { 2339 return HeaderPlaintext{ 2340 Version__: HeaderPlaintextVersion_V3, 2341 V3__: &v, 2342 } 2343} 2344 2345func NewHeaderPlaintextWithV4(v HeaderPlaintextUnsupported) HeaderPlaintext { 2346 return HeaderPlaintext{ 2347 Version__: HeaderPlaintextVersion_V4, 2348 V4__: &v, 2349 } 2350} 2351 2352func NewHeaderPlaintextWithV5(v HeaderPlaintextUnsupported) HeaderPlaintext { 2353 return HeaderPlaintext{ 2354 Version__: HeaderPlaintextVersion_V5, 2355 V5__: &v, 2356 } 2357} 2358 2359func NewHeaderPlaintextWithV6(v HeaderPlaintextUnsupported) HeaderPlaintext { 2360 return HeaderPlaintext{ 2361 Version__: HeaderPlaintextVersion_V6, 2362 V6__: &v, 2363 } 2364} 2365 2366func NewHeaderPlaintextWithV7(v HeaderPlaintextUnsupported) HeaderPlaintext { 2367 return HeaderPlaintext{ 2368 Version__: HeaderPlaintextVersion_V7, 2369 V7__: &v, 2370 } 2371} 2372 2373func NewHeaderPlaintextWithV8(v HeaderPlaintextUnsupported) HeaderPlaintext { 2374 return HeaderPlaintext{ 2375 Version__: HeaderPlaintextVersion_V8, 2376 V8__: &v, 2377 } 2378} 2379 2380func NewHeaderPlaintextWithV9(v HeaderPlaintextUnsupported) HeaderPlaintext { 2381 return HeaderPlaintext{ 2382 Version__: HeaderPlaintextVersion_V9, 2383 V9__: &v, 2384 } 2385} 2386 2387func NewHeaderPlaintextWithV10(v HeaderPlaintextUnsupported) HeaderPlaintext { 2388 return HeaderPlaintext{ 2389 Version__: HeaderPlaintextVersion_V10, 2390 V10__: &v, 2391 } 2392} 2393 2394func (o HeaderPlaintext) DeepCopy() HeaderPlaintext { 2395 return HeaderPlaintext{ 2396 Version__: o.Version__.DeepCopy(), 2397 V1__: (func(x *HeaderPlaintextV1) *HeaderPlaintextV1 { 2398 if x == nil { 2399 return nil 2400 } 2401 tmp := (*x).DeepCopy() 2402 return &tmp 2403 })(o.V1__), 2404 V2__: (func(x *HeaderPlaintextUnsupported) *HeaderPlaintextUnsupported { 2405 if x == nil { 2406 return nil 2407 } 2408 tmp := (*x).DeepCopy() 2409 return &tmp 2410 })(o.V2__), 2411 V3__: (func(x *HeaderPlaintextUnsupported) *HeaderPlaintextUnsupported { 2412 if x == nil { 2413 return nil 2414 } 2415 tmp := (*x).DeepCopy() 2416 return &tmp 2417 })(o.V3__), 2418 V4__: (func(x *HeaderPlaintextUnsupported) *HeaderPlaintextUnsupported { 2419 if x == nil { 2420 return nil 2421 } 2422 tmp := (*x).DeepCopy() 2423 return &tmp 2424 })(o.V4__), 2425 V5__: (func(x *HeaderPlaintextUnsupported) *HeaderPlaintextUnsupported { 2426 if x == nil { 2427 return nil 2428 } 2429 tmp := (*x).DeepCopy() 2430 return &tmp 2431 })(o.V5__), 2432 V6__: (func(x *HeaderPlaintextUnsupported) *HeaderPlaintextUnsupported { 2433 if x == nil { 2434 return nil 2435 } 2436 tmp := (*x).DeepCopy() 2437 return &tmp 2438 })(o.V6__), 2439 V7__: (func(x *HeaderPlaintextUnsupported) *HeaderPlaintextUnsupported { 2440 if x == nil { 2441 return nil 2442 } 2443 tmp := (*x).DeepCopy() 2444 return &tmp 2445 })(o.V7__), 2446 V8__: (func(x *HeaderPlaintextUnsupported) *HeaderPlaintextUnsupported { 2447 if x == nil { 2448 return nil 2449 } 2450 tmp := (*x).DeepCopy() 2451 return &tmp 2452 })(o.V8__), 2453 V9__: (func(x *HeaderPlaintextUnsupported) *HeaderPlaintextUnsupported { 2454 if x == nil { 2455 return nil 2456 } 2457 tmp := (*x).DeepCopy() 2458 return &tmp 2459 })(o.V9__), 2460 V10__: (func(x *HeaderPlaintextUnsupported) *HeaderPlaintextUnsupported { 2461 if x == nil { 2462 return nil 2463 } 2464 tmp := (*x).DeepCopy() 2465 return &tmp 2466 })(o.V10__), 2467 } 2468} 2469 2470type BodyPlaintextVersion int 2471 2472const ( 2473 BodyPlaintextVersion_V1 BodyPlaintextVersion = 1 2474 BodyPlaintextVersion_V2 BodyPlaintextVersion = 2 2475 BodyPlaintextVersion_V3 BodyPlaintextVersion = 3 2476 BodyPlaintextVersion_V4 BodyPlaintextVersion = 4 2477 BodyPlaintextVersion_V5 BodyPlaintextVersion = 5 2478 BodyPlaintextVersion_V6 BodyPlaintextVersion = 6 2479 BodyPlaintextVersion_V7 BodyPlaintextVersion = 7 2480 BodyPlaintextVersion_V8 BodyPlaintextVersion = 8 2481 BodyPlaintextVersion_V9 BodyPlaintextVersion = 9 2482 BodyPlaintextVersion_V10 BodyPlaintextVersion = 10 2483) 2484 2485func (o BodyPlaintextVersion) DeepCopy() BodyPlaintextVersion { return o } 2486 2487var BodyPlaintextVersionMap = map[string]BodyPlaintextVersion{ 2488 "V1": 1, 2489 "V2": 2, 2490 "V3": 3, 2491 "V4": 4, 2492 "V5": 5, 2493 "V6": 6, 2494 "V7": 7, 2495 "V8": 8, 2496 "V9": 9, 2497 "V10": 10, 2498} 2499 2500var BodyPlaintextVersionRevMap = map[BodyPlaintextVersion]string{ 2501 1: "V1", 2502 2: "V2", 2503 3: "V3", 2504 4: "V4", 2505 5: "V5", 2506 6: "V6", 2507 7: "V7", 2508 8: "V8", 2509 9: "V9", 2510 10: "V10", 2511} 2512 2513func (e BodyPlaintextVersion) String() string { 2514 if v, ok := BodyPlaintextVersionRevMap[e]; ok { 2515 return v 2516 } 2517 return fmt.Sprintf("%v", int(e)) 2518} 2519 2520type BodyPlaintextMetaInfo struct { 2521 Crit bool `codec:"crit" json:"crit"` 2522} 2523 2524func (o BodyPlaintextMetaInfo) DeepCopy() BodyPlaintextMetaInfo { 2525 return BodyPlaintextMetaInfo{ 2526 Crit: o.Crit, 2527 } 2528} 2529 2530type BodyPlaintextUnsupported struct { 2531 Mi BodyPlaintextMetaInfo `codec:"mi" json:"mi"` 2532} 2533 2534func (o BodyPlaintextUnsupported) DeepCopy() BodyPlaintextUnsupported { 2535 return BodyPlaintextUnsupported{ 2536 Mi: o.Mi.DeepCopy(), 2537 } 2538} 2539 2540type BodyPlaintextV1 struct { 2541 MessageBody MessageBody `codec:"messageBody" json:"messageBody"` 2542} 2543 2544func (o BodyPlaintextV1) DeepCopy() BodyPlaintextV1 { 2545 return BodyPlaintextV1{ 2546 MessageBody: o.MessageBody.DeepCopy(), 2547 } 2548} 2549 2550type BodyPlaintextV2 struct { 2551 MessageBody MessageBody `codec:"messageBody" json:"messageBody"` 2552 Mi BodyPlaintextMetaInfo `codec:"mi" json:"mi"` 2553} 2554 2555func (o BodyPlaintextV2) DeepCopy() BodyPlaintextV2 { 2556 return BodyPlaintextV2{ 2557 MessageBody: o.MessageBody.DeepCopy(), 2558 Mi: o.Mi.DeepCopy(), 2559 } 2560} 2561 2562type BodyPlaintext struct { 2563 Version__ BodyPlaintextVersion `codec:"version" json:"version"` 2564 V1__ *BodyPlaintextV1 `codec:"v1,omitempty" json:"v1,omitempty"` 2565 V2__ *BodyPlaintextV2 `codec:"v2,omitempty" json:"v2,omitempty"` 2566 V3__ *BodyPlaintextUnsupported `codec:"v3,omitempty" json:"v3,omitempty"` 2567 V4__ *BodyPlaintextUnsupported `codec:"v4,omitempty" json:"v4,omitempty"` 2568 V5__ *BodyPlaintextUnsupported `codec:"v5,omitempty" json:"v5,omitempty"` 2569 V6__ *BodyPlaintextUnsupported `codec:"v6,omitempty" json:"v6,omitempty"` 2570 V7__ *BodyPlaintextUnsupported `codec:"v7,omitempty" json:"v7,omitempty"` 2571 V8__ *BodyPlaintextUnsupported `codec:"v8,omitempty" json:"v8,omitempty"` 2572 V9__ *BodyPlaintextUnsupported `codec:"v9,omitempty" json:"v9,omitempty"` 2573 V10__ *BodyPlaintextUnsupported `codec:"v10,omitempty" json:"v10,omitempty"` 2574} 2575 2576func (o *BodyPlaintext) Version() (ret BodyPlaintextVersion, err error) { 2577 switch o.Version__ { 2578 case BodyPlaintextVersion_V1: 2579 if o.V1__ == nil { 2580 err = errors.New("unexpected nil value for V1__") 2581 return ret, err 2582 } 2583 case BodyPlaintextVersion_V2: 2584 if o.V2__ == nil { 2585 err = errors.New("unexpected nil value for V2__") 2586 return ret, err 2587 } 2588 case BodyPlaintextVersion_V3: 2589 if o.V3__ == nil { 2590 err = errors.New("unexpected nil value for V3__") 2591 return ret, err 2592 } 2593 case BodyPlaintextVersion_V4: 2594 if o.V4__ == nil { 2595 err = errors.New("unexpected nil value for V4__") 2596 return ret, err 2597 } 2598 case BodyPlaintextVersion_V5: 2599 if o.V5__ == nil { 2600 err = errors.New("unexpected nil value for V5__") 2601 return ret, err 2602 } 2603 case BodyPlaintextVersion_V6: 2604 if o.V6__ == nil { 2605 err = errors.New("unexpected nil value for V6__") 2606 return ret, err 2607 } 2608 case BodyPlaintextVersion_V7: 2609 if o.V7__ == nil { 2610 err = errors.New("unexpected nil value for V7__") 2611 return ret, err 2612 } 2613 case BodyPlaintextVersion_V8: 2614 if o.V8__ == nil { 2615 err = errors.New("unexpected nil value for V8__") 2616 return ret, err 2617 } 2618 case BodyPlaintextVersion_V9: 2619 if o.V9__ == nil { 2620 err = errors.New("unexpected nil value for V9__") 2621 return ret, err 2622 } 2623 case BodyPlaintextVersion_V10: 2624 if o.V10__ == nil { 2625 err = errors.New("unexpected nil value for V10__") 2626 return ret, err 2627 } 2628 } 2629 return o.Version__, nil 2630} 2631 2632func (o BodyPlaintext) V1() (res BodyPlaintextV1) { 2633 if o.Version__ != BodyPlaintextVersion_V1 { 2634 panic("wrong case accessed") 2635 } 2636 if o.V1__ == nil { 2637 return 2638 } 2639 return *o.V1__ 2640} 2641 2642func (o BodyPlaintext) V2() (res BodyPlaintextV2) { 2643 if o.Version__ != BodyPlaintextVersion_V2 { 2644 panic("wrong case accessed") 2645 } 2646 if o.V2__ == nil { 2647 return 2648 } 2649 return *o.V2__ 2650} 2651 2652func (o BodyPlaintext) V3() (res BodyPlaintextUnsupported) { 2653 if o.Version__ != BodyPlaintextVersion_V3 { 2654 panic("wrong case accessed") 2655 } 2656 if o.V3__ == nil { 2657 return 2658 } 2659 return *o.V3__ 2660} 2661 2662func (o BodyPlaintext) V4() (res BodyPlaintextUnsupported) { 2663 if o.Version__ != BodyPlaintextVersion_V4 { 2664 panic("wrong case accessed") 2665 } 2666 if o.V4__ == nil { 2667 return 2668 } 2669 return *o.V4__ 2670} 2671 2672func (o BodyPlaintext) V5() (res BodyPlaintextUnsupported) { 2673 if o.Version__ != BodyPlaintextVersion_V5 { 2674 panic("wrong case accessed") 2675 } 2676 if o.V5__ == nil { 2677 return 2678 } 2679 return *o.V5__ 2680} 2681 2682func (o BodyPlaintext) V6() (res BodyPlaintextUnsupported) { 2683 if o.Version__ != BodyPlaintextVersion_V6 { 2684 panic("wrong case accessed") 2685 } 2686 if o.V6__ == nil { 2687 return 2688 } 2689 return *o.V6__ 2690} 2691 2692func (o BodyPlaintext) V7() (res BodyPlaintextUnsupported) { 2693 if o.Version__ != BodyPlaintextVersion_V7 { 2694 panic("wrong case accessed") 2695 } 2696 if o.V7__ == nil { 2697 return 2698 } 2699 return *o.V7__ 2700} 2701 2702func (o BodyPlaintext) V8() (res BodyPlaintextUnsupported) { 2703 if o.Version__ != BodyPlaintextVersion_V8 { 2704 panic("wrong case accessed") 2705 } 2706 if o.V8__ == nil { 2707 return 2708 } 2709 return *o.V8__ 2710} 2711 2712func (o BodyPlaintext) V9() (res BodyPlaintextUnsupported) { 2713 if o.Version__ != BodyPlaintextVersion_V9 { 2714 panic("wrong case accessed") 2715 } 2716 if o.V9__ == nil { 2717 return 2718 } 2719 return *o.V9__ 2720} 2721 2722func (o BodyPlaintext) V10() (res BodyPlaintextUnsupported) { 2723 if o.Version__ != BodyPlaintextVersion_V10 { 2724 panic("wrong case accessed") 2725 } 2726 if o.V10__ == nil { 2727 return 2728 } 2729 return *o.V10__ 2730} 2731 2732func NewBodyPlaintextWithV1(v BodyPlaintextV1) BodyPlaintext { 2733 return BodyPlaintext{ 2734 Version__: BodyPlaintextVersion_V1, 2735 V1__: &v, 2736 } 2737} 2738 2739func NewBodyPlaintextWithV2(v BodyPlaintextV2) BodyPlaintext { 2740 return BodyPlaintext{ 2741 Version__: BodyPlaintextVersion_V2, 2742 V2__: &v, 2743 } 2744} 2745 2746func NewBodyPlaintextWithV3(v BodyPlaintextUnsupported) BodyPlaintext { 2747 return BodyPlaintext{ 2748 Version__: BodyPlaintextVersion_V3, 2749 V3__: &v, 2750 } 2751} 2752 2753func NewBodyPlaintextWithV4(v BodyPlaintextUnsupported) BodyPlaintext { 2754 return BodyPlaintext{ 2755 Version__: BodyPlaintextVersion_V4, 2756 V4__: &v, 2757 } 2758} 2759 2760func NewBodyPlaintextWithV5(v BodyPlaintextUnsupported) BodyPlaintext { 2761 return BodyPlaintext{ 2762 Version__: BodyPlaintextVersion_V5, 2763 V5__: &v, 2764 } 2765} 2766 2767func NewBodyPlaintextWithV6(v BodyPlaintextUnsupported) BodyPlaintext { 2768 return BodyPlaintext{ 2769 Version__: BodyPlaintextVersion_V6, 2770 V6__: &v, 2771 } 2772} 2773 2774func NewBodyPlaintextWithV7(v BodyPlaintextUnsupported) BodyPlaintext { 2775 return BodyPlaintext{ 2776 Version__: BodyPlaintextVersion_V7, 2777 V7__: &v, 2778 } 2779} 2780 2781func NewBodyPlaintextWithV8(v BodyPlaintextUnsupported) BodyPlaintext { 2782 return BodyPlaintext{ 2783 Version__: BodyPlaintextVersion_V8, 2784 V8__: &v, 2785 } 2786} 2787 2788func NewBodyPlaintextWithV9(v BodyPlaintextUnsupported) BodyPlaintext { 2789 return BodyPlaintext{ 2790 Version__: BodyPlaintextVersion_V9, 2791 V9__: &v, 2792 } 2793} 2794 2795func NewBodyPlaintextWithV10(v BodyPlaintextUnsupported) BodyPlaintext { 2796 return BodyPlaintext{ 2797 Version__: BodyPlaintextVersion_V10, 2798 V10__: &v, 2799 } 2800} 2801 2802func (o BodyPlaintext) DeepCopy() BodyPlaintext { 2803 return BodyPlaintext{ 2804 Version__: o.Version__.DeepCopy(), 2805 V1__: (func(x *BodyPlaintextV1) *BodyPlaintextV1 { 2806 if x == nil { 2807 return nil 2808 } 2809 tmp := (*x).DeepCopy() 2810 return &tmp 2811 })(o.V1__), 2812 V2__: (func(x *BodyPlaintextV2) *BodyPlaintextV2 { 2813 if x == nil { 2814 return nil 2815 } 2816 tmp := (*x).DeepCopy() 2817 return &tmp 2818 })(o.V2__), 2819 V3__: (func(x *BodyPlaintextUnsupported) *BodyPlaintextUnsupported { 2820 if x == nil { 2821 return nil 2822 } 2823 tmp := (*x).DeepCopy() 2824 return &tmp 2825 })(o.V3__), 2826 V4__: (func(x *BodyPlaintextUnsupported) *BodyPlaintextUnsupported { 2827 if x == nil { 2828 return nil 2829 } 2830 tmp := (*x).DeepCopy() 2831 return &tmp 2832 })(o.V4__), 2833 V5__: (func(x *BodyPlaintextUnsupported) *BodyPlaintextUnsupported { 2834 if x == nil { 2835 return nil 2836 } 2837 tmp := (*x).DeepCopy() 2838 return &tmp 2839 })(o.V5__), 2840 V6__: (func(x *BodyPlaintextUnsupported) *BodyPlaintextUnsupported { 2841 if x == nil { 2842 return nil 2843 } 2844 tmp := (*x).DeepCopy() 2845 return &tmp 2846 })(o.V6__), 2847 V7__: (func(x *BodyPlaintextUnsupported) *BodyPlaintextUnsupported { 2848 if x == nil { 2849 return nil 2850 } 2851 tmp := (*x).DeepCopy() 2852 return &tmp 2853 })(o.V7__), 2854 V8__: (func(x *BodyPlaintextUnsupported) *BodyPlaintextUnsupported { 2855 if x == nil { 2856 return nil 2857 } 2858 tmp := (*x).DeepCopy() 2859 return &tmp 2860 })(o.V8__), 2861 V9__: (func(x *BodyPlaintextUnsupported) *BodyPlaintextUnsupported { 2862 if x == nil { 2863 return nil 2864 } 2865 tmp := (*x).DeepCopy() 2866 return &tmp 2867 })(o.V9__), 2868 V10__: (func(x *BodyPlaintextUnsupported) *BodyPlaintextUnsupported { 2869 if x == nil { 2870 return nil 2871 } 2872 tmp := (*x).DeepCopy() 2873 return &tmp 2874 })(o.V10__), 2875 } 2876} 2877 2878type MessagePlaintext struct { 2879 ClientHeader MessageClientHeader `codec:"clientHeader" json:"clientHeader"` 2880 MessageBody MessageBody `codec:"messageBody" json:"messageBody"` 2881 SupersedesOutboxID *OutboxID `codec:"supersedesOutboxID,omitempty" json:"supersedesOutboxID,omitempty"` 2882 Emojis []HarvestedEmoji `codec:"emojis" json:"emojis"` 2883} 2884 2885func (o MessagePlaintext) DeepCopy() MessagePlaintext { 2886 return MessagePlaintext{ 2887 ClientHeader: o.ClientHeader.DeepCopy(), 2888 MessageBody: o.MessageBody.DeepCopy(), 2889 SupersedesOutboxID: (func(x *OutboxID) *OutboxID { 2890 if x == nil { 2891 return nil 2892 } 2893 tmp := (*x).DeepCopy() 2894 return &tmp 2895 })(o.SupersedesOutboxID), 2896 Emojis: (func(x []HarvestedEmoji) []HarvestedEmoji { 2897 if x == nil { 2898 return nil 2899 } 2900 ret := make([]HarvestedEmoji, len(x)) 2901 for i, v := range x { 2902 vCopy := v.DeepCopy() 2903 ret[i] = vCopy 2904 } 2905 return ret 2906 })(o.Emojis), 2907 } 2908} 2909 2910type MessageUnboxedValid struct { 2911 ClientHeader MessageClientHeaderVerified `codec:"clientHeader" json:"clientHeader"` 2912 ServerHeader MessageServerHeader `codec:"serverHeader" json:"serverHeader"` 2913 MessageBody MessageBody `codec:"messageBody" json:"messageBody"` 2914 SenderUsername string `codec:"senderUsername" json:"senderUsername"` 2915 SenderDeviceName string `codec:"senderDeviceName" json:"senderDeviceName"` 2916 SenderDeviceType keybase1.DeviceTypeV2 `codec:"senderDeviceType" json:"senderDeviceType"` 2917 BodyHash Hash `codec:"bodyHash" json:"bodyHash"` 2918 HeaderHash Hash `codec:"headerHash" json:"headerHash"` 2919 HeaderSignature *SignatureInfo `codec:"headerSignature,omitempty" json:"headerSignature,omitempty"` 2920 VerificationKey *[]byte `codec:"verificationKey,omitempty" json:"verificationKey,omitempty"` 2921 SenderDeviceRevokedAt *gregor1.Time `codec:"senderDeviceRevokedAt,omitempty" json:"senderDeviceRevokedAt,omitempty"` 2922 AtMentionUsernames []string `codec:"atMentionUsernames" json:"atMentionUsernames"` 2923 AtMentions []gregor1.UID `codec:"atMentions" json:"atMentions"` 2924 ChannelMention ChannelMention `codec:"channelMention" json:"channelMention"` 2925 MaybeMentions []MaybeMention `codec:"maybeMentions" json:"maybeMentions"` 2926 ChannelNameMentions []ChannelNameMention `codec:"channelNameMentions" json:"channelNameMentions"` 2927 Reactions ReactionMap `codec:"reactions" json:"reactions"` 2928 Unfurls map[MessageID]UnfurlResult `codec:"unfurls" json:"unfurls"` 2929 Emojis []HarvestedEmoji `codec:"emojis" json:"emojis"` 2930 ReplyTo *MessageUnboxed `codec:"replyTo,omitempty" json:"replyTo,omitempty"` 2931 BotUsername string `codec:"botUsername" json:"botUsername"` 2932} 2933 2934func (o MessageUnboxedValid) DeepCopy() MessageUnboxedValid { 2935 return MessageUnboxedValid{ 2936 ClientHeader: o.ClientHeader.DeepCopy(), 2937 ServerHeader: o.ServerHeader.DeepCopy(), 2938 MessageBody: o.MessageBody.DeepCopy(), 2939 SenderUsername: o.SenderUsername, 2940 SenderDeviceName: o.SenderDeviceName, 2941 SenderDeviceType: o.SenderDeviceType.DeepCopy(), 2942 BodyHash: o.BodyHash.DeepCopy(), 2943 HeaderHash: o.HeaderHash.DeepCopy(), 2944 HeaderSignature: (func(x *SignatureInfo) *SignatureInfo { 2945 if x == nil { 2946 return nil 2947 } 2948 tmp := (*x).DeepCopy() 2949 return &tmp 2950 })(o.HeaderSignature), 2951 VerificationKey: (func(x *[]byte) *[]byte { 2952 if x == nil { 2953 return nil 2954 } 2955 tmp := (func(x []byte) []byte { 2956 if x == nil { 2957 return nil 2958 } 2959 return append([]byte{}, x...) 2960 })((*x)) 2961 return &tmp 2962 })(o.VerificationKey), 2963 SenderDeviceRevokedAt: (func(x *gregor1.Time) *gregor1.Time { 2964 if x == nil { 2965 return nil 2966 } 2967 tmp := (*x).DeepCopy() 2968 return &tmp 2969 })(o.SenderDeviceRevokedAt), 2970 AtMentionUsernames: (func(x []string) []string { 2971 if x == nil { 2972 return nil 2973 } 2974 ret := make([]string, len(x)) 2975 for i, v := range x { 2976 vCopy := v 2977 ret[i] = vCopy 2978 } 2979 return ret 2980 })(o.AtMentionUsernames), 2981 AtMentions: (func(x []gregor1.UID) []gregor1.UID { 2982 if x == nil { 2983 return nil 2984 } 2985 ret := make([]gregor1.UID, len(x)) 2986 for i, v := range x { 2987 vCopy := v.DeepCopy() 2988 ret[i] = vCopy 2989 } 2990 return ret 2991 })(o.AtMentions), 2992 ChannelMention: o.ChannelMention.DeepCopy(), 2993 MaybeMentions: (func(x []MaybeMention) []MaybeMention { 2994 if x == nil { 2995 return nil 2996 } 2997 ret := make([]MaybeMention, len(x)) 2998 for i, v := range x { 2999 vCopy := v.DeepCopy() 3000 ret[i] = vCopy 3001 } 3002 return ret 3003 })(o.MaybeMentions), 3004 ChannelNameMentions: (func(x []ChannelNameMention) []ChannelNameMention { 3005 if x == nil { 3006 return nil 3007 } 3008 ret := make([]ChannelNameMention, len(x)) 3009 for i, v := range x { 3010 vCopy := v.DeepCopy() 3011 ret[i] = vCopy 3012 } 3013 return ret 3014 })(o.ChannelNameMentions), 3015 Reactions: o.Reactions.DeepCopy(), 3016 Unfurls: (func(x map[MessageID]UnfurlResult) map[MessageID]UnfurlResult { 3017 if x == nil { 3018 return nil 3019 } 3020 ret := make(map[MessageID]UnfurlResult, len(x)) 3021 for k, v := range x { 3022 kCopy := k.DeepCopy() 3023 vCopy := v.DeepCopy() 3024 ret[kCopy] = vCopy 3025 } 3026 return ret 3027 })(o.Unfurls), 3028 Emojis: (func(x []HarvestedEmoji) []HarvestedEmoji { 3029 if x == nil { 3030 return nil 3031 } 3032 ret := make([]HarvestedEmoji, len(x)) 3033 for i, v := range x { 3034 vCopy := v.DeepCopy() 3035 ret[i] = vCopy 3036 } 3037 return ret 3038 })(o.Emojis), 3039 ReplyTo: (func(x *MessageUnboxed) *MessageUnboxed { 3040 if x == nil { 3041 return nil 3042 } 3043 tmp := (*x).DeepCopy() 3044 return &tmp 3045 })(o.ReplyTo), 3046 BotUsername: o.BotUsername, 3047 } 3048} 3049 3050type MessageUnboxedErrorType int 3051 3052const ( 3053 MessageUnboxedErrorType_MISC MessageUnboxedErrorType = 0 3054 MessageUnboxedErrorType_BADVERSION_CRITICAL MessageUnboxedErrorType = 1 3055 MessageUnboxedErrorType_BADVERSION MessageUnboxedErrorType = 2 3056 MessageUnboxedErrorType_IDENTIFY MessageUnboxedErrorType = 3 3057 MessageUnboxedErrorType_EPHEMERAL MessageUnboxedErrorType = 4 3058 MessageUnboxedErrorType_PAIRWISE_MISSING MessageUnboxedErrorType = 5 3059) 3060 3061func (o MessageUnboxedErrorType) DeepCopy() MessageUnboxedErrorType { return o } 3062 3063var MessageUnboxedErrorTypeMap = map[string]MessageUnboxedErrorType{ 3064 "MISC": 0, 3065 "BADVERSION_CRITICAL": 1, 3066 "BADVERSION": 2, 3067 "IDENTIFY": 3, 3068 "EPHEMERAL": 4, 3069 "PAIRWISE_MISSING": 5, 3070} 3071 3072var MessageUnboxedErrorTypeRevMap = map[MessageUnboxedErrorType]string{ 3073 0: "MISC", 3074 1: "BADVERSION_CRITICAL", 3075 2: "BADVERSION", 3076 3: "IDENTIFY", 3077 4: "EPHEMERAL", 3078 5: "PAIRWISE_MISSING", 3079} 3080 3081func (e MessageUnboxedErrorType) String() string { 3082 if v, ok := MessageUnboxedErrorTypeRevMap[e]; ok { 3083 return v 3084 } 3085 return fmt.Sprintf("%v", int(e)) 3086} 3087 3088type MessageUnboxedError struct { 3089 ErrType MessageUnboxedErrorType `codec:"errType" json:"errType"` 3090 ErrMsg string `codec:"errMsg" json:"errMsg"` 3091 InternalErrMsg string `codec:"internalErrMsg" json:"internalErrMsg"` 3092 VersionKind VersionKind `codec:"versionKind" json:"versionKind"` 3093 VersionNumber int `codec:"versionNumber" json:"versionNumber"` 3094 IsCritical bool `codec:"isCritical" json:"isCritical"` 3095 SenderUsername string `codec:"senderUsername" json:"senderUsername"` 3096 SenderDeviceName string `codec:"senderDeviceName" json:"senderDeviceName"` 3097 SenderDeviceType keybase1.DeviceTypeV2 `codec:"senderDeviceType" json:"senderDeviceType"` 3098 MessageID MessageID `codec:"messageID" json:"messageID"` 3099 MessageType MessageType `codec:"messageType" json:"messageType"` 3100 Ctime gregor1.Time `codec:"ctime" json:"ctime"` 3101 IsEphemeral bool `codec:"isEphemeral" json:"isEphemeral"` 3102 ExplodedBy *string `codec:"explodedBy,omitempty" json:"explodedBy,omitempty"` 3103 Etime gregor1.Time `codec:"etime" json:"etime"` 3104 BotUsername string `codec:"botUsername" json:"botUsername"` 3105} 3106 3107func (o MessageUnboxedError) DeepCopy() MessageUnboxedError { 3108 return MessageUnboxedError{ 3109 ErrType: o.ErrType.DeepCopy(), 3110 ErrMsg: o.ErrMsg, 3111 InternalErrMsg: o.InternalErrMsg, 3112 VersionKind: o.VersionKind.DeepCopy(), 3113 VersionNumber: o.VersionNumber, 3114 IsCritical: o.IsCritical, 3115 SenderUsername: o.SenderUsername, 3116 SenderDeviceName: o.SenderDeviceName, 3117 SenderDeviceType: o.SenderDeviceType.DeepCopy(), 3118 MessageID: o.MessageID.DeepCopy(), 3119 MessageType: o.MessageType.DeepCopy(), 3120 Ctime: o.Ctime.DeepCopy(), 3121 IsEphemeral: o.IsEphemeral, 3122 ExplodedBy: (func(x *string) *string { 3123 if x == nil { 3124 return nil 3125 } 3126 tmp := (*x) 3127 return &tmp 3128 })(o.ExplodedBy), 3129 Etime: o.Etime.DeepCopy(), 3130 BotUsername: o.BotUsername, 3131 } 3132} 3133 3134type MessageUnboxedPlaceholder struct { 3135 MessageID MessageID `codec:"messageID" json:"messageID"` 3136 Hidden bool `codec:"hidden" json:"hidden"` 3137} 3138 3139func (o MessageUnboxedPlaceholder) DeepCopy() MessageUnboxedPlaceholder { 3140 return MessageUnboxedPlaceholder{ 3141 MessageID: o.MessageID.DeepCopy(), 3142 Hidden: o.Hidden, 3143 } 3144} 3145 3146type JourneycardType int 3147 3148const ( 3149 JourneycardType_WELCOME JourneycardType = 0 3150 JourneycardType_POPULAR_CHANNELS JourneycardType = 1 3151 JourneycardType_ADD_PEOPLE JourneycardType = 2 3152 JourneycardType_CREATE_CHANNELS JourneycardType = 3 3153 JourneycardType_MSG_ATTENTION JourneycardType = 4 3154 JourneycardType_UNUSED JourneycardType = 5 3155 JourneycardType_CHANNEL_INACTIVE JourneycardType = 6 3156 JourneycardType_MSG_NO_ANSWER JourneycardType = 7 3157) 3158 3159func (o JourneycardType) DeepCopy() JourneycardType { return o } 3160 3161var JourneycardTypeMap = map[string]JourneycardType{ 3162 "WELCOME": 0, 3163 "POPULAR_CHANNELS": 1, 3164 "ADD_PEOPLE": 2, 3165 "CREATE_CHANNELS": 3, 3166 "MSG_ATTENTION": 4, 3167 "UNUSED": 5, 3168 "CHANNEL_INACTIVE": 6, 3169 "MSG_NO_ANSWER": 7, 3170} 3171 3172var JourneycardTypeRevMap = map[JourneycardType]string{ 3173 0: "WELCOME", 3174 1: "POPULAR_CHANNELS", 3175 2: "ADD_PEOPLE", 3176 3: "CREATE_CHANNELS", 3177 4: "MSG_ATTENTION", 3178 5: "UNUSED", 3179 6: "CHANNEL_INACTIVE", 3180 7: "MSG_NO_ANSWER", 3181} 3182 3183func (e JourneycardType) String() string { 3184 if v, ok := JourneycardTypeRevMap[e]; ok { 3185 return v 3186 } 3187 return fmt.Sprintf("%v", int(e)) 3188} 3189 3190type MessageUnboxedJourneycard struct { 3191 PrevID MessageID `codec:"prevID" json:"prevID"` 3192 Ordinal int `codec:"ordinal" json:"ordinal"` 3193 CardType JourneycardType `codec:"cardType" json:"cardType"` 3194 HighlightMsgID MessageID `codec:"highlightMsgID" json:"highlightMsgID"` 3195 OpenTeam bool `codec:"openTeam" json:"openTeam"` 3196} 3197 3198func (o MessageUnboxedJourneycard) DeepCopy() MessageUnboxedJourneycard { 3199 return MessageUnboxedJourneycard{ 3200 PrevID: o.PrevID.DeepCopy(), 3201 Ordinal: o.Ordinal, 3202 CardType: o.CardType.DeepCopy(), 3203 HighlightMsgID: o.HighlightMsgID.DeepCopy(), 3204 OpenTeam: o.OpenTeam, 3205 } 3206} 3207 3208type MessageUnboxed struct { 3209 State__ MessageUnboxedState `codec:"state" json:"state"` 3210 Valid__ *MessageUnboxedValid `codec:"valid,omitempty" json:"valid,omitempty"` 3211 Error__ *MessageUnboxedError `codec:"error,omitempty" json:"error,omitempty"` 3212 Outbox__ *OutboxRecord `codec:"outbox,omitempty" json:"outbox,omitempty"` 3213 Placeholder__ *MessageUnboxedPlaceholder `codec:"placeholder,omitempty" json:"placeholder,omitempty"` 3214 Journeycard__ *MessageUnboxedJourneycard `codec:"journeycard,omitempty" json:"journeycard,omitempty"` 3215} 3216 3217func (o *MessageUnboxed) State() (ret MessageUnboxedState, err error) { 3218 switch o.State__ { 3219 case MessageUnboxedState_VALID: 3220 if o.Valid__ == nil { 3221 err = errors.New("unexpected nil value for Valid__") 3222 return ret, err 3223 } 3224 case MessageUnboxedState_ERROR: 3225 if o.Error__ == nil { 3226 err = errors.New("unexpected nil value for Error__") 3227 return ret, err 3228 } 3229 case MessageUnboxedState_OUTBOX: 3230 if o.Outbox__ == nil { 3231 err = errors.New("unexpected nil value for Outbox__") 3232 return ret, err 3233 } 3234 case MessageUnboxedState_PLACEHOLDER: 3235 if o.Placeholder__ == nil { 3236 err = errors.New("unexpected nil value for Placeholder__") 3237 return ret, err 3238 } 3239 case MessageUnboxedState_JOURNEYCARD: 3240 if o.Journeycard__ == nil { 3241 err = errors.New("unexpected nil value for Journeycard__") 3242 return ret, err 3243 } 3244 } 3245 return o.State__, nil 3246} 3247 3248func (o MessageUnboxed) Valid() (res MessageUnboxedValid) { 3249 if o.State__ != MessageUnboxedState_VALID { 3250 panic("wrong case accessed") 3251 } 3252 if o.Valid__ == nil { 3253 return 3254 } 3255 return *o.Valid__ 3256} 3257 3258func (o MessageUnboxed) Error() (res MessageUnboxedError) { 3259 if o.State__ != MessageUnboxedState_ERROR { 3260 panic("wrong case accessed") 3261 } 3262 if o.Error__ == nil { 3263 return 3264 } 3265 return *o.Error__ 3266} 3267 3268func (o MessageUnboxed) Outbox() (res OutboxRecord) { 3269 if o.State__ != MessageUnboxedState_OUTBOX { 3270 panic("wrong case accessed") 3271 } 3272 if o.Outbox__ == nil { 3273 return 3274 } 3275 return *o.Outbox__ 3276} 3277 3278func (o MessageUnboxed) Placeholder() (res MessageUnboxedPlaceholder) { 3279 if o.State__ != MessageUnboxedState_PLACEHOLDER { 3280 panic("wrong case accessed") 3281 } 3282 if o.Placeholder__ == nil { 3283 return 3284 } 3285 return *o.Placeholder__ 3286} 3287 3288func (o MessageUnboxed) Journeycard() (res MessageUnboxedJourneycard) { 3289 if o.State__ != MessageUnboxedState_JOURNEYCARD { 3290 panic("wrong case accessed") 3291 } 3292 if o.Journeycard__ == nil { 3293 return 3294 } 3295 return *o.Journeycard__ 3296} 3297 3298func NewMessageUnboxedWithValid(v MessageUnboxedValid) MessageUnboxed { 3299 return MessageUnboxed{ 3300 State__: MessageUnboxedState_VALID, 3301 Valid__: &v, 3302 } 3303} 3304 3305func NewMessageUnboxedWithError(v MessageUnboxedError) MessageUnboxed { 3306 return MessageUnboxed{ 3307 State__: MessageUnboxedState_ERROR, 3308 Error__: &v, 3309 } 3310} 3311 3312func NewMessageUnboxedWithOutbox(v OutboxRecord) MessageUnboxed { 3313 return MessageUnboxed{ 3314 State__: MessageUnboxedState_OUTBOX, 3315 Outbox__: &v, 3316 } 3317} 3318 3319func NewMessageUnboxedWithPlaceholder(v MessageUnboxedPlaceholder) MessageUnboxed { 3320 return MessageUnboxed{ 3321 State__: MessageUnboxedState_PLACEHOLDER, 3322 Placeholder__: &v, 3323 } 3324} 3325 3326func NewMessageUnboxedWithJourneycard(v MessageUnboxedJourneycard) MessageUnboxed { 3327 return MessageUnboxed{ 3328 State__: MessageUnboxedState_JOURNEYCARD, 3329 Journeycard__: &v, 3330 } 3331} 3332 3333func (o MessageUnboxed) DeepCopy() MessageUnboxed { 3334 return MessageUnboxed{ 3335 State__: o.State__.DeepCopy(), 3336 Valid__: (func(x *MessageUnboxedValid) *MessageUnboxedValid { 3337 if x == nil { 3338 return nil 3339 } 3340 tmp := (*x).DeepCopy() 3341 return &tmp 3342 })(o.Valid__), 3343 Error__: (func(x *MessageUnboxedError) *MessageUnboxedError { 3344 if x == nil { 3345 return nil 3346 } 3347 tmp := (*x).DeepCopy() 3348 return &tmp 3349 })(o.Error__), 3350 Outbox__: (func(x *OutboxRecord) *OutboxRecord { 3351 if x == nil { 3352 return nil 3353 } 3354 tmp := (*x).DeepCopy() 3355 return &tmp 3356 })(o.Outbox__), 3357 Placeholder__: (func(x *MessageUnboxedPlaceholder) *MessageUnboxedPlaceholder { 3358 if x == nil { 3359 return nil 3360 } 3361 tmp := (*x).DeepCopy() 3362 return &tmp 3363 })(o.Placeholder__), 3364 Journeycard__: (func(x *MessageUnboxedJourneycard) *MessageUnboxedJourneycard { 3365 if x == nil { 3366 return nil 3367 } 3368 tmp := (*x).DeepCopy() 3369 return &tmp 3370 })(o.Journeycard__), 3371 } 3372} 3373 3374type UnreadFirstNumLimit struct { 3375 NumRead int `codec:"NumRead" json:"NumRead"` 3376 AtLeast int `codec:"AtLeast" json:"AtLeast"` 3377 AtMost int `codec:"AtMost" json:"AtMost"` 3378} 3379 3380func (o UnreadFirstNumLimit) DeepCopy() UnreadFirstNumLimit { 3381 return UnreadFirstNumLimit{ 3382 NumRead: o.NumRead, 3383 AtLeast: o.AtLeast, 3384 AtMost: o.AtMost, 3385 } 3386} 3387 3388type ConversationLocalParticipant struct { 3389 Username string `codec:"username" json:"username"` 3390 InConvName bool `codec:"inConvName" json:"inConvName"` 3391 Fullname *string `codec:"fullname,omitempty" json:"fullname,omitempty"` 3392 ContactName *string `codec:"contactName,omitempty" json:"contactName,omitempty"` 3393} 3394 3395func (o ConversationLocalParticipant) DeepCopy() ConversationLocalParticipant { 3396 return ConversationLocalParticipant{ 3397 Username: o.Username, 3398 InConvName: o.InConvName, 3399 Fullname: (func(x *string) *string { 3400 if x == nil { 3401 return nil 3402 } 3403 tmp := (*x) 3404 return &tmp 3405 })(o.Fullname), 3406 ContactName: (func(x *string) *string { 3407 if x == nil { 3408 return nil 3409 } 3410 tmp := (*x) 3411 return &tmp 3412 })(o.ContactName), 3413 } 3414} 3415 3416type ConversationPinnedMessage struct { 3417 Message MessageUnboxed `codec:"message" json:"message"` 3418 PinnerUsername string `codec:"pinnerUsername" json:"pinnerUsername"` 3419} 3420 3421func (o ConversationPinnedMessage) DeepCopy() ConversationPinnedMessage { 3422 return ConversationPinnedMessage{ 3423 Message: o.Message.DeepCopy(), 3424 PinnerUsername: o.PinnerUsername, 3425 } 3426} 3427 3428type ConversationInfoLocal struct { 3429 Id ConversationID `codec:"id" json:"id"` 3430 Triple ConversationIDTriple `codec:"triple" json:"triple"` 3431 TlfName string `codec:"tlfName" json:"tlfName"` 3432 TopicName string `codec:"topicName" json:"topicName"` 3433 Headline string `codec:"headline" json:"headline"` 3434 HeadlineEmojis []HarvestedEmoji `codec:"headlineEmojis" json:"headlineEmojis"` 3435 SnippetMsg *MessageUnboxed `codec:"snippetMsg,omitempty" json:"snippetMsg,omitempty"` 3436 PinnedMsg *ConversationPinnedMessage `codec:"pinnedMsg,omitempty" json:"pinnedMsg,omitempty"` 3437 Draft *string `codec:"draft,omitempty" json:"draft,omitempty"` 3438 Visibility keybase1.TLFVisibility `codec:"visibility" json:"visibility"` 3439 IsDefaultConv bool `codec:"isDefaultConv" json:"isDefaultConv"` 3440 Status ConversationStatus `codec:"status" json:"status"` 3441 MembersType ConversationMembersType `codec:"membersType" json:"membersType"` 3442 MemberStatus ConversationMemberStatus `codec:"memberStatus" json:"memberStatus"` 3443 TeamType TeamType `codec:"teamType" json:"teamType"` 3444 Existence ConversationExistence `codec:"existence" json:"existence"` 3445 Version ConversationVers `codec:"version" json:"version"` 3446 LocalVersion LocalConversationVers `codec:"localVersion" json:"localVersion"` 3447 Participants []ConversationLocalParticipant `codec:"participants" json:"participants"` 3448 FinalizeInfo *ConversationFinalizeInfo `codec:"finalizeInfo,omitempty" json:"finalizeInfo,omitempty"` 3449 ResetNames []string `codec:"resetNames" json:"resetNames"` 3450} 3451 3452func (o ConversationInfoLocal) DeepCopy() ConversationInfoLocal { 3453 return ConversationInfoLocal{ 3454 Id: o.Id.DeepCopy(), 3455 Triple: o.Triple.DeepCopy(), 3456 TlfName: o.TlfName, 3457 TopicName: o.TopicName, 3458 Headline: o.Headline, 3459 HeadlineEmojis: (func(x []HarvestedEmoji) []HarvestedEmoji { 3460 if x == nil { 3461 return nil 3462 } 3463 ret := make([]HarvestedEmoji, len(x)) 3464 for i, v := range x { 3465 vCopy := v.DeepCopy() 3466 ret[i] = vCopy 3467 } 3468 return ret 3469 })(o.HeadlineEmojis), 3470 SnippetMsg: (func(x *MessageUnboxed) *MessageUnboxed { 3471 if x == nil { 3472 return nil 3473 } 3474 tmp := (*x).DeepCopy() 3475 return &tmp 3476 })(o.SnippetMsg), 3477 PinnedMsg: (func(x *ConversationPinnedMessage) *ConversationPinnedMessage { 3478 if x == nil { 3479 return nil 3480 } 3481 tmp := (*x).DeepCopy() 3482 return &tmp 3483 })(o.PinnedMsg), 3484 Draft: (func(x *string) *string { 3485 if x == nil { 3486 return nil 3487 } 3488 tmp := (*x) 3489 return &tmp 3490 })(o.Draft), 3491 Visibility: o.Visibility.DeepCopy(), 3492 IsDefaultConv: o.IsDefaultConv, 3493 Status: o.Status.DeepCopy(), 3494 MembersType: o.MembersType.DeepCopy(), 3495 MemberStatus: o.MemberStatus.DeepCopy(), 3496 TeamType: o.TeamType.DeepCopy(), 3497 Existence: o.Existence.DeepCopy(), 3498 Version: o.Version.DeepCopy(), 3499 LocalVersion: o.LocalVersion.DeepCopy(), 3500 Participants: (func(x []ConversationLocalParticipant) []ConversationLocalParticipant { 3501 if x == nil { 3502 return nil 3503 } 3504 ret := make([]ConversationLocalParticipant, len(x)) 3505 for i, v := range x { 3506 vCopy := v.DeepCopy() 3507 ret[i] = vCopy 3508 } 3509 return ret 3510 })(o.Participants), 3511 FinalizeInfo: (func(x *ConversationFinalizeInfo) *ConversationFinalizeInfo { 3512 if x == nil { 3513 return nil 3514 } 3515 tmp := (*x).DeepCopy() 3516 return &tmp 3517 })(o.FinalizeInfo), 3518 ResetNames: (func(x []string) []string { 3519 if x == nil { 3520 return nil 3521 } 3522 ret := make([]string, len(x)) 3523 for i, v := range x { 3524 vCopy := v 3525 ret[i] = vCopy 3526 } 3527 return ret 3528 })(o.ResetNames), 3529 } 3530} 3531 3532type ConversationErrorType int 3533 3534const ( 3535 ConversationErrorType_PERMANENT ConversationErrorType = 0 3536 ConversationErrorType_MISSINGINFO ConversationErrorType = 1 3537 ConversationErrorType_SELFREKEYNEEDED ConversationErrorType = 2 3538 ConversationErrorType_OTHERREKEYNEEDED ConversationErrorType = 3 3539 ConversationErrorType_IDENTIFY ConversationErrorType = 4 3540 ConversationErrorType_TRANSIENT ConversationErrorType = 5 3541 ConversationErrorType_NONE ConversationErrorType = 6 3542) 3543 3544func (o ConversationErrorType) DeepCopy() ConversationErrorType { return o } 3545 3546var ConversationErrorTypeMap = map[string]ConversationErrorType{ 3547 "PERMANENT": 0, 3548 "MISSINGINFO": 1, 3549 "SELFREKEYNEEDED": 2, 3550 "OTHERREKEYNEEDED": 3, 3551 "IDENTIFY": 4, 3552 "TRANSIENT": 5, 3553 "NONE": 6, 3554} 3555 3556var ConversationErrorTypeRevMap = map[ConversationErrorType]string{ 3557 0: "PERMANENT", 3558 1: "MISSINGINFO", 3559 2: "SELFREKEYNEEDED", 3560 3: "OTHERREKEYNEEDED", 3561 4: "IDENTIFY", 3562 5: "TRANSIENT", 3563 6: "NONE", 3564} 3565 3566func (e ConversationErrorType) String() string { 3567 if v, ok := ConversationErrorTypeRevMap[e]; ok { 3568 return v 3569 } 3570 return fmt.Sprintf("%v", int(e)) 3571} 3572 3573type ConversationErrorLocal struct { 3574 Typ ConversationErrorType `codec:"typ" json:"typ"` 3575 Message string `codec:"message" json:"message"` 3576 RemoteConv Conversation `codec:"remoteConv" json:"remoteConv"` 3577 UnverifiedTLFName string `codec:"unverifiedTLFName" json:"unverifiedTLFName"` 3578 RekeyInfo *ConversationErrorRekey `codec:"rekeyInfo,omitempty" json:"rekeyInfo,omitempty"` 3579} 3580 3581func (o ConversationErrorLocal) DeepCopy() ConversationErrorLocal { 3582 return ConversationErrorLocal{ 3583 Typ: o.Typ.DeepCopy(), 3584 Message: o.Message, 3585 RemoteConv: o.RemoteConv.DeepCopy(), 3586 UnverifiedTLFName: o.UnverifiedTLFName, 3587 RekeyInfo: (func(x *ConversationErrorRekey) *ConversationErrorRekey { 3588 if x == nil { 3589 return nil 3590 } 3591 tmp := (*x).DeepCopy() 3592 return &tmp 3593 })(o.RekeyInfo), 3594 } 3595} 3596 3597type ConversationErrorRekey struct { 3598 TlfName string `codec:"tlfName" json:"tlfName"` 3599 TlfPublic bool `codec:"tlfPublic" json:"tlfPublic"` 3600 Rekeyers []string `codec:"rekeyers" json:"rekeyers"` 3601 WriterNames []string `codec:"writerNames" json:"writerNames"` 3602 ReaderNames []string `codec:"readerNames" json:"readerNames"` 3603} 3604 3605func (o ConversationErrorRekey) DeepCopy() ConversationErrorRekey { 3606 return ConversationErrorRekey{ 3607 TlfName: o.TlfName, 3608 TlfPublic: o.TlfPublic, 3609 Rekeyers: (func(x []string) []string { 3610 if x == nil { 3611 return nil 3612 } 3613 ret := make([]string, len(x)) 3614 for i, v := range x { 3615 vCopy := v 3616 ret[i] = vCopy 3617 } 3618 return ret 3619 })(o.Rekeyers), 3620 WriterNames: (func(x []string) []string { 3621 if x == nil { 3622 return nil 3623 } 3624 ret := make([]string, len(x)) 3625 for i, v := range x { 3626 vCopy := v 3627 ret[i] = vCopy 3628 } 3629 return ret 3630 })(o.WriterNames), 3631 ReaderNames: (func(x []string) []string { 3632 if x == nil { 3633 return nil 3634 } 3635 ret := make([]string, len(x)) 3636 for i, v := range x { 3637 vCopy := v 3638 ret[i] = vCopy 3639 } 3640 return ret 3641 })(o.ReaderNames), 3642 } 3643} 3644 3645type ConversationMinWriterRoleInfoLocal struct { 3646 ChangedBy string `codec:"changedBy" json:"changedBy"` 3647 CannotWrite bool `codec:"cannotWrite" json:"cannotWrite"` 3648 Role keybase1.TeamRole `codec:"role" json:"role"` 3649} 3650 3651func (o ConversationMinWriterRoleInfoLocal) DeepCopy() ConversationMinWriterRoleInfoLocal { 3652 return ConversationMinWriterRoleInfoLocal{ 3653 ChangedBy: o.ChangedBy, 3654 CannotWrite: o.CannotWrite, 3655 Role: o.Role.DeepCopy(), 3656 } 3657} 3658 3659type ConversationSettingsLocal struct { 3660 MinWriterRoleInfo *ConversationMinWriterRoleInfoLocal `codec:"minWriterRoleInfo,omitempty" json:"minWriterRoleInfo,omitempty"` 3661} 3662 3663func (o ConversationSettingsLocal) DeepCopy() ConversationSettingsLocal { 3664 return ConversationSettingsLocal{ 3665 MinWriterRoleInfo: (func(x *ConversationMinWriterRoleInfoLocal) *ConversationMinWriterRoleInfoLocal { 3666 if x == nil { 3667 return nil 3668 } 3669 tmp := (*x).DeepCopy() 3670 return &tmp 3671 })(o.MinWriterRoleInfo), 3672 } 3673} 3674 3675type ConversationLocal struct { 3676 Error *ConversationErrorLocal `codec:"error,omitempty" json:"error,omitempty"` 3677 Info ConversationInfoLocal `codec:"info" json:"info"` 3678 ReaderInfo ConversationReaderInfo `codec:"readerInfo" json:"readerInfo"` 3679 CreatorInfo *ConversationCreatorInfoLocal `codec:"creatorInfo,omitempty" json:"creatorInfo,omitempty"` 3680 Notifications *ConversationNotificationInfo `codec:"notifications,omitempty" json:"notifications,omitempty"` 3681 Supersedes []ConversationMetadata `codec:"supersedes" json:"supersedes"` 3682 SupersededBy []ConversationMetadata `codec:"supersededBy" json:"supersededBy"` 3683 MaxMessages []MessageSummary `codec:"maxMessages" json:"maxMessages"` 3684 IsEmpty bool `codec:"isEmpty" json:"isEmpty"` 3685 IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` 3686 Expunge Expunge `codec:"expunge" json:"expunge"` 3687 ConvRetention *RetentionPolicy `codec:"convRetention,omitempty" json:"convRetention,omitempty"` 3688 TeamRetention *RetentionPolicy `codec:"teamRetention,omitempty" json:"teamRetention,omitempty"` 3689 ConvSettings *ConversationSettingsLocal `codec:"convSettings,omitempty" json:"convSettings,omitempty"` 3690 Commands ConversationCommandGroups `codec:"commands" json:"commands"` 3691 BotCommands ConversationCommandGroups `codec:"botCommands" json:"botCommands"` 3692 BotAliases map[string]string `codec:"botAliases" json:"botAliases"` 3693} 3694 3695func (o ConversationLocal) DeepCopy() ConversationLocal { 3696 return ConversationLocal{ 3697 Error: (func(x *ConversationErrorLocal) *ConversationErrorLocal { 3698 if x == nil { 3699 return nil 3700 } 3701 tmp := (*x).DeepCopy() 3702 return &tmp 3703 })(o.Error), 3704 Info: o.Info.DeepCopy(), 3705 ReaderInfo: o.ReaderInfo.DeepCopy(), 3706 CreatorInfo: (func(x *ConversationCreatorInfoLocal) *ConversationCreatorInfoLocal { 3707 if x == nil { 3708 return nil 3709 } 3710 tmp := (*x).DeepCopy() 3711 return &tmp 3712 })(o.CreatorInfo), 3713 Notifications: (func(x *ConversationNotificationInfo) *ConversationNotificationInfo { 3714 if x == nil { 3715 return nil 3716 } 3717 tmp := (*x).DeepCopy() 3718 return &tmp 3719 })(o.Notifications), 3720 Supersedes: (func(x []ConversationMetadata) []ConversationMetadata { 3721 if x == nil { 3722 return nil 3723 } 3724 ret := make([]ConversationMetadata, len(x)) 3725 for i, v := range x { 3726 vCopy := v.DeepCopy() 3727 ret[i] = vCopy 3728 } 3729 return ret 3730 })(o.Supersedes), 3731 SupersededBy: (func(x []ConversationMetadata) []ConversationMetadata { 3732 if x == nil { 3733 return nil 3734 } 3735 ret := make([]ConversationMetadata, len(x)) 3736 for i, v := range x { 3737 vCopy := v.DeepCopy() 3738 ret[i] = vCopy 3739 } 3740 return ret 3741 })(o.SupersededBy), 3742 MaxMessages: (func(x []MessageSummary) []MessageSummary { 3743 if x == nil { 3744 return nil 3745 } 3746 ret := make([]MessageSummary, len(x)) 3747 for i, v := range x { 3748 vCopy := v.DeepCopy() 3749 ret[i] = vCopy 3750 } 3751 return ret 3752 })(o.MaxMessages), 3753 IsEmpty: o.IsEmpty, 3754 IdentifyFailures: (func(x []keybase1.TLFIdentifyFailure) []keybase1.TLFIdentifyFailure { 3755 if x == nil { 3756 return nil 3757 } 3758 ret := make([]keybase1.TLFIdentifyFailure, len(x)) 3759 for i, v := range x { 3760 vCopy := v.DeepCopy() 3761 ret[i] = vCopy 3762 } 3763 return ret 3764 })(o.IdentifyFailures), 3765 Expunge: o.Expunge.DeepCopy(), 3766 ConvRetention: (func(x *RetentionPolicy) *RetentionPolicy { 3767 if x == nil { 3768 return nil 3769 } 3770 tmp := (*x).DeepCopy() 3771 return &tmp 3772 })(o.ConvRetention), 3773 TeamRetention: (func(x *RetentionPolicy) *RetentionPolicy { 3774 if x == nil { 3775 return nil 3776 } 3777 tmp := (*x).DeepCopy() 3778 return &tmp 3779 })(o.TeamRetention), 3780 ConvSettings: (func(x *ConversationSettingsLocal) *ConversationSettingsLocal { 3781 if x == nil { 3782 return nil 3783 } 3784 tmp := (*x).DeepCopy() 3785 return &tmp 3786 })(o.ConvSettings), 3787 Commands: o.Commands.DeepCopy(), 3788 BotCommands: o.BotCommands.DeepCopy(), 3789 BotAliases: (func(x map[string]string) map[string]string { 3790 if x == nil { 3791 return nil 3792 } 3793 ret := make(map[string]string, len(x)) 3794 for k, v := range x { 3795 kCopy := k 3796 vCopy := v 3797 ret[kCopy] = vCopy 3798 } 3799 return ret 3800 })(o.BotAliases), 3801 } 3802} 3803 3804type NonblockFetchRes struct { 3805 Offline bool `codec:"offline" json:"offline"` 3806 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 3807 IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` 3808} 3809 3810func (o NonblockFetchRes) DeepCopy() NonblockFetchRes { 3811 return NonblockFetchRes{ 3812 Offline: o.Offline, 3813 RateLimits: (func(x []RateLimit) []RateLimit { 3814 if x == nil { 3815 return nil 3816 } 3817 ret := make([]RateLimit, len(x)) 3818 for i, v := range x { 3819 vCopy := v.DeepCopy() 3820 ret[i] = vCopy 3821 } 3822 return ret 3823 })(o.RateLimits), 3824 IdentifyFailures: (func(x []keybase1.TLFIdentifyFailure) []keybase1.TLFIdentifyFailure { 3825 if x == nil { 3826 return nil 3827 } 3828 ret := make([]keybase1.TLFIdentifyFailure, len(x)) 3829 for i, v := range x { 3830 vCopy := v.DeepCopy() 3831 ret[i] = vCopy 3832 } 3833 return ret 3834 })(o.IdentifyFailures), 3835 } 3836} 3837 3838type ThreadView struct { 3839 Messages []MessageUnboxed `codec:"messages" json:"messages"` 3840 Pagination *Pagination `codec:"pagination,omitempty" json:"pagination,omitempty"` 3841} 3842 3843func (o ThreadView) DeepCopy() ThreadView { 3844 return ThreadView{ 3845 Messages: (func(x []MessageUnboxed) []MessageUnboxed { 3846 if x == nil { 3847 return nil 3848 } 3849 ret := make([]MessageUnboxed, len(x)) 3850 for i, v := range x { 3851 vCopy := v.DeepCopy() 3852 ret[i] = vCopy 3853 } 3854 return ret 3855 })(o.Messages), 3856 Pagination: (func(x *Pagination) *Pagination { 3857 if x == nil { 3858 return nil 3859 } 3860 tmp := (*x).DeepCopy() 3861 return &tmp 3862 })(o.Pagination), 3863 } 3864} 3865 3866type MessageIDControlMode int 3867 3868const ( 3869 MessageIDControlMode_OLDERMESSAGES MessageIDControlMode = 0 3870 MessageIDControlMode_NEWERMESSAGES MessageIDControlMode = 1 3871 MessageIDControlMode_CENTERED MessageIDControlMode = 2 3872 MessageIDControlMode_UNREADLINE MessageIDControlMode = 3 3873) 3874 3875func (o MessageIDControlMode) DeepCopy() MessageIDControlMode { return o } 3876 3877var MessageIDControlModeMap = map[string]MessageIDControlMode{ 3878 "OLDERMESSAGES": 0, 3879 "NEWERMESSAGES": 1, 3880 "CENTERED": 2, 3881 "UNREADLINE": 3, 3882} 3883 3884var MessageIDControlModeRevMap = map[MessageIDControlMode]string{ 3885 0: "OLDERMESSAGES", 3886 1: "NEWERMESSAGES", 3887 2: "CENTERED", 3888 3: "UNREADLINE", 3889} 3890 3891func (e MessageIDControlMode) String() string { 3892 if v, ok := MessageIDControlModeRevMap[e]; ok { 3893 return v 3894 } 3895 return fmt.Sprintf("%v", int(e)) 3896} 3897 3898type MessageIDControl struct { 3899 Pivot *MessageID `codec:"pivot,omitempty" json:"pivot,omitempty"` 3900 Mode MessageIDControlMode `codec:"mode" json:"mode"` 3901 Num int `codec:"num" json:"num"` 3902} 3903 3904func (o MessageIDControl) DeepCopy() MessageIDControl { 3905 return MessageIDControl{ 3906 Pivot: (func(x *MessageID) *MessageID { 3907 if x == nil { 3908 return nil 3909 } 3910 tmp := (*x).DeepCopy() 3911 return &tmp 3912 })(o.Pivot), 3913 Mode: o.Mode.DeepCopy(), 3914 Num: o.Num, 3915 } 3916} 3917 3918type GetThreadQuery struct { 3919 MarkAsRead bool `codec:"markAsRead" json:"markAsRead"` 3920 MessageTypes []MessageType `codec:"messageTypes" json:"messageTypes"` 3921 DisableResolveSupersedes bool `codec:"disableResolveSupersedes" json:"disableResolveSupersedes"` 3922 EnableDeletePlaceholders bool `codec:"enableDeletePlaceholders" json:"enableDeletePlaceholders"` 3923 DisablePostProcessThread bool `codec:"disablePostProcessThread" json:"disablePostProcessThread"` 3924 Before *gregor1.Time `codec:"before,omitempty" json:"before,omitempty"` 3925 After *gregor1.Time `codec:"after,omitempty" json:"after,omitempty"` 3926 MessageIDControl *MessageIDControl `codec:"messageIDControl,omitempty" json:"messageIDControl,omitempty"` 3927} 3928 3929func (o GetThreadQuery) DeepCopy() GetThreadQuery { 3930 return GetThreadQuery{ 3931 MarkAsRead: o.MarkAsRead, 3932 MessageTypes: (func(x []MessageType) []MessageType { 3933 if x == nil { 3934 return nil 3935 } 3936 ret := make([]MessageType, len(x)) 3937 for i, v := range x { 3938 vCopy := v.DeepCopy() 3939 ret[i] = vCopy 3940 } 3941 return ret 3942 })(o.MessageTypes), 3943 DisableResolveSupersedes: o.DisableResolveSupersedes, 3944 EnableDeletePlaceholders: o.EnableDeletePlaceholders, 3945 DisablePostProcessThread: o.DisablePostProcessThread, 3946 Before: (func(x *gregor1.Time) *gregor1.Time { 3947 if x == nil { 3948 return nil 3949 } 3950 tmp := (*x).DeepCopy() 3951 return &tmp 3952 })(o.Before), 3953 After: (func(x *gregor1.Time) *gregor1.Time { 3954 if x == nil { 3955 return nil 3956 } 3957 tmp := (*x).DeepCopy() 3958 return &tmp 3959 })(o.After), 3960 MessageIDControl: (func(x *MessageIDControl) *MessageIDControl { 3961 if x == nil { 3962 return nil 3963 } 3964 tmp := (*x).DeepCopy() 3965 return &tmp 3966 })(o.MessageIDControl), 3967 } 3968} 3969 3970type GetThreadLocalRes struct { 3971 Thread ThreadView `codec:"thread" json:"thread"` 3972 Offline bool `codec:"offline" json:"offline"` 3973 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 3974 IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` 3975} 3976 3977func (o GetThreadLocalRes) DeepCopy() GetThreadLocalRes { 3978 return GetThreadLocalRes{ 3979 Thread: o.Thread.DeepCopy(), 3980 Offline: o.Offline, 3981 RateLimits: (func(x []RateLimit) []RateLimit { 3982 if x == nil { 3983 return nil 3984 } 3985 ret := make([]RateLimit, len(x)) 3986 for i, v := range x { 3987 vCopy := v.DeepCopy() 3988 ret[i] = vCopy 3989 } 3990 return ret 3991 })(o.RateLimits), 3992 IdentifyFailures: (func(x []keybase1.TLFIdentifyFailure) []keybase1.TLFIdentifyFailure { 3993 if x == nil { 3994 return nil 3995 } 3996 ret := make([]keybase1.TLFIdentifyFailure, len(x)) 3997 for i, v := range x { 3998 vCopy := v.DeepCopy() 3999 ret[i] = vCopy 4000 } 4001 return ret 4002 })(o.IdentifyFailures), 4003 } 4004} 4005 4006type GetThreadNonblockCbMode int 4007 4008const ( 4009 GetThreadNonblockCbMode_FULL GetThreadNonblockCbMode = 0 4010 GetThreadNonblockCbMode_INCREMENTAL GetThreadNonblockCbMode = 1 4011) 4012 4013func (o GetThreadNonblockCbMode) DeepCopy() GetThreadNonblockCbMode { return o } 4014 4015var GetThreadNonblockCbModeMap = map[string]GetThreadNonblockCbMode{ 4016 "FULL": 0, 4017 "INCREMENTAL": 1, 4018} 4019 4020var GetThreadNonblockCbModeRevMap = map[GetThreadNonblockCbMode]string{ 4021 0: "FULL", 4022 1: "INCREMENTAL", 4023} 4024 4025func (e GetThreadNonblockCbMode) String() string { 4026 if v, ok := GetThreadNonblockCbModeRevMap[e]; ok { 4027 return v 4028 } 4029 return fmt.Sprintf("%v", int(e)) 4030} 4031 4032type GetThreadNonblockPgMode int 4033 4034const ( 4035 GetThreadNonblockPgMode_DEFAULT GetThreadNonblockPgMode = 0 4036 GetThreadNonblockPgMode_SERVER GetThreadNonblockPgMode = 1 4037) 4038 4039func (o GetThreadNonblockPgMode) DeepCopy() GetThreadNonblockPgMode { return o } 4040 4041var GetThreadNonblockPgModeMap = map[string]GetThreadNonblockPgMode{ 4042 "DEFAULT": 0, 4043 "SERVER": 1, 4044} 4045 4046var GetThreadNonblockPgModeRevMap = map[GetThreadNonblockPgMode]string{ 4047 0: "DEFAULT", 4048 1: "SERVER", 4049} 4050 4051func (e GetThreadNonblockPgMode) String() string { 4052 if v, ok := GetThreadNonblockPgModeRevMap[e]; ok { 4053 return v 4054 } 4055 return fmt.Sprintf("%v", int(e)) 4056} 4057 4058type UnreadlineRes struct { 4059 Offline bool `codec:"offline" json:"offline"` 4060 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 4061 IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` 4062 UnreadlineID *MessageID `codec:"unreadlineID,omitempty" json:"unreadlineID,omitempty"` 4063} 4064 4065func (o UnreadlineRes) DeepCopy() UnreadlineRes { 4066 return UnreadlineRes{ 4067 Offline: o.Offline, 4068 RateLimits: (func(x []RateLimit) []RateLimit { 4069 if x == nil { 4070 return nil 4071 } 4072 ret := make([]RateLimit, len(x)) 4073 for i, v := range x { 4074 vCopy := v.DeepCopy() 4075 ret[i] = vCopy 4076 } 4077 return ret 4078 })(o.RateLimits), 4079 IdentifyFailures: (func(x []keybase1.TLFIdentifyFailure) []keybase1.TLFIdentifyFailure { 4080 if x == nil { 4081 return nil 4082 } 4083 ret := make([]keybase1.TLFIdentifyFailure, len(x)) 4084 for i, v := range x { 4085 vCopy := v.DeepCopy() 4086 ret[i] = vCopy 4087 } 4088 return ret 4089 })(o.IdentifyFailures), 4090 UnreadlineID: (func(x *MessageID) *MessageID { 4091 if x == nil { 4092 return nil 4093 } 4094 tmp := (*x).DeepCopy() 4095 return &tmp 4096 })(o.UnreadlineID), 4097 } 4098} 4099 4100type NameQuery struct { 4101 Name string `codec:"name" json:"name"` 4102 TlfID *TLFID `codec:"tlfID,omitempty" json:"tlfID,omitempty"` 4103 MembersType ConversationMembersType `codec:"membersType" json:"membersType"` 4104} 4105 4106func (o NameQuery) DeepCopy() NameQuery { 4107 return NameQuery{ 4108 Name: o.Name, 4109 TlfID: (func(x *TLFID) *TLFID { 4110 if x == nil { 4111 return nil 4112 } 4113 tmp := (*x).DeepCopy() 4114 return &tmp 4115 })(o.TlfID), 4116 MembersType: o.MembersType.DeepCopy(), 4117 } 4118} 4119 4120type GetInboxLocalQuery struct { 4121 Name *NameQuery `codec:"name,omitempty" json:"name,omitempty"` 4122 TopicName *string `codec:"topicName,omitempty" json:"topicName,omitempty"` 4123 ConvIDs []ConversationID `codec:"convIDs" json:"convIDs"` 4124 TopicType *TopicType `codec:"topicType,omitempty" json:"topicType,omitempty"` 4125 TlfVisibility *keybase1.TLFVisibility `codec:"tlfVisibility,omitempty" json:"tlfVisibility,omitempty"` 4126 Before *gregor1.Time `codec:"before,omitempty" json:"before,omitempty"` 4127 After *gregor1.Time `codec:"after,omitempty" json:"after,omitempty"` 4128 OneChatTypePerTLF *bool `codec:"oneChatTypePerTLF,omitempty" json:"oneChatTypePerTLF,omitempty"` 4129 Status []ConversationStatus `codec:"status" json:"status"` 4130 MemberStatus []ConversationMemberStatus `codec:"memberStatus" json:"memberStatus"` 4131 UnreadOnly bool `codec:"unreadOnly" json:"unreadOnly"` 4132 ReadOnly bool `codec:"readOnly" json:"readOnly"` 4133 ComputeActiveList bool `codec:"computeActiveList" json:"computeActiveList"` 4134} 4135 4136func (o GetInboxLocalQuery) DeepCopy() GetInboxLocalQuery { 4137 return GetInboxLocalQuery{ 4138 Name: (func(x *NameQuery) *NameQuery { 4139 if x == nil { 4140 return nil 4141 } 4142 tmp := (*x).DeepCopy() 4143 return &tmp 4144 })(o.Name), 4145 TopicName: (func(x *string) *string { 4146 if x == nil { 4147 return nil 4148 } 4149 tmp := (*x) 4150 return &tmp 4151 })(o.TopicName), 4152 ConvIDs: (func(x []ConversationID) []ConversationID { 4153 if x == nil { 4154 return nil 4155 } 4156 ret := make([]ConversationID, len(x)) 4157 for i, v := range x { 4158 vCopy := v.DeepCopy() 4159 ret[i] = vCopy 4160 } 4161 return ret 4162 })(o.ConvIDs), 4163 TopicType: (func(x *TopicType) *TopicType { 4164 if x == nil { 4165 return nil 4166 } 4167 tmp := (*x).DeepCopy() 4168 return &tmp 4169 })(o.TopicType), 4170 TlfVisibility: (func(x *keybase1.TLFVisibility) *keybase1.TLFVisibility { 4171 if x == nil { 4172 return nil 4173 } 4174 tmp := (*x).DeepCopy() 4175 return &tmp 4176 })(o.TlfVisibility), 4177 Before: (func(x *gregor1.Time) *gregor1.Time { 4178 if x == nil { 4179 return nil 4180 } 4181 tmp := (*x).DeepCopy() 4182 return &tmp 4183 })(o.Before), 4184 After: (func(x *gregor1.Time) *gregor1.Time { 4185 if x == nil { 4186 return nil 4187 } 4188 tmp := (*x).DeepCopy() 4189 return &tmp 4190 })(o.After), 4191 OneChatTypePerTLF: (func(x *bool) *bool { 4192 if x == nil { 4193 return nil 4194 } 4195 tmp := (*x) 4196 return &tmp 4197 })(o.OneChatTypePerTLF), 4198 Status: (func(x []ConversationStatus) []ConversationStatus { 4199 if x == nil { 4200 return nil 4201 } 4202 ret := make([]ConversationStatus, len(x)) 4203 for i, v := range x { 4204 vCopy := v.DeepCopy() 4205 ret[i] = vCopy 4206 } 4207 return ret 4208 })(o.Status), 4209 MemberStatus: (func(x []ConversationMemberStatus) []ConversationMemberStatus { 4210 if x == nil { 4211 return nil 4212 } 4213 ret := make([]ConversationMemberStatus, len(x)) 4214 for i, v := range x { 4215 vCopy := v.DeepCopy() 4216 ret[i] = vCopy 4217 } 4218 return ret 4219 })(o.MemberStatus), 4220 UnreadOnly: o.UnreadOnly, 4221 ReadOnly: o.ReadOnly, 4222 ComputeActiveList: o.ComputeActiveList, 4223 } 4224} 4225 4226type GetInboxAndUnboxLocalRes struct { 4227 Conversations []ConversationLocal `codec:"conversations" json:"conversations"` 4228 Offline bool `codec:"offline" json:"offline"` 4229 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 4230 IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` 4231} 4232 4233func (o GetInboxAndUnboxLocalRes) DeepCopy() GetInboxAndUnboxLocalRes { 4234 return GetInboxAndUnboxLocalRes{ 4235 Conversations: (func(x []ConversationLocal) []ConversationLocal { 4236 if x == nil { 4237 return nil 4238 } 4239 ret := make([]ConversationLocal, len(x)) 4240 for i, v := range x { 4241 vCopy := v.DeepCopy() 4242 ret[i] = vCopy 4243 } 4244 return ret 4245 })(o.Conversations), 4246 Offline: o.Offline, 4247 RateLimits: (func(x []RateLimit) []RateLimit { 4248 if x == nil { 4249 return nil 4250 } 4251 ret := make([]RateLimit, len(x)) 4252 for i, v := range x { 4253 vCopy := v.DeepCopy() 4254 ret[i] = vCopy 4255 } 4256 return ret 4257 })(o.RateLimits), 4258 IdentifyFailures: (func(x []keybase1.TLFIdentifyFailure) []keybase1.TLFIdentifyFailure { 4259 if x == nil { 4260 return nil 4261 } 4262 ret := make([]keybase1.TLFIdentifyFailure, len(x)) 4263 for i, v := range x { 4264 vCopy := v.DeepCopy() 4265 ret[i] = vCopy 4266 } 4267 return ret 4268 })(o.IdentifyFailures), 4269 } 4270} 4271 4272type GetInboxAndUnboxUILocalRes struct { 4273 Conversations []InboxUIItem `codec:"conversations" json:"conversations"` 4274 Offline bool `codec:"offline" json:"offline"` 4275 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 4276 IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` 4277} 4278 4279func (o GetInboxAndUnboxUILocalRes) DeepCopy() GetInboxAndUnboxUILocalRes { 4280 return GetInboxAndUnboxUILocalRes{ 4281 Conversations: (func(x []InboxUIItem) []InboxUIItem { 4282 if x == nil { 4283 return nil 4284 } 4285 ret := make([]InboxUIItem, len(x)) 4286 for i, v := range x { 4287 vCopy := v.DeepCopy() 4288 ret[i] = vCopy 4289 } 4290 return ret 4291 })(o.Conversations), 4292 Offline: o.Offline, 4293 RateLimits: (func(x []RateLimit) []RateLimit { 4294 if x == nil { 4295 return nil 4296 } 4297 ret := make([]RateLimit, len(x)) 4298 for i, v := range x { 4299 vCopy := v.DeepCopy() 4300 ret[i] = vCopy 4301 } 4302 return ret 4303 })(o.RateLimits), 4304 IdentifyFailures: (func(x []keybase1.TLFIdentifyFailure) []keybase1.TLFIdentifyFailure { 4305 if x == nil { 4306 return nil 4307 } 4308 ret := make([]keybase1.TLFIdentifyFailure, len(x)) 4309 for i, v := range x { 4310 vCopy := v.DeepCopy() 4311 ret[i] = vCopy 4312 } 4313 return ret 4314 })(o.IdentifyFailures), 4315 } 4316} 4317 4318type InboxLayoutReselectMode int 4319 4320const ( 4321 InboxLayoutReselectMode_DEFAULT InboxLayoutReselectMode = 0 4322 InboxLayoutReselectMode_FORCE InboxLayoutReselectMode = 1 4323) 4324 4325func (o InboxLayoutReselectMode) DeepCopy() InboxLayoutReselectMode { return o } 4326 4327var InboxLayoutReselectModeMap = map[string]InboxLayoutReselectMode{ 4328 "DEFAULT": 0, 4329 "FORCE": 1, 4330} 4331 4332var InboxLayoutReselectModeRevMap = map[InboxLayoutReselectMode]string{ 4333 0: "DEFAULT", 4334 1: "FORCE", 4335} 4336 4337func (e InboxLayoutReselectMode) String() string { 4338 if v, ok := InboxLayoutReselectModeRevMap[e]; ok { 4339 return v 4340 } 4341 return fmt.Sprintf("%v", int(e)) 4342} 4343 4344type PostLocalRes struct { 4345 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 4346 MessageID MessageID `codec:"messageID" json:"messageID"` 4347 IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` 4348} 4349 4350func (o PostLocalRes) DeepCopy() PostLocalRes { 4351 return PostLocalRes{ 4352 RateLimits: (func(x []RateLimit) []RateLimit { 4353 if x == nil { 4354 return nil 4355 } 4356 ret := make([]RateLimit, len(x)) 4357 for i, v := range x { 4358 vCopy := v.DeepCopy() 4359 ret[i] = vCopy 4360 } 4361 return ret 4362 })(o.RateLimits), 4363 MessageID: o.MessageID.DeepCopy(), 4364 IdentifyFailures: (func(x []keybase1.TLFIdentifyFailure) []keybase1.TLFIdentifyFailure { 4365 if x == nil { 4366 return nil 4367 } 4368 ret := make([]keybase1.TLFIdentifyFailure, len(x)) 4369 for i, v := range x { 4370 vCopy := v.DeepCopy() 4371 ret[i] = vCopy 4372 } 4373 return ret 4374 })(o.IdentifyFailures), 4375 } 4376} 4377 4378type PostLocalNonblockRes struct { 4379 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 4380 OutboxID OutboxID `codec:"outboxID" json:"outboxID"` 4381 IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` 4382} 4383 4384func (o PostLocalNonblockRes) DeepCopy() PostLocalNonblockRes { 4385 return PostLocalNonblockRes{ 4386 RateLimits: (func(x []RateLimit) []RateLimit { 4387 if x == nil { 4388 return nil 4389 } 4390 ret := make([]RateLimit, len(x)) 4391 for i, v := range x { 4392 vCopy := v.DeepCopy() 4393 ret[i] = vCopy 4394 } 4395 return ret 4396 })(o.RateLimits), 4397 OutboxID: o.OutboxID.DeepCopy(), 4398 IdentifyFailures: (func(x []keybase1.TLFIdentifyFailure) []keybase1.TLFIdentifyFailure { 4399 if x == nil { 4400 return nil 4401 } 4402 ret := make([]keybase1.TLFIdentifyFailure, len(x)) 4403 for i, v := range x { 4404 vCopy := v.DeepCopy() 4405 ret[i] = vCopy 4406 } 4407 return ret 4408 })(o.IdentifyFailures), 4409 } 4410} 4411 4412type EditTarget struct { 4413 MessageID *MessageID `codec:"messageID,omitempty" json:"messageID,omitempty"` 4414 OutboxID *OutboxID `codec:"outboxID,omitempty" json:"outboxID,omitempty"` 4415} 4416 4417func (o EditTarget) DeepCopy() EditTarget { 4418 return EditTarget{ 4419 MessageID: (func(x *MessageID) *MessageID { 4420 if x == nil { 4421 return nil 4422 } 4423 tmp := (*x).DeepCopy() 4424 return &tmp 4425 })(o.MessageID), 4426 OutboxID: (func(x *OutboxID) *OutboxID { 4427 if x == nil { 4428 return nil 4429 } 4430 tmp := (*x).DeepCopy() 4431 return &tmp 4432 })(o.OutboxID), 4433 } 4434} 4435 4436type SetConversationStatusLocalRes struct { 4437 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 4438 IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` 4439} 4440 4441func (o SetConversationStatusLocalRes) DeepCopy() SetConversationStatusLocalRes { 4442 return SetConversationStatusLocalRes{ 4443 RateLimits: (func(x []RateLimit) []RateLimit { 4444 if x == nil { 4445 return nil 4446 } 4447 ret := make([]RateLimit, len(x)) 4448 for i, v := range x { 4449 vCopy := v.DeepCopy() 4450 ret[i] = vCopy 4451 } 4452 return ret 4453 })(o.RateLimits), 4454 IdentifyFailures: (func(x []keybase1.TLFIdentifyFailure) []keybase1.TLFIdentifyFailure { 4455 if x == nil { 4456 return nil 4457 } 4458 ret := make([]keybase1.TLFIdentifyFailure, len(x)) 4459 for i, v := range x { 4460 vCopy := v.DeepCopy() 4461 ret[i] = vCopy 4462 } 4463 return ret 4464 })(o.IdentifyFailures), 4465 } 4466} 4467 4468type NewConversationsLocalRes struct { 4469 Results []NewConversationsLocalResult `codec:"results" json:"results"` 4470 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 4471 IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` 4472} 4473 4474func (o NewConversationsLocalRes) DeepCopy() NewConversationsLocalRes { 4475 return NewConversationsLocalRes{ 4476 Results: (func(x []NewConversationsLocalResult) []NewConversationsLocalResult { 4477 if x == nil { 4478 return nil 4479 } 4480 ret := make([]NewConversationsLocalResult, len(x)) 4481 for i, v := range x { 4482 vCopy := v.DeepCopy() 4483 ret[i] = vCopy 4484 } 4485 return ret 4486 })(o.Results), 4487 RateLimits: (func(x []RateLimit) []RateLimit { 4488 if x == nil { 4489 return nil 4490 } 4491 ret := make([]RateLimit, len(x)) 4492 for i, v := range x { 4493 vCopy := v.DeepCopy() 4494 ret[i] = vCopy 4495 } 4496 return ret 4497 })(o.RateLimits), 4498 IdentifyFailures: (func(x []keybase1.TLFIdentifyFailure) []keybase1.TLFIdentifyFailure { 4499 if x == nil { 4500 return nil 4501 } 4502 ret := make([]keybase1.TLFIdentifyFailure, len(x)) 4503 for i, v := range x { 4504 vCopy := v.DeepCopy() 4505 ret[i] = vCopy 4506 } 4507 return ret 4508 })(o.IdentifyFailures), 4509 } 4510} 4511 4512type NewConversationsLocalResult struct { 4513 Result *NewConversationLocalRes `codec:"result,omitempty" json:"result,omitempty"` 4514 Err *string `codec:"err,omitempty" json:"err,omitempty"` 4515} 4516 4517func (o NewConversationsLocalResult) DeepCopy() NewConversationsLocalResult { 4518 return NewConversationsLocalResult{ 4519 Result: (func(x *NewConversationLocalRes) *NewConversationLocalRes { 4520 if x == nil { 4521 return nil 4522 } 4523 tmp := (*x).DeepCopy() 4524 return &tmp 4525 })(o.Result), 4526 Err: (func(x *string) *string { 4527 if x == nil { 4528 return nil 4529 } 4530 tmp := (*x) 4531 return &tmp 4532 })(o.Err), 4533 } 4534} 4535 4536type NewConversationLocalArgument struct { 4537 TlfName string `codec:"tlfName" json:"tlfName"` 4538 TopicType TopicType `codec:"topicType" json:"topicType"` 4539 TlfVisibility keybase1.TLFVisibility `codec:"tlfVisibility" json:"tlfVisibility"` 4540 TopicName *string `codec:"topicName,omitempty" json:"topicName,omitempty"` 4541 MembersType ConversationMembersType `codec:"membersType" json:"membersType"` 4542} 4543 4544func (o NewConversationLocalArgument) DeepCopy() NewConversationLocalArgument { 4545 return NewConversationLocalArgument{ 4546 TlfName: o.TlfName, 4547 TopicType: o.TopicType.DeepCopy(), 4548 TlfVisibility: o.TlfVisibility.DeepCopy(), 4549 TopicName: (func(x *string) *string { 4550 if x == nil { 4551 return nil 4552 } 4553 tmp := (*x) 4554 return &tmp 4555 })(o.TopicName), 4556 MembersType: o.MembersType.DeepCopy(), 4557 } 4558} 4559 4560type NewConversationLocalRes struct { 4561 Conv ConversationLocal `codec:"conv" json:"conv"` 4562 UiConv InboxUIItem `codec:"uiConv" json:"uiConv"` 4563 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 4564 IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` 4565} 4566 4567func (o NewConversationLocalRes) DeepCopy() NewConversationLocalRes { 4568 return NewConversationLocalRes{ 4569 Conv: o.Conv.DeepCopy(), 4570 UiConv: o.UiConv.DeepCopy(), 4571 RateLimits: (func(x []RateLimit) []RateLimit { 4572 if x == nil { 4573 return nil 4574 } 4575 ret := make([]RateLimit, len(x)) 4576 for i, v := range x { 4577 vCopy := v.DeepCopy() 4578 ret[i] = vCopy 4579 } 4580 return ret 4581 })(o.RateLimits), 4582 IdentifyFailures: (func(x []keybase1.TLFIdentifyFailure) []keybase1.TLFIdentifyFailure { 4583 if x == nil { 4584 return nil 4585 } 4586 ret := make([]keybase1.TLFIdentifyFailure, len(x)) 4587 for i, v := range x { 4588 vCopy := v.DeepCopy() 4589 ret[i] = vCopy 4590 } 4591 return ret 4592 })(o.IdentifyFailures), 4593 } 4594} 4595 4596type GetInboxSummaryForCLILocalQuery struct { 4597 TopicType TopicType `codec:"topicType" json:"topicType"` 4598 After string `codec:"after" json:"after"` 4599 Before string `codec:"before" json:"before"` 4600 Visibility keybase1.TLFVisibility `codec:"visibility" json:"visibility"` 4601 Status []ConversationStatus `codec:"status" json:"status"` 4602 ConvIDs []ConversationID `codec:"convIDs" json:"convIDs"` 4603 UnreadFirst bool `codec:"unreadFirst" json:"unreadFirst"` 4604 UnreadFirstLimit UnreadFirstNumLimit `codec:"unreadFirstLimit" json:"unreadFirstLimit"` 4605 ActivitySortedLimit int `codec:"activitySortedLimit" json:"activitySortedLimit"` 4606} 4607 4608func (o GetInboxSummaryForCLILocalQuery) DeepCopy() GetInboxSummaryForCLILocalQuery { 4609 return GetInboxSummaryForCLILocalQuery{ 4610 TopicType: o.TopicType.DeepCopy(), 4611 After: o.After, 4612 Before: o.Before, 4613 Visibility: o.Visibility.DeepCopy(), 4614 Status: (func(x []ConversationStatus) []ConversationStatus { 4615 if x == nil { 4616 return nil 4617 } 4618 ret := make([]ConversationStatus, len(x)) 4619 for i, v := range x { 4620 vCopy := v.DeepCopy() 4621 ret[i] = vCopy 4622 } 4623 return ret 4624 })(o.Status), 4625 ConvIDs: (func(x []ConversationID) []ConversationID { 4626 if x == nil { 4627 return nil 4628 } 4629 ret := make([]ConversationID, len(x)) 4630 for i, v := range x { 4631 vCopy := v.DeepCopy() 4632 ret[i] = vCopy 4633 } 4634 return ret 4635 })(o.ConvIDs), 4636 UnreadFirst: o.UnreadFirst, 4637 UnreadFirstLimit: o.UnreadFirstLimit.DeepCopy(), 4638 ActivitySortedLimit: o.ActivitySortedLimit, 4639 } 4640} 4641 4642type GetInboxSummaryForCLILocalRes struct { 4643 Conversations []ConversationLocal `codec:"conversations" json:"conversations"` 4644 Offline bool `codec:"offline" json:"offline"` 4645 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 4646} 4647 4648func (o GetInboxSummaryForCLILocalRes) DeepCopy() GetInboxSummaryForCLILocalRes { 4649 return GetInboxSummaryForCLILocalRes{ 4650 Conversations: (func(x []ConversationLocal) []ConversationLocal { 4651 if x == nil { 4652 return nil 4653 } 4654 ret := make([]ConversationLocal, len(x)) 4655 for i, v := range x { 4656 vCopy := v.DeepCopy() 4657 ret[i] = vCopy 4658 } 4659 return ret 4660 })(o.Conversations), 4661 Offline: o.Offline, 4662 RateLimits: (func(x []RateLimit) []RateLimit { 4663 if x == nil { 4664 return nil 4665 } 4666 ret := make([]RateLimit, len(x)) 4667 for i, v := range x { 4668 vCopy := v.DeepCopy() 4669 ret[i] = vCopy 4670 } 4671 return ret 4672 })(o.RateLimits), 4673 } 4674} 4675 4676type GetConversationForCLILocalQuery struct { 4677 MarkAsRead bool `codec:"markAsRead" json:"markAsRead"` 4678 MessageTypes []MessageType `codec:"MessageTypes" json:"MessageTypes"` 4679 Since *string `codec:"Since,omitempty" json:"Since,omitempty"` 4680 Limit UnreadFirstNumLimit `codec:"limit" json:"limit"` 4681 Conv ConversationLocal `codec:"conv" json:"conv"` 4682} 4683 4684func (o GetConversationForCLILocalQuery) DeepCopy() GetConversationForCLILocalQuery { 4685 return GetConversationForCLILocalQuery{ 4686 MarkAsRead: o.MarkAsRead, 4687 MessageTypes: (func(x []MessageType) []MessageType { 4688 if x == nil { 4689 return nil 4690 } 4691 ret := make([]MessageType, len(x)) 4692 for i, v := range x { 4693 vCopy := v.DeepCopy() 4694 ret[i] = vCopy 4695 } 4696 return ret 4697 })(o.MessageTypes), 4698 Since: (func(x *string) *string { 4699 if x == nil { 4700 return nil 4701 } 4702 tmp := (*x) 4703 return &tmp 4704 })(o.Since), 4705 Limit: o.Limit.DeepCopy(), 4706 Conv: o.Conv.DeepCopy(), 4707 } 4708} 4709 4710type GetConversationForCLILocalRes struct { 4711 Conversation ConversationLocal `codec:"conversation" json:"conversation"` 4712 Messages []MessageUnboxed `codec:"messages" json:"messages"` 4713 Offline bool `codec:"offline" json:"offline"` 4714 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 4715} 4716 4717func (o GetConversationForCLILocalRes) DeepCopy() GetConversationForCLILocalRes { 4718 return GetConversationForCLILocalRes{ 4719 Conversation: o.Conversation.DeepCopy(), 4720 Messages: (func(x []MessageUnboxed) []MessageUnboxed { 4721 if x == nil { 4722 return nil 4723 } 4724 ret := make([]MessageUnboxed, len(x)) 4725 for i, v := range x { 4726 vCopy := v.DeepCopy() 4727 ret[i] = vCopy 4728 } 4729 return ret 4730 })(o.Messages), 4731 Offline: o.Offline, 4732 RateLimits: (func(x []RateLimit) []RateLimit { 4733 if x == nil { 4734 return nil 4735 } 4736 ret := make([]RateLimit, len(x)) 4737 for i, v := range x { 4738 vCopy := v.DeepCopy() 4739 ret[i] = vCopy 4740 } 4741 return ret 4742 })(o.RateLimits), 4743 } 4744} 4745 4746type GetMessagesLocalRes struct { 4747 Messages []MessageUnboxed `codec:"messages" json:"messages"` 4748 Offline bool `codec:"offline" json:"offline"` 4749 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 4750 IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` 4751} 4752 4753func (o GetMessagesLocalRes) DeepCopy() GetMessagesLocalRes { 4754 return GetMessagesLocalRes{ 4755 Messages: (func(x []MessageUnboxed) []MessageUnboxed { 4756 if x == nil { 4757 return nil 4758 } 4759 ret := make([]MessageUnboxed, len(x)) 4760 for i, v := range x { 4761 vCopy := v.DeepCopy() 4762 ret[i] = vCopy 4763 } 4764 return ret 4765 })(o.Messages), 4766 Offline: o.Offline, 4767 RateLimits: (func(x []RateLimit) []RateLimit { 4768 if x == nil { 4769 return nil 4770 } 4771 ret := make([]RateLimit, len(x)) 4772 for i, v := range x { 4773 vCopy := v.DeepCopy() 4774 ret[i] = vCopy 4775 } 4776 return ret 4777 })(o.RateLimits), 4778 IdentifyFailures: (func(x []keybase1.TLFIdentifyFailure) []keybase1.TLFIdentifyFailure { 4779 if x == nil { 4780 return nil 4781 } 4782 ret := make([]keybase1.TLFIdentifyFailure, len(x)) 4783 for i, v := range x { 4784 vCopy := v.DeepCopy() 4785 ret[i] = vCopy 4786 } 4787 return ret 4788 })(o.IdentifyFailures), 4789 } 4790} 4791 4792type PostFileAttachmentArg struct { 4793 ConversationID ConversationID `codec:"conversationID" json:"conversationID"` 4794 TlfName string `codec:"tlfName" json:"tlfName"` 4795 Visibility keybase1.TLFVisibility `codec:"visibility" json:"visibility"` 4796 Filename string `codec:"filename" json:"filename"` 4797 Title string `codec:"title" json:"title"` 4798 Metadata []byte `codec:"metadata" json:"metadata"` 4799 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 4800 CallerPreview *MakePreviewRes `codec:"callerPreview,omitempty" json:"callerPreview,omitempty"` 4801 OutboxID *OutboxID `codec:"outboxID,omitempty" json:"outboxID,omitempty"` 4802 EphemeralLifetime *gregor1.DurationSec `codec:"ephemeralLifetime,omitempty" json:"ephemeralLifetime,omitempty"` 4803} 4804 4805func (o PostFileAttachmentArg) DeepCopy() PostFileAttachmentArg { 4806 return PostFileAttachmentArg{ 4807 ConversationID: o.ConversationID.DeepCopy(), 4808 TlfName: o.TlfName, 4809 Visibility: o.Visibility.DeepCopy(), 4810 Filename: o.Filename, 4811 Title: o.Title, 4812 Metadata: (func(x []byte) []byte { 4813 if x == nil { 4814 return nil 4815 } 4816 return append([]byte{}, x...) 4817 })(o.Metadata), 4818 IdentifyBehavior: o.IdentifyBehavior.DeepCopy(), 4819 CallerPreview: (func(x *MakePreviewRes) *MakePreviewRes { 4820 if x == nil { 4821 return nil 4822 } 4823 tmp := (*x).DeepCopy() 4824 return &tmp 4825 })(o.CallerPreview), 4826 OutboxID: (func(x *OutboxID) *OutboxID { 4827 if x == nil { 4828 return nil 4829 } 4830 tmp := (*x).DeepCopy() 4831 return &tmp 4832 })(o.OutboxID), 4833 EphemeralLifetime: (func(x *gregor1.DurationSec) *gregor1.DurationSec { 4834 if x == nil { 4835 return nil 4836 } 4837 tmp := (*x).DeepCopy() 4838 return &tmp 4839 })(o.EphemeralLifetime), 4840 } 4841} 4842 4843type GetNextAttachmentMessageLocalRes struct { 4844 Message *UIMessage `codec:"message,omitempty" json:"message,omitempty"` 4845 Offline bool `codec:"offline" json:"offline"` 4846 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 4847 IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` 4848} 4849 4850func (o GetNextAttachmentMessageLocalRes) DeepCopy() GetNextAttachmentMessageLocalRes { 4851 return GetNextAttachmentMessageLocalRes{ 4852 Message: (func(x *UIMessage) *UIMessage { 4853 if x == nil { 4854 return nil 4855 } 4856 tmp := (*x).DeepCopy() 4857 return &tmp 4858 })(o.Message), 4859 Offline: o.Offline, 4860 RateLimits: (func(x []RateLimit) []RateLimit { 4861 if x == nil { 4862 return nil 4863 } 4864 ret := make([]RateLimit, len(x)) 4865 for i, v := range x { 4866 vCopy := v.DeepCopy() 4867 ret[i] = vCopy 4868 } 4869 return ret 4870 })(o.RateLimits), 4871 IdentifyFailures: (func(x []keybase1.TLFIdentifyFailure) []keybase1.TLFIdentifyFailure { 4872 if x == nil { 4873 return nil 4874 } 4875 ret := make([]keybase1.TLFIdentifyFailure, len(x)) 4876 for i, v := range x { 4877 vCopy := v.DeepCopy() 4878 ret[i] = vCopy 4879 } 4880 return ret 4881 })(o.IdentifyFailures), 4882 } 4883} 4884 4885type DownloadAttachmentLocalRes struct { 4886 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 4887 IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` 4888} 4889 4890func (o DownloadAttachmentLocalRes) DeepCopy() DownloadAttachmentLocalRes { 4891 return DownloadAttachmentLocalRes{ 4892 RateLimits: (func(x []RateLimit) []RateLimit { 4893 if x == nil { 4894 return nil 4895 } 4896 ret := make([]RateLimit, len(x)) 4897 for i, v := range x { 4898 vCopy := v.DeepCopy() 4899 ret[i] = vCopy 4900 } 4901 return ret 4902 })(o.RateLimits), 4903 IdentifyFailures: (func(x []keybase1.TLFIdentifyFailure) []keybase1.TLFIdentifyFailure { 4904 if x == nil { 4905 return nil 4906 } 4907 ret := make([]keybase1.TLFIdentifyFailure, len(x)) 4908 for i, v := range x { 4909 vCopy := v.DeepCopy() 4910 ret[i] = vCopy 4911 } 4912 return ret 4913 })(o.IdentifyFailures), 4914 } 4915} 4916 4917type DownloadFileAttachmentLocalRes struct { 4918 FilePath string `codec:"filePath" json:"filePath"` 4919 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 4920 IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` 4921} 4922 4923func (o DownloadFileAttachmentLocalRes) DeepCopy() DownloadFileAttachmentLocalRes { 4924 return DownloadFileAttachmentLocalRes{ 4925 FilePath: o.FilePath, 4926 RateLimits: (func(x []RateLimit) []RateLimit { 4927 if x == nil { 4928 return nil 4929 } 4930 ret := make([]RateLimit, len(x)) 4931 for i, v := range x { 4932 vCopy := v.DeepCopy() 4933 ret[i] = vCopy 4934 } 4935 return ret 4936 })(o.RateLimits), 4937 IdentifyFailures: (func(x []keybase1.TLFIdentifyFailure) []keybase1.TLFIdentifyFailure { 4938 if x == nil { 4939 return nil 4940 } 4941 ret := make([]keybase1.TLFIdentifyFailure, len(x)) 4942 for i, v := range x { 4943 vCopy := v.DeepCopy() 4944 ret[i] = vCopy 4945 } 4946 return ret 4947 })(o.IdentifyFailures), 4948 } 4949} 4950 4951type PreviewLocationTyp int 4952 4953const ( 4954 PreviewLocationTyp_URL PreviewLocationTyp = 0 4955 PreviewLocationTyp_FILE PreviewLocationTyp = 1 4956 PreviewLocationTyp_BYTES PreviewLocationTyp = 2 4957) 4958 4959func (o PreviewLocationTyp) DeepCopy() PreviewLocationTyp { return o } 4960 4961var PreviewLocationTypMap = map[string]PreviewLocationTyp{ 4962 "URL": 0, 4963 "FILE": 1, 4964 "BYTES": 2, 4965} 4966 4967var PreviewLocationTypRevMap = map[PreviewLocationTyp]string{ 4968 0: "URL", 4969 1: "FILE", 4970 2: "BYTES", 4971} 4972 4973func (e PreviewLocationTyp) String() string { 4974 if v, ok := PreviewLocationTypRevMap[e]; ok { 4975 return v 4976 } 4977 return fmt.Sprintf("%v", int(e)) 4978} 4979 4980type PreviewLocation struct { 4981 Ltyp__ PreviewLocationTyp `codec:"ltyp" json:"ltyp"` 4982 Url__ *string `codec:"url,omitempty" json:"url,omitempty"` 4983 File__ *string `codec:"file,omitempty" json:"file,omitempty"` 4984 Bytes__ *[]byte `codec:"bytes,omitempty" json:"bytes,omitempty"` 4985} 4986 4987func (o *PreviewLocation) Ltyp() (ret PreviewLocationTyp, err error) { 4988 switch o.Ltyp__ { 4989 case PreviewLocationTyp_URL: 4990 if o.Url__ == nil { 4991 err = errors.New("unexpected nil value for Url__") 4992 return ret, err 4993 } 4994 case PreviewLocationTyp_FILE: 4995 if o.File__ == nil { 4996 err = errors.New("unexpected nil value for File__") 4997 return ret, err 4998 } 4999 case PreviewLocationTyp_BYTES: 5000 if o.Bytes__ == nil { 5001 err = errors.New("unexpected nil value for Bytes__") 5002 return ret, err 5003 } 5004 } 5005 return o.Ltyp__, nil 5006} 5007 5008func (o PreviewLocation) Url() (res string) { 5009 if o.Ltyp__ != PreviewLocationTyp_URL { 5010 panic("wrong case accessed") 5011 } 5012 if o.Url__ == nil { 5013 return 5014 } 5015 return *o.Url__ 5016} 5017 5018func (o PreviewLocation) File() (res string) { 5019 if o.Ltyp__ != PreviewLocationTyp_FILE { 5020 panic("wrong case accessed") 5021 } 5022 if o.File__ == nil { 5023 return 5024 } 5025 return *o.File__ 5026} 5027 5028func (o PreviewLocation) Bytes() (res []byte) { 5029 if o.Ltyp__ != PreviewLocationTyp_BYTES { 5030 panic("wrong case accessed") 5031 } 5032 if o.Bytes__ == nil { 5033 return 5034 } 5035 return *o.Bytes__ 5036} 5037 5038func NewPreviewLocationWithUrl(v string) PreviewLocation { 5039 return PreviewLocation{ 5040 Ltyp__: PreviewLocationTyp_URL, 5041 Url__: &v, 5042 } 5043} 5044 5045func NewPreviewLocationWithFile(v string) PreviewLocation { 5046 return PreviewLocation{ 5047 Ltyp__: PreviewLocationTyp_FILE, 5048 File__: &v, 5049 } 5050} 5051 5052func NewPreviewLocationWithBytes(v []byte) PreviewLocation { 5053 return PreviewLocation{ 5054 Ltyp__: PreviewLocationTyp_BYTES, 5055 Bytes__: &v, 5056 } 5057} 5058 5059func (o PreviewLocation) DeepCopy() PreviewLocation { 5060 return PreviewLocation{ 5061 Ltyp__: o.Ltyp__.DeepCopy(), 5062 Url__: (func(x *string) *string { 5063 if x == nil { 5064 return nil 5065 } 5066 tmp := (*x) 5067 return &tmp 5068 })(o.Url__), 5069 File__: (func(x *string) *string { 5070 if x == nil { 5071 return nil 5072 } 5073 tmp := (*x) 5074 return &tmp 5075 })(o.File__), 5076 Bytes__: (func(x *[]byte) *[]byte { 5077 if x == nil { 5078 return nil 5079 } 5080 tmp := (func(x []byte) []byte { 5081 if x == nil { 5082 return nil 5083 } 5084 return append([]byte{}, x...) 5085 })((*x)) 5086 return &tmp 5087 })(o.Bytes__), 5088 } 5089} 5090 5091type MakePreviewRes struct { 5092 MimeType string `codec:"mimeType" json:"mimeType"` 5093 PreviewMimeType *string `codec:"previewMimeType,omitempty" json:"previewMimeType,omitempty"` 5094 Location *PreviewLocation `codec:"location,omitempty" json:"location,omitempty"` 5095 Metadata *AssetMetadata `codec:"metadata,omitempty" json:"metadata,omitempty"` 5096 BaseMetadata *AssetMetadata `codec:"baseMetadata,omitempty" json:"baseMetadata,omitempty"` 5097} 5098 5099func (o MakePreviewRes) DeepCopy() MakePreviewRes { 5100 return MakePreviewRes{ 5101 MimeType: o.MimeType, 5102 PreviewMimeType: (func(x *string) *string { 5103 if x == nil { 5104 return nil 5105 } 5106 tmp := (*x) 5107 return &tmp 5108 })(o.PreviewMimeType), 5109 Location: (func(x *PreviewLocation) *PreviewLocation { 5110 if x == nil { 5111 return nil 5112 } 5113 tmp := (*x).DeepCopy() 5114 return &tmp 5115 })(o.Location), 5116 Metadata: (func(x *AssetMetadata) *AssetMetadata { 5117 if x == nil { 5118 return nil 5119 } 5120 tmp := (*x).DeepCopy() 5121 return &tmp 5122 })(o.Metadata), 5123 BaseMetadata: (func(x *AssetMetadata) *AssetMetadata { 5124 if x == nil { 5125 return nil 5126 } 5127 tmp := (*x).DeepCopy() 5128 return &tmp 5129 })(o.BaseMetadata), 5130 } 5131} 5132 5133type MarkAsReadLocalRes struct { 5134 Offline bool `codec:"offline" json:"offline"` 5135 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 5136} 5137 5138func (o MarkAsReadLocalRes) DeepCopy() MarkAsReadLocalRes { 5139 return MarkAsReadLocalRes{ 5140 Offline: o.Offline, 5141 RateLimits: (func(x []RateLimit) []RateLimit { 5142 if x == nil { 5143 return nil 5144 } 5145 ret := make([]RateLimit, len(x)) 5146 for i, v := range x { 5147 vCopy := v.DeepCopy() 5148 ret[i] = vCopy 5149 } 5150 return ret 5151 })(o.RateLimits), 5152 } 5153} 5154 5155type MarkTLFAsReadLocalRes struct { 5156 Offline bool `codec:"offline" json:"offline"` 5157 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 5158} 5159 5160func (o MarkTLFAsReadLocalRes) DeepCopy() MarkTLFAsReadLocalRes { 5161 return MarkTLFAsReadLocalRes{ 5162 Offline: o.Offline, 5163 RateLimits: (func(x []RateLimit) []RateLimit { 5164 if x == nil { 5165 return nil 5166 } 5167 ret := make([]RateLimit, len(x)) 5168 for i, v := range x { 5169 vCopy := v.DeepCopy() 5170 ret[i] = vCopy 5171 } 5172 return ret 5173 })(o.RateLimits), 5174 } 5175} 5176 5177type FindConversationsLocalRes struct { 5178 Conversations []ConversationLocal `codec:"conversations" json:"conversations"` 5179 UiConversations []InboxUIItem `codec:"uiConversations" json:"uiConversations"` 5180 Offline bool `codec:"offline" json:"offline"` 5181 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 5182 IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` 5183} 5184 5185func (o FindConversationsLocalRes) DeepCopy() FindConversationsLocalRes { 5186 return FindConversationsLocalRes{ 5187 Conversations: (func(x []ConversationLocal) []ConversationLocal { 5188 if x == nil { 5189 return nil 5190 } 5191 ret := make([]ConversationLocal, len(x)) 5192 for i, v := range x { 5193 vCopy := v.DeepCopy() 5194 ret[i] = vCopy 5195 } 5196 return ret 5197 })(o.Conversations), 5198 UiConversations: (func(x []InboxUIItem) []InboxUIItem { 5199 if x == nil { 5200 return nil 5201 } 5202 ret := make([]InboxUIItem, len(x)) 5203 for i, v := range x { 5204 vCopy := v.DeepCopy() 5205 ret[i] = vCopy 5206 } 5207 return ret 5208 })(o.UiConversations), 5209 Offline: o.Offline, 5210 RateLimits: (func(x []RateLimit) []RateLimit { 5211 if x == nil { 5212 return nil 5213 } 5214 ret := make([]RateLimit, len(x)) 5215 for i, v := range x { 5216 vCopy := v.DeepCopy() 5217 ret[i] = vCopy 5218 } 5219 return ret 5220 })(o.RateLimits), 5221 IdentifyFailures: (func(x []keybase1.TLFIdentifyFailure) []keybase1.TLFIdentifyFailure { 5222 if x == nil { 5223 return nil 5224 } 5225 ret := make([]keybase1.TLFIdentifyFailure, len(x)) 5226 for i, v := range x { 5227 vCopy := v.DeepCopy() 5228 ret[i] = vCopy 5229 } 5230 return ret 5231 })(o.IdentifyFailures), 5232 } 5233} 5234 5235type JoinLeaveConversationLocalRes struct { 5236 Offline bool `codec:"offline" json:"offline"` 5237 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 5238} 5239 5240func (o JoinLeaveConversationLocalRes) DeepCopy() JoinLeaveConversationLocalRes { 5241 return JoinLeaveConversationLocalRes{ 5242 Offline: o.Offline, 5243 RateLimits: (func(x []RateLimit) []RateLimit { 5244 if x == nil { 5245 return nil 5246 } 5247 ret := make([]RateLimit, len(x)) 5248 for i, v := range x { 5249 vCopy := v.DeepCopy() 5250 ret[i] = vCopy 5251 } 5252 return ret 5253 })(o.RateLimits), 5254 } 5255} 5256 5257type PreviewConversationLocalRes struct { 5258 Conv InboxUIItem `codec:"conv" json:"conv"` 5259 Offline bool `codec:"offline" json:"offline"` 5260 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 5261} 5262 5263func (o PreviewConversationLocalRes) DeepCopy() PreviewConversationLocalRes { 5264 return PreviewConversationLocalRes{ 5265 Conv: o.Conv.DeepCopy(), 5266 Offline: o.Offline, 5267 RateLimits: (func(x []RateLimit) []RateLimit { 5268 if x == nil { 5269 return nil 5270 } 5271 ret := make([]RateLimit, len(x)) 5272 for i, v := range x { 5273 vCopy := v.DeepCopy() 5274 ret[i] = vCopy 5275 } 5276 return ret 5277 })(o.RateLimits), 5278 } 5279} 5280 5281type DeleteConversationLocalRes struct { 5282 Offline bool `codec:"offline" json:"offline"` 5283 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 5284} 5285 5286func (o DeleteConversationLocalRes) DeepCopy() DeleteConversationLocalRes { 5287 return DeleteConversationLocalRes{ 5288 Offline: o.Offline, 5289 RateLimits: (func(x []RateLimit) []RateLimit { 5290 if x == nil { 5291 return nil 5292 } 5293 ret := make([]RateLimit, len(x)) 5294 for i, v := range x { 5295 vCopy := v.DeepCopy() 5296 ret[i] = vCopy 5297 } 5298 return ret 5299 })(o.RateLimits), 5300 } 5301} 5302 5303type RemoveFromConversationLocalRes struct { 5304 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 5305} 5306 5307func (o RemoveFromConversationLocalRes) DeepCopy() RemoveFromConversationLocalRes { 5308 return RemoveFromConversationLocalRes{ 5309 RateLimits: (func(x []RateLimit) []RateLimit { 5310 if x == nil { 5311 return nil 5312 } 5313 ret := make([]RateLimit, len(x)) 5314 for i, v := range x { 5315 vCopy := v.DeepCopy() 5316 ret[i] = vCopy 5317 } 5318 return ret 5319 })(o.RateLimits), 5320 } 5321} 5322 5323type GetTLFConversationsLocalRes struct { 5324 Convs []InboxUIItem `codec:"convs" json:"convs"` 5325 Offline bool `codec:"offline" json:"offline"` 5326 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 5327} 5328 5329func (o GetTLFConversationsLocalRes) DeepCopy() GetTLFConversationsLocalRes { 5330 return GetTLFConversationsLocalRes{ 5331 Convs: (func(x []InboxUIItem) []InboxUIItem { 5332 if x == nil { 5333 return nil 5334 } 5335 ret := make([]InboxUIItem, len(x)) 5336 for i, v := range x { 5337 vCopy := v.DeepCopy() 5338 ret[i] = vCopy 5339 } 5340 return ret 5341 })(o.Convs), 5342 Offline: o.Offline, 5343 RateLimits: (func(x []RateLimit) []RateLimit { 5344 if x == nil { 5345 return nil 5346 } 5347 ret := make([]RateLimit, len(x)) 5348 for i, v := range x { 5349 vCopy := v.DeepCopy() 5350 ret[i] = vCopy 5351 } 5352 return ret 5353 })(o.RateLimits), 5354 } 5355} 5356 5357type GetChannelMembershipsLocalRes struct { 5358 Channels []ChannelNameMention `codec:"channels" json:"channels"` 5359 Offline bool `codec:"offline" json:"offline"` 5360 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 5361} 5362 5363func (o GetChannelMembershipsLocalRes) DeepCopy() GetChannelMembershipsLocalRes { 5364 return GetChannelMembershipsLocalRes{ 5365 Channels: (func(x []ChannelNameMention) []ChannelNameMention { 5366 if x == nil { 5367 return nil 5368 } 5369 ret := make([]ChannelNameMention, len(x)) 5370 for i, v := range x { 5371 vCopy := v.DeepCopy() 5372 ret[i] = vCopy 5373 } 5374 return ret 5375 })(o.Channels), 5376 Offline: o.Offline, 5377 RateLimits: (func(x []RateLimit) []RateLimit { 5378 if x == nil { 5379 return nil 5380 } 5381 ret := make([]RateLimit, len(x)) 5382 for i, v := range x { 5383 vCopy := v.DeepCopy() 5384 ret[i] = vCopy 5385 } 5386 return ret 5387 })(o.RateLimits), 5388 } 5389} 5390 5391type GetMutualTeamsLocalRes struct { 5392 TeamIDs []keybase1.TeamID `codec:"teamIDs" json:"teamIDs"` 5393 Offline bool `codec:"offline" json:"offline"` 5394 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 5395} 5396 5397func (o GetMutualTeamsLocalRes) DeepCopy() GetMutualTeamsLocalRes { 5398 return GetMutualTeamsLocalRes{ 5399 TeamIDs: (func(x []keybase1.TeamID) []keybase1.TeamID { 5400 if x == nil { 5401 return nil 5402 } 5403 ret := make([]keybase1.TeamID, len(x)) 5404 for i, v := range x { 5405 vCopy := v.DeepCopy() 5406 ret[i] = vCopy 5407 } 5408 return ret 5409 })(o.TeamIDs), 5410 Offline: o.Offline, 5411 RateLimits: (func(x []RateLimit) []RateLimit { 5412 if x == nil { 5413 return nil 5414 } 5415 ret := make([]RateLimit, len(x)) 5416 for i, v := range x { 5417 vCopy := v.DeepCopy() 5418 ret[i] = vCopy 5419 } 5420 return ret 5421 })(o.RateLimits), 5422 } 5423} 5424 5425type SetAppNotificationSettingsLocalRes struct { 5426 Offline bool `codec:"offline" json:"offline"` 5427 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 5428} 5429 5430func (o SetAppNotificationSettingsLocalRes) DeepCopy() SetAppNotificationSettingsLocalRes { 5431 return SetAppNotificationSettingsLocalRes{ 5432 Offline: o.Offline, 5433 RateLimits: (func(x []RateLimit) []RateLimit { 5434 if x == nil { 5435 return nil 5436 } 5437 ret := make([]RateLimit, len(x)) 5438 for i, v := range x { 5439 vCopy := v.DeepCopy() 5440 ret[i] = vCopy 5441 } 5442 return ret 5443 })(o.RateLimits), 5444 } 5445} 5446 5447type AppNotificationSettingLocal struct { 5448 DeviceType keybase1.DeviceType `codec:"deviceType" json:"deviceType"` 5449 Kind NotificationKind `codec:"kind" json:"kind"` 5450 Enabled bool `codec:"enabled" json:"enabled"` 5451} 5452 5453func (o AppNotificationSettingLocal) DeepCopy() AppNotificationSettingLocal { 5454 return AppNotificationSettingLocal{ 5455 DeviceType: o.DeviceType.DeepCopy(), 5456 Kind: o.Kind.DeepCopy(), 5457 Enabled: o.Enabled, 5458 } 5459} 5460 5461type ResetConvMember struct { 5462 Username string `codec:"username" json:"username"` 5463 Uid gregor1.UID `codec:"uid" json:"uid"` 5464 Conv ConversationID `codec:"conv" json:"conv"` 5465} 5466 5467func (o ResetConvMember) DeepCopy() ResetConvMember { 5468 return ResetConvMember{ 5469 Username: o.Username, 5470 Uid: o.Uid.DeepCopy(), 5471 Conv: o.Conv.DeepCopy(), 5472 } 5473} 5474 5475type GetAllResetConvMembersRes struct { 5476 Members []ResetConvMember `codec:"members" json:"members"` 5477 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 5478} 5479 5480func (o GetAllResetConvMembersRes) DeepCopy() GetAllResetConvMembersRes { 5481 return GetAllResetConvMembersRes{ 5482 Members: (func(x []ResetConvMember) []ResetConvMember { 5483 if x == nil { 5484 return nil 5485 } 5486 ret := make([]ResetConvMember, len(x)) 5487 for i, v := range x { 5488 vCopy := v.DeepCopy() 5489 ret[i] = vCopy 5490 } 5491 return ret 5492 })(o.Members), 5493 RateLimits: (func(x []RateLimit) []RateLimit { 5494 if x == nil { 5495 return nil 5496 } 5497 ret := make([]RateLimit, len(x)) 5498 for i, v := range x { 5499 vCopy := v.DeepCopy() 5500 ret[i] = vCopy 5501 } 5502 return ret 5503 })(o.RateLimits), 5504 } 5505} 5506 5507type SearchRegexpRes struct { 5508 Offline bool `codec:"offline" json:"offline"` 5509 Hits []ChatSearchHit `codec:"hits" json:"hits"` 5510 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 5511 IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` 5512} 5513 5514func (o SearchRegexpRes) DeepCopy() SearchRegexpRes { 5515 return SearchRegexpRes{ 5516 Offline: o.Offline, 5517 Hits: (func(x []ChatSearchHit) []ChatSearchHit { 5518 if x == nil { 5519 return nil 5520 } 5521 ret := make([]ChatSearchHit, len(x)) 5522 for i, v := range x { 5523 vCopy := v.DeepCopy() 5524 ret[i] = vCopy 5525 } 5526 return ret 5527 })(o.Hits), 5528 RateLimits: (func(x []RateLimit) []RateLimit { 5529 if x == nil { 5530 return nil 5531 } 5532 ret := make([]RateLimit, len(x)) 5533 for i, v := range x { 5534 vCopy := v.DeepCopy() 5535 ret[i] = vCopy 5536 } 5537 return ret 5538 })(o.RateLimits), 5539 IdentifyFailures: (func(x []keybase1.TLFIdentifyFailure) []keybase1.TLFIdentifyFailure { 5540 if x == nil { 5541 return nil 5542 } 5543 ret := make([]keybase1.TLFIdentifyFailure, len(x)) 5544 for i, v := range x { 5545 vCopy := v.DeepCopy() 5546 ret[i] = vCopy 5547 } 5548 return ret 5549 })(o.IdentifyFailures), 5550 } 5551} 5552 5553type SearchInboxRes struct { 5554 Offline bool `codec:"offline" json:"offline"` 5555 Res *ChatSearchInboxResults `codec:"res,omitempty" json:"res,omitempty"` 5556 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 5557 IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` 5558} 5559 5560func (o SearchInboxRes) DeepCopy() SearchInboxRes { 5561 return SearchInboxRes{ 5562 Offline: o.Offline, 5563 Res: (func(x *ChatSearchInboxResults) *ChatSearchInboxResults { 5564 if x == nil { 5565 return nil 5566 } 5567 tmp := (*x).DeepCopy() 5568 return &tmp 5569 })(o.Res), 5570 RateLimits: (func(x []RateLimit) []RateLimit { 5571 if x == nil { 5572 return nil 5573 } 5574 ret := make([]RateLimit, len(x)) 5575 for i, v := range x { 5576 vCopy := v.DeepCopy() 5577 ret[i] = vCopy 5578 } 5579 return ret 5580 })(o.RateLimits), 5581 IdentifyFailures: (func(x []keybase1.TLFIdentifyFailure) []keybase1.TLFIdentifyFailure { 5582 if x == nil { 5583 return nil 5584 } 5585 ret := make([]keybase1.TLFIdentifyFailure, len(x)) 5586 for i, v := range x { 5587 vCopy := v.DeepCopy() 5588 ret[i] = vCopy 5589 } 5590 return ret 5591 })(o.IdentifyFailures), 5592 } 5593} 5594 5595type SimpleSearchInboxConvNamesHit struct { 5596 Name string `codec:"name" json:"name"` 5597 ConvID ConversationID `codec:"convID" json:"convID"` 5598 IsTeam bool `codec:"isTeam" json:"isTeam"` 5599 Parts []string `codec:"parts" json:"parts"` 5600 TlfName string `codec:"tlfName" json:"tlfName"` 5601} 5602 5603func (o SimpleSearchInboxConvNamesHit) DeepCopy() SimpleSearchInboxConvNamesHit { 5604 return SimpleSearchInboxConvNamesHit{ 5605 Name: o.Name, 5606 ConvID: o.ConvID.DeepCopy(), 5607 IsTeam: o.IsTeam, 5608 Parts: (func(x []string) []string { 5609 if x == nil { 5610 return nil 5611 } 5612 ret := make([]string, len(x)) 5613 for i, v := range x { 5614 vCopy := v 5615 ret[i] = vCopy 5616 } 5617 return ret 5618 })(o.Parts), 5619 TlfName: o.TlfName, 5620 } 5621} 5622 5623type ProfileSearchConvStats struct { 5624 Err string `codec:"err" json:"err"` 5625 ConvName string `codec:"convName" json:"convName"` 5626 MinConvID MessageID `codec:"minConvID" json:"minConvID"` 5627 MaxConvID MessageID `codec:"maxConvID" json:"maxConvID"` 5628 NumMissing int `codec:"numMissing" json:"numMissing"` 5629 NumMessages int `codec:"numMessages" json:"numMessages"` 5630 IndexSizeDisk int `codec:"indexSizeDisk" json:"indexSizeDisk"` 5631 IndexSizeMem int64 `codec:"indexSizeMem" json:"indexSizeMem"` 5632 DurationMsec gregor1.DurationMsec `codec:"durationMsec" json:"durationMsec"` 5633 PercentIndexed int `codec:"percentIndexed" json:"percentIndexed"` 5634} 5635 5636func (o ProfileSearchConvStats) DeepCopy() ProfileSearchConvStats { 5637 return ProfileSearchConvStats{ 5638 Err: o.Err, 5639 ConvName: o.ConvName, 5640 MinConvID: o.MinConvID.DeepCopy(), 5641 MaxConvID: o.MaxConvID.DeepCopy(), 5642 NumMissing: o.NumMissing, 5643 NumMessages: o.NumMessages, 5644 IndexSizeDisk: o.IndexSizeDisk, 5645 IndexSizeMem: o.IndexSizeMem, 5646 DurationMsec: o.DurationMsec.DeepCopy(), 5647 PercentIndexed: o.PercentIndexed, 5648 } 5649} 5650 5651type BuiltinCommandGroup struct { 5652 Typ ConversationBuiltinCommandTyp `codec:"typ" json:"typ"` 5653 Commands []ConversationCommand `codec:"commands" json:"commands"` 5654} 5655 5656func (o BuiltinCommandGroup) DeepCopy() BuiltinCommandGroup { 5657 return BuiltinCommandGroup{ 5658 Typ: o.Typ.DeepCopy(), 5659 Commands: (func(x []ConversationCommand) []ConversationCommand { 5660 if x == nil { 5661 return nil 5662 } 5663 ret := make([]ConversationCommand, len(x)) 5664 for i, v := range x { 5665 vCopy := v.DeepCopy() 5666 ret[i] = vCopy 5667 } 5668 return ret 5669 })(o.Commands), 5670 } 5671} 5672 5673type StaticConfig struct { 5674 DeletableByDeleteHistory []MessageType `codec:"deletableByDeleteHistory" json:"deletableByDeleteHistory"` 5675 BuiltinCommands []BuiltinCommandGroup `codec:"builtinCommands" json:"builtinCommands"` 5676} 5677 5678func (o StaticConfig) DeepCopy() StaticConfig { 5679 return StaticConfig{ 5680 DeletableByDeleteHistory: (func(x []MessageType) []MessageType { 5681 if x == nil { 5682 return nil 5683 } 5684 ret := make([]MessageType, len(x)) 5685 for i, v := range x { 5686 vCopy := v.DeepCopy() 5687 ret[i] = vCopy 5688 } 5689 return ret 5690 })(o.DeletableByDeleteHistory), 5691 BuiltinCommands: (func(x []BuiltinCommandGroup) []BuiltinCommandGroup { 5692 if x == nil { 5693 return nil 5694 } 5695 ret := make([]BuiltinCommandGroup, len(x)) 5696 for i, v := range x { 5697 vCopy := v.DeepCopy() 5698 ret[i] = vCopy 5699 } 5700 return ret 5701 })(o.BuiltinCommands), 5702 } 5703} 5704 5705type UnfurlPromptAction int 5706 5707const ( 5708 UnfurlPromptAction_ALWAYS UnfurlPromptAction = 0 5709 UnfurlPromptAction_NEVER UnfurlPromptAction = 1 5710 UnfurlPromptAction_ACCEPT UnfurlPromptAction = 2 5711 UnfurlPromptAction_NOTNOW UnfurlPromptAction = 3 5712 UnfurlPromptAction_ONETIME UnfurlPromptAction = 4 5713) 5714 5715func (o UnfurlPromptAction) DeepCopy() UnfurlPromptAction { return o } 5716 5717var UnfurlPromptActionMap = map[string]UnfurlPromptAction{ 5718 "ALWAYS": 0, 5719 "NEVER": 1, 5720 "ACCEPT": 2, 5721 "NOTNOW": 3, 5722 "ONETIME": 4, 5723} 5724 5725var UnfurlPromptActionRevMap = map[UnfurlPromptAction]string{ 5726 0: "ALWAYS", 5727 1: "NEVER", 5728 2: "ACCEPT", 5729 3: "NOTNOW", 5730 4: "ONETIME", 5731} 5732 5733func (e UnfurlPromptAction) String() string { 5734 if v, ok := UnfurlPromptActionRevMap[e]; ok { 5735 return v 5736 } 5737 return fmt.Sprintf("%v", int(e)) 5738} 5739 5740type UnfurlPromptResult struct { 5741 ActionType__ UnfurlPromptAction `codec:"actionType" json:"actionType"` 5742 Accept__ *string `codec:"accept,omitempty" json:"accept,omitempty"` 5743 Onetime__ *string `codec:"onetime,omitempty" json:"onetime,omitempty"` 5744} 5745 5746func (o *UnfurlPromptResult) ActionType() (ret UnfurlPromptAction, err error) { 5747 switch o.ActionType__ { 5748 case UnfurlPromptAction_ACCEPT: 5749 if o.Accept__ == nil { 5750 err = errors.New("unexpected nil value for Accept__") 5751 return ret, err 5752 } 5753 case UnfurlPromptAction_ONETIME: 5754 if o.Onetime__ == nil { 5755 err = errors.New("unexpected nil value for Onetime__") 5756 return ret, err 5757 } 5758 } 5759 return o.ActionType__, nil 5760} 5761 5762func (o UnfurlPromptResult) Accept() (res string) { 5763 if o.ActionType__ != UnfurlPromptAction_ACCEPT { 5764 panic("wrong case accessed") 5765 } 5766 if o.Accept__ == nil { 5767 return 5768 } 5769 return *o.Accept__ 5770} 5771 5772func (o UnfurlPromptResult) Onetime() (res string) { 5773 if o.ActionType__ != UnfurlPromptAction_ONETIME { 5774 panic("wrong case accessed") 5775 } 5776 if o.Onetime__ == nil { 5777 return 5778 } 5779 return *o.Onetime__ 5780} 5781 5782func NewUnfurlPromptResultWithAlways() UnfurlPromptResult { 5783 return UnfurlPromptResult{ 5784 ActionType__: UnfurlPromptAction_ALWAYS, 5785 } 5786} 5787 5788func NewUnfurlPromptResultWithNever() UnfurlPromptResult { 5789 return UnfurlPromptResult{ 5790 ActionType__: UnfurlPromptAction_NEVER, 5791 } 5792} 5793 5794func NewUnfurlPromptResultWithNotnow() UnfurlPromptResult { 5795 return UnfurlPromptResult{ 5796 ActionType__: UnfurlPromptAction_NOTNOW, 5797 } 5798} 5799 5800func NewUnfurlPromptResultWithAccept(v string) UnfurlPromptResult { 5801 return UnfurlPromptResult{ 5802 ActionType__: UnfurlPromptAction_ACCEPT, 5803 Accept__: &v, 5804 } 5805} 5806 5807func NewUnfurlPromptResultWithOnetime(v string) UnfurlPromptResult { 5808 return UnfurlPromptResult{ 5809 ActionType__: UnfurlPromptAction_ONETIME, 5810 Onetime__: &v, 5811 } 5812} 5813 5814func (o UnfurlPromptResult) DeepCopy() UnfurlPromptResult { 5815 return UnfurlPromptResult{ 5816 ActionType__: o.ActionType__.DeepCopy(), 5817 Accept__: (func(x *string) *string { 5818 if x == nil { 5819 return nil 5820 } 5821 tmp := (*x) 5822 return &tmp 5823 })(o.Accept__), 5824 Onetime__: (func(x *string) *string { 5825 if x == nil { 5826 return nil 5827 } 5828 tmp := (*x) 5829 return &tmp 5830 })(o.Onetime__), 5831 } 5832} 5833 5834type GalleryItemTyp int 5835 5836const ( 5837 GalleryItemTyp_MEDIA GalleryItemTyp = 0 5838 GalleryItemTyp_LINK GalleryItemTyp = 1 5839 GalleryItemTyp_DOC GalleryItemTyp = 2 5840) 5841 5842func (o GalleryItemTyp) DeepCopy() GalleryItemTyp { return o } 5843 5844var GalleryItemTypMap = map[string]GalleryItemTyp{ 5845 "MEDIA": 0, 5846 "LINK": 1, 5847 "DOC": 2, 5848} 5849 5850var GalleryItemTypRevMap = map[GalleryItemTyp]string{ 5851 0: "MEDIA", 5852 1: "LINK", 5853 2: "DOC", 5854} 5855 5856func (e GalleryItemTyp) String() string { 5857 if v, ok := GalleryItemTypRevMap[e]; ok { 5858 return v 5859 } 5860 return fmt.Sprintf("%v", int(e)) 5861} 5862 5863type LoadGalleryRes struct { 5864 Messages []UIMessage `codec:"messages" json:"messages"` 5865 Last bool `codec:"last" json:"last"` 5866 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 5867 IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` 5868} 5869 5870func (o LoadGalleryRes) DeepCopy() LoadGalleryRes { 5871 return LoadGalleryRes{ 5872 Messages: (func(x []UIMessage) []UIMessage { 5873 if x == nil { 5874 return nil 5875 } 5876 ret := make([]UIMessage, len(x)) 5877 for i, v := range x { 5878 vCopy := v.DeepCopy() 5879 ret[i] = vCopy 5880 } 5881 return ret 5882 })(o.Messages), 5883 Last: o.Last, 5884 RateLimits: (func(x []RateLimit) []RateLimit { 5885 if x == nil { 5886 return nil 5887 } 5888 ret := make([]RateLimit, len(x)) 5889 for i, v := range x { 5890 vCopy := v.DeepCopy() 5891 ret[i] = vCopy 5892 } 5893 return ret 5894 })(o.RateLimits), 5895 IdentifyFailures: (func(x []keybase1.TLFIdentifyFailure) []keybase1.TLFIdentifyFailure { 5896 if x == nil { 5897 return nil 5898 } 5899 ret := make([]keybase1.TLFIdentifyFailure, len(x)) 5900 for i, v := range x { 5901 vCopy := v.DeepCopy() 5902 ret[i] = vCopy 5903 } 5904 return ret 5905 })(o.IdentifyFailures), 5906 } 5907} 5908 5909type LoadFlipRes struct { 5910 Status UICoinFlipStatus `codec:"status" json:"status"` 5911 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 5912 IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"` 5913} 5914 5915func (o LoadFlipRes) DeepCopy() LoadFlipRes { 5916 return LoadFlipRes{ 5917 Status: o.Status.DeepCopy(), 5918 RateLimits: (func(x []RateLimit) []RateLimit { 5919 if x == nil { 5920 return nil 5921 } 5922 ret := make([]RateLimit, len(x)) 5923 for i, v := range x { 5924 vCopy := v.DeepCopy() 5925 ret[i] = vCopy 5926 } 5927 return ret 5928 })(o.RateLimits), 5929 IdentifyFailures: (func(x []keybase1.TLFIdentifyFailure) []keybase1.TLFIdentifyFailure { 5930 if x == nil { 5931 return nil 5932 } 5933 ret := make([]keybase1.TLFIdentifyFailure, len(x)) 5934 for i, v := range x { 5935 vCopy := v.DeepCopy() 5936 ret[i] = vCopy 5937 } 5938 return ret 5939 })(o.IdentifyFailures), 5940 } 5941} 5942 5943type UserBotExtendedDescription struct { 5944 Title string `codec:"title" json:"title"` 5945 DesktopBody string `codec:"desktopBody" json:"desktop_body"` 5946 MobileBody string `codec:"mobileBody" json:"mobile_body"` 5947} 5948 5949func (o UserBotExtendedDescription) DeepCopy() UserBotExtendedDescription { 5950 return UserBotExtendedDescription{ 5951 Title: o.Title, 5952 DesktopBody: o.DesktopBody, 5953 MobileBody: o.MobileBody, 5954 } 5955} 5956 5957type UserBotCommandOutput struct { 5958 Name string `codec:"name" json:"name"` 5959 Description string `codec:"description" json:"description"` 5960 Usage string `codec:"usage" json:"usage"` 5961 ExtendedDescription *UserBotExtendedDescription `codec:"extendedDescription,omitempty" json:"extended_description,omitempty"` 5962 Username string `codec:"username" json:"username"` 5963} 5964 5965func (o UserBotCommandOutput) DeepCopy() UserBotCommandOutput { 5966 return UserBotCommandOutput{ 5967 Name: o.Name, 5968 Description: o.Description, 5969 Usage: o.Usage, 5970 ExtendedDescription: (func(x *UserBotExtendedDescription) *UserBotExtendedDescription { 5971 if x == nil { 5972 return nil 5973 } 5974 tmp := (*x).DeepCopy() 5975 return &tmp 5976 })(o.ExtendedDescription), 5977 Username: o.Username, 5978 } 5979} 5980 5981type UserBotCommandInput struct { 5982 Name string `codec:"name" json:"name"` 5983 Description string `codec:"description" json:"description"` 5984 Usage string `codec:"usage" json:"usage"` 5985 ExtendedDescription *UserBotExtendedDescription `codec:"extendedDescription,omitempty" json:"extended_description,omitempty"` 5986} 5987 5988func (o UserBotCommandInput) DeepCopy() UserBotCommandInput { 5989 return UserBotCommandInput{ 5990 Name: o.Name, 5991 Description: o.Description, 5992 Usage: o.Usage, 5993 ExtendedDescription: (func(x *UserBotExtendedDescription) *UserBotExtendedDescription { 5994 if x == nil { 5995 return nil 5996 } 5997 tmp := (*x).DeepCopy() 5998 return &tmp 5999 })(o.ExtendedDescription), 6000 } 6001} 6002 6003type AdvertiseCommandsParam struct { 6004 Typ BotCommandsAdvertisementTyp `codec:"typ" json:"typ"` 6005 Commands []UserBotCommandInput `codec:"commands" json:"commands"` 6006 TeamName *string `codec:"teamName,omitempty" json:"teamName,omitempty"` 6007 ConvID *ConversationID `codec:"convID,omitempty" json:"convID,omitempty"` 6008} 6009 6010func (o AdvertiseCommandsParam) DeepCopy() AdvertiseCommandsParam { 6011 return AdvertiseCommandsParam{ 6012 Typ: o.Typ.DeepCopy(), 6013 Commands: (func(x []UserBotCommandInput) []UserBotCommandInput { 6014 if x == nil { 6015 return nil 6016 } 6017 ret := make([]UserBotCommandInput, len(x)) 6018 for i, v := range x { 6019 vCopy := v.DeepCopy() 6020 ret[i] = vCopy 6021 } 6022 return ret 6023 })(o.Commands), 6024 TeamName: (func(x *string) *string { 6025 if x == nil { 6026 return nil 6027 } 6028 tmp := (*x) 6029 return &tmp 6030 })(o.TeamName), 6031 ConvID: (func(x *ConversationID) *ConversationID { 6032 if x == nil { 6033 return nil 6034 } 6035 tmp := (*x).DeepCopy() 6036 return &tmp 6037 })(o.ConvID), 6038 } 6039} 6040 6041type AdvertiseBotCommandsLocalRes struct { 6042 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 6043} 6044 6045func (o AdvertiseBotCommandsLocalRes) DeepCopy() AdvertiseBotCommandsLocalRes { 6046 return AdvertiseBotCommandsLocalRes{ 6047 RateLimits: (func(x []RateLimit) []RateLimit { 6048 if x == nil { 6049 return nil 6050 } 6051 ret := make([]RateLimit, len(x)) 6052 for i, v := range x { 6053 vCopy := v.DeepCopy() 6054 ret[i] = vCopy 6055 } 6056 return ret 6057 })(o.RateLimits), 6058 } 6059} 6060 6061type ListBotCommandsLocalRes struct { 6062 Commands []UserBotCommandOutput `codec:"commands" json:"commands"` 6063 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 6064} 6065 6066func (o ListBotCommandsLocalRes) DeepCopy() ListBotCommandsLocalRes { 6067 return ListBotCommandsLocalRes{ 6068 Commands: (func(x []UserBotCommandOutput) []UserBotCommandOutput { 6069 if x == nil { 6070 return nil 6071 } 6072 ret := make([]UserBotCommandOutput, len(x)) 6073 for i, v := range x { 6074 vCopy := v.DeepCopy() 6075 ret[i] = vCopy 6076 } 6077 return ret 6078 })(o.Commands), 6079 RateLimits: (func(x []RateLimit) []RateLimit { 6080 if x == nil { 6081 return nil 6082 } 6083 ret := make([]RateLimit, len(x)) 6084 for i, v := range x { 6085 vCopy := v.DeepCopy() 6086 ret[i] = vCopy 6087 } 6088 return ret 6089 })(o.RateLimits), 6090 } 6091} 6092 6093type ClearBotCommandsFilter struct { 6094 Typ BotCommandsAdvertisementTyp `codec:"typ" json:"typ"` 6095 TeamName *string `codec:"teamName,omitempty" json:"teamName,omitempty"` 6096 ConvID *ConversationID `codec:"convID,omitempty" json:"convID,omitempty"` 6097} 6098 6099func (o ClearBotCommandsFilter) DeepCopy() ClearBotCommandsFilter { 6100 return ClearBotCommandsFilter{ 6101 Typ: o.Typ.DeepCopy(), 6102 TeamName: (func(x *string) *string { 6103 if x == nil { 6104 return nil 6105 } 6106 tmp := (*x) 6107 return &tmp 6108 })(o.TeamName), 6109 ConvID: (func(x *ConversationID) *ConversationID { 6110 if x == nil { 6111 return nil 6112 } 6113 tmp := (*x).DeepCopy() 6114 return &tmp 6115 })(o.ConvID), 6116 } 6117} 6118 6119type ClearBotCommandsLocalRes struct { 6120 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 6121} 6122 6123func (o ClearBotCommandsLocalRes) DeepCopy() ClearBotCommandsLocalRes { 6124 return ClearBotCommandsLocalRes{ 6125 RateLimits: (func(x []RateLimit) []RateLimit { 6126 if x == nil { 6127 return nil 6128 } 6129 ret := make([]RateLimit, len(x)) 6130 for i, v := range x { 6131 vCopy := v.DeepCopy() 6132 ret[i] = vCopy 6133 } 6134 return ret 6135 })(o.RateLimits), 6136 } 6137} 6138 6139type PinMessageRes struct { 6140 RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"` 6141} 6142 6143func (o PinMessageRes) DeepCopy() PinMessageRes { 6144 return PinMessageRes{ 6145 RateLimits: (func(x []RateLimit) []RateLimit { 6146 if x == nil { 6147 return nil 6148 } 6149 ret := make([]RateLimit, len(x)) 6150 for i, v := range x { 6151 vCopy := v.DeepCopy() 6152 ret[i] = vCopy 6153 } 6154 return ret 6155 })(o.RateLimits), 6156 } 6157} 6158 6159type ConvSearchHit struct { 6160 Name string `codec:"name" json:"name"` 6161 ConvID ConversationID `codec:"convID" json:"convID"` 6162 IsTeam bool `codec:"isTeam" json:"isTeam"` 6163 Parts []string `codec:"parts" json:"parts"` 6164} 6165 6166func (o ConvSearchHit) DeepCopy() ConvSearchHit { 6167 return ConvSearchHit{ 6168 Name: o.Name, 6169 ConvID: o.ConvID.DeepCopy(), 6170 IsTeam: o.IsTeam, 6171 Parts: (func(x []string) []string { 6172 if x == nil { 6173 return nil 6174 } 6175 ret := make([]string, len(x)) 6176 for i, v := range x { 6177 vCopy := v 6178 ret[i] = vCopy 6179 } 6180 return ret 6181 })(o.Parts), 6182 } 6183} 6184 6185type LocalMtimeUpdate struct { 6186 ConvID ConversationID `codec:"convID" json:"convID"` 6187 Mtime gregor1.Time `codec:"mtime" json:"mtime"` 6188} 6189 6190func (o LocalMtimeUpdate) DeepCopy() LocalMtimeUpdate { 6191 return LocalMtimeUpdate{ 6192 ConvID: o.ConvID.DeepCopy(), 6193 Mtime: o.Mtime.DeepCopy(), 6194 } 6195} 6196 6197type SnippetDecoration int 6198 6199const ( 6200 SnippetDecoration_NONE SnippetDecoration = 0 6201 SnippetDecoration_PENDING_MESSAGE SnippetDecoration = 1 6202 SnippetDecoration_FAILED_PENDING_MESSAGE SnippetDecoration = 2 6203 SnippetDecoration_EXPLODING_MESSAGE SnippetDecoration = 3 6204 SnippetDecoration_EXPLODED_MESSAGE SnippetDecoration = 4 6205 SnippetDecoration_AUDIO_ATTACHMENT SnippetDecoration = 5 6206 SnippetDecoration_VIDEO_ATTACHMENT SnippetDecoration = 6 6207 SnippetDecoration_PHOTO_ATTACHMENT SnippetDecoration = 7 6208 SnippetDecoration_FILE_ATTACHMENT SnippetDecoration = 8 6209 SnippetDecoration_STELLAR_RECEIVED SnippetDecoration = 9 6210 SnippetDecoration_STELLAR_SENT SnippetDecoration = 10 6211 SnippetDecoration_PINNED_MESSAGE SnippetDecoration = 11 6212) 6213 6214func (o SnippetDecoration) DeepCopy() SnippetDecoration { return o } 6215 6216var SnippetDecorationMap = map[string]SnippetDecoration{ 6217 "NONE": 0, 6218 "PENDING_MESSAGE": 1, 6219 "FAILED_PENDING_MESSAGE": 2, 6220 "EXPLODING_MESSAGE": 3, 6221 "EXPLODED_MESSAGE": 4, 6222 "AUDIO_ATTACHMENT": 5, 6223 "VIDEO_ATTACHMENT": 6, 6224 "PHOTO_ATTACHMENT": 7, 6225 "FILE_ATTACHMENT": 8, 6226 "STELLAR_RECEIVED": 9, 6227 "STELLAR_SENT": 10, 6228 "PINNED_MESSAGE": 11, 6229} 6230 6231var SnippetDecorationRevMap = map[SnippetDecoration]string{ 6232 0: "NONE", 6233 1: "PENDING_MESSAGE", 6234 2: "FAILED_PENDING_MESSAGE", 6235 3: "EXPLODING_MESSAGE", 6236 4: "EXPLODED_MESSAGE", 6237 5: "AUDIO_ATTACHMENT", 6238 6: "VIDEO_ATTACHMENT", 6239 7: "PHOTO_ATTACHMENT", 6240 8: "FILE_ATTACHMENT", 6241 9: "STELLAR_RECEIVED", 6242 10: "STELLAR_SENT", 6243 11: "PINNED_MESSAGE", 6244} 6245 6246func (e SnippetDecoration) String() string { 6247 if v, ok := SnippetDecorationRevMap[e]; ok { 6248 return v 6249 } 6250 return fmt.Sprintf("%v", int(e)) 6251} 6252 6253type WelcomeMessageDisplay struct { 6254 Set bool `codec:"set" json:"set"` 6255 Display string `codec:"display" json:"display"` 6256 Raw string `codec:"raw" json:"raw"` 6257} 6258 6259func (o WelcomeMessageDisplay) DeepCopy() WelcomeMessageDisplay { 6260 return WelcomeMessageDisplay{ 6261 Set: o.Set, 6262 Display: o.Display, 6263 Raw: o.Raw, 6264 } 6265} 6266 6267type WelcomeMessage struct { 6268 Set bool `codec:"set" json:"set"` 6269 Raw string `codec:"raw" json:"raw"` 6270} 6271 6272func (o WelcomeMessage) DeepCopy() WelcomeMessage { 6273 return WelcomeMessage{ 6274 Set: o.Set, 6275 Raw: o.Raw, 6276 } 6277} 6278 6279type GetDefaultTeamChannelsLocalRes struct { 6280 Convs []InboxUIItem `codec:"convs" json:"convs"` 6281 RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` 6282} 6283 6284func (o GetDefaultTeamChannelsLocalRes) DeepCopy() GetDefaultTeamChannelsLocalRes { 6285 return GetDefaultTeamChannelsLocalRes{ 6286 Convs: (func(x []InboxUIItem) []InboxUIItem { 6287 if x == nil { 6288 return nil 6289 } 6290 ret := make([]InboxUIItem, len(x)) 6291 for i, v := range x { 6292 vCopy := v.DeepCopy() 6293 ret[i] = vCopy 6294 } 6295 return ret 6296 })(o.Convs), 6297 RateLimit: (func(x *RateLimit) *RateLimit { 6298 if x == nil { 6299 return nil 6300 } 6301 tmp := (*x).DeepCopy() 6302 return &tmp 6303 })(o.RateLimit), 6304 } 6305} 6306 6307type SetDefaultTeamChannelsLocalRes struct { 6308 RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` 6309} 6310 6311func (o SetDefaultTeamChannelsLocalRes) DeepCopy() SetDefaultTeamChannelsLocalRes { 6312 return SetDefaultTeamChannelsLocalRes{ 6313 RateLimit: (func(x *RateLimit) *RateLimit { 6314 if x == nil { 6315 return nil 6316 } 6317 tmp := (*x).DeepCopy() 6318 return &tmp 6319 })(o.RateLimit), 6320 } 6321} 6322 6323type LastActiveTimeAll struct { 6324 Teams map[TLFIDStr]gregor1.Time `codec:"teams" json:"teams"` 6325 Channels map[ConvIDStr]gregor1.Time `codec:"channels" json:"channels"` 6326} 6327 6328func (o LastActiveTimeAll) DeepCopy() LastActiveTimeAll { 6329 return LastActiveTimeAll{ 6330 Teams: (func(x map[TLFIDStr]gregor1.Time) map[TLFIDStr]gregor1.Time { 6331 if x == nil { 6332 return nil 6333 } 6334 ret := make(map[TLFIDStr]gregor1.Time, len(x)) 6335 for k, v := range x { 6336 kCopy := k.DeepCopy() 6337 vCopy := v.DeepCopy() 6338 ret[kCopy] = vCopy 6339 } 6340 return ret 6341 })(o.Teams), 6342 Channels: (func(x map[ConvIDStr]gregor1.Time) map[ConvIDStr]gregor1.Time { 6343 if x == nil { 6344 return nil 6345 } 6346 ret := make(map[ConvIDStr]gregor1.Time, len(x)) 6347 for k, v := range x { 6348 kCopy := k.DeepCopy() 6349 vCopy := v.DeepCopy() 6350 ret[kCopy] = vCopy 6351 } 6352 return ret 6353 })(o.Channels), 6354 } 6355} 6356 6357type LastActiveStatusAll struct { 6358 Teams map[TLFIDStr]LastActiveStatus `codec:"teams" json:"teams"` 6359 Channels map[ConvIDStr]LastActiveStatus `codec:"channels" json:"channels"` 6360} 6361 6362func (o LastActiveStatusAll) DeepCopy() LastActiveStatusAll { 6363 return LastActiveStatusAll{ 6364 Teams: (func(x map[TLFIDStr]LastActiveStatus) map[TLFIDStr]LastActiveStatus { 6365 if x == nil { 6366 return nil 6367 } 6368 ret := make(map[TLFIDStr]LastActiveStatus, len(x)) 6369 for k, v := range x { 6370 kCopy := k.DeepCopy() 6371 vCopy := v.DeepCopy() 6372 ret[kCopy] = vCopy 6373 } 6374 return ret 6375 })(o.Teams), 6376 Channels: (func(x map[ConvIDStr]LastActiveStatus) map[ConvIDStr]LastActiveStatus { 6377 if x == nil { 6378 return nil 6379 } 6380 ret := make(map[ConvIDStr]LastActiveStatus, len(x)) 6381 for k, v := range x { 6382 kCopy := k.DeepCopy() 6383 vCopy := v.DeepCopy() 6384 ret[kCopy] = vCopy 6385 } 6386 return ret 6387 })(o.Channels), 6388 } 6389} 6390 6391type EmojiError struct { 6392 Clidisplay string `codec:"clidisplay" json:"clidisplay"` 6393 Uidisplay string `codec:"uidisplay" json:"uidisplay"` 6394} 6395 6396func (o EmojiError) DeepCopy() EmojiError { 6397 return EmojiError{ 6398 Clidisplay: o.Clidisplay, 6399 Uidisplay: o.Uidisplay, 6400 } 6401} 6402 6403type AddEmojiRes struct { 6404 RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` 6405 Error *EmojiError `codec:"error,omitempty" json:"error,omitempty"` 6406} 6407 6408func (o AddEmojiRes) DeepCopy() AddEmojiRes { 6409 return AddEmojiRes{ 6410 RateLimit: (func(x *RateLimit) *RateLimit { 6411 if x == nil { 6412 return nil 6413 } 6414 tmp := (*x).DeepCopy() 6415 return &tmp 6416 })(o.RateLimit), 6417 Error: (func(x *EmojiError) *EmojiError { 6418 if x == nil { 6419 return nil 6420 } 6421 tmp := (*x).DeepCopy() 6422 return &tmp 6423 })(o.Error), 6424 } 6425} 6426 6427type AddEmojisRes struct { 6428 RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` 6429 SuccessFilenames []string `codec:"successFilenames" json:"successFilenames"` 6430 FailedFilenames map[string]EmojiError `codec:"failedFilenames" json:"failedFilenames"` 6431} 6432 6433func (o AddEmojisRes) DeepCopy() AddEmojisRes { 6434 return AddEmojisRes{ 6435 RateLimit: (func(x *RateLimit) *RateLimit { 6436 if x == nil { 6437 return nil 6438 } 6439 tmp := (*x).DeepCopy() 6440 return &tmp 6441 })(o.RateLimit), 6442 SuccessFilenames: (func(x []string) []string { 6443 if x == nil { 6444 return nil 6445 } 6446 ret := make([]string, len(x)) 6447 for i, v := range x { 6448 vCopy := v 6449 ret[i] = vCopy 6450 } 6451 return ret 6452 })(o.SuccessFilenames), 6453 FailedFilenames: (func(x map[string]EmojiError) map[string]EmojiError { 6454 if x == nil { 6455 return nil 6456 } 6457 ret := make(map[string]EmojiError, len(x)) 6458 for k, v := range x { 6459 kCopy := k 6460 vCopy := v.DeepCopy() 6461 ret[kCopy] = vCopy 6462 } 6463 return ret 6464 })(o.FailedFilenames), 6465 } 6466} 6467 6468type AddEmojiAliasRes struct { 6469 RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` 6470 Error *EmojiError `codec:"error,omitempty" json:"error,omitempty"` 6471} 6472 6473func (o AddEmojiAliasRes) DeepCopy() AddEmojiAliasRes { 6474 return AddEmojiAliasRes{ 6475 RateLimit: (func(x *RateLimit) *RateLimit { 6476 if x == nil { 6477 return nil 6478 } 6479 tmp := (*x).DeepCopy() 6480 return &tmp 6481 })(o.RateLimit), 6482 Error: (func(x *EmojiError) *EmojiError { 6483 if x == nil { 6484 return nil 6485 } 6486 tmp := (*x).DeepCopy() 6487 return &tmp 6488 })(o.Error), 6489 } 6490} 6491 6492type RemoveEmojiRes struct { 6493 RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` 6494} 6495 6496func (o RemoveEmojiRes) DeepCopy() RemoveEmojiRes { 6497 return RemoveEmojiRes{ 6498 RateLimit: (func(x *RateLimit) *RateLimit { 6499 if x == nil { 6500 return nil 6501 } 6502 tmp := (*x).DeepCopy() 6503 return &tmp 6504 })(o.RateLimit), 6505 } 6506} 6507 6508type UserEmojiRes struct { 6509 Emojis UserEmojis `codec:"emojis" json:"emojis"` 6510 RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"` 6511} 6512 6513func (o UserEmojiRes) DeepCopy() UserEmojiRes { 6514 return UserEmojiRes{ 6515 Emojis: o.Emojis.DeepCopy(), 6516 RateLimit: (func(x *RateLimit) *RateLimit { 6517 if x == nil { 6518 return nil 6519 } 6520 tmp := (*x).DeepCopy() 6521 return &tmp 6522 })(o.RateLimit), 6523 } 6524} 6525 6526type EmojiFetchOpts struct { 6527 GetCreationInfo bool `codec:"getCreationInfo" json:"getCreationInfo"` 6528 GetAliases bool `codec:"getAliases" json:"getAliases"` 6529 OnlyInTeam bool `codec:"onlyInTeam" json:"onlyInTeam"` 6530} 6531 6532func (o EmojiFetchOpts) DeepCopy() EmojiFetchOpts { 6533 return EmojiFetchOpts{ 6534 GetCreationInfo: o.GetCreationInfo, 6535 GetAliases: o.GetAliases, 6536 OnlyInTeam: o.OnlyInTeam, 6537 } 6538} 6539 6540type GetThreadLocalArg struct { 6541 ConversationID ConversationID `codec:"conversationID" json:"conversationID"` 6542 Reason GetThreadReason `codec:"reason" json:"reason"` 6543 Query *GetThreadQuery `codec:"query,omitempty" json:"query,omitempty"` 6544 Pagination *Pagination `codec:"pagination,omitempty" json:"pagination,omitempty"` 6545 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6546} 6547 6548type GetThreadNonblockArg struct { 6549 SessionID int `codec:"sessionID" json:"sessionID"` 6550 ConversationID ConversationID `codec:"conversationID" json:"conversationID"` 6551 CbMode GetThreadNonblockCbMode `codec:"cbMode" json:"cbMode"` 6552 Reason GetThreadReason `codec:"reason" json:"reason"` 6553 Pgmode GetThreadNonblockPgMode `codec:"pgmode" json:"pgmode"` 6554 Query *GetThreadQuery `codec:"query,omitempty" json:"query,omitempty"` 6555 KnownRemotes []string `codec:"knownRemotes" json:"knownRemotes"` 6556 Pagination *UIPagination `codec:"pagination,omitempty" json:"pagination,omitempty"` 6557 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6558} 6559 6560type GetUnreadlineArg struct { 6561 SessionID int `codec:"sessionID" json:"sessionID"` 6562 ConvID ConversationID `codec:"convID" json:"convID"` 6563 ReadMsgID MessageID `codec:"readMsgID" json:"readMsgID"` 6564 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6565} 6566 6567type GetInboxAndUnboxLocalArg struct { 6568 Query *GetInboxLocalQuery `codec:"query,omitempty" json:"query,omitempty"` 6569 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6570} 6571 6572type GetInboxAndUnboxUILocalArg struct { 6573 Query *GetInboxLocalQuery `codec:"query,omitempty" json:"query,omitempty"` 6574 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6575} 6576 6577type RequestInboxLayoutArg struct { 6578 ReselectMode InboxLayoutReselectMode `codec:"reselectMode" json:"reselectMode"` 6579} 6580 6581type RequestInboxUnboxArg struct { 6582 ConvIDs []ConversationID `codec:"convIDs" json:"convIDs"` 6583} 6584 6585type RequestInboxSmallIncreaseArg struct { 6586} 6587 6588type RequestInboxSmallResetArg struct { 6589} 6590 6591type GetInboxNonblockLocalArg struct { 6592 SessionID int `codec:"sessionID" json:"sessionID"` 6593 MaxUnbox *int `codec:"maxUnbox,omitempty" json:"maxUnbox,omitempty"` 6594 SkipUnverified bool `codec:"skipUnverified" json:"skipUnverified"` 6595 Query *GetInboxLocalQuery `codec:"query,omitempty" json:"query,omitempty"` 6596 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6597} 6598 6599type PostLocalArg struct { 6600 SessionID int `codec:"sessionID" json:"sessionID"` 6601 ConversationID ConversationID `codec:"conversationID" json:"conversationID"` 6602 Msg MessagePlaintext `codec:"msg" json:"msg"` 6603 ReplyTo *MessageID `codec:"replyTo,omitempty" json:"replyTo,omitempty"` 6604 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6605 SkipInChatPayments bool `codec:"skipInChatPayments" json:"skipInChatPayments"` 6606} 6607 6608type GenerateOutboxIDArg struct { 6609} 6610 6611type PostLocalNonblockArg struct { 6612 SessionID int `codec:"sessionID" json:"sessionID"` 6613 ConversationID ConversationID `codec:"conversationID" json:"conversationID"` 6614 Msg MessagePlaintext `codec:"msg" json:"msg"` 6615 ClientPrev MessageID `codec:"clientPrev" json:"clientPrev"` 6616 OutboxID *OutboxID `codec:"outboxID,omitempty" json:"outboxID,omitempty"` 6617 ReplyTo *MessageID `codec:"replyTo,omitempty" json:"replyTo,omitempty"` 6618 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6619 SkipInChatPayments bool `codec:"skipInChatPayments" json:"skipInChatPayments"` 6620} 6621 6622type ForwardMessageArg struct { 6623 SessionID int `codec:"sessionID" json:"sessionID"` 6624 SrcConvID ConversationID `codec:"srcConvID" json:"srcConvID"` 6625 DstConvID ConversationID `codec:"dstConvID" json:"dstConvID"` 6626 MsgID MessageID `codec:"msgID" json:"msgID"` 6627 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6628} 6629 6630type ForwardMessageNonblockArg struct { 6631 SessionID int `codec:"sessionID" json:"sessionID"` 6632 SrcConvID ConversationID `codec:"srcConvID" json:"srcConvID"` 6633 DstConvID ConversationID `codec:"dstConvID" json:"dstConvID"` 6634 MsgID MessageID `codec:"msgID" json:"msgID"` 6635 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6636} 6637 6638type PostTextNonblockArg struct { 6639 SessionID int `codec:"sessionID" json:"sessionID"` 6640 ConversationID ConversationID `codec:"conversationID" json:"conversationID"` 6641 TlfName string `codec:"tlfName" json:"tlfName"` 6642 TlfPublic bool `codec:"tlfPublic" json:"tlfPublic"` 6643 Body string `codec:"body" json:"body"` 6644 ClientPrev MessageID `codec:"clientPrev" json:"clientPrev"` 6645 ReplyTo *MessageID `codec:"replyTo,omitempty" json:"replyTo,omitempty"` 6646 OutboxID *OutboxID `codec:"outboxID,omitempty" json:"outboxID,omitempty"` 6647 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6648 EphemeralLifetime *gregor1.DurationSec `codec:"ephemeralLifetime,omitempty" json:"ephemeralLifetime,omitempty"` 6649} 6650 6651type PostDeleteNonblockArg struct { 6652 ConversationID ConversationID `codec:"conversationID" json:"conversationID"` 6653 TlfName string `codec:"tlfName" json:"tlfName"` 6654 TlfPublic bool `codec:"tlfPublic" json:"tlfPublic"` 6655 Supersedes MessageID `codec:"supersedes" json:"supersedes"` 6656 ClientPrev MessageID `codec:"clientPrev" json:"clientPrev"` 6657 OutboxID *OutboxID `codec:"outboxID,omitempty" json:"outboxID,omitempty"` 6658 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6659} 6660 6661type PostEditNonblockArg struct { 6662 ConversationID ConversationID `codec:"conversationID" json:"conversationID"` 6663 TlfName string `codec:"tlfName" json:"tlfName"` 6664 TlfPublic bool `codec:"tlfPublic" json:"tlfPublic"` 6665 Target EditTarget `codec:"target" json:"target"` 6666 Body string `codec:"body" json:"body"` 6667 OutboxID *OutboxID `codec:"outboxID,omitempty" json:"outboxID,omitempty"` 6668 ClientPrev MessageID `codec:"clientPrev" json:"clientPrev"` 6669 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6670} 6671 6672type PostReactionNonblockArg struct { 6673 ConversationID ConversationID `codec:"conversationID" json:"conversationID"` 6674 TlfName string `codec:"tlfName" json:"tlfName"` 6675 TlfPublic bool `codec:"tlfPublic" json:"tlfPublic"` 6676 Supersedes MessageID `codec:"supersedes" json:"supersedes"` 6677 Body string `codec:"body" json:"body"` 6678 OutboxID *OutboxID `codec:"outboxID,omitempty" json:"outboxID,omitempty"` 6679 ClientPrev MessageID `codec:"clientPrev" json:"clientPrev"` 6680 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6681} 6682 6683type PostHeadlineNonblockArg struct { 6684 ConversationID ConversationID `codec:"conversationID" json:"conversationID"` 6685 TlfName string `codec:"tlfName" json:"tlfName"` 6686 TlfPublic bool `codec:"tlfPublic" json:"tlfPublic"` 6687 Headline string `codec:"headline" json:"headline"` 6688 OutboxID *OutboxID `codec:"outboxID,omitempty" json:"outboxID,omitempty"` 6689 ClientPrev MessageID `codec:"clientPrev" json:"clientPrev"` 6690 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6691} 6692 6693type PostHeadlineArg struct { 6694 ConversationID ConversationID `codec:"conversationID" json:"conversationID"` 6695 TlfName string `codec:"tlfName" json:"tlfName"` 6696 TlfPublic bool `codec:"tlfPublic" json:"tlfPublic"` 6697 Headline string `codec:"headline" json:"headline"` 6698 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6699} 6700 6701type PostMetadataNonblockArg struct { 6702 ConversationID ConversationID `codec:"conversationID" json:"conversationID"` 6703 TlfName string `codec:"tlfName" json:"tlfName"` 6704 TlfPublic bool `codec:"tlfPublic" json:"tlfPublic"` 6705 ChannelName string `codec:"channelName" json:"channelName"` 6706 OutboxID *OutboxID `codec:"outboxID,omitempty" json:"outboxID,omitempty"` 6707 ClientPrev MessageID `codec:"clientPrev" json:"clientPrev"` 6708 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6709} 6710 6711type PostMetadataArg struct { 6712 ConversationID ConversationID `codec:"conversationID" json:"conversationID"` 6713 TlfName string `codec:"tlfName" json:"tlfName"` 6714 TlfPublic bool `codec:"tlfPublic" json:"tlfPublic"` 6715 ChannelName string `codec:"channelName" json:"channelName"` 6716 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6717} 6718 6719type PostDeleteHistoryUptoArg struct { 6720 ConversationID ConversationID `codec:"conversationID" json:"conversationID"` 6721 TlfName string `codec:"tlfName" json:"tlfName"` 6722 TlfPublic bool `codec:"tlfPublic" json:"tlfPublic"` 6723 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6724 Upto MessageID `codec:"upto" json:"upto"` 6725} 6726 6727type PostDeleteHistoryThroughArg struct { 6728 ConversationID ConversationID `codec:"conversationID" json:"conversationID"` 6729 TlfName string `codec:"tlfName" json:"tlfName"` 6730 TlfPublic bool `codec:"tlfPublic" json:"tlfPublic"` 6731 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6732 Through MessageID `codec:"through" json:"through"` 6733} 6734 6735type PostDeleteHistoryByAgeArg struct { 6736 ConversationID ConversationID `codec:"conversationID" json:"conversationID"` 6737 TlfName string `codec:"tlfName" json:"tlfName"` 6738 TlfPublic bool `codec:"tlfPublic" json:"tlfPublic"` 6739 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6740 Age gregor1.DurationSec `codec:"age" json:"age"` 6741} 6742 6743type SetConversationStatusLocalArg struct { 6744 ConversationID ConversationID `codec:"conversationID" json:"conversationID"` 6745 Status ConversationStatus `codec:"status" json:"status"` 6746 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6747} 6748 6749type NewConversationsLocalArg struct { 6750 NewConversationLocalArguments []NewConversationLocalArgument `codec:"newConversationLocalArguments" json:"newConversationLocalArguments"` 6751 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6752} 6753 6754type NewConversationLocalArg struct { 6755 TlfName string `codec:"tlfName" json:"tlfName"` 6756 TopicType TopicType `codec:"topicType" json:"topicType"` 6757 TlfVisibility keybase1.TLFVisibility `codec:"tlfVisibility" json:"tlfVisibility"` 6758 TopicName *string `codec:"topicName,omitempty" json:"topicName,omitempty"` 6759 MembersType ConversationMembersType `codec:"membersType" json:"membersType"` 6760 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6761} 6762 6763type GetInboxSummaryForCLILocalArg struct { 6764 Query GetInboxSummaryForCLILocalQuery `codec:"query" json:"query"` 6765} 6766 6767type GetConversationForCLILocalArg struct { 6768 Query GetConversationForCLILocalQuery `codec:"query" json:"query"` 6769} 6770 6771type GetMessagesLocalArg struct { 6772 ConversationID ConversationID `codec:"conversationID" json:"conversationID"` 6773 MessageIDs []MessageID `codec:"messageIDs" json:"messageIDs"` 6774 DisableResolveSupersedes bool `codec:"disableResolveSupersedes" json:"disableResolveSupersedes"` 6775 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6776} 6777 6778type PostFileAttachmentLocalArg struct { 6779 SessionID int `codec:"sessionID" json:"sessionID"` 6780 Arg PostFileAttachmentArg `codec:"arg" json:"arg"` 6781} 6782 6783type PostFileAttachmentLocalNonblockArg struct { 6784 SessionID int `codec:"sessionID" json:"sessionID"` 6785 Arg PostFileAttachmentArg `codec:"arg" json:"arg"` 6786 ClientPrev MessageID `codec:"clientPrev" json:"clientPrev"` 6787} 6788 6789type GetNextAttachmentMessageLocalArg struct { 6790 ConvID ConversationID `codec:"convID" json:"convID"` 6791 MessageID MessageID `codec:"messageID" json:"messageID"` 6792 BackInTime bool `codec:"backInTime" json:"backInTime"` 6793 AssetTypes []AssetMetadataType `codec:"assetTypes" json:"assetTypes"` 6794 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6795} 6796 6797type DownloadAttachmentLocalArg struct { 6798 SessionID int `codec:"sessionID" json:"sessionID"` 6799 ConversationID ConversationID `codec:"conversationID" json:"conversationID"` 6800 MessageID MessageID `codec:"messageID" json:"messageID"` 6801 Sink keybase1.Stream `codec:"sink" json:"sink"` 6802 Preview bool `codec:"preview" json:"preview"` 6803 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6804} 6805 6806type DownloadFileAttachmentLocalArg struct { 6807 SessionID int `codec:"sessionID" json:"sessionID"` 6808 ConversationID ConversationID `codec:"conversationID" json:"conversationID"` 6809 MessageID MessageID `codec:"messageID" json:"messageID"` 6810 DownloadToCache bool `codec:"downloadToCache" json:"downloadToCache"` 6811 Preview bool `codec:"preview" json:"preview"` 6812 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6813} 6814 6815type ConfigureFileAttachmentDownloadLocalArg struct { 6816 CacheDirOverride string `codec:"cacheDirOverride" json:"cacheDirOverride"` 6817 DownloadDirOverride string `codec:"downloadDirOverride" json:"downloadDirOverride"` 6818} 6819 6820type MakePreviewArg struct { 6821 SessionID int `codec:"sessionID" json:"sessionID"` 6822 Filename string `codec:"filename" json:"filename"` 6823 OutboxID OutboxID `codec:"outboxID" json:"outboxID"` 6824} 6825 6826type MakeAudioPreviewArg struct { 6827 Amps []float64 `codec:"amps" json:"amps"` 6828 Duration int `codec:"duration" json:"duration"` 6829} 6830 6831type GetUploadTempFileArg struct { 6832 OutboxID OutboxID `codec:"outboxID" json:"outboxID"` 6833 Filename string `codec:"filename" json:"filename"` 6834} 6835 6836type MakeUploadTempFileArg struct { 6837 OutboxID OutboxID `codec:"outboxID" json:"outboxID"` 6838 Filename string `codec:"filename" json:"filename"` 6839 Data []byte `codec:"data" json:"data"` 6840} 6841 6842type CancelUploadTempFileArg struct { 6843 OutboxID OutboxID `codec:"outboxID" json:"outboxID"` 6844} 6845 6846type CancelPostArg struct { 6847 OutboxID OutboxID `codec:"outboxID" json:"outboxID"` 6848} 6849 6850type RetryPostArg struct { 6851 OutboxID OutboxID `codec:"outboxID" json:"outboxID"` 6852 IdentifyBehavior *keybase1.TLFIdentifyBehavior `codec:"identifyBehavior,omitempty" json:"identifyBehavior,omitempty"` 6853} 6854 6855type MarkAsReadLocalArg struct { 6856 SessionID int `codec:"sessionID" json:"sessionID"` 6857 ConversationID ConversationID `codec:"conversationID" json:"conversationID"` 6858 MsgID *MessageID `codec:"msgID,omitempty" json:"msgID,omitempty"` 6859} 6860 6861type MarkTLFAsReadLocalArg struct { 6862 SessionID int `codec:"sessionID" json:"sessionID"` 6863 TlfID TLFID `codec:"tlfID" json:"tlfID"` 6864} 6865 6866type FindConversationsLocalArg struct { 6867 TlfName string `codec:"tlfName" json:"tlfName"` 6868 MembersType ConversationMembersType `codec:"membersType" json:"membersType"` 6869 Visibility keybase1.TLFVisibility `codec:"visibility" json:"visibility"` 6870 TopicType TopicType `codec:"topicType" json:"topicType"` 6871 TopicName string `codec:"topicName" json:"topicName"` 6872 OneChatPerTLF *bool `codec:"oneChatPerTLF,omitempty" json:"oneChatPerTLF,omitempty"` 6873 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6874} 6875 6876type FindGeneralConvFromTeamIDArg struct { 6877 TeamID keybase1.TeamID `codec:"teamID" json:"teamID"` 6878} 6879 6880type UpdateTypingArg struct { 6881 ConversationID ConversationID `codec:"conversationID" json:"conversationID"` 6882 Typing bool `codec:"typing" json:"typing"` 6883} 6884 6885type UpdateUnsentTextArg struct { 6886 ConversationID ConversationID `codec:"conversationID" json:"conversationID"` 6887 TlfName string `codec:"tlfName" json:"tlfName"` 6888 Text string `codec:"text" json:"text"` 6889} 6890 6891type JoinConversationLocalArg struct { 6892 TlfName string `codec:"tlfName" json:"tlfName"` 6893 TopicType TopicType `codec:"topicType" json:"topicType"` 6894 Visibility keybase1.TLFVisibility `codec:"visibility" json:"visibility"` 6895 TopicName string `codec:"topicName" json:"topicName"` 6896} 6897 6898type JoinConversationByIDLocalArg struct { 6899 ConvID ConversationID `codec:"convID" json:"convID"` 6900} 6901 6902type LeaveConversationLocalArg struct { 6903 ConvID ConversationID `codec:"convID" json:"convID"` 6904} 6905 6906type PreviewConversationByIDLocalArg struct { 6907 ConvID ConversationID `codec:"convID" json:"convID"` 6908} 6909 6910type DeleteConversationLocalArg struct { 6911 SessionID int `codec:"sessionID" json:"sessionID"` 6912 ConvID ConversationID `codec:"convID" json:"convID"` 6913 ChannelName string `codec:"channelName" json:"channelName"` 6914 Confirmed bool `codec:"confirmed" json:"confirmed"` 6915} 6916 6917type RemoveFromConversationLocalArg struct { 6918 ConvID ConversationID `codec:"convID" json:"convID"` 6919 Usernames []string `codec:"usernames" json:"usernames"` 6920} 6921 6922type GetTLFConversationsLocalArg struct { 6923 TlfName string `codec:"tlfName" json:"tlfName"` 6924 TopicType TopicType `codec:"topicType" json:"topicType"` 6925 MembersType ConversationMembersType `codec:"membersType" json:"membersType"` 6926} 6927 6928type GetChannelMembershipsLocalArg struct { 6929 TeamID keybase1.TeamID `codec:"teamID" json:"teamID"` 6930 Uid gregor1.UID `codec:"uid" json:"uid"` 6931} 6932 6933type GetMutualTeamsLocalArg struct { 6934 Usernames []string `codec:"usernames" json:"usernames"` 6935} 6936 6937type SetAppNotificationSettingsLocalArg struct { 6938 ConvID ConversationID `codec:"convID" json:"convID"` 6939 ChannelWide bool `codec:"channelWide" json:"channelWide"` 6940 Settings []AppNotificationSettingLocal `codec:"settings" json:"settings"` 6941} 6942 6943type SetGlobalAppNotificationSettingsLocalArg struct { 6944 Settings map[string]bool `codec:"settings" json:"settings"` 6945} 6946 6947type GetGlobalAppNotificationSettingsLocalArg struct { 6948} 6949 6950type UnboxMobilePushNotificationArg struct { 6951 Payload string `codec:"payload" json:"payload"` 6952 ConvID string `codec:"convID" json:"convID"` 6953 MembersType ConversationMembersType `codec:"membersType" json:"membersType"` 6954 PushIDs []string `codec:"pushIDs" json:"pushIDs"` 6955 ShouldAck bool `codec:"shouldAck" json:"shouldAck"` 6956} 6957 6958type AddTeamMemberAfterResetArg struct { 6959 Username string `codec:"username" json:"username"` 6960 ConvID ConversationID `codec:"convID" json:"convID"` 6961} 6962 6963type GetAllResetConvMembersArg struct { 6964} 6965 6966type SetConvRetentionLocalArg struct { 6967 ConvID ConversationID `codec:"convID" json:"convID"` 6968 Policy RetentionPolicy `codec:"policy" json:"policy"` 6969} 6970 6971type SetTeamRetentionLocalArg struct { 6972 TeamID keybase1.TeamID `codec:"teamID" json:"teamID"` 6973 Policy RetentionPolicy `codec:"policy" json:"policy"` 6974} 6975 6976type GetTeamRetentionLocalArg struct { 6977 TeamID keybase1.TeamID `codec:"teamID" json:"teamID"` 6978} 6979 6980type SetConvMinWriterRoleLocalArg struct { 6981 ConvID ConversationID `codec:"convID" json:"convID"` 6982 Role keybase1.TeamRole `codec:"role" json:"role"` 6983} 6984 6985type UpgradeKBFSConversationToImpteamArg struct { 6986 ConvID ConversationID `codec:"convID" json:"convID"` 6987} 6988 6989type SearchRegexpArg struct { 6990 SessionID int `codec:"sessionID" json:"sessionID"` 6991 ConvID ConversationID `codec:"convID" json:"convID"` 6992 Query string `codec:"query" json:"query"` 6993 Opts SearchOpts `codec:"opts" json:"opts"` 6994 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 6995} 6996 6997type CancelActiveInboxSearchArg struct { 6998} 6999 7000type SearchInboxArg struct { 7001 SessionID int `codec:"sessionID" json:"sessionID"` 7002 Query string `codec:"query" json:"query"` 7003 Opts SearchOpts `codec:"opts" json:"opts"` 7004 NamesOnly bool `codec:"namesOnly" json:"namesOnly"` 7005 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 7006} 7007 7008type SimpleSearchInboxConvNamesArg struct { 7009 Query string `codec:"query" json:"query"` 7010} 7011 7012type CancelActiveSearchArg struct { 7013} 7014 7015type ProfileChatSearchArg struct { 7016 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 7017} 7018 7019type GetStaticConfigArg struct { 7020} 7021 7022type ResolveUnfurlPromptArg struct { 7023 ConvID ConversationID `codec:"convID" json:"convID"` 7024 MsgID MessageID `codec:"msgID" json:"msgID"` 7025 Result UnfurlPromptResult `codec:"result" json:"result"` 7026 IdentifyBehavior keybase1.TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"` 7027} 7028 7029type GetUnfurlSettingsArg struct { 7030} 7031 7032type SaveUnfurlSettingsArg struct { 7033 Mode UnfurlMode `codec:"mode" json:"mode"` 7034 Whitelist []string `codec:"whitelist" json:"whitelist"` 7035} 7036 7037type ToggleMessageCollapseArg struct { 7038 ConvID ConversationID `codec:"convID" json:"convID"` 7039 MsgID MessageID `codec:"msgID" json:"msgID"` 7040 Collapse bool `codec:"collapse" json:"collapse"` 7041} 7042 7043type BulkAddToConvArg struct { 7044 ConvID ConversationID `codec:"convID" json:"convID"` 7045 Usernames []string `codec:"usernames" json:"usernames"` 7046} 7047 7048type BulkAddToManyConvsArg struct { 7049 Conversations []ConversationID `codec:"conversations" json:"conversations"` 7050 Usernames []string `codec:"usernames" json:"usernames"` 7051} 7052 7053type PutReacjiSkinToneArg struct { 7054 SkinTone keybase1.ReacjiSkinTone `codec:"skinTone" json:"skinTone"` 7055} 7056 7057type ResolveMaybeMentionArg struct { 7058 Mention MaybeMention `codec:"mention" json:"mention"` 7059} 7060 7061type LoadGalleryArg struct { 7062 SessionID int `codec:"sessionID" json:"sessionID"` 7063 ConvID ConversationID `codec:"convID" json:"convID"` 7064 Typ GalleryItemTyp `codec:"typ" json:"typ"` 7065 Num int `codec:"num" json:"num"` 7066 FromMsgID *MessageID `codec:"fromMsgID,omitempty" json:"fromMsgID,omitempty"` 7067} 7068 7069type LoadFlipArg struct { 7070 HostConvID ConversationID `codec:"hostConvID" json:"hostConvID"` 7071 HostMsgID MessageID `codec:"hostMsgID" json:"hostMsgID"` 7072 FlipConvID ConversationID `codec:"flipConvID" json:"flipConvID"` 7073 GameID FlipGameID `codec:"gameID" json:"gameID"` 7074} 7075 7076type LocationUpdateArg struct { 7077 Coord Coordinate `codec:"coord" json:"coord"` 7078} 7079 7080type AdvertiseBotCommandsLocalArg struct { 7081 Alias *string `codec:"alias,omitempty" json:"alias,omitempty"` 7082 Advertisements []AdvertiseCommandsParam `codec:"advertisements" json:"advertisements"` 7083} 7084 7085type ListBotCommandsLocalArg struct { 7086 ConvID ConversationID `codec:"convID" json:"convID"` 7087} 7088 7089type ListPublicBotCommandsLocalArg struct { 7090 Username string `codec:"username" json:"username"` 7091} 7092 7093type ClearBotCommandsLocalArg struct { 7094 Filter *ClearBotCommandsFilter `codec:"filter,omitempty" json:"filter,omitempty"` 7095} 7096 7097type PinMessageArg struct { 7098 ConvID ConversationID `codec:"convID" json:"convID"` 7099 MsgID MessageID `codec:"msgID" json:"msgID"` 7100} 7101 7102type UnpinMessageArg struct { 7103 ConvID ConversationID `codec:"convID" json:"convID"` 7104} 7105 7106type IgnorePinnedMessageArg struct { 7107 ConvID ConversationID `codec:"convID" json:"convID"` 7108} 7109 7110type AddBotMemberArg struct { 7111 ConvID ConversationID `codec:"convID" json:"convID"` 7112 Username string `codec:"username" json:"username"` 7113 BotSettings *keybase1.TeamBotSettings `codec:"botSettings,omitempty" json:"botSettings,omitempty"` 7114 Role keybase1.TeamRole `codec:"role" json:"role"` 7115} 7116 7117type EditBotMemberArg struct { 7118 ConvID ConversationID `codec:"convID" json:"convID"` 7119 Username string `codec:"username" json:"username"` 7120 BotSettings *keybase1.TeamBotSettings `codec:"botSettings,omitempty" json:"botSettings,omitempty"` 7121 Role keybase1.TeamRole `codec:"role" json:"role"` 7122} 7123 7124type RemoveBotMemberArg struct { 7125 ConvID ConversationID `codec:"convID" json:"convID"` 7126 Username string `codec:"username" json:"username"` 7127} 7128 7129type SetBotMemberSettingsArg struct { 7130 ConvID ConversationID `codec:"convID" json:"convID"` 7131 Username string `codec:"username" json:"username"` 7132 BotSettings keybase1.TeamBotSettings `codec:"botSettings" json:"botSettings"` 7133} 7134 7135type GetBotMemberSettingsArg struct { 7136 ConvID ConversationID `codec:"convID" json:"convID"` 7137 Username string `codec:"username" json:"username"` 7138} 7139 7140type GetTeamRoleInConversationArg struct { 7141 ConvID ConversationID `codec:"convID" json:"convID"` 7142 Username string `codec:"username" json:"username"` 7143} 7144 7145type AddBotConvSearchArg struct { 7146 Term string `codec:"term" json:"term"` 7147} 7148 7149type ForwardMessageConvSearchArg struct { 7150 Term string `codec:"term" json:"term"` 7151} 7152 7153type TeamIDFromTLFNameArg struct { 7154 TlfName string `codec:"tlfName" json:"tlfName"` 7155 MembersType ConversationMembersType `codec:"membersType" json:"membersType"` 7156 TlfPublic bool `codec:"tlfPublic" json:"tlfPublic"` 7157} 7158 7159type DismissJourneycardArg struct { 7160 ConvID ConversationID `codec:"convID" json:"convID"` 7161 CardType JourneycardType `codec:"cardType" json:"cardType"` 7162} 7163 7164type SetWelcomeMessageArg struct { 7165 TeamID keybase1.TeamID `codec:"teamID" json:"teamID"` 7166 Message WelcomeMessage `codec:"message" json:"message"` 7167} 7168 7169type GetWelcomeMessageArg struct { 7170 TeamID keybase1.TeamID `codec:"teamID" json:"teamID"` 7171} 7172 7173type GetDefaultTeamChannelsLocalArg struct { 7174 TeamID keybase1.TeamID `codec:"teamID" json:"teamID"` 7175} 7176 7177type SetDefaultTeamChannelsLocalArg struct { 7178 TeamID keybase1.TeamID `codec:"teamID" json:"teamID"` 7179 Convs []ConvIDStr `codec:"convs" json:"convs"` 7180} 7181 7182type GetLastActiveForTLFArg struct { 7183 TlfID TLFIDStr `codec:"tlfID" json:"tlfID"` 7184} 7185 7186type GetLastActiveForTeamsArg struct { 7187} 7188 7189type GetRecentJoinsLocalArg struct { 7190 ConvID ConversationID `codec:"convID" json:"convID"` 7191} 7192 7193type RefreshParticipantsArg struct { 7194 ConvID ConversationID `codec:"convID" json:"convID"` 7195} 7196 7197type GetLastActiveAtLocalArg struct { 7198 TeamID keybase1.TeamID `codec:"teamID" json:"teamID"` 7199 Username string `codec:"username" json:"username"` 7200} 7201 7202type GetLastActiveAtMultiLocalArg struct { 7203 TeamIDs []keybase1.TeamID `codec:"teamIDs" json:"teamIDs"` 7204 Username string `codec:"username" json:"username"` 7205} 7206 7207type GetParticipantsArg struct { 7208 ConvID ConversationID `codec:"convID" json:"convID"` 7209} 7210 7211type AddEmojiArg struct { 7212 ConvID ConversationID `codec:"convID" json:"convID"` 7213 Alias string `codec:"alias" json:"alias"` 7214 Filename string `codec:"filename" json:"filename"` 7215 AllowOverwrite bool `codec:"allowOverwrite" json:"allowOverwrite"` 7216} 7217 7218type AddEmojisArg struct { 7219 ConvID ConversationID `codec:"convID" json:"convID"` 7220 Aliases []string `codec:"aliases" json:"aliases"` 7221 Filenames []string `codec:"filenames" json:"filenames"` 7222 AllowOverwrite []bool `codec:"allowOverwrite" json:"allowOverwrite"` 7223} 7224 7225type AddEmojiAliasArg struct { 7226 ConvID ConversationID `codec:"convID" json:"convID"` 7227 NewAlias string `codec:"newAlias" json:"newAlias"` 7228 ExistingAlias string `codec:"existingAlias" json:"existingAlias"` 7229} 7230 7231type RemoveEmojiArg struct { 7232 ConvID ConversationID `codec:"convID" json:"convID"` 7233 Alias string `codec:"alias" json:"alias"` 7234} 7235 7236type UserEmojisArg struct { 7237 Opts EmojiFetchOpts `codec:"opts" json:"opts"` 7238 ConvID *ConversationID `codec:"convID,omitempty" json:"convID,omitempty"` 7239} 7240 7241type ToggleEmojiAnimationsArg struct { 7242 Enabled bool `codec:"enabled" json:"enabled"` 7243} 7244 7245type LocalInterface interface { 7246 GetThreadLocal(context.Context, GetThreadLocalArg) (GetThreadLocalRes, error) 7247 GetThreadNonblock(context.Context, GetThreadNonblockArg) (NonblockFetchRes, error) 7248 GetUnreadline(context.Context, GetUnreadlineArg) (UnreadlineRes, error) 7249 GetInboxAndUnboxLocal(context.Context, GetInboxAndUnboxLocalArg) (GetInboxAndUnboxLocalRes, error) 7250 GetInboxAndUnboxUILocal(context.Context, GetInboxAndUnboxUILocalArg) (GetInboxAndUnboxUILocalRes, error) 7251 RequestInboxLayout(context.Context, InboxLayoutReselectMode) error 7252 RequestInboxUnbox(context.Context, []ConversationID) error 7253 RequestInboxSmallIncrease(context.Context) error 7254 RequestInboxSmallReset(context.Context) error 7255 GetInboxNonblockLocal(context.Context, GetInboxNonblockLocalArg) (NonblockFetchRes, error) 7256 PostLocal(context.Context, PostLocalArg) (PostLocalRes, error) 7257 GenerateOutboxID(context.Context) (OutboxID, error) 7258 PostLocalNonblock(context.Context, PostLocalNonblockArg) (PostLocalNonblockRes, error) 7259 ForwardMessage(context.Context, ForwardMessageArg) (PostLocalRes, error) 7260 ForwardMessageNonblock(context.Context, ForwardMessageNonblockArg) (PostLocalNonblockRes, error) 7261 PostTextNonblock(context.Context, PostTextNonblockArg) (PostLocalNonblockRes, error) 7262 PostDeleteNonblock(context.Context, PostDeleteNonblockArg) (PostLocalNonblockRes, error) 7263 PostEditNonblock(context.Context, PostEditNonblockArg) (PostLocalNonblockRes, error) 7264 PostReactionNonblock(context.Context, PostReactionNonblockArg) (PostLocalNonblockRes, error) 7265 PostHeadlineNonblock(context.Context, PostHeadlineNonblockArg) (PostLocalNonblockRes, error) 7266 PostHeadline(context.Context, PostHeadlineArg) (PostLocalRes, error) 7267 PostMetadataNonblock(context.Context, PostMetadataNonblockArg) (PostLocalNonblockRes, error) 7268 PostMetadata(context.Context, PostMetadataArg) (PostLocalRes, error) 7269 PostDeleteHistoryUpto(context.Context, PostDeleteHistoryUptoArg) (PostLocalRes, error) 7270 PostDeleteHistoryThrough(context.Context, PostDeleteHistoryThroughArg) (PostLocalRes, error) 7271 PostDeleteHistoryByAge(context.Context, PostDeleteHistoryByAgeArg) (PostLocalRes, error) 7272 SetConversationStatusLocal(context.Context, SetConversationStatusLocalArg) (SetConversationStatusLocalRes, error) 7273 NewConversationsLocal(context.Context, NewConversationsLocalArg) (NewConversationsLocalRes, error) 7274 NewConversationLocal(context.Context, NewConversationLocalArg) (NewConversationLocalRes, error) 7275 GetInboxSummaryForCLILocal(context.Context, GetInboxSummaryForCLILocalQuery) (GetInboxSummaryForCLILocalRes, error) 7276 GetConversationForCLILocal(context.Context, GetConversationForCLILocalQuery) (GetConversationForCLILocalRes, error) 7277 GetMessagesLocal(context.Context, GetMessagesLocalArg) (GetMessagesLocalRes, error) 7278 PostFileAttachmentLocal(context.Context, PostFileAttachmentLocalArg) (PostLocalRes, error) 7279 PostFileAttachmentLocalNonblock(context.Context, PostFileAttachmentLocalNonblockArg) (PostLocalNonblockRes, error) 7280 GetNextAttachmentMessageLocal(context.Context, GetNextAttachmentMessageLocalArg) (GetNextAttachmentMessageLocalRes, error) 7281 DownloadAttachmentLocal(context.Context, DownloadAttachmentLocalArg) (DownloadAttachmentLocalRes, error) 7282 DownloadFileAttachmentLocal(context.Context, DownloadFileAttachmentLocalArg) (DownloadFileAttachmentLocalRes, error) 7283 ConfigureFileAttachmentDownloadLocal(context.Context, ConfigureFileAttachmentDownloadLocalArg) error 7284 MakePreview(context.Context, MakePreviewArg) (MakePreviewRes, error) 7285 MakeAudioPreview(context.Context, MakeAudioPreviewArg) (MakePreviewRes, error) 7286 GetUploadTempFile(context.Context, GetUploadTempFileArg) (string, error) 7287 MakeUploadTempFile(context.Context, MakeUploadTempFileArg) (string, error) 7288 CancelUploadTempFile(context.Context, OutboxID) error 7289 CancelPost(context.Context, OutboxID) error 7290 RetryPost(context.Context, RetryPostArg) error 7291 MarkAsReadLocal(context.Context, MarkAsReadLocalArg) (MarkAsReadLocalRes, error) 7292 MarkTLFAsReadLocal(context.Context, MarkTLFAsReadLocalArg) (MarkTLFAsReadLocalRes, error) 7293 FindConversationsLocal(context.Context, FindConversationsLocalArg) (FindConversationsLocalRes, error) 7294 FindGeneralConvFromTeamID(context.Context, keybase1.TeamID) (InboxUIItem, error) 7295 UpdateTyping(context.Context, UpdateTypingArg) error 7296 UpdateUnsentText(context.Context, UpdateUnsentTextArg) error 7297 JoinConversationLocal(context.Context, JoinConversationLocalArg) (JoinLeaveConversationLocalRes, error) 7298 JoinConversationByIDLocal(context.Context, ConversationID) (JoinLeaveConversationLocalRes, error) 7299 LeaveConversationLocal(context.Context, ConversationID) (JoinLeaveConversationLocalRes, error) 7300 PreviewConversationByIDLocal(context.Context, ConversationID) (PreviewConversationLocalRes, error) 7301 DeleteConversationLocal(context.Context, DeleteConversationLocalArg) (DeleteConversationLocalRes, error) 7302 RemoveFromConversationLocal(context.Context, RemoveFromConversationLocalArg) (RemoveFromConversationLocalRes, error) 7303 GetTLFConversationsLocal(context.Context, GetTLFConversationsLocalArg) (GetTLFConversationsLocalRes, error) 7304 GetChannelMembershipsLocal(context.Context, GetChannelMembershipsLocalArg) (GetChannelMembershipsLocalRes, error) 7305 GetMutualTeamsLocal(context.Context, []string) (GetMutualTeamsLocalRes, error) 7306 SetAppNotificationSettingsLocal(context.Context, SetAppNotificationSettingsLocalArg) (SetAppNotificationSettingsLocalRes, error) 7307 SetGlobalAppNotificationSettingsLocal(context.Context, map[string]bool) error 7308 GetGlobalAppNotificationSettingsLocal(context.Context) (GlobalAppNotificationSettings, error) 7309 UnboxMobilePushNotification(context.Context, UnboxMobilePushNotificationArg) (string, error) 7310 AddTeamMemberAfterReset(context.Context, AddTeamMemberAfterResetArg) error 7311 GetAllResetConvMembers(context.Context) (GetAllResetConvMembersRes, error) 7312 SetConvRetentionLocal(context.Context, SetConvRetentionLocalArg) error 7313 SetTeamRetentionLocal(context.Context, SetTeamRetentionLocalArg) error 7314 GetTeamRetentionLocal(context.Context, keybase1.TeamID) (*RetentionPolicy, error) 7315 SetConvMinWriterRoleLocal(context.Context, SetConvMinWriterRoleLocalArg) error 7316 UpgradeKBFSConversationToImpteam(context.Context, ConversationID) error 7317 SearchRegexp(context.Context, SearchRegexpArg) (SearchRegexpRes, error) 7318 CancelActiveInboxSearch(context.Context) error 7319 SearchInbox(context.Context, SearchInboxArg) (SearchInboxRes, error) 7320 SimpleSearchInboxConvNames(context.Context, string) ([]SimpleSearchInboxConvNamesHit, error) 7321 CancelActiveSearch(context.Context) error 7322 ProfileChatSearch(context.Context, keybase1.TLFIdentifyBehavior) (map[ConvIDStr]ProfileSearchConvStats, error) 7323 GetStaticConfig(context.Context) (StaticConfig, error) 7324 ResolveUnfurlPrompt(context.Context, ResolveUnfurlPromptArg) error 7325 GetUnfurlSettings(context.Context) (UnfurlSettingsDisplay, error) 7326 SaveUnfurlSettings(context.Context, SaveUnfurlSettingsArg) error 7327 ToggleMessageCollapse(context.Context, ToggleMessageCollapseArg) error 7328 BulkAddToConv(context.Context, BulkAddToConvArg) error 7329 BulkAddToManyConvs(context.Context, BulkAddToManyConvsArg) error 7330 PutReacjiSkinTone(context.Context, keybase1.ReacjiSkinTone) (keybase1.UserReacjis, error) 7331 ResolveMaybeMention(context.Context, MaybeMention) error 7332 LoadGallery(context.Context, LoadGalleryArg) (LoadGalleryRes, error) 7333 LoadFlip(context.Context, LoadFlipArg) (LoadFlipRes, error) 7334 LocationUpdate(context.Context, Coordinate) error 7335 AdvertiseBotCommandsLocal(context.Context, AdvertiseBotCommandsLocalArg) (AdvertiseBotCommandsLocalRes, error) 7336 ListBotCommandsLocal(context.Context, ConversationID) (ListBotCommandsLocalRes, error) 7337 ListPublicBotCommandsLocal(context.Context, string) (ListBotCommandsLocalRes, error) 7338 ClearBotCommandsLocal(context.Context, *ClearBotCommandsFilter) (ClearBotCommandsLocalRes, error) 7339 PinMessage(context.Context, PinMessageArg) (PinMessageRes, error) 7340 UnpinMessage(context.Context, ConversationID) (PinMessageRes, error) 7341 IgnorePinnedMessage(context.Context, ConversationID) error 7342 AddBotMember(context.Context, AddBotMemberArg) error 7343 EditBotMember(context.Context, EditBotMemberArg) error 7344 RemoveBotMember(context.Context, RemoveBotMemberArg) error 7345 SetBotMemberSettings(context.Context, SetBotMemberSettingsArg) error 7346 GetBotMemberSettings(context.Context, GetBotMemberSettingsArg) (keybase1.TeamBotSettings, error) 7347 GetTeamRoleInConversation(context.Context, GetTeamRoleInConversationArg) (keybase1.TeamRole, error) 7348 AddBotConvSearch(context.Context, string) ([]ConvSearchHit, error) 7349 ForwardMessageConvSearch(context.Context, string) ([]ConvSearchHit, error) 7350 TeamIDFromTLFName(context.Context, TeamIDFromTLFNameArg) (keybase1.TeamID, error) 7351 DismissJourneycard(context.Context, DismissJourneycardArg) error 7352 SetWelcomeMessage(context.Context, SetWelcomeMessageArg) error 7353 GetWelcomeMessage(context.Context, keybase1.TeamID) (WelcomeMessageDisplay, error) 7354 GetDefaultTeamChannelsLocal(context.Context, keybase1.TeamID) (GetDefaultTeamChannelsLocalRes, error) 7355 SetDefaultTeamChannelsLocal(context.Context, SetDefaultTeamChannelsLocalArg) (SetDefaultTeamChannelsLocalRes, error) 7356 GetLastActiveForTLF(context.Context, TLFIDStr) (LastActiveStatus, error) 7357 GetLastActiveForTeams(context.Context) (LastActiveStatusAll, error) 7358 GetRecentJoinsLocal(context.Context, ConversationID) (int, error) 7359 RefreshParticipants(context.Context, ConversationID) error 7360 GetLastActiveAtLocal(context.Context, GetLastActiveAtLocalArg) (gregor1.Time, error) 7361 GetLastActiveAtMultiLocal(context.Context, GetLastActiveAtMultiLocalArg) (map[keybase1.TeamID]gregor1.Time, error) 7362 GetParticipants(context.Context, ConversationID) ([]ConversationLocalParticipant, error) 7363 AddEmoji(context.Context, AddEmojiArg) (AddEmojiRes, error) 7364 AddEmojis(context.Context, AddEmojisArg) (AddEmojisRes, error) 7365 AddEmojiAlias(context.Context, AddEmojiAliasArg) (AddEmojiAliasRes, error) 7366 RemoveEmoji(context.Context, RemoveEmojiArg) (RemoveEmojiRes, error) 7367 UserEmojis(context.Context, UserEmojisArg) (UserEmojiRes, error) 7368 ToggleEmojiAnimations(context.Context, bool) error 7369} 7370 7371func LocalProtocol(i LocalInterface) rpc.Protocol { 7372 return rpc.Protocol{ 7373 Name: "chat.1.local", 7374 Methods: map[string]rpc.ServeHandlerDescription{ 7375 "getThreadLocal": { 7376 MakeArg: func() interface{} { 7377 var ret [1]GetThreadLocalArg 7378 return &ret 7379 }, 7380 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7381 typedArgs, ok := args.(*[1]GetThreadLocalArg) 7382 if !ok { 7383 err = rpc.NewTypeError((*[1]GetThreadLocalArg)(nil), args) 7384 return 7385 } 7386 ret, err = i.GetThreadLocal(ctx, typedArgs[0]) 7387 return 7388 }, 7389 }, 7390 "getThreadNonblock": { 7391 MakeArg: func() interface{} { 7392 var ret [1]GetThreadNonblockArg 7393 return &ret 7394 }, 7395 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7396 typedArgs, ok := args.(*[1]GetThreadNonblockArg) 7397 if !ok { 7398 err = rpc.NewTypeError((*[1]GetThreadNonblockArg)(nil), args) 7399 return 7400 } 7401 ret, err = i.GetThreadNonblock(ctx, typedArgs[0]) 7402 return 7403 }, 7404 }, 7405 "getUnreadline": { 7406 MakeArg: func() interface{} { 7407 var ret [1]GetUnreadlineArg 7408 return &ret 7409 }, 7410 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7411 typedArgs, ok := args.(*[1]GetUnreadlineArg) 7412 if !ok { 7413 err = rpc.NewTypeError((*[1]GetUnreadlineArg)(nil), args) 7414 return 7415 } 7416 ret, err = i.GetUnreadline(ctx, typedArgs[0]) 7417 return 7418 }, 7419 }, 7420 "getInboxAndUnboxLocal": { 7421 MakeArg: func() interface{} { 7422 var ret [1]GetInboxAndUnboxLocalArg 7423 return &ret 7424 }, 7425 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7426 typedArgs, ok := args.(*[1]GetInboxAndUnboxLocalArg) 7427 if !ok { 7428 err = rpc.NewTypeError((*[1]GetInboxAndUnboxLocalArg)(nil), args) 7429 return 7430 } 7431 ret, err = i.GetInboxAndUnboxLocal(ctx, typedArgs[0]) 7432 return 7433 }, 7434 }, 7435 "getInboxAndUnboxUILocal": { 7436 MakeArg: func() interface{} { 7437 var ret [1]GetInboxAndUnboxUILocalArg 7438 return &ret 7439 }, 7440 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7441 typedArgs, ok := args.(*[1]GetInboxAndUnboxUILocalArg) 7442 if !ok { 7443 err = rpc.NewTypeError((*[1]GetInboxAndUnboxUILocalArg)(nil), args) 7444 return 7445 } 7446 ret, err = i.GetInboxAndUnboxUILocal(ctx, typedArgs[0]) 7447 return 7448 }, 7449 }, 7450 "requestInboxLayout": { 7451 MakeArg: func() interface{} { 7452 var ret [1]RequestInboxLayoutArg 7453 return &ret 7454 }, 7455 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7456 typedArgs, ok := args.(*[1]RequestInboxLayoutArg) 7457 if !ok { 7458 err = rpc.NewTypeError((*[1]RequestInboxLayoutArg)(nil), args) 7459 return 7460 } 7461 err = i.RequestInboxLayout(ctx, typedArgs[0].ReselectMode) 7462 return 7463 }, 7464 }, 7465 "requestInboxUnbox": { 7466 MakeArg: func() interface{} { 7467 var ret [1]RequestInboxUnboxArg 7468 return &ret 7469 }, 7470 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7471 typedArgs, ok := args.(*[1]RequestInboxUnboxArg) 7472 if !ok { 7473 err = rpc.NewTypeError((*[1]RequestInboxUnboxArg)(nil), args) 7474 return 7475 } 7476 err = i.RequestInboxUnbox(ctx, typedArgs[0].ConvIDs) 7477 return 7478 }, 7479 }, 7480 "requestInboxSmallIncrease": { 7481 MakeArg: func() interface{} { 7482 var ret [1]RequestInboxSmallIncreaseArg 7483 return &ret 7484 }, 7485 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7486 err = i.RequestInboxSmallIncrease(ctx) 7487 return 7488 }, 7489 }, 7490 "requestInboxSmallReset": { 7491 MakeArg: func() interface{} { 7492 var ret [1]RequestInboxSmallResetArg 7493 return &ret 7494 }, 7495 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7496 err = i.RequestInboxSmallReset(ctx) 7497 return 7498 }, 7499 }, 7500 "getInboxNonblockLocal": { 7501 MakeArg: func() interface{} { 7502 var ret [1]GetInboxNonblockLocalArg 7503 return &ret 7504 }, 7505 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7506 typedArgs, ok := args.(*[1]GetInboxNonblockLocalArg) 7507 if !ok { 7508 err = rpc.NewTypeError((*[1]GetInboxNonblockLocalArg)(nil), args) 7509 return 7510 } 7511 ret, err = i.GetInboxNonblockLocal(ctx, typedArgs[0]) 7512 return 7513 }, 7514 }, 7515 "postLocal": { 7516 MakeArg: func() interface{} { 7517 var ret [1]PostLocalArg 7518 return &ret 7519 }, 7520 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7521 typedArgs, ok := args.(*[1]PostLocalArg) 7522 if !ok { 7523 err = rpc.NewTypeError((*[1]PostLocalArg)(nil), args) 7524 return 7525 } 7526 ret, err = i.PostLocal(ctx, typedArgs[0]) 7527 return 7528 }, 7529 }, 7530 "generateOutboxID": { 7531 MakeArg: func() interface{} { 7532 var ret [1]GenerateOutboxIDArg 7533 return &ret 7534 }, 7535 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7536 ret, err = i.GenerateOutboxID(ctx) 7537 return 7538 }, 7539 }, 7540 "postLocalNonblock": { 7541 MakeArg: func() interface{} { 7542 var ret [1]PostLocalNonblockArg 7543 return &ret 7544 }, 7545 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7546 typedArgs, ok := args.(*[1]PostLocalNonblockArg) 7547 if !ok { 7548 err = rpc.NewTypeError((*[1]PostLocalNonblockArg)(nil), args) 7549 return 7550 } 7551 ret, err = i.PostLocalNonblock(ctx, typedArgs[0]) 7552 return 7553 }, 7554 }, 7555 "forwardMessage": { 7556 MakeArg: func() interface{} { 7557 var ret [1]ForwardMessageArg 7558 return &ret 7559 }, 7560 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7561 typedArgs, ok := args.(*[1]ForwardMessageArg) 7562 if !ok { 7563 err = rpc.NewTypeError((*[1]ForwardMessageArg)(nil), args) 7564 return 7565 } 7566 ret, err = i.ForwardMessage(ctx, typedArgs[0]) 7567 return 7568 }, 7569 }, 7570 "forwardMessageNonblock": { 7571 MakeArg: func() interface{} { 7572 var ret [1]ForwardMessageNonblockArg 7573 return &ret 7574 }, 7575 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7576 typedArgs, ok := args.(*[1]ForwardMessageNonblockArg) 7577 if !ok { 7578 err = rpc.NewTypeError((*[1]ForwardMessageNonblockArg)(nil), args) 7579 return 7580 } 7581 ret, err = i.ForwardMessageNonblock(ctx, typedArgs[0]) 7582 return 7583 }, 7584 }, 7585 "postTextNonblock": { 7586 MakeArg: func() interface{} { 7587 var ret [1]PostTextNonblockArg 7588 return &ret 7589 }, 7590 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7591 typedArgs, ok := args.(*[1]PostTextNonblockArg) 7592 if !ok { 7593 err = rpc.NewTypeError((*[1]PostTextNonblockArg)(nil), args) 7594 return 7595 } 7596 ret, err = i.PostTextNonblock(ctx, typedArgs[0]) 7597 return 7598 }, 7599 }, 7600 "postDeleteNonblock": { 7601 MakeArg: func() interface{} { 7602 var ret [1]PostDeleteNonblockArg 7603 return &ret 7604 }, 7605 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7606 typedArgs, ok := args.(*[1]PostDeleteNonblockArg) 7607 if !ok { 7608 err = rpc.NewTypeError((*[1]PostDeleteNonblockArg)(nil), args) 7609 return 7610 } 7611 ret, err = i.PostDeleteNonblock(ctx, typedArgs[0]) 7612 return 7613 }, 7614 }, 7615 "postEditNonblock": { 7616 MakeArg: func() interface{} { 7617 var ret [1]PostEditNonblockArg 7618 return &ret 7619 }, 7620 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7621 typedArgs, ok := args.(*[1]PostEditNonblockArg) 7622 if !ok { 7623 err = rpc.NewTypeError((*[1]PostEditNonblockArg)(nil), args) 7624 return 7625 } 7626 ret, err = i.PostEditNonblock(ctx, typedArgs[0]) 7627 return 7628 }, 7629 }, 7630 "postReactionNonblock": { 7631 MakeArg: func() interface{} { 7632 var ret [1]PostReactionNonblockArg 7633 return &ret 7634 }, 7635 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7636 typedArgs, ok := args.(*[1]PostReactionNonblockArg) 7637 if !ok { 7638 err = rpc.NewTypeError((*[1]PostReactionNonblockArg)(nil), args) 7639 return 7640 } 7641 ret, err = i.PostReactionNonblock(ctx, typedArgs[0]) 7642 return 7643 }, 7644 }, 7645 "postHeadlineNonblock": { 7646 MakeArg: func() interface{} { 7647 var ret [1]PostHeadlineNonblockArg 7648 return &ret 7649 }, 7650 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7651 typedArgs, ok := args.(*[1]PostHeadlineNonblockArg) 7652 if !ok { 7653 err = rpc.NewTypeError((*[1]PostHeadlineNonblockArg)(nil), args) 7654 return 7655 } 7656 ret, err = i.PostHeadlineNonblock(ctx, typedArgs[0]) 7657 return 7658 }, 7659 }, 7660 "postHeadline": { 7661 MakeArg: func() interface{} { 7662 var ret [1]PostHeadlineArg 7663 return &ret 7664 }, 7665 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7666 typedArgs, ok := args.(*[1]PostHeadlineArg) 7667 if !ok { 7668 err = rpc.NewTypeError((*[1]PostHeadlineArg)(nil), args) 7669 return 7670 } 7671 ret, err = i.PostHeadline(ctx, typedArgs[0]) 7672 return 7673 }, 7674 }, 7675 "postMetadataNonblock": { 7676 MakeArg: func() interface{} { 7677 var ret [1]PostMetadataNonblockArg 7678 return &ret 7679 }, 7680 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7681 typedArgs, ok := args.(*[1]PostMetadataNonblockArg) 7682 if !ok { 7683 err = rpc.NewTypeError((*[1]PostMetadataNonblockArg)(nil), args) 7684 return 7685 } 7686 ret, err = i.PostMetadataNonblock(ctx, typedArgs[0]) 7687 return 7688 }, 7689 }, 7690 "postMetadata": { 7691 MakeArg: func() interface{} { 7692 var ret [1]PostMetadataArg 7693 return &ret 7694 }, 7695 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7696 typedArgs, ok := args.(*[1]PostMetadataArg) 7697 if !ok { 7698 err = rpc.NewTypeError((*[1]PostMetadataArg)(nil), args) 7699 return 7700 } 7701 ret, err = i.PostMetadata(ctx, typedArgs[0]) 7702 return 7703 }, 7704 }, 7705 "postDeleteHistoryUpto": { 7706 MakeArg: func() interface{} { 7707 var ret [1]PostDeleteHistoryUptoArg 7708 return &ret 7709 }, 7710 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7711 typedArgs, ok := args.(*[1]PostDeleteHistoryUptoArg) 7712 if !ok { 7713 err = rpc.NewTypeError((*[1]PostDeleteHistoryUptoArg)(nil), args) 7714 return 7715 } 7716 ret, err = i.PostDeleteHistoryUpto(ctx, typedArgs[0]) 7717 return 7718 }, 7719 }, 7720 "postDeleteHistoryThrough": { 7721 MakeArg: func() interface{} { 7722 var ret [1]PostDeleteHistoryThroughArg 7723 return &ret 7724 }, 7725 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7726 typedArgs, ok := args.(*[1]PostDeleteHistoryThroughArg) 7727 if !ok { 7728 err = rpc.NewTypeError((*[1]PostDeleteHistoryThroughArg)(nil), args) 7729 return 7730 } 7731 ret, err = i.PostDeleteHistoryThrough(ctx, typedArgs[0]) 7732 return 7733 }, 7734 }, 7735 "postDeleteHistoryByAge": { 7736 MakeArg: func() interface{} { 7737 var ret [1]PostDeleteHistoryByAgeArg 7738 return &ret 7739 }, 7740 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7741 typedArgs, ok := args.(*[1]PostDeleteHistoryByAgeArg) 7742 if !ok { 7743 err = rpc.NewTypeError((*[1]PostDeleteHistoryByAgeArg)(nil), args) 7744 return 7745 } 7746 ret, err = i.PostDeleteHistoryByAge(ctx, typedArgs[0]) 7747 return 7748 }, 7749 }, 7750 "SetConversationStatusLocal": { 7751 MakeArg: func() interface{} { 7752 var ret [1]SetConversationStatusLocalArg 7753 return &ret 7754 }, 7755 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7756 typedArgs, ok := args.(*[1]SetConversationStatusLocalArg) 7757 if !ok { 7758 err = rpc.NewTypeError((*[1]SetConversationStatusLocalArg)(nil), args) 7759 return 7760 } 7761 ret, err = i.SetConversationStatusLocal(ctx, typedArgs[0]) 7762 return 7763 }, 7764 }, 7765 "newConversationsLocal": { 7766 MakeArg: func() interface{} { 7767 var ret [1]NewConversationsLocalArg 7768 return &ret 7769 }, 7770 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7771 typedArgs, ok := args.(*[1]NewConversationsLocalArg) 7772 if !ok { 7773 err = rpc.NewTypeError((*[1]NewConversationsLocalArg)(nil), args) 7774 return 7775 } 7776 ret, err = i.NewConversationsLocal(ctx, typedArgs[0]) 7777 return 7778 }, 7779 }, 7780 "newConversationLocal": { 7781 MakeArg: func() interface{} { 7782 var ret [1]NewConversationLocalArg 7783 return &ret 7784 }, 7785 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7786 typedArgs, ok := args.(*[1]NewConversationLocalArg) 7787 if !ok { 7788 err = rpc.NewTypeError((*[1]NewConversationLocalArg)(nil), args) 7789 return 7790 } 7791 ret, err = i.NewConversationLocal(ctx, typedArgs[0]) 7792 return 7793 }, 7794 }, 7795 "getInboxSummaryForCLILocal": { 7796 MakeArg: func() interface{} { 7797 var ret [1]GetInboxSummaryForCLILocalArg 7798 return &ret 7799 }, 7800 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7801 typedArgs, ok := args.(*[1]GetInboxSummaryForCLILocalArg) 7802 if !ok { 7803 err = rpc.NewTypeError((*[1]GetInboxSummaryForCLILocalArg)(nil), args) 7804 return 7805 } 7806 ret, err = i.GetInboxSummaryForCLILocal(ctx, typedArgs[0].Query) 7807 return 7808 }, 7809 }, 7810 "getConversationForCLILocal": { 7811 MakeArg: func() interface{} { 7812 var ret [1]GetConversationForCLILocalArg 7813 return &ret 7814 }, 7815 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7816 typedArgs, ok := args.(*[1]GetConversationForCLILocalArg) 7817 if !ok { 7818 err = rpc.NewTypeError((*[1]GetConversationForCLILocalArg)(nil), args) 7819 return 7820 } 7821 ret, err = i.GetConversationForCLILocal(ctx, typedArgs[0].Query) 7822 return 7823 }, 7824 }, 7825 "GetMessagesLocal": { 7826 MakeArg: func() interface{} { 7827 var ret [1]GetMessagesLocalArg 7828 return &ret 7829 }, 7830 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7831 typedArgs, ok := args.(*[1]GetMessagesLocalArg) 7832 if !ok { 7833 err = rpc.NewTypeError((*[1]GetMessagesLocalArg)(nil), args) 7834 return 7835 } 7836 ret, err = i.GetMessagesLocal(ctx, typedArgs[0]) 7837 return 7838 }, 7839 }, 7840 "postFileAttachmentLocal": { 7841 MakeArg: func() interface{} { 7842 var ret [1]PostFileAttachmentLocalArg 7843 return &ret 7844 }, 7845 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7846 typedArgs, ok := args.(*[1]PostFileAttachmentLocalArg) 7847 if !ok { 7848 err = rpc.NewTypeError((*[1]PostFileAttachmentLocalArg)(nil), args) 7849 return 7850 } 7851 ret, err = i.PostFileAttachmentLocal(ctx, typedArgs[0]) 7852 return 7853 }, 7854 }, 7855 "postFileAttachmentLocalNonblock": { 7856 MakeArg: func() interface{} { 7857 var ret [1]PostFileAttachmentLocalNonblockArg 7858 return &ret 7859 }, 7860 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7861 typedArgs, ok := args.(*[1]PostFileAttachmentLocalNonblockArg) 7862 if !ok { 7863 err = rpc.NewTypeError((*[1]PostFileAttachmentLocalNonblockArg)(nil), args) 7864 return 7865 } 7866 ret, err = i.PostFileAttachmentLocalNonblock(ctx, typedArgs[0]) 7867 return 7868 }, 7869 }, 7870 "getNextAttachmentMessageLocal": { 7871 MakeArg: func() interface{} { 7872 var ret [1]GetNextAttachmentMessageLocalArg 7873 return &ret 7874 }, 7875 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7876 typedArgs, ok := args.(*[1]GetNextAttachmentMessageLocalArg) 7877 if !ok { 7878 err = rpc.NewTypeError((*[1]GetNextAttachmentMessageLocalArg)(nil), args) 7879 return 7880 } 7881 ret, err = i.GetNextAttachmentMessageLocal(ctx, typedArgs[0]) 7882 return 7883 }, 7884 }, 7885 "DownloadAttachmentLocal": { 7886 MakeArg: func() interface{} { 7887 var ret [1]DownloadAttachmentLocalArg 7888 return &ret 7889 }, 7890 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7891 typedArgs, ok := args.(*[1]DownloadAttachmentLocalArg) 7892 if !ok { 7893 err = rpc.NewTypeError((*[1]DownloadAttachmentLocalArg)(nil), args) 7894 return 7895 } 7896 ret, err = i.DownloadAttachmentLocal(ctx, typedArgs[0]) 7897 return 7898 }, 7899 }, 7900 "DownloadFileAttachmentLocal": { 7901 MakeArg: func() interface{} { 7902 var ret [1]DownloadFileAttachmentLocalArg 7903 return &ret 7904 }, 7905 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7906 typedArgs, ok := args.(*[1]DownloadFileAttachmentLocalArg) 7907 if !ok { 7908 err = rpc.NewTypeError((*[1]DownloadFileAttachmentLocalArg)(nil), args) 7909 return 7910 } 7911 ret, err = i.DownloadFileAttachmentLocal(ctx, typedArgs[0]) 7912 return 7913 }, 7914 }, 7915 "ConfigureFileAttachmentDownloadLocal": { 7916 MakeArg: func() interface{} { 7917 var ret [1]ConfigureFileAttachmentDownloadLocalArg 7918 return &ret 7919 }, 7920 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7921 typedArgs, ok := args.(*[1]ConfigureFileAttachmentDownloadLocalArg) 7922 if !ok { 7923 err = rpc.NewTypeError((*[1]ConfigureFileAttachmentDownloadLocalArg)(nil), args) 7924 return 7925 } 7926 err = i.ConfigureFileAttachmentDownloadLocal(ctx, typedArgs[0]) 7927 return 7928 }, 7929 }, 7930 "makePreview": { 7931 MakeArg: func() interface{} { 7932 var ret [1]MakePreviewArg 7933 return &ret 7934 }, 7935 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7936 typedArgs, ok := args.(*[1]MakePreviewArg) 7937 if !ok { 7938 err = rpc.NewTypeError((*[1]MakePreviewArg)(nil), args) 7939 return 7940 } 7941 ret, err = i.MakePreview(ctx, typedArgs[0]) 7942 return 7943 }, 7944 }, 7945 "makeAudioPreview": { 7946 MakeArg: func() interface{} { 7947 var ret [1]MakeAudioPreviewArg 7948 return &ret 7949 }, 7950 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7951 typedArgs, ok := args.(*[1]MakeAudioPreviewArg) 7952 if !ok { 7953 err = rpc.NewTypeError((*[1]MakeAudioPreviewArg)(nil), args) 7954 return 7955 } 7956 ret, err = i.MakeAudioPreview(ctx, typedArgs[0]) 7957 return 7958 }, 7959 }, 7960 "getUploadTempFile": { 7961 MakeArg: func() interface{} { 7962 var ret [1]GetUploadTempFileArg 7963 return &ret 7964 }, 7965 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7966 typedArgs, ok := args.(*[1]GetUploadTempFileArg) 7967 if !ok { 7968 err = rpc.NewTypeError((*[1]GetUploadTempFileArg)(nil), args) 7969 return 7970 } 7971 ret, err = i.GetUploadTempFile(ctx, typedArgs[0]) 7972 return 7973 }, 7974 }, 7975 "makeUploadTempFile": { 7976 MakeArg: func() interface{} { 7977 var ret [1]MakeUploadTempFileArg 7978 return &ret 7979 }, 7980 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7981 typedArgs, ok := args.(*[1]MakeUploadTempFileArg) 7982 if !ok { 7983 err = rpc.NewTypeError((*[1]MakeUploadTempFileArg)(nil), args) 7984 return 7985 } 7986 ret, err = i.MakeUploadTempFile(ctx, typedArgs[0]) 7987 return 7988 }, 7989 }, 7990 "cancelUploadTempFile": { 7991 MakeArg: func() interface{} { 7992 var ret [1]CancelUploadTempFileArg 7993 return &ret 7994 }, 7995 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 7996 typedArgs, ok := args.(*[1]CancelUploadTempFileArg) 7997 if !ok { 7998 err = rpc.NewTypeError((*[1]CancelUploadTempFileArg)(nil), args) 7999 return 8000 } 8001 err = i.CancelUploadTempFile(ctx, typedArgs[0].OutboxID) 8002 return 8003 }, 8004 }, 8005 "CancelPost": { 8006 MakeArg: func() interface{} { 8007 var ret [1]CancelPostArg 8008 return &ret 8009 }, 8010 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8011 typedArgs, ok := args.(*[1]CancelPostArg) 8012 if !ok { 8013 err = rpc.NewTypeError((*[1]CancelPostArg)(nil), args) 8014 return 8015 } 8016 err = i.CancelPost(ctx, typedArgs[0].OutboxID) 8017 return 8018 }, 8019 }, 8020 "RetryPost": { 8021 MakeArg: func() interface{} { 8022 var ret [1]RetryPostArg 8023 return &ret 8024 }, 8025 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8026 typedArgs, ok := args.(*[1]RetryPostArg) 8027 if !ok { 8028 err = rpc.NewTypeError((*[1]RetryPostArg)(nil), args) 8029 return 8030 } 8031 err = i.RetryPost(ctx, typedArgs[0]) 8032 return 8033 }, 8034 }, 8035 "markAsReadLocal": { 8036 MakeArg: func() interface{} { 8037 var ret [1]MarkAsReadLocalArg 8038 return &ret 8039 }, 8040 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8041 typedArgs, ok := args.(*[1]MarkAsReadLocalArg) 8042 if !ok { 8043 err = rpc.NewTypeError((*[1]MarkAsReadLocalArg)(nil), args) 8044 return 8045 } 8046 ret, err = i.MarkAsReadLocal(ctx, typedArgs[0]) 8047 return 8048 }, 8049 }, 8050 "markTLFAsReadLocal": { 8051 MakeArg: func() interface{} { 8052 var ret [1]MarkTLFAsReadLocalArg 8053 return &ret 8054 }, 8055 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8056 typedArgs, ok := args.(*[1]MarkTLFAsReadLocalArg) 8057 if !ok { 8058 err = rpc.NewTypeError((*[1]MarkTLFAsReadLocalArg)(nil), args) 8059 return 8060 } 8061 ret, err = i.MarkTLFAsReadLocal(ctx, typedArgs[0]) 8062 return 8063 }, 8064 }, 8065 "findConversationsLocal": { 8066 MakeArg: func() interface{} { 8067 var ret [1]FindConversationsLocalArg 8068 return &ret 8069 }, 8070 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8071 typedArgs, ok := args.(*[1]FindConversationsLocalArg) 8072 if !ok { 8073 err = rpc.NewTypeError((*[1]FindConversationsLocalArg)(nil), args) 8074 return 8075 } 8076 ret, err = i.FindConversationsLocal(ctx, typedArgs[0]) 8077 return 8078 }, 8079 }, 8080 "findGeneralConvFromTeamID": { 8081 MakeArg: func() interface{} { 8082 var ret [1]FindGeneralConvFromTeamIDArg 8083 return &ret 8084 }, 8085 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8086 typedArgs, ok := args.(*[1]FindGeneralConvFromTeamIDArg) 8087 if !ok { 8088 err = rpc.NewTypeError((*[1]FindGeneralConvFromTeamIDArg)(nil), args) 8089 return 8090 } 8091 ret, err = i.FindGeneralConvFromTeamID(ctx, typedArgs[0].TeamID) 8092 return 8093 }, 8094 }, 8095 "updateTyping": { 8096 MakeArg: func() interface{} { 8097 var ret [1]UpdateTypingArg 8098 return &ret 8099 }, 8100 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8101 typedArgs, ok := args.(*[1]UpdateTypingArg) 8102 if !ok { 8103 err = rpc.NewTypeError((*[1]UpdateTypingArg)(nil), args) 8104 return 8105 } 8106 err = i.UpdateTyping(ctx, typedArgs[0]) 8107 return 8108 }, 8109 }, 8110 "updateUnsentText": { 8111 MakeArg: func() interface{} { 8112 var ret [1]UpdateUnsentTextArg 8113 return &ret 8114 }, 8115 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8116 typedArgs, ok := args.(*[1]UpdateUnsentTextArg) 8117 if !ok { 8118 err = rpc.NewTypeError((*[1]UpdateUnsentTextArg)(nil), args) 8119 return 8120 } 8121 err = i.UpdateUnsentText(ctx, typedArgs[0]) 8122 return 8123 }, 8124 }, 8125 "joinConversationLocal": { 8126 MakeArg: func() interface{} { 8127 var ret [1]JoinConversationLocalArg 8128 return &ret 8129 }, 8130 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8131 typedArgs, ok := args.(*[1]JoinConversationLocalArg) 8132 if !ok { 8133 err = rpc.NewTypeError((*[1]JoinConversationLocalArg)(nil), args) 8134 return 8135 } 8136 ret, err = i.JoinConversationLocal(ctx, typedArgs[0]) 8137 return 8138 }, 8139 }, 8140 "joinConversationByIDLocal": { 8141 MakeArg: func() interface{} { 8142 var ret [1]JoinConversationByIDLocalArg 8143 return &ret 8144 }, 8145 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8146 typedArgs, ok := args.(*[1]JoinConversationByIDLocalArg) 8147 if !ok { 8148 err = rpc.NewTypeError((*[1]JoinConversationByIDLocalArg)(nil), args) 8149 return 8150 } 8151 ret, err = i.JoinConversationByIDLocal(ctx, typedArgs[0].ConvID) 8152 return 8153 }, 8154 }, 8155 "leaveConversationLocal": { 8156 MakeArg: func() interface{} { 8157 var ret [1]LeaveConversationLocalArg 8158 return &ret 8159 }, 8160 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8161 typedArgs, ok := args.(*[1]LeaveConversationLocalArg) 8162 if !ok { 8163 err = rpc.NewTypeError((*[1]LeaveConversationLocalArg)(nil), args) 8164 return 8165 } 8166 ret, err = i.LeaveConversationLocal(ctx, typedArgs[0].ConvID) 8167 return 8168 }, 8169 }, 8170 "previewConversationByIDLocal": { 8171 MakeArg: func() interface{} { 8172 var ret [1]PreviewConversationByIDLocalArg 8173 return &ret 8174 }, 8175 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8176 typedArgs, ok := args.(*[1]PreviewConversationByIDLocalArg) 8177 if !ok { 8178 err = rpc.NewTypeError((*[1]PreviewConversationByIDLocalArg)(nil), args) 8179 return 8180 } 8181 ret, err = i.PreviewConversationByIDLocal(ctx, typedArgs[0].ConvID) 8182 return 8183 }, 8184 }, 8185 "deleteConversationLocal": { 8186 MakeArg: func() interface{} { 8187 var ret [1]DeleteConversationLocalArg 8188 return &ret 8189 }, 8190 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8191 typedArgs, ok := args.(*[1]DeleteConversationLocalArg) 8192 if !ok { 8193 err = rpc.NewTypeError((*[1]DeleteConversationLocalArg)(nil), args) 8194 return 8195 } 8196 ret, err = i.DeleteConversationLocal(ctx, typedArgs[0]) 8197 return 8198 }, 8199 }, 8200 "removeFromConversationLocal": { 8201 MakeArg: func() interface{} { 8202 var ret [1]RemoveFromConversationLocalArg 8203 return &ret 8204 }, 8205 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8206 typedArgs, ok := args.(*[1]RemoveFromConversationLocalArg) 8207 if !ok { 8208 err = rpc.NewTypeError((*[1]RemoveFromConversationLocalArg)(nil), args) 8209 return 8210 } 8211 ret, err = i.RemoveFromConversationLocal(ctx, typedArgs[0]) 8212 return 8213 }, 8214 }, 8215 "getTLFConversationsLocal": { 8216 MakeArg: func() interface{} { 8217 var ret [1]GetTLFConversationsLocalArg 8218 return &ret 8219 }, 8220 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8221 typedArgs, ok := args.(*[1]GetTLFConversationsLocalArg) 8222 if !ok { 8223 err = rpc.NewTypeError((*[1]GetTLFConversationsLocalArg)(nil), args) 8224 return 8225 } 8226 ret, err = i.GetTLFConversationsLocal(ctx, typedArgs[0]) 8227 return 8228 }, 8229 }, 8230 "getChannelMembershipsLocal": { 8231 MakeArg: func() interface{} { 8232 var ret [1]GetChannelMembershipsLocalArg 8233 return &ret 8234 }, 8235 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8236 typedArgs, ok := args.(*[1]GetChannelMembershipsLocalArg) 8237 if !ok { 8238 err = rpc.NewTypeError((*[1]GetChannelMembershipsLocalArg)(nil), args) 8239 return 8240 } 8241 ret, err = i.GetChannelMembershipsLocal(ctx, typedArgs[0]) 8242 return 8243 }, 8244 }, 8245 "getMutualTeamsLocal": { 8246 MakeArg: func() interface{} { 8247 var ret [1]GetMutualTeamsLocalArg 8248 return &ret 8249 }, 8250 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8251 typedArgs, ok := args.(*[1]GetMutualTeamsLocalArg) 8252 if !ok { 8253 err = rpc.NewTypeError((*[1]GetMutualTeamsLocalArg)(nil), args) 8254 return 8255 } 8256 ret, err = i.GetMutualTeamsLocal(ctx, typedArgs[0].Usernames) 8257 return 8258 }, 8259 }, 8260 "setAppNotificationSettingsLocal": { 8261 MakeArg: func() interface{} { 8262 var ret [1]SetAppNotificationSettingsLocalArg 8263 return &ret 8264 }, 8265 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8266 typedArgs, ok := args.(*[1]SetAppNotificationSettingsLocalArg) 8267 if !ok { 8268 err = rpc.NewTypeError((*[1]SetAppNotificationSettingsLocalArg)(nil), args) 8269 return 8270 } 8271 ret, err = i.SetAppNotificationSettingsLocal(ctx, typedArgs[0]) 8272 return 8273 }, 8274 }, 8275 "setGlobalAppNotificationSettingsLocal": { 8276 MakeArg: func() interface{} { 8277 var ret [1]SetGlobalAppNotificationSettingsLocalArg 8278 return &ret 8279 }, 8280 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8281 typedArgs, ok := args.(*[1]SetGlobalAppNotificationSettingsLocalArg) 8282 if !ok { 8283 err = rpc.NewTypeError((*[1]SetGlobalAppNotificationSettingsLocalArg)(nil), args) 8284 return 8285 } 8286 err = i.SetGlobalAppNotificationSettingsLocal(ctx, typedArgs[0].Settings) 8287 return 8288 }, 8289 }, 8290 "getGlobalAppNotificationSettingsLocal": { 8291 MakeArg: func() interface{} { 8292 var ret [1]GetGlobalAppNotificationSettingsLocalArg 8293 return &ret 8294 }, 8295 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8296 ret, err = i.GetGlobalAppNotificationSettingsLocal(ctx) 8297 return 8298 }, 8299 }, 8300 "unboxMobilePushNotification": { 8301 MakeArg: func() interface{} { 8302 var ret [1]UnboxMobilePushNotificationArg 8303 return &ret 8304 }, 8305 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8306 typedArgs, ok := args.(*[1]UnboxMobilePushNotificationArg) 8307 if !ok { 8308 err = rpc.NewTypeError((*[1]UnboxMobilePushNotificationArg)(nil), args) 8309 return 8310 } 8311 ret, err = i.UnboxMobilePushNotification(ctx, typedArgs[0]) 8312 return 8313 }, 8314 }, 8315 "addTeamMemberAfterReset": { 8316 MakeArg: func() interface{} { 8317 var ret [1]AddTeamMemberAfterResetArg 8318 return &ret 8319 }, 8320 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8321 typedArgs, ok := args.(*[1]AddTeamMemberAfterResetArg) 8322 if !ok { 8323 err = rpc.NewTypeError((*[1]AddTeamMemberAfterResetArg)(nil), args) 8324 return 8325 } 8326 err = i.AddTeamMemberAfterReset(ctx, typedArgs[0]) 8327 return 8328 }, 8329 }, 8330 "getAllResetConvMembers": { 8331 MakeArg: func() interface{} { 8332 var ret [1]GetAllResetConvMembersArg 8333 return &ret 8334 }, 8335 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8336 ret, err = i.GetAllResetConvMembers(ctx) 8337 return 8338 }, 8339 }, 8340 "setConvRetentionLocal": { 8341 MakeArg: func() interface{} { 8342 var ret [1]SetConvRetentionLocalArg 8343 return &ret 8344 }, 8345 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8346 typedArgs, ok := args.(*[1]SetConvRetentionLocalArg) 8347 if !ok { 8348 err = rpc.NewTypeError((*[1]SetConvRetentionLocalArg)(nil), args) 8349 return 8350 } 8351 err = i.SetConvRetentionLocal(ctx, typedArgs[0]) 8352 return 8353 }, 8354 }, 8355 "setTeamRetentionLocal": { 8356 MakeArg: func() interface{} { 8357 var ret [1]SetTeamRetentionLocalArg 8358 return &ret 8359 }, 8360 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8361 typedArgs, ok := args.(*[1]SetTeamRetentionLocalArg) 8362 if !ok { 8363 err = rpc.NewTypeError((*[1]SetTeamRetentionLocalArg)(nil), args) 8364 return 8365 } 8366 err = i.SetTeamRetentionLocal(ctx, typedArgs[0]) 8367 return 8368 }, 8369 }, 8370 "getTeamRetentionLocal": { 8371 MakeArg: func() interface{} { 8372 var ret [1]GetTeamRetentionLocalArg 8373 return &ret 8374 }, 8375 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8376 typedArgs, ok := args.(*[1]GetTeamRetentionLocalArg) 8377 if !ok { 8378 err = rpc.NewTypeError((*[1]GetTeamRetentionLocalArg)(nil), args) 8379 return 8380 } 8381 ret, err = i.GetTeamRetentionLocal(ctx, typedArgs[0].TeamID) 8382 return 8383 }, 8384 }, 8385 "setConvMinWriterRoleLocal": { 8386 MakeArg: func() interface{} { 8387 var ret [1]SetConvMinWriterRoleLocalArg 8388 return &ret 8389 }, 8390 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8391 typedArgs, ok := args.(*[1]SetConvMinWriterRoleLocalArg) 8392 if !ok { 8393 err = rpc.NewTypeError((*[1]SetConvMinWriterRoleLocalArg)(nil), args) 8394 return 8395 } 8396 err = i.SetConvMinWriterRoleLocal(ctx, typedArgs[0]) 8397 return 8398 }, 8399 }, 8400 "upgradeKBFSConversationToImpteam": { 8401 MakeArg: func() interface{} { 8402 var ret [1]UpgradeKBFSConversationToImpteamArg 8403 return &ret 8404 }, 8405 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8406 typedArgs, ok := args.(*[1]UpgradeKBFSConversationToImpteamArg) 8407 if !ok { 8408 err = rpc.NewTypeError((*[1]UpgradeKBFSConversationToImpteamArg)(nil), args) 8409 return 8410 } 8411 err = i.UpgradeKBFSConversationToImpteam(ctx, typedArgs[0].ConvID) 8412 return 8413 }, 8414 }, 8415 "searchRegexp": { 8416 MakeArg: func() interface{} { 8417 var ret [1]SearchRegexpArg 8418 return &ret 8419 }, 8420 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8421 typedArgs, ok := args.(*[1]SearchRegexpArg) 8422 if !ok { 8423 err = rpc.NewTypeError((*[1]SearchRegexpArg)(nil), args) 8424 return 8425 } 8426 ret, err = i.SearchRegexp(ctx, typedArgs[0]) 8427 return 8428 }, 8429 }, 8430 "cancelActiveInboxSearch": { 8431 MakeArg: func() interface{} { 8432 var ret [1]CancelActiveInboxSearchArg 8433 return &ret 8434 }, 8435 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8436 err = i.CancelActiveInboxSearch(ctx) 8437 return 8438 }, 8439 }, 8440 "searchInbox": { 8441 MakeArg: func() interface{} { 8442 var ret [1]SearchInboxArg 8443 return &ret 8444 }, 8445 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8446 typedArgs, ok := args.(*[1]SearchInboxArg) 8447 if !ok { 8448 err = rpc.NewTypeError((*[1]SearchInboxArg)(nil), args) 8449 return 8450 } 8451 ret, err = i.SearchInbox(ctx, typedArgs[0]) 8452 return 8453 }, 8454 }, 8455 "simpleSearchInboxConvNames": { 8456 MakeArg: func() interface{} { 8457 var ret [1]SimpleSearchInboxConvNamesArg 8458 return &ret 8459 }, 8460 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8461 typedArgs, ok := args.(*[1]SimpleSearchInboxConvNamesArg) 8462 if !ok { 8463 err = rpc.NewTypeError((*[1]SimpleSearchInboxConvNamesArg)(nil), args) 8464 return 8465 } 8466 ret, err = i.SimpleSearchInboxConvNames(ctx, typedArgs[0].Query) 8467 return 8468 }, 8469 }, 8470 "cancelActiveSearch": { 8471 MakeArg: func() interface{} { 8472 var ret [1]CancelActiveSearchArg 8473 return &ret 8474 }, 8475 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8476 err = i.CancelActiveSearch(ctx) 8477 return 8478 }, 8479 }, 8480 "profileChatSearch": { 8481 MakeArg: func() interface{} { 8482 var ret [1]ProfileChatSearchArg 8483 return &ret 8484 }, 8485 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8486 typedArgs, ok := args.(*[1]ProfileChatSearchArg) 8487 if !ok { 8488 err = rpc.NewTypeError((*[1]ProfileChatSearchArg)(nil), args) 8489 return 8490 } 8491 ret, err = i.ProfileChatSearch(ctx, typedArgs[0].IdentifyBehavior) 8492 return 8493 }, 8494 }, 8495 "getStaticConfig": { 8496 MakeArg: func() interface{} { 8497 var ret [1]GetStaticConfigArg 8498 return &ret 8499 }, 8500 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8501 ret, err = i.GetStaticConfig(ctx) 8502 return 8503 }, 8504 }, 8505 "resolveUnfurlPrompt": { 8506 MakeArg: func() interface{} { 8507 var ret [1]ResolveUnfurlPromptArg 8508 return &ret 8509 }, 8510 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8511 typedArgs, ok := args.(*[1]ResolveUnfurlPromptArg) 8512 if !ok { 8513 err = rpc.NewTypeError((*[1]ResolveUnfurlPromptArg)(nil), args) 8514 return 8515 } 8516 err = i.ResolveUnfurlPrompt(ctx, typedArgs[0]) 8517 return 8518 }, 8519 }, 8520 "getUnfurlSettings": { 8521 MakeArg: func() interface{} { 8522 var ret [1]GetUnfurlSettingsArg 8523 return &ret 8524 }, 8525 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8526 ret, err = i.GetUnfurlSettings(ctx) 8527 return 8528 }, 8529 }, 8530 "saveUnfurlSettings": { 8531 MakeArg: func() interface{} { 8532 var ret [1]SaveUnfurlSettingsArg 8533 return &ret 8534 }, 8535 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8536 typedArgs, ok := args.(*[1]SaveUnfurlSettingsArg) 8537 if !ok { 8538 err = rpc.NewTypeError((*[1]SaveUnfurlSettingsArg)(nil), args) 8539 return 8540 } 8541 err = i.SaveUnfurlSettings(ctx, typedArgs[0]) 8542 return 8543 }, 8544 }, 8545 "toggleMessageCollapse": { 8546 MakeArg: func() interface{} { 8547 var ret [1]ToggleMessageCollapseArg 8548 return &ret 8549 }, 8550 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8551 typedArgs, ok := args.(*[1]ToggleMessageCollapseArg) 8552 if !ok { 8553 err = rpc.NewTypeError((*[1]ToggleMessageCollapseArg)(nil), args) 8554 return 8555 } 8556 err = i.ToggleMessageCollapse(ctx, typedArgs[0]) 8557 return 8558 }, 8559 }, 8560 "bulkAddToConv": { 8561 MakeArg: func() interface{} { 8562 var ret [1]BulkAddToConvArg 8563 return &ret 8564 }, 8565 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8566 typedArgs, ok := args.(*[1]BulkAddToConvArg) 8567 if !ok { 8568 err = rpc.NewTypeError((*[1]BulkAddToConvArg)(nil), args) 8569 return 8570 } 8571 err = i.BulkAddToConv(ctx, typedArgs[0]) 8572 return 8573 }, 8574 }, 8575 "bulkAddToManyConvs": { 8576 MakeArg: func() interface{} { 8577 var ret [1]BulkAddToManyConvsArg 8578 return &ret 8579 }, 8580 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8581 typedArgs, ok := args.(*[1]BulkAddToManyConvsArg) 8582 if !ok { 8583 err = rpc.NewTypeError((*[1]BulkAddToManyConvsArg)(nil), args) 8584 return 8585 } 8586 err = i.BulkAddToManyConvs(ctx, typedArgs[0]) 8587 return 8588 }, 8589 }, 8590 "putReacjiSkinTone": { 8591 MakeArg: func() interface{} { 8592 var ret [1]PutReacjiSkinToneArg 8593 return &ret 8594 }, 8595 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8596 typedArgs, ok := args.(*[1]PutReacjiSkinToneArg) 8597 if !ok { 8598 err = rpc.NewTypeError((*[1]PutReacjiSkinToneArg)(nil), args) 8599 return 8600 } 8601 ret, err = i.PutReacjiSkinTone(ctx, typedArgs[0].SkinTone) 8602 return 8603 }, 8604 }, 8605 "resolveMaybeMention": { 8606 MakeArg: func() interface{} { 8607 var ret [1]ResolveMaybeMentionArg 8608 return &ret 8609 }, 8610 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8611 typedArgs, ok := args.(*[1]ResolveMaybeMentionArg) 8612 if !ok { 8613 err = rpc.NewTypeError((*[1]ResolveMaybeMentionArg)(nil), args) 8614 return 8615 } 8616 err = i.ResolveMaybeMention(ctx, typedArgs[0].Mention) 8617 return 8618 }, 8619 }, 8620 "loadGallery": { 8621 MakeArg: func() interface{} { 8622 var ret [1]LoadGalleryArg 8623 return &ret 8624 }, 8625 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8626 typedArgs, ok := args.(*[1]LoadGalleryArg) 8627 if !ok { 8628 err = rpc.NewTypeError((*[1]LoadGalleryArg)(nil), args) 8629 return 8630 } 8631 ret, err = i.LoadGallery(ctx, typedArgs[0]) 8632 return 8633 }, 8634 }, 8635 "loadFlip": { 8636 MakeArg: func() interface{} { 8637 var ret [1]LoadFlipArg 8638 return &ret 8639 }, 8640 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8641 typedArgs, ok := args.(*[1]LoadFlipArg) 8642 if !ok { 8643 err = rpc.NewTypeError((*[1]LoadFlipArg)(nil), args) 8644 return 8645 } 8646 ret, err = i.LoadFlip(ctx, typedArgs[0]) 8647 return 8648 }, 8649 }, 8650 "locationUpdate": { 8651 MakeArg: func() interface{} { 8652 var ret [1]LocationUpdateArg 8653 return &ret 8654 }, 8655 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8656 typedArgs, ok := args.(*[1]LocationUpdateArg) 8657 if !ok { 8658 err = rpc.NewTypeError((*[1]LocationUpdateArg)(nil), args) 8659 return 8660 } 8661 err = i.LocationUpdate(ctx, typedArgs[0].Coord) 8662 return 8663 }, 8664 }, 8665 "advertiseBotCommandsLocal": { 8666 MakeArg: func() interface{} { 8667 var ret [1]AdvertiseBotCommandsLocalArg 8668 return &ret 8669 }, 8670 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8671 typedArgs, ok := args.(*[1]AdvertiseBotCommandsLocalArg) 8672 if !ok { 8673 err = rpc.NewTypeError((*[1]AdvertiseBotCommandsLocalArg)(nil), args) 8674 return 8675 } 8676 ret, err = i.AdvertiseBotCommandsLocal(ctx, typedArgs[0]) 8677 return 8678 }, 8679 }, 8680 "listBotCommandsLocal": { 8681 MakeArg: func() interface{} { 8682 var ret [1]ListBotCommandsLocalArg 8683 return &ret 8684 }, 8685 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8686 typedArgs, ok := args.(*[1]ListBotCommandsLocalArg) 8687 if !ok { 8688 err = rpc.NewTypeError((*[1]ListBotCommandsLocalArg)(nil), args) 8689 return 8690 } 8691 ret, err = i.ListBotCommandsLocal(ctx, typedArgs[0].ConvID) 8692 return 8693 }, 8694 }, 8695 "listPublicBotCommandsLocal": { 8696 MakeArg: func() interface{} { 8697 var ret [1]ListPublicBotCommandsLocalArg 8698 return &ret 8699 }, 8700 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8701 typedArgs, ok := args.(*[1]ListPublicBotCommandsLocalArg) 8702 if !ok { 8703 err = rpc.NewTypeError((*[1]ListPublicBotCommandsLocalArg)(nil), args) 8704 return 8705 } 8706 ret, err = i.ListPublicBotCommandsLocal(ctx, typedArgs[0].Username) 8707 return 8708 }, 8709 }, 8710 "clearBotCommandsLocal": { 8711 MakeArg: func() interface{} { 8712 var ret [1]ClearBotCommandsLocalArg 8713 return &ret 8714 }, 8715 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8716 typedArgs, ok := args.(*[1]ClearBotCommandsLocalArg) 8717 if !ok { 8718 err = rpc.NewTypeError((*[1]ClearBotCommandsLocalArg)(nil), args) 8719 return 8720 } 8721 ret, err = i.ClearBotCommandsLocal(ctx, typedArgs[0].Filter) 8722 return 8723 }, 8724 }, 8725 "pinMessage": { 8726 MakeArg: func() interface{} { 8727 var ret [1]PinMessageArg 8728 return &ret 8729 }, 8730 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8731 typedArgs, ok := args.(*[1]PinMessageArg) 8732 if !ok { 8733 err = rpc.NewTypeError((*[1]PinMessageArg)(nil), args) 8734 return 8735 } 8736 ret, err = i.PinMessage(ctx, typedArgs[0]) 8737 return 8738 }, 8739 }, 8740 "unpinMessage": { 8741 MakeArg: func() interface{} { 8742 var ret [1]UnpinMessageArg 8743 return &ret 8744 }, 8745 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8746 typedArgs, ok := args.(*[1]UnpinMessageArg) 8747 if !ok { 8748 err = rpc.NewTypeError((*[1]UnpinMessageArg)(nil), args) 8749 return 8750 } 8751 ret, err = i.UnpinMessage(ctx, typedArgs[0].ConvID) 8752 return 8753 }, 8754 }, 8755 "ignorePinnedMessage": { 8756 MakeArg: func() interface{} { 8757 var ret [1]IgnorePinnedMessageArg 8758 return &ret 8759 }, 8760 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8761 typedArgs, ok := args.(*[1]IgnorePinnedMessageArg) 8762 if !ok { 8763 err = rpc.NewTypeError((*[1]IgnorePinnedMessageArg)(nil), args) 8764 return 8765 } 8766 err = i.IgnorePinnedMessage(ctx, typedArgs[0].ConvID) 8767 return 8768 }, 8769 }, 8770 "addBotMember": { 8771 MakeArg: func() interface{} { 8772 var ret [1]AddBotMemberArg 8773 return &ret 8774 }, 8775 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8776 typedArgs, ok := args.(*[1]AddBotMemberArg) 8777 if !ok { 8778 err = rpc.NewTypeError((*[1]AddBotMemberArg)(nil), args) 8779 return 8780 } 8781 err = i.AddBotMember(ctx, typedArgs[0]) 8782 return 8783 }, 8784 }, 8785 "editBotMember": { 8786 MakeArg: func() interface{} { 8787 var ret [1]EditBotMemberArg 8788 return &ret 8789 }, 8790 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8791 typedArgs, ok := args.(*[1]EditBotMemberArg) 8792 if !ok { 8793 err = rpc.NewTypeError((*[1]EditBotMemberArg)(nil), args) 8794 return 8795 } 8796 err = i.EditBotMember(ctx, typedArgs[0]) 8797 return 8798 }, 8799 }, 8800 "removeBotMember": { 8801 MakeArg: func() interface{} { 8802 var ret [1]RemoveBotMemberArg 8803 return &ret 8804 }, 8805 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8806 typedArgs, ok := args.(*[1]RemoveBotMemberArg) 8807 if !ok { 8808 err = rpc.NewTypeError((*[1]RemoveBotMemberArg)(nil), args) 8809 return 8810 } 8811 err = i.RemoveBotMember(ctx, typedArgs[0]) 8812 return 8813 }, 8814 }, 8815 "setBotMemberSettings": { 8816 MakeArg: func() interface{} { 8817 var ret [1]SetBotMemberSettingsArg 8818 return &ret 8819 }, 8820 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8821 typedArgs, ok := args.(*[1]SetBotMemberSettingsArg) 8822 if !ok { 8823 err = rpc.NewTypeError((*[1]SetBotMemberSettingsArg)(nil), args) 8824 return 8825 } 8826 err = i.SetBotMemberSettings(ctx, typedArgs[0]) 8827 return 8828 }, 8829 }, 8830 "getBotMemberSettings": { 8831 MakeArg: func() interface{} { 8832 var ret [1]GetBotMemberSettingsArg 8833 return &ret 8834 }, 8835 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8836 typedArgs, ok := args.(*[1]GetBotMemberSettingsArg) 8837 if !ok { 8838 err = rpc.NewTypeError((*[1]GetBotMemberSettingsArg)(nil), args) 8839 return 8840 } 8841 ret, err = i.GetBotMemberSettings(ctx, typedArgs[0]) 8842 return 8843 }, 8844 }, 8845 "getTeamRoleInConversation": { 8846 MakeArg: func() interface{} { 8847 var ret [1]GetTeamRoleInConversationArg 8848 return &ret 8849 }, 8850 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8851 typedArgs, ok := args.(*[1]GetTeamRoleInConversationArg) 8852 if !ok { 8853 err = rpc.NewTypeError((*[1]GetTeamRoleInConversationArg)(nil), args) 8854 return 8855 } 8856 ret, err = i.GetTeamRoleInConversation(ctx, typedArgs[0]) 8857 return 8858 }, 8859 }, 8860 "addBotConvSearch": { 8861 MakeArg: func() interface{} { 8862 var ret [1]AddBotConvSearchArg 8863 return &ret 8864 }, 8865 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8866 typedArgs, ok := args.(*[1]AddBotConvSearchArg) 8867 if !ok { 8868 err = rpc.NewTypeError((*[1]AddBotConvSearchArg)(nil), args) 8869 return 8870 } 8871 ret, err = i.AddBotConvSearch(ctx, typedArgs[0].Term) 8872 return 8873 }, 8874 }, 8875 "forwardMessageConvSearch": { 8876 MakeArg: func() interface{} { 8877 var ret [1]ForwardMessageConvSearchArg 8878 return &ret 8879 }, 8880 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8881 typedArgs, ok := args.(*[1]ForwardMessageConvSearchArg) 8882 if !ok { 8883 err = rpc.NewTypeError((*[1]ForwardMessageConvSearchArg)(nil), args) 8884 return 8885 } 8886 ret, err = i.ForwardMessageConvSearch(ctx, typedArgs[0].Term) 8887 return 8888 }, 8889 }, 8890 "teamIDFromTLFName": { 8891 MakeArg: func() interface{} { 8892 var ret [1]TeamIDFromTLFNameArg 8893 return &ret 8894 }, 8895 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8896 typedArgs, ok := args.(*[1]TeamIDFromTLFNameArg) 8897 if !ok { 8898 err = rpc.NewTypeError((*[1]TeamIDFromTLFNameArg)(nil), args) 8899 return 8900 } 8901 ret, err = i.TeamIDFromTLFName(ctx, typedArgs[0]) 8902 return 8903 }, 8904 }, 8905 "dismissJourneycard": { 8906 MakeArg: func() interface{} { 8907 var ret [1]DismissJourneycardArg 8908 return &ret 8909 }, 8910 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8911 typedArgs, ok := args.(*[1]DismissJourneycardArg) 8912 if !ok { 8913 err = rpc.NewTypeError((*[1]DismissJourneycardArg)(nil), args) 8914 return 8915 } 8916 err = i.DismissJourneycard(ctx, typedArgs[0]) 8917 return 8918 }, 8919 }, 8920 "setWelcomeMessage": { 8921 MakeArg: func() interface{} { 8922 var ret [1]SetWelcomeMessageArg 8923 return &ret 8924 }, 8925 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8926 typedArgs, ok := args.(*[1]SetWelcomeMessageArg) 8927 if !ok { 8928 err = rpc.NewTypeError((*[1]SetWelcomeMessageArg)(nil), args) 8929 return 8930 } 8931 err = i.SetWelcomeMessage(ctx, typedArgs[0]) 8932 return 8933 }, 8934 }, 8935 "getWelcomeMessage": { 8936 MakeArg: func() interface{} { 8937 var ret [1]GetWelcomeMessageArg 8938 return &ret 8939 }, 8940 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8941 typedArgs, ok := args.(*[1]GetWelcomeMessageArg) 8942 if !ok { 8943 err = rpc.NewTypeError((*[1]GetWelcomeMessageArg)(nil), args) 8944 return 8945 } 8946 ret, err = i.GetWelcomeMessage(ctx, typedArgs[0].TeamID) 8947 return 8948 }, 8949 }, 8950 "getDefaultTeamChannelsLocal": { 8951 MakeArg: func() interface{} { 8952 var ret [1]GetDefaultTeamChannelsLocalArg 8953 return &ret 8954 }, 8955 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8956 typedArgs, ok := args.(*[1]GetDefaultTeamChannelsLocalArg) 8957 if !ok { 8958 err = rpc.NewTypeError((*[1]GetDefaultTeamChannelsLocalArg)(nil), args) 8959 return 8960 } 8961 ret, err = i.GetDefaultTeamChannelsLocal(ctx, typedArgs[0].TeamID) 8962 return 8963 }, 8964 }, 8965 "setDefaultTeamChannelsLocal": { 8966 MakeArg: func() interface{} { 8967 var ret [1]SetDefaultTeamChannelsLocalArg 8968 return &ret 8969 }, 8970 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8971 typedArgs, ok := args.(*[1]SetDefaultTeamChannelsLocalArg) 8972 if !ok { 8973 err = rpc.NewTypeError((*[1]SetDefaultTeamChannelsLocalArg)(nil), args) 8974 return 8975 } 8976 ret, err = i.SetDefaultTeamChannelsLocal(ctx, typedArgs[0]) 8977 return 8978 }, 8979 }, 8980 "getLastActiveForTLF": { 8981 MakeArg: func() interface{} { 8982 var ret [1]GetLastActiveForTLFArg 8983 return &ret 8984 }, 8985 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 8986 typedArgs, ok := args.(*[1]GetLastActiveForTLFArg) 8987 if !ok { 8988 err = rpc.NewTypeError((*[1]GetLastActiveForTLFArg)(nil), args) 8989 return 8990 } 8991 ret, err = i.GetLastActiveForTLF(ctx, typedArgs[0].TlfID) 8992 return 8993 }, 8994 }, 8995 "getLastActiveForTeams": { 8996 MakeArg: func() interface{} { 8997 var ret [1]GetLastActiveForTeamsArg 8998 return &ret 8999 }, 9000 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 9001 ret, err = i.GetLastActiveForTeams(ctx) 9002 return 9003 }, 9004 }, 9005 "getRecentJoinsLocal": { 9006 MakeArg: func() interface{} { 9007 var ret [1]GetRecentJoinsLocalArg 9008 return &ret 9009 }, 9010 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 9011 typedArgs, ok := args.(*[1]GetRecentJoinsLocalArg) 9012 if !ok { 9013 err = rpc.NewTypeError((*[1]GetRecentJoinsLocalArg)(nil), args) 9014 return 9015 } 9016 ret, err = i.GetRecentJoinsLocal(ctx, typedArgs[0].ConvID) 9017 return 9018 }, 9019 }, 9020 "refreshParticipants": { 9021 MakeArg: func() interface{} { 9022 var ret [1]RefreshParticipantsArg 9023 return &ret 9024 }, 9025 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 9026 typedArgs, ok := args.(*[1]RefreshParticipantsArg) 9027 if !ok { 9028 err = rpc.NewTypeError((*[1]RefreshParticipantsArg)(nil), args) 9029 return 9030 } 9031 err = i.RefreshParticipants(ctx, typedArgs[0].ConvID) 9032 return 9033 }, 9034 }, 9035 "getLastActiveAtLocal": { 9036 MakeArg: func() interface{} { 9037 var ret [1]GetLastActiveAtLocalArg 9038 return &ret 9039 }, 9040 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 9041 typedArgs, ok := args.(*[1]GetLastActiveAtLocalArg) 9042 if !ok { 9043 err = rpc.NewTypeError((*[1]GetLastActiveAtLocalArg)(nil), args) 9044 return 9045 } 9046 ret, err = i.GetLastActiveAtLocal(ctx, typedArgs[0]) 9047 return 9048 }, 9049 }, 9050 "getLastActiveAtMultiLocal": { 9051 MakeArg: func() interface{} { 9052 var ret [1]GetLastActiveAtMultiLocalArg 9053 return &ret 9054 }, 9055 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 9056 typedArgs, ok := args.(*[1]GetLastActiveAtMultiLocalArg) 9057 if !ok { 9058 err = rpc.NewTypeError((*[1]GetLastActiveAtMultiLocalArg)(nil), args) 9059 return 9060 } 9061 ret, err = i.GetLastActiveAtMultiLocal(ctx, typedArgs[0]) 9062 return 9063 }, 9064 }, 9065 "getParticipants": { 9066 MakeArg: func() interface{} { 9067 var ret [1]GetParticipantsArg 9068 return &ret 9069 }, 9070 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 9071 typedArgs, ok := args.(*[1]GetParticipantsArg) 9072 if !ok { 9073 err = rpc.NewTypeError((*[1]GetParticipantsArg)(nil), args) 9074 return 9075 } 9076 ret, err = i.GetParticipants(ctx, typedArgs[0].ConvID) 9077 return 9078 }, 9079 }, 9080 "addEmoji": { 9081 MakeArg: func() interface{} { 9082 var ret [1]AddEmojiArg 9083 return &ret 9084 }, 9085 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 9086 typedArgs, ok := args.(*[1]AddEmojiArg) 9087 if !ok { 9088 err = rpc.NewTypeError((*[1]AddEmojiArg)(nil), args) 9089 return 9090 } 9091 ret, err = i.AddEmoji(ctx, typedArgs[0]) 9092 return 9093 }, 9094 }, 9095 "addEmojis": { 9096 MakeArg: func() interface{} { 9097 var ret [1]AddEmojisArg 9098 return &ret 9099 }, 9100 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 9101 typedArgs, ok := args.(*[1]AddEmojisArg) 9102 if !ok { 9103 err = rpc.NewTypeError((*[1]AddEmojisArg)(nil), args) 9104 return 9105 } 9106 ret, err = i.AddEmojis(ctx, typedArgs[0]) 9107 return 9108 }, 9109 }, 9110 "addEmojiAlias": { 9111 MakeArg: func() interface{} { 9112 var ret [1]AddEmojiAliasArg 9113 return &ret 9114 }, 9115 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 9116 typedArgs, ok := args.(*[1]AddEmojiAliasArg) 9117 if !ok { 9118 err = rpc.NewTypeError((*[1]AddEmojiAliasArg)(nil), args) 9119 return 9120 } 9121 ret, err = i.AddEmojiAlias(ctx, typedArgs[0]) 9122 return 9123 }, 9124 }, 9125 "removeEmoji": { 9126 MakeArg: func() interface{} { 9127 var ret [1]RemoveEmojiArg 9128 return &ret 9129 }, 9130 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 9131 typedArgs, ok := args.(*[1]RemoveEmojiArg) 9132 if !ok { 9133 err = rpc.NewTypeError((*[1]RemoveEmojiArg)(nil), args) 9134 return 9135 } 9136 ret, err = i.RemoveEmoji(ctx, typedArgs[0]) 9137 return 9138 }, 9139 }, 9140 "userEmojis": { 9141 MakeArg: func() interface{} { 9142 var ret [1]UserEmojisArg 9143 return &ret 9144 }, 9145 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 9146 typedArgs, ok := args.(*[1]UserEmojisArg) 9147 if !ok { 9148 err = rpc.NewTypeError((*[1]UserEmojisArg)(nil), args) 9149 return 9150 } 9151 ret, err = i.UserEmojis(ctx, typedArgs[0]) 9152 return 9153 }, 9154 }, 9155 "toggleEmojiAnimations": { 9156 MakeArg: func() interface{} { 9157 var ret [1]ToggleEmojiAnimationsArg 9158 return &ret 9159 }, 9160 Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) { 9161 typedArgs, ok := args.(*[1]ToggleEmojiAnimationsArg) 9162 if !ok { 9163 err = rpc.NewTypeError((*[1]ToggleEmojiAnimationsArg)(nil), args) 9164 return 9165 } 9166 err = i.ToggleEmojiAnimations(ctx, typedArgs[0].Enabled) 9167 return 9168 }, 9169 }, 9170 }, 9171 } 9172} 9173 9174type LocalClient struct { 9175 Cli rpc.GenericClient 9176} 9177 9178func (c LocalClient) GetThreadLocal(ctx context.Context, __arg GetThreadLocalArg) (res GetThreadLocalRes, err error) { 9179 err = c.Cli.Call(ctx, "chat.1.local.getThreadLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9180 return 9181} 9182 9183func (c LocalClient) GetThreadNonblock(ctx context.Context, __arg GetThreadNonblockArg) (res NonblockFetchRes, err error) { 9184 err = c.Cli.Call(ctx, "chat.1.local.getThreadNonblock", []interface{}{__arg}, &res, 30000*time.Millisecond) 9185 return 9186} 9187 9188func (c LocalClient) GetUnreadline(ctx context.Context, __arg GetUnreadlineArg) (res UnreadlineRes, err error) { 9189 err = c.Cli.Call(ctx, "chat.1.local.getUnreadline", []interface{}{__arg}, &res, 0*time.Millisecond) 9190 return 9191} 9192 9193func (c LocalClient) GetInboxAndUnboxLocal(ctx context.Context, __arg GetInboxAndUnboxLocalArg) (res GetInboxAndUnboxLocalRes, err error) { 9194 err = c.Cli.Call(ctx, "chat.1.local.getInboxAndUnboxLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9195 return 9196} 9197 9198func (c LocalClient) GetInboxAndUnboxUILocal(ctx context.Context, __arg GetInboxAndUnboxUILocalArg) (res GetInboxAndUnboxUILocalRes, err error) { 9199 err = c.Cli.Call(ctx, "chat.1.local.getInboxAndUnboxUILocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9200 return 9201} 9202 9203func (c LocalClient) RequestInboxLayout(ctx context.Context, reselectMode InboxLayoutReselectMode) (err error) { 9204 __arg := RequestInboxLayoutArg{ReselectMode: reselectMode} 9205 err = c.Cli.Call(ctx, "chat.1.local.requestInboxLayout", []interface{}{__arg}, nil, 0*time.Millisecond) 9206 return 9207} 9208 9209func (c LocalClient) RequestInboxUnbox(ctx context.Context, convIDs []ConversationID) (err error) { 9210 __arg := RequestInboxUnboxArg{ConvIDs: convIDs} 9211 err = c.Cli.Call(ctx, "chat.1.local.requestInboxUnbox", []interface{}{__arg}, nil, 0*time.Millisecond) 9212 return 9213} 9214 9215func (c LocalClient) RequestInboxSmallIncrease(ctx context.Context) (err error) { 9216 err = c.Cli.Call(ctx, "chat.1.local.requestInboxSmallIncrease", []interface{}{RequestInboxSmallIncreaseArg{}}, nil, 0*time.Millisecond) 9217 return 9218} 9219 9220func (c LocalClient) RequestInboxSmallReset(ctx context.Context) (err error) { 9221 err = c.Cli.Call(ctx, "chat.1.local.requestInboxSmallReset", []interface{}{RequestInboxSmallResetArg{}}, nil, 0*time.Millisecond) 9222 return 9223} 9224 9225func (c LocalClient) GetInboxNonblockLocal(ctx context.Context, __arg GetInboxNonblockLocalArg) (res NonblockFetchRes, err error) { 9226 err = c.Cli.Call(ctx, "chat.1.local.getInboxNonblockLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9227 return 9228} 9229 9230func (c LocalClient) PostLocal(ctx context.Context, __arg PostLocalArg) (res PostLocalRes, err error) { 9231 err = c.Cli.Call(ctx, "chat.1.local.postLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9232 return 9233} 9234 9235func (c LocalClient) GenerateOutboxID(ctx context.Context) (res OutboxID, err error) { 9236 err = c.Cli.Call(ctx, "chat.1.local.generateOutboxID", []interface{}{GenerateOutboxIDArg{}}, &res, 0*time.Millisecond) 9237 return 9238} 9239 9240func (c LocalClient) PostLocalNonblock(ctx context.Context, __arg PostLocalNonblockArg) (res PostLocalNonblockRes, err error) { 9241 err = c.Cli.Call(ctx, "chat.1.local.postLocalNonblock", []interface{}{__arg}, &res, 30000*time.Millisecond) 9242 return 9243} 9244 9245func (c LocalClient) ForwardMessage(ctx context.Context, __arg ForwardMessageArg) (res PostLocalRes, err error) { 9246 err = c.Cli.Call(ctx, "chat.1.local.forwardMessage", []interface{}{__arg}, &res, 0*time.Millisecond) 9247 return 9248} 9249 9250func (c LocalClient) ForwardMessageNonblock(ctx context.Context, __arg ForwardMessageNonblockArg) (res PostLocalNonblockRes, err error) { 9251 err = c.Cli.Call(ctx, "chat.1.local.forwardMessageNonblock", []interface{}{__arg}, &res, 30000*time.Millisecond) 9252 return 9253} 9254 9255func (c LocalClient) PostTextNonblock(ctx context.Context, __arg PostTextNonblockArg) (res PostLocalNonblockRes, err error) { 9256 err = c.Cli.Call(ctx, "chat.1.local.postTextNonblock", []interface{}{__arg}, &res, 30000*time.Millisecond) 9257 return 9258} 9259 9260func (c LocalClient) PostDeleteNonblock(ctx context.Context, __arg PostDeleteNonblockArg) (res PostLocalNonblockRes, err error) { 9261 err = c.Cli.Call(ctx, "chat.1.local.postDeleteNonblock", []interface{}{__arg}, &res, 30000*time.Millisecond) 9262 return 9263} 9264 9265func (c LocalClient) PostEditNonblock(ctx context.Context, __arg PostEditNonblockArg) (res PostLocalNonblockRes, err error) { 9266 err = c.Cli.Call(ctx, "chat.1.local.postEditNonblock", []interface{}{__arg}, &res, 30000*time.Millisecond) 9267 return 9268} 9269 9270func (c LocalClient) PostReactionNonblock(ctx context.Context, __arg PostReactionNonblockArg) (res PostLocalNonblockRes, err error) { 9271 err = c.Cli.Call(ctx, "chat.1.local.postReactionNonblock", []interface{}{__arg}, &res, 30000*time.Millisecond) 9272 return 9273} 9274 9275func (c LocalClient) PostHeadlineNonblock(ctx context.Context, __arg PostHeadlineNonblockArg) (res PostLocalNonblockRes, err error) { 9276 err = c.Cli.Call(ctx, "chat.1.local.postHeadlineNonblock", []interface{}{__arg}, &res, 30000*time.Millisecond) 9277 return 9278} 9279 9280func (c LocalClient) PostHeadline(ctx context.Context, __arg PostHeadlineArg) (res PostLocalRes, err error) { 9281 err = c.Cli.Call(ctx, "chat.1.local.postHeadline", []interface{}{__arg}, &res, 0*time.Millisecond) 9282 return 9283} 9284 9285func (c LocalClient) PostMetadataNonblock(ctx context.Context, __arg PostMetadataNonblockArg) (res PostLocalNonblockRes, err error) { 9286 err = c.Cli.Call(ctx, "chat.1.local.postMetadataNonblock", []interface{}{__arg}, &res, 30000*time.Millisecond) 9287 return 9288} 9289 9290func (c LocalClient) PostMetadata(ctx context.Context, __arg PostMetadataArg) (res PostLocalRes, err error) { 9291 err = c.Cli.Call(ctx, "chat.1.local.postMetadata", []interface{}{__arg}, &res, 0*time.Millisecond) 9292 return 9293} 9294 9295func (c LocalClient) PostDeleteHistoryUpto(ctx context.Context, __arg PostDeleteHistoryUptoArg) (res PostLocalRes, err error) { 9296 err = c.Cli.Call(ctx, "chat.1.local.postDeleteHistoryUpto", []interface{}{__arg}, &res, 0*time.Millisecond) 9297 return 9298} 9299 9300func (c LocalClient) PostDeleteHistoryThrough(ctx context.Context, __arg PostDeleteHistoryThroughArg) (res PostLocalRes, err error) { 9301 err = c.Cli.Call(ctx, "chat.1.local.postDeleteHistoryThrough", []interface{}{__arg}, &res, 0*time.Millisecond) 9302 return 9303} 9304 9305func (c LocalClient) PostDeleteHistoryByAge(ctx context.Context, __arg PostDeleteHistoryByAgeArg) (res PostLocalRes, err error) { 9306 err = c.Cli.Call(ctx, "chat.1.local.postDeleteHistoryByAge", []interface{}{__arg}, &res, 0*time.Millisecond) 9307 return 9308} 9309 9310func (c LocalClient) SetConversationStatusLocal(ctx context.Context, __arg SetConversationStatusLocalArg) (res SetConversationStatusLocalRes, err error) { 9311 err = c.Cli.Call(ctx, "chat.1.local.SetConversationStatusLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9312 return 9313} 9314 9315func (c LocalClient) NewConversationsLocal(ctx context.Context, __arg NewConversationsLocalArg) (res NewConversationsLocalRes, err error) { 9316 err = c.Cli.Call(ctx, "chat.1.local.newConversationsLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9317 return 9318} 9319 9320func (c LocalClient) NewConversationLocal(ctx context.Context, __arg NewConversationLocalArg) (res NewConversationLocalRes, err error) { 9321 err = c.Cli.Call(ctx, "chat.1.local.newConversationLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9322 return 9323} 9324 9325func (c LocalClient) GetInboxSummaryForCLILocal(ctx context.Context, query GetInboxSummaryForCLILocalQuery) (res GetInboxSummaryForCLILocalRes, err error) { 9326 __arg := GetInboxSummaryForCLILocalArg{Query: query} 9327 err = c.Cli.Call(ctx, "chat.1.local.getInboxSummaryForCLILocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9328 return 9329} 9330 9331func (c LocalClient) GetConversationForCLILocal(ctx context.Context, query GetConversationForCLILocalQuery) (res GetConversationForCLILocalRes, err error) { 9332 __arg := GetConversationForCLILocalArg{Query: query} 9333 err = c.Cli.Call(ctx, "chat.1.local.getConversationForCLILocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9334 return 9335} 9336 9337func (c LocalClient) GetMessagesLocal(ctx context.Context, __arg GetMessagesLocalArg) (res GetMessagesLocalRes, err error) { 9338 err = c.Cli.Call(ctx, "chat.1.local.GetMessagesLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9339 return 9340} 9341 9342func (c LocalClient) PostFileAttachmentLocal(ctx context.Context, __arg PostFileAttachmentLocalArg) (res PostLocalRes, err error) { 9343 err = c.Cli.Call(ctx, "chat.1.local.postFileAttachmentLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9344 return 9345} 9346 9347func (c LocalClient) PostFileAttachmentLocalNonblock(ctx context.Context, __arg PostFileAttachmentLocalNonblockArg) (res PostLocalNonblockRes, err error) { 9348 err = c.Cli.Call(ctx, "chat.1.local.postFileAttachmentLocalNonblock", []interface{}{__arg}, &res, 30000*time.Millisecond) 9349 return 9350} 9351 9352func (c LocalClient) GetNextAttachmentMessageLocal(ctx context.Context, __arg GetNextAttachmentMessageLocalArg) (res GetNextAttachmentMessageLocalRes, err error) { 9353 err = c.Cli.Call(ctx, "chat.1.local.getNextAttachmentMessageLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9354 return 9355} 9356 9357func (c LocalClient) DownloadAttachmentLocal(ctx context.Context, __arg DownloadAttachmentLocalArg) (res DownloadAttachmentLocalRes, err error) { 9358 err = c.Cli.Call(ctx, "chat.1.local.DownloadAttachmentLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9359 return 9360} 9361 9362func (c LocalClient) DownloadFileAttachmentLocal(ctx context.Context, __arg DownloadFileAttachmentLocalArg) (res DownloadFileAttachmentLocalRes, err error) { 9363 err = c.Cli.Call(ctx, "chat.1.local.DownloadFileAttachmentLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9364 return 9365} 9366 9367func (c LocalClient) ConfigureFileAttachmentDownloadLocal(ctx context.Context, __arg ConfigureFileAttachmentDownloadLocalArg) (err error) { 9368 err = c.Cli.Call(ctx, "chat.1.local.ConfigureFileAttachmentDownloadLocal", []interface{}{__arg}, nil, 0*time.Millisecond) 9369 return 9370} 9371 9372func (c LocalClient) MakePreview(ctx context.Context, __arg MakePreviewArg) (res MakePreviewRes, err error) { 9373 err = c.Cli.Call(ctx, "chat.1.local.makePreview", []interface{}{__arg}, &res, 0*time.Millisecond) 9374 return 9375} 9376 9377func (c LocalClient) MakeAudioPreview(ctx context.Context, __arg MakeAudioPreviewArg) (res MakePreviewRes, err error) { 9378 err = c.Cli.Call(ctx, "chat.1.local.makeAudioPreview", []interface{}{__arg}, &res, 0*time.Millisecond) 9379 return 9380} 9381 9382func (c LocalClient) GetUploadTempFile(ctx context.Context, __arg GetUploadTempFileArg) (res string, err error) { 9383 err = c.Cli.Call(ctx, "chat.1.local.getUploadTempFile", []interface{}{__arg}, &res, 0*time.Millisecond) 9384 return 9385} 9386 9387func (c LocalClient) MakeUploadTempFile(ctx context.Context, __arg MakeUploadTempFileArg) (res string, err error) { 9388 err = c.Cli.Call(ctx, "chat.1.local.makeUploadTempFile", []interface{}{__arg}, &res, 0*time.Millisecond) 9389 return 9390} 9391 9392func (c LocalClient) CancelUploadTempFile(ctx context.Context, outboxID OutboxID) (err error) { 9393 __arg := CancelUploadTempFileArg{OutboxID: outboxID} 9394 err = c.Cli.Call(ctx, "chat.1.local.cancelUploadTempFile", []interface{}{__arg}, nil, 0*time.Millisecond) 9395 return 9396} 9397 9398func (c LocalClient) CancelPost(ctx context.Context, outboxID OutboxID) (err error) { 9399 __arg := CancelPostArg{OutboxID: outboxID} 9400 err = c.Cli.Call(ctx, "chat.1.local.CancelPost", []interface{}{__arg}, nil, 0*time.Millisecond) 9401 return 9402} 9403 9404func (c LocalClient) RetryPost(ctx context.Context, __arg RetryPostArg) (err error) { 9405 err = c.Cli.Call(ctx, "chat.1.local.RetryPost", []interface{}{__arg}, nil, 0*time.Millisecond) 9406 return 9407} 9408 9409func (c LocalClient) MarkAsReadLocal(ctx context.Context, __arg MarkAsReadLocalArg) (res MarkAsReadLocalRes, err error) { 9410 err = c.Cli.Call(ctx, "chat.1.local.markAsReadLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9411 return 9412} 9413 9414func (c LocalClient) MarkTLFAsReadLocal(ctx context.Context, __arg MarkTLFAsReadLocalArg) (res MarkTLFAsReadLocalRes, err error) { 9415 err = c.Cli.Call(ctx, "chat.1.local.markTLFAsReadLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9416 return 9417} 9418 9419func (c LocalClient) FindConversationsLocal(ctx context.Context, __arg FindConversationsLocalArg) (res FindConversationsLocalRes, err error) { 9420 err = c.Cli.Call(ctx, "chat.1.local.findConversationsLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9421 return 9422} 9423 9424func (c LocalClient) FindGeneralConvFromTeamID(ctx context.Context, teamID keybase1.TeamID) (res InboxUIItem, err error) { 9425 __arg := FindGeneralConvFromTeamIDArg{TeamID: teamID} 9426 err = c.Cli.Call(ctx, "chat.1.local.findGeneralConvFromTeamID", []interface{}{__arg}, &res, 0*time.Millisecond) 9427 return 9428} 9429 9430func (c LocalClient) UpdateTyping(ctx context.Context, __arg UpdateTypingArg) (err error) { 9431 err = c.Cli.Call(ctx, "chat.1.local.updateTyping", []interface{}{__arg}, nil, 0*time.Millisecond) 9432 return 9433} 9434 9435func (c LocalClient) UpdateUnsentText(ctx context.Context, __arg UpdateUnsentTextArg) (err error) { 9436 err = c.Cli.Call(ctx, "chat.1.local.updateUnsentText", []interface{}{__arg}, nil, 0*time.Millisecond) 9437 return 9438} 9439 9440func (c LocalClient) JoinConversationLocal(ctx context.Context, __arg JoinConversationLocalArg) (res JoinLeaveConversationLocalRes, err error) { 9441 err = c.Cli.Call(ctx, "chat.1.local.joinConversationLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9442 return 9443} 9444 9445func (c LocalClient) JoinConversationByIDLocal(ctx context.Context, convID ConversationID) (res JoinLeaveConversationLocalRes, err error) { 9446 __arg := JoinConversationByIDLocalArg{ConvID: convID} 9447 err = c.Cli.Call(ctx, "chat.1.local.joinConversationByIDLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9448 return 9449} 9450 9451func (c LocalClient) LeaveConversationLocal(ctx context.Context, convID ConversationID) (res JoinLeaveConversationLocalRes, err error) { 9452 __arg := LeaveConversationLocalArg{ConvID: convID} 9453 err = c.Cli.Call(ctx, "chat.1.local.leaveConversationLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9454 return 9455} 9456 9457func (c LocalClient) PreviewConversationByIDLocal(ctx context.Context, convID ConversationID) (res PreviewConversationLocalRes, err error) { 9458 __arg := PreviewConversationByIDLocalArg{ConvID: convID} 9459 err = c.Cli.Call(ctx, "chat.1.local.previewConversationByIDLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9460 return 9461} 9462 9463func (c LocalClient) DeleteConversationLocal(ctx context.Context, __arg DeleteConversationLocalArg) (res DeleteConversationLocalRes, err error) { 9464 err = c.Cli.Call(ctx, "chat.1.local.deleteConversationLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9465 return 9466} 9467 9468func (c LocalClient) RemoveFromConversationLocal(ctx context.Context, __arg RemoveFromConversationLocalArg) (res RemoveFromConversationLocalRes, err error) { 9469 err = c.Cli.Call(ctx, "chat.1.local.removeFromConversationLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9470 return 9471} 9472 9473func (c LocalClient) GetTLFConversationsLocal(ctx context.Context, __arg GetTLFConversationsLocalArg) (res GetTLFConversationsLocalRes, err error) { 9474 err = c.Cli.Call(ctx, "chat.1.local.getTLFConversationsLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9475 return 9476} 9477 9478func (c LocalClient) GetChannelMembershipsLocal(ctx context.Context, __arg GetChannelMembershipsLocalArg) (res GetChannelMembershipsLocalRes, err error) { 9479 err = c.Cli.Call(ctx, "chat.1.local.getChannelMembershipsLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9480 return 9481} 9482 9483func (c LocalClient) GetMutualTeamsLocal(ctx context.Context, usernames []string) (res GetMutualTeamsLocalRes, err error) { 9484 __arg := GetMutualTeamsLocalArg{Usernames: usernames} 9485 err = c.Cli.Call(ctx, "chat.1.local.getMutualTeamsLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9486 return 9487} 9488 9489func (c LocalClient) SetAppNotificationSettingsLocal(ctx context.Context, __arg SetAppNotificationSettingsLocalArg) (res SetAppNotificationSettingsLocalRes, err error) { 9490 err = c.Cli.Call(ctx, "chat.1.local.setAppNotificationSettingsLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9491 return 9492} 9493 9494func (c LocalClient) SetGlobalAppNotificationSettingsLocal(ctx context.Context, settings map[string]bool) (err error) { 9495 __arg := SetGlobalAppNotificationSettingsLocalArg{Settings: settings} 9496 err = c.Cli.Call(ctx, "chat.1.local.setGlobalAppNotificationSettingsLocal", []interface{}{__arg}, nil, 0*time.Millisecond) 9497 return 9498} 9499 9500func (c LocalClient) GetGlobalAppNotificationSettingsLocal(ctx context.Context) (res GlobalAppNotificationSettings, err error) { 9501 err = c.Cli.Call(ctx, "chat.1.local.getGlobalAppNotificationSettingsLocal", []interface{}{GetGlobalAppNotificationSettingsLocalArg{}}, &res, 0*time.Millisecond) 9502 return 9503} 9504 9505func (c LocalClient) UnboxMobilePushNotification(ctx context.Context, __arg UnboxMobilePushNotificationArg) (res string, err error) { 9506 err = c.Cli.Call(ctx, "chat.1.local.unboxMobilePushNotification", []interface{}{__arg}, &res, 0*time.Millisecond) 9507 return 9508} 9509 9510func (c LocalClient) AddTeamMemberAfterReset(ctx context.Context, __arg AddTeamMemberAfterResetArg) (err error) { 9511 err = c.Cli.Call(ctx, "chat.1.local.addTeamMemberAfterReset", []interface{}{__arg}, nil, 0*time.Millisecond) 9512 return 9513} 9514 9515func (c LocalClient) GetAllResetConvMembers(ctx context.Context) (res GetAllResetConvMembersRes, err error) { 9516 err = c.Cli.Call(ctx, "chat.1.local.getAllResetConvMembers", []interface{}{GetAllResetConvMembersArg{}}, &res, 0*time.Millisecond) 9517 return 9518} 9519 9520func (c LocalClient) SetConvRetentionLocal(ctx context.Context, __arg SetConvRetentionLocalArg) (err error) { 9521 err = c.Cli.Call(ctx, "chat.1.local.setConvRetentionLocal", []interface{}{__arg}, nil, 0*time.Millisecond) 9522 return 9523} 9524 9525func (c LocalClient) SetTeamRetentionLocal(ctx context.Context, __arg SetTeamRetentionLocalArg) (err error) { 9526 err = c.Cli.Call(ctx, "chat.1.local.setTeamRetentionLocal", []interface{}{__arg}, nil, 0*time.Millisecond) 9527 return 9528} 9529 9530func (c LocalClient) GetTeamRetentionLocal(ctx context.Context, teamID keybase1.TeamID) (res *RetentionPolicy, err error) { 9531 __arg := GetTeamRetentionLocalArg{TeamID: teamID} 9532 err = c.Cli.Call(ctx, "chat.1.local.getTeamRetentionLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9533 return 9534} 9535 9536func (c LocalClient) SetConvMinWriterRoleLocal(ctx context.Context, __arg SetConvMinWriterRoleLocalArg) (err error) { 9537 err = c.Cli.Call(ctx, "chat.1.local.setConvMinWriterRoleLocal", []interface{}{__arg}, nil, 0*time.Millisecond) 9538 return 9539} 9540 9541func (c LocalClient) UpgradeKBFSConversationToImpteam(ctx context.Context, convID ConversationID) (err error) { 9542 __arg := UpgradeKBFSConversationToImpteamArg{ConvID: convID} 9543 err = c.Cli.Call(ctx, "chat.1.local.upgradeKBFSConversationToImpteam", []interface{}{__arg}, nil, 0*time.Millisecond) 9544 return 9545} 9546 9547func (c LocalClient) SearchRegexp(ctx context.Context, __arg SearchRegexpArg) (res SearchRegexpRes, err error) { 9548 err = c.Cli.Call(ctx, "chat.1.local.searchRegexp", []interface{}{__arg}, &res, 0*time.Millisecond) 9549 return 9550} 9551 9552func (c LocalClient) CancelActiveInboxSearch(ctx context.Context) (err error) { 9553 err = c.Cli.Call(ctx, "chat.1.local.cancelActiveInboxSearch", []interface{}{CancelActiveInboxSearchArg{}}, nil, 0*time.Millisecond) 9554 return 9555} 9556 9557func (c LocalClient) SearchInbox(ctx context.Context, __arg SearchInboxArg) (res SearchInboxRes, err error) { 9558 err = c.Cli.Call(ctx, "chat.1.local.searchInbox", []interface{}{__arg}, &res, 0*time.Millisecond) 9559 return 9560} 9561 9562func (c LocalClient) SimpleSearchInboxConvNames(ctx context.Context, query string) (res []SimpleSearchInboxConvNamesHit, err error) { 9563 __arg := SimpleSearchInboxConvNamesArg{Query: query} 9564 err = c.Cli.Call(ctx, "chat.1.local.simpleSearchInboxConvNames", []interface{}{__arg}, &res, 0*time.Millisecond) 9565 return 9566} 9567 9568func (c LocalClient) CancelActiveSearch(ctx context.Context) (err error) { 9569 err = c.Cli.Call(ctx, "chat.1.local.cancelActiveSearch", []interface{}{CancelActiveSearchArg{}}, nil, 0*time.Millisecond) 9570 return 9571} 9572 9573func (c LocalClient) ProfileChatSearch(ctx context.Context, identifyBehavior keybase1.TLFIdentifyBehavior) (res map[ConvIDStr]ProfileSearchConvStats, err error) { 9574 __arg := ProfileChatSearchArg{IdentifyBehavior: identifyBehavior} 9575 err = c.Cli.Call(ctx, "chat.1.local.profileChatSearch", []interface{}{__arg}, &res, 0*time.Millisecond) 9576 return 9577} 9578 9579func (c LocalClient) GetStaticConfig(ctx context.Context) (res StaticConfig, err error) { 9580 err = c.Cli.Call(ctx, "chat.1.local.getStaticConfig", []interface{}{GetStaticConfigArg{}}, &res, 0*time.Millisecond) 9581 return 9582} 9583 9584func (c LocalClient) ResolveUnfurlPrompt(ctx context.Context, __arg ResolveUnfurlPromptArg) (err error) { 9585 err = c.Cli.Call(ctx, "chat.1.local.resolveUnfurlPrompt", []interface{}{__arg}, nil, 0*time.Millisecond) 9586 return 9587} 9588 9589func (c LocalClient) GetUnfurlSettings(ctx context.Context) (res UnfurlSettingsDisplay, err error) { 9590 err = c.Cli.Call(ctx, "chat.1.local.getUnfurlSettings", []interface{}{GetUnfurlSettingsArg{}}, &res, 0*time.Millisecond) 9591 return 9592} 9593 9594func (c LocalClient) SaveUnfurlSettings(ctx context.Context, __arg SaveUnfurlSettingsArg) (err error) { 9595 err = c.Cli.Call(ctx, "chat.1.local.saveUnfurlSettings", []interface{}{__arg}, nil, 0*time.Millisecond) 9596 return 9597} 9598 9599func (c LocalClient) ToggleMessageCollapse(ctx context.Context, __arg ToggleMessageCollapseArg) (err error) { 9600 err = c.Cli.Call(ctx, "chat.1.local.toggleMessageCollapse", []interface{}{__arg}, nil, 0*time.Millisecond) 9601 return 9602} 9603 9604func (c LocalClient) BulkAddToConv(ctx context.Context, __arg BulkAddToConvArg) (err error) { 9605 err = c.Cli.Call(ctx, "chat.1.local.bulkAddToConv", []interface{}{__arg}, nil, 0*time.Millisecond) 9606 return 9607} 9608 9609func (c LocalClient) BulkAddToManyConvs(ctx context.Context, __arg BulkAddToManyConvsArg) (err error) { 9610 err = c.Cli.Call(ctx, "chat.1.local.bulkAddToManyConvs", []interface{}{__arg}, nil, 0*time.Millisecond) 9611 return 9612} 9613 9614func (c LocalClient) PutReacjiSkinTone(ctx context.Context, skinTone keybase1.ReacjiSkinTone) (res keybase1.UserReacjis, err error) { 9615 __arg := PutReacjiSkinToneArg{SkinTone: skinTone} 9616 err = c.Cli.Call(ctx, "chat.1.local.putReacjiSkinTone", []interface{}{__arg}, &res, 0*time.Millisecond) 9617 return 9618} 9619 9620func (c LocalClient) ResolveMaybeMention(ctx context.Context, mention MaybeMention) (err error) { 9621 __arg := ResolveMaybeMentionArg{Mention: mention} 9622 err = c.Cli.Call(ctx, "chat.1.local.resolveMaybeMention", []interface{}{__arg}, nil, 0*time.Millisecond) 9623 return 9624} 9625 9626func (c LocalClient) LoadGallery(ctx context.Context, __arg LoadGalleryArg) (res LoadGalleryRes, err error) { 9627 err = c.Cli.Call(ctx, "chat.1.local.loadGallery", []interface{}{__arg}, &res, 0*time.Millisecond) 9628 return 9629} 9630 9631func (c LocalClient) LoadFlip(ctx context.Context, __arg LoadFlipArg) (res LoadFlipRes, err error) { 9632 err = c.Cli.Call(ctx, "chat.1.local.loadFlip", []interface{}{__arg}, &res, 0*time.Millisecond) 9633 return 9634} 9635 9636func (c LocalClient) LocationUpdate(ctx context.Context, coord Coordinate) (err error) { 9637 __arg := LocationUpdateArg{Coord: coord} 9638 err = c.Cli.Call(ctx, "chat.1.local.locationUpdate", []interface{}{__arg}, nil, 0*time.Millisecond) 9639 return 9640} 9641 9642func (c LocalClient) AdvertiseBotCommandsLocal(ctx context.Context, __arg AdvertiseBotCommandsLocalArg) (res AdvertiseBotCommandsLocalRes, err error) { 9643 err = c.Cli.Call(ctx, "chat.1.local.advertiseBotCommandsLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9644 return 9645} 9646 9647func (c LocalClient) ListBotCommandsLocal(ctx context.Context, convID ConversationID) (res ListBotCommandsLocalRes, err error) { 9648 __arg := ListBotCommandsLocalArg{ConvID: convID} 9649 err = c.Cli.Call(ctx, "chat.1.local.listBotCommandsLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9650 return 9651} 9652 9653func (c LocalClient) ListPublicBotCommandsLocal(ctx context.Context, username string) (res ListBotCommandsLocalRes, err error) { 9654 __arg := ListPublicBotCommandsLocalArg{Username: username} 9655 err = c.Cli.Call(ctx, "chat.1.local.listPublicBotCommandsLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9656 return 9657} 9658 9659func (c LocalClient) ClearBotCommandsLocal(ctx context.Context, filter *ClearBotCommandsFilter) (res ClearBotCommandsLocalRes, err error) { 9660 __arg := ClearBotCommandsLocalArg{Filter: filter} 9661 err = c.Cli.Call(ctx, "chat.1.local.clearBotCommandsLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9662 return 9663} 9664 9665func (c LocalClient) PinMessage(ctx context.Context, __arg PinMessageArg) (res PinMessageRes, err error) { 9666 err = c.Cli.Call(ctx, "chat.1.local.pinMessage", []interface{}{__arg}, &res, 0*time.Millisecond) 9667 return 9668} 9669 9670func (c LocalClient) UnpinMessage(ctx context.Context, convID ConversationID) (res PinMessageRes, err error) { 9671 __arg := UnpinMessageArg{ConvID: convID} 9672 err = c.Cli.Call(ctx, "chat.1.local.unpinMessage", []interface{}{__arg}, &res, 0*time.Millisecond) 9673 return 9674} 9675 9676func (c LocalClient) IgnorePinnedMessage(ctx context.Context, convID ConversationID) (err error) { 9677 __arg := IgnorePinnedMessageArg{ConvID: convID} 9678 err = c.Cli.Call(ctx, "chat.1.local.ignorePinnedMessage", []interface{}{__arg}, nil, 0*time.Millisecond) 9679 return 9680} 9681 9682func (c LocalClient) AddBotMember(ctx context.Context, __arg AddBotMemberArg) (err error) { 9683 err = c.Cli.Call(ctx, "chat.1.local.addBotMember", []interface{}{__arg}, nil, 0*time.Millisecond) 9684 return 9685} 9686 9687func (c LocalClient) EditBotMember(ctx context.Context, __arg EditBotMemberArg) (err error) { 9688 err = c.Cli.Call(ctx, "chat.1.local.editBotMember", []interface{}{__arg}, nil, 0*time.Millisecond) 9689 return 9690} 9691 9692func (c LocalClient) RemoveBotMember(ctx context.Context, __arg RemoveBotMemberArg) (err error) { 9693 err = c.Cli.Call(ctx, "chat.1.local.removeBotMember", []interface{}{__arg}, nil, 0*time.Millisecond) 9694 return 9695} 9696 9697func (c LocalClient) SetBotMemberSettings(ctx context.Context, __arg SetBotMemberSettingsArg) (err error) { 9698 err = c.Cli.Call(ctx, "chat.1.local.setBotMemberSettings", []interface{}{__arg}, nil, 0*time.Millisecond) 9699 return 9700} 9701 9702func (c LocalClient) GetBotMemberSettings(ctx context.Context, __arg GetBotMemberSettingsArg) (res keybase1.TeamBotSettings, err error) { 9703 err = c.Cli.Call(ctx, "chat.1.local.getBotMemberSettings", []interface{}{__arg}, &res, 0*time.Millisecond) 9704 return 9705} 9706 9707func (c LocalClient) GetTeamRoleInConversation(ctx context.Context, __arg GetTeamRoleInConversationArg) (res keybase1.TeamRole, err error) { 9708 err = c.Cli.Call(ctx, "chat.1.local.getTeamRoleInConversation", []interface{}{__arg}, &res, 0*time.Millisecond) 9709 return 9710} 9711 9712func (c LocalClient) AddBotConvSearch(ctx context.Context, term string) (res []ConvSearchHit, err error) { 9713 __arg := AddBotConvSearchArg{Term: term} 9714 err = c.Cli.Call(ctx, "chat.1.local.addBotConvSearch", []interface{}{__arg}, &res, 0*time.Millisecond) 9715 return 9716} 9717 9718func (c LocalClient) ForwardMessageConvSearch(ctx context.Context, term string) (res []ConvSearchHit, err error) { 9719 __arg := ForwardMessageConvSearchArg{Term: term} 9720 err = c.Cli.Call(ctx, "chat.1.local.forwardMessageConvSearch", []interface{}{__arg}, &res, 0*time.Millisecond) 9721 return 9722} 9723 9724func (c LocalClient) TeamIDFromTLFName(ctx context.Context, __arg TeamIDFromTLFNameArg) (res keybase1.TeamID, err error) { 9725 err = c.Cli.Call(ctx, "chat.1.local.teamIDFromTLFName", []interface{}{__arg}, &res, 0*time.Millisecond) 9726 return 9727} 9728 9729func (c LocalClient) DismissJourneycard(ctx context.Context, __arg DismissJourneycardArg) (err error) { 9730 err = c.Cli.Call(ctx, "chat.1.local.dismissJourneycard", []interface{}{__arg}, nil, 0*time.Millisecond) 9731 return 9732} 9733 9734func (c LocalClient) SetWelcomeMessage(ctx context.Context, __arg SetWelcomeMessageArg) (err error) { 9735 err = c.Cli.Call(ctx, "chat.1.local.setWelcomeMessage", []interface{}{__arg}, nil, 0*time.Millisecond) 9736 return 9737} 9738 9739func (c LocalClient) GetWelcomeMessage(ctx context.Context, teamID keybase1.TeamID) (res WelcomeMessageDisplay, err error) { 9740 __arg := GetWelcomeMessageArg{TeamID: teamID} 9741 err = c.Cli.Call(ctx, "chat.1.local.getWelcomeMessage", []interface{}{__arg}, &res, 0*time.Millisecond) 9742 return 9743} 9744 9745func (c LocalClient) GetDefaultTeamChannelsLocal(ctx context.Context, teamID keybase1.TeamID) (res GetDefaultTeamChannelsLocalRes, err error) { 9746 __arg := GetDefaultTeamChannelsLocalArg{TeamID: teamID} 9747 err = c.Cli.Call(ctx, "chat.1.local.getDefaultTeamChannelsLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9748 return 9749} 9750 9751func (c LocalClient) SetDefaultTeamChannelsLocal(ctx context.Context, __arg SetDefaultTeamChannelsLocalArg) (res SetDefaultTeamChannelsLocalRes, err error) { 9752 err = c.Cli.Call(ctx, "chat.1.local.setDefaultTeamChannelsLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9753 return 9754} 9755 9756func (c LocalClient) GetLastActiveForTLF(ctx context.Context, tlfID TLFIDStr) (res LastActiveStatus, err error) { 9757 __arg := GetLastActiveForTLFArg{TlfID: tlfID} 9758 err = c.Cli.Call(ctx, "chat.1.local.getLastActiveForTLF", []interface{}{__arg}, &res, 0*time.Millisecond) 9759 return 9760} 9761 9762func (c LocalClient) GetLastActiveForTeams(ctx context.Context) (res LastActiveStatusAll, err error) { 9763 err = c.Cli.Call(ctx, "chat.1.local.getLastActiveForTeams", []interface{}{GetLastActiveForTeamsArg{}}, &res, 0*time.Millisecond) 9764 return 9765} 9766 9767func (c LocalClient) GetRecentJoinsLocal(ctx context.Context, convID ConversationID) (res int, err error) { 9768 __arg := GetRecentJoinsLocalArg{ConvID: convID} 9769 err = c.Cli.Call(ctx, "chat.1.local.getRecentJoinsLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9770 return 9771} 9772 9773func (c LocalClient) RefreshParticipants(ctx context.Context, convID ConversationID) (err error) { 9774 __arg := RefreshParticipantsArg{ConvID: convID} 9775 err = c.Cli.Call(ctx, "chat.1.local.refreshParticipants", []interface{}{__arg}, nil, 0*time.Millisecond) 9776 return 9777} 9778 9779func (c LocalClient) GetLastActiveAtLocal(ctx context.Context, __arg GetLastActiveAtLocalArg) (res gregor1.Time, err error) { 9780 err = c.Cli.Call(ctx, "chat.1.local.getLastActiveAtLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9781 return 9782} 9783 9784func (c LocalClient) GetLastActiveAtMultiLocal(ctx context.Context, __arg GetLastActiveAtMultiLocalArg) (res map[keybase1.TeamID]gregor1.Time, err error) { 9785 err = c.Cli.Call(ctx, "chat.1.local.getLastActiveAtMultiLocal", []interface{}{__arg}, &res, 0*time.Millisecond) 9786 return 9787} 9788 9789func (c LocalClient) GetParticipants(ctx context.Context, convID ConversationID) (res []ConversationLocalParticipant, err error) { 9790 __arg := GetParticipantsArg{ConvID: convID} 9791 err = c.Cli.Call(ctx, "chat.1.local.getParticipants", []interface{}{__arg}, &res, 0*time.Millisecond) 9792 return 9793} 9794 9795func (c LocalClient) AddEmoji(ctx context.Context, __arg AddEmojiArg) (res AddEmojiRes, err error) { 9796 err = c.Cli.Call(ctx, "chat.1.local.addEmoji", []interface{}{__arg}, &res, 0*time.Millisecond) 9797 return 9798} 9799 9800func (c LocalClient) AddEmojis(ctx context.Context, __arg AddEmojisArg) (res AddEmojisRes, err error) { 9801 err = c.Cli.Call(ctx, "chat.1.local.addEmojis", []interface{}{__arg}, &res, 0*time.Millisecond) 9802 return 9803} 9804 9805func (c LocalClient) AddEmojiAlias(ctx context.Context, __arg AddEmojiAliasArg) (res AddEmojiAliasRes, err error) { 9806 err = c.Cli.Call(ctx, "chat.1.local.addEmojiAlias", []interface{}{__arg}, &res, 0*time.Millisecond) 9807 return 9808} 9809 9810func (c LocalClient) RemoveEmoji(ctx context.Context, __arg RemoveEmojiArg) (res RemoveEmojiRes, err error) { 9811 err = c.Cli.Call(ctx, "chat.1.local.removeEmoji", []interface{}{__arg}, &res, 0*time.Millisecond) 9812 return 9813} 9814 9815func (c LocalClient) UserEmojis(ctx context.Context, __arg UserEmojisArg) (res UserEmojiRes, err error) { 9816 err = c.Cli.Call(ctx, "chat.1.local.userEmojis", []interface{}{__arg}, &res, 0*time.Millisecond) 9817 return 9818} 9819 9820func (c LocalClient) ToggleEmojiAnimations(ctx context.Context, enabled bool) (err error) { 9821 __arg := ToggleEmojiAnimationsArg{Enabled: enabled} 9822 err = c.Cli.Call(ctx, "chat.1.local.toggleEmojiAnimations", []interface{}{__arg}, nil, 0*time.Millisecond) 9823 return 9824} 9825