|
|
|
// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
|
|
|
|
// Input file: ../client/protocol/avdl/chat1/chat_ui.avdl
|
|
|
|
|
|
|
|
package chat1
|
|
|
|
|
|
|
|
import (
|
|
|
|
gregor1 "samhofi.us/x/keybase/v2/types/gregor1"
|
|
|
|
keybase1 "samhofi.us/x/keybase/v2/types/keybase1"
|
|
|
|
stellar1 "samhofi.us/x/keybase/v2/types/stellar1"
|
|
|
|
"errors"
|
|
|
|
"fmt"
|
|
|
|
)
|
|
|
|
|
|
|
|
type UIPagination struct {
|
|
|
|
Next string `codec:"next" json:"next"`
|
|
|
|
Previous string `codec:"previous" json:"previous"`
|
|
|
|
Num int `codec:"num" json:"num"`
|
|
|
|
Last bool `codec:"last" json:"last"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIPagination) DeepCopy() UIPagination {
|
|
|
|
return UIPagination{
|
|
|
|
Next: o.Next,
|
|
|
|
Previous: o.Previous,
|
|
|
|
Num: o.Num,
|
|
|
|
Last: o.Last,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIInboxSmallTeamRow struct {
|
|
|
|
ConvID ConvIDStr `codec:"convID" json:"convID"`
|
|
|
|
Name string `codec:"name" json:"name"`
|
|
|
|
Time gregor1.Time `codec:"time" json:"time"`
|
|
|
|
Snippet *string `codec:"snippet,omitempty" json:"snippet,omitempty"`
|
|
|
|
SnippetDecoration SnippetDecoration `codec:"snippetDecoration" json:"snippetDecoration"`
|
|
|
|
Draft *string `codec:"draft,omitempty" json:"draft,omitempty"`
|
|
|
|
IsMuted bool `codec:"isMuted" json:"isMuted"`
|
|
|
|
IsTeam bool `codec:"isTeam" json:"isTeam"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIInboxSmallTeamRow) DeepCopy() UIInboxSmallTeamRow {
|
|
|
|
return UIInboxSmallTeamRow{
|
|
|
|
ConvID: o.ConvID.DeepCopy(),
|
|
|
|
Name: o.Name,
|
|
|
|
Time: o.Time.DeepCopy(),
|
|
|
|
Snippet: (func(x *string) *string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x)
|
|
|
|
return &tmp
|
|
|
|
})(o.Snippet),
|
|
|
|
SnippetDecoration: o.SnippetDecoration.DeepCopy(),
|
|
|
|
Draft: (func(x *string) *string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x)
|
|
|
|
return &tmp
|
|
|
|
})(o.Draft),
|
|
|
|
IsMuted: o.IsMuted,
|
|
|
|
IsTeam: o.IsTeam,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIInboxBigTeamRowTyp int
|
|
|
|
|
|
|
|
const (
|
|
|
|
UIInboxBigTeamRowTyp_LABEL UIInboxBigTeamRowTyp = 1
|
|
|
|
UIInboxBigTeamRowTyp_CHANNEL UIInboxBigTeamRowTyp = 2
|
|
|
|
)
|
|
|
|
|
|
|
|
func (o UIInboxBigTeamRowTyp) DeepCopy() UIInboxBigTeamRowTyp { return o }
|
|
|
|
|
|
|
|
var UIInboxBigTeamRowTypMap = map[string]UIInboxBigTeamRowTyp{
|
|
|
|
"LABEL": 1,
|
|
|
|
"CHANNEL": 2,
|
|
|
|
}
|
|
|
|
|
|
|
|
var UIInboxBigTeamRowTypRevMap = map[UIInboxBigTeamRowTyp]string{
|
|
|
|
1: "LABEL",
|
|
|
|
2: "CHANNEL",
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e UIInboxBigTeamRowTyp) String() string {
|
|
|
|
if v, ok := UIInboxBigTeamRowTypRevMap[e]; ok {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
return fmt.Sprintf("%v", int(e))
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIInboxBigTeamChannelRow struct {
|
|
|
|
ConvID ConvIDStr `codec:"convID" json:"convID"`
|
|
|
|
Teamname string `codec:"teamname" json:"teamname"`
|
|
|
|
Channelname string `codec:"channelname" json:"channelname"`
|
|
|
|
Draft *string `codec:"draft,omitempty" json:"draft,omitempty"`
|
|
|
|
IsMuted bool `codec:"isMuted" json:"isMuted"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIInboxBigTeamChannelRow) DeepCopy() UIInboxBigTeamChannelRow {
|
|
|
|
return UIInboxBigTeamChannelRow{
|
|
|
|
ConvID: o.ConvID.DeepCopy(),
|
|
|
|
Teamname: o.Teamname,
|
|
|
|
Channelname: o.Channelname,
|
|
|
|
Draft: (func(x *string) *string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x)
|
|
|
|
return &tmp
|
|
|
|
})(o.Draft),
|
|
|
|
IsMuted: o.IsMuted,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIInboxBigTeamLabelRow struct {
|
|
|
|
Name string `codec:"name" json:"name"`
|
|
|
|
Id TLFIDStr `codec:"id" json:"id"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIInboxBigTeamLabelRow) DeepCopy() UIInboxBigTeamLabelRow {
|
|
|
|
return UIInboxBigTeamLabelRow{
|
|
|
|
Name: o.Name,
|
|
|
|
Id: o.Id.DeepCopy(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIInboxBigTeamRow struct {
|
|
|
|
State__ UIInboxBigTeamRowTyp `codec:"state" json:"state"`
|
|
|
|
Label__ *UIInboxBigTeamLabelRow `codec:"label,omitempty" json:"label,omitempty"`
|
|
|
|
Channel__ *UIInboxBigTeamChannelRow `codec:"channel,omitempty" json:"channel,omitempty"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o *UIInboxBigTeamRow) State() (ret UIInboxBigTeamRowTyp, err error) {
|
|
|
|
switch o.State__ {
|
|
|
|
case UIInboxBigTeamRowTyp_LABEL:
|
|
|
|
if o.Label__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Label__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
case UIInboxBigTeamRowTyp_CHANNEL:
|
|
|
|
if o.Channel__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Channel__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return o.State__, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIInboxBigTeamRow) Label() (res UIInboxBigTeamLabelRow) {
|
|
|
|
if o.State__ != UIInboxBigTeamRowTyp_LABEL {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Label__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Label__
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIInboxBigTeamRow) Channel() (res UIInboxBigTeamChannelRow) {
|
|
|
|
if o.State__ != UIInboxBigTeamRowTyp_CHANNEL {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Channel__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Channel__
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUIInboxBigTeamRowWithLabel(v UIInboxBigTeamLabelRow) UIInboxBigTeamRow {
|
|
|
|
return UIInboxBigTeamRow{
|
|
|
|
State__: UIInboxBigTeamRowTyp_LABEL,
|
|
|
|
Label__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUIInboxBigTeamRowWithChannel(v UIInboxBigTeamChannelRow) UIInboxBigTeamRow {
|
|
|
|
return UIInboxBigTeamRow{
|
|
|
|
State__: UIInboxBigTeamRowTyp_CHANNEL,
|
|
|
|
Channel__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIInboxBigTeamRow) DeepCopy() UIInboxBigTeamRow {
|
|
|
|
return UIInboxBigTeamRow{
|
|
|
|
State__: o.State__.DeepCopy(),
|
|
|
|
Label__: (func(x *UIInboxBigTeamLabelRow) *UIInboxBigTeamLabelRow {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Label__),
|
|
|
|
Channel__: (func(x *UIInboxBigTeamChannelRow) *UIInboxBigTeamChannelRow {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Channel__),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIInboxReselectInfo struct {
|
|
|
|
OldConvID ConvIDStr `codec:"oldConvID" json:"oldConvID"`
|
|
|
|
NewConvID *ConvIDStr `codec:"newConvID,omitempty" json:"newConvID,omitempty"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIInboxReselectInfo) DeepCopy() UIInboxReselectInfo {
|
|
|
|
return UIInboxReselectInfo{
|
|
|
|
OldConvID: o.OldConvID.DeepCopy(),
|
|
|
|
NewConvID: (func(x *ConvIDStr) *ConvIDStr {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.NewConvID),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIInboxLayout struct {
|
|
|
|
TotalSmallTeams int `codec:"totalSmallTeams" json:"totalSmallTeams"`
|
|
|
|
SmallTeams []UIInboxSmallTeamRow `codec:"smallTeams" json:"smallTeams"`
|
|
|
|
BigTeams []UIInboxBigTeamRow `codec:"bigTeams" json:"bigTeams"`
|
|
|
|
ReselectInfo *UIInboxReselectInfo `codec:"reselectInfo,omitempty" json:"reselectInfo,omitempty"`
|
|
|
|
WidgetList []UIInboxSmallTeamRow `codec:"widgetList" json:"widgetList"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIInboxLayout) DeepCopy() UIInboxLayout {
|
|
|
|
return UIInboxLayout{
|
|
|
|
TotalSmallTeams: o.TotalSmallTeams,
|
|
|
|
SmallTeams: (func(x []UIInboxSmallTeamRow) []UIInboxSmallTeamRow {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]UIInboxSmallTeamRow, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.SmallTeams),
|
|
|
|
BigTeams: (func(x []UIInboxBigTeamRow) []UIInboxBigTeamRow {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]UIInboxBigTeamRow, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.BigTeams),
|
|
|
|
ReselectInfo: (func(x *UIInboxReselectInfo) *UIInboxReselectInfo {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.ReselectInfo),
|
|
|
|
WidgetList: (func(x []UIInboxSmallTeamRow) []UIInboxSmallTeamRow {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]UIInboxSmallTeamRow, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.WidgetList),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UnverifiedInboxUIItemMetadata struct {
|
|
|
|
ChannelName string `codec:"channelName" json:"channelName"`
|
|
|
|
Headline string `codec:"headline" json:"headline"`
|
|
|
|
HeadlineDecorated string `codec:"headlineDecorated" json:"headlineDecorated"`
|
|
|
|
Snippet string `codec:"snippet" json:"snippet"`
|
|
|
|
SnippetDecoration SnippetDecoration `codec:"snippetDecoration" json:"snippetDecoration"`
|
|
|
|
WriterNames []string `codec:"writerNames" json:"writerNames"`
|
|
|
|
ResetParticipants []string `codec:"resetParticipants" json:"resetParticipants"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UnverifiedInboxUIItemMetadata) DeepCopy() UnverifiedInboxUIItemMetadata {
|
|
|
|
return UnverifiedInboxUIItemMetadata{
|
|
|
|
ChannelName: o.ChannelName,
|
|
|
|
Headline: o.Headline,
|
|
|
|
HeadlineDecorated: o.HeadlineDecorated,
|
|
|
|
Snippet: o.Snippet,
|
|
|
|
SnippetDecoration: o.SnippetDecoration.DeepCopy(),
|
|
|
|
WriterNames: (func(x []string) []string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]string, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.WriterNames),
|
|
|
|
ResetParticipants: (func(x []string) []string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]string, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.ResetParticipants),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UnverifiedInboxUIItem struct {
|
|
|
|
ConvID ConvIDStr `codec:"convID" json:"convID"`
|
|
|
|
TlfID TLFIDStr `codec:"tlfID" json:"tlfID"`
|
|
|
|
TopicType TopicType `codec:"topicType" json:"topicType"`
|
|
|
|
IsPublic bool `codec:"isPublic" json:"isPublic"`
|
|
|
|
IsDefaultConv bool `codec:"isDefaultConv" json:"isDefaultConv"`
|
|
|
|
Name string `codec:"name" json:"name"`
|
|
|
|
Visibility keybase1.TLFVisibility `codec:"visibility" json:"visibility"`
|
|
|
|
Status ConversationStatus `codec:"status" json:"status"`
|
|
|
|
MembersType ConversationMembersType `codec:"membersType" json:"membersType"`
|
|
|
|
MemberStatus ConversationMemberStatus `codec:"memberStatus" json:"memberStatus"`
|
|
|
|
TeamType TeamType `codec:"teamType" json:"teamType"`
|
|
|
|
Notifications *ConversationNotificationInfo `codec:"notifications,omitempty" json:"notifications,omitempty"`
|
|
|
|
Time gregor1.Time `codec:"time" json:"time"`
|
|
|
|
Version ConversationVers `codec:"version" json:"version"`
|
|
|
|
LocalVersion LocalConversationVers `codec:"localVersion" json:"localVersion"`
|
|
|
|
ConvRetention *RetentionPolicy `codec:"convRetention,omitempty" json:"convRetention,omitempty"`
|
|
|
|
TeamRetention *RetentionPolicy `codec:"teamRetention,omitempty" json:"teamRetention,omitempty"`
|
|
|
|
MaxMsgID MessageID `codec:"maxMsgID" json:"maxMsgID"`
|
|
|
|
MaxVisibleMsgID MessageID `codec:"maxVisibleMsgID" json:"maxVisibleMsgID"`
|
|
|
|
ReadMsgID MessageID `codec:"readMsgID" json:"readMsgID"`
|
|
|
|
LocalMetadata *UnverifiedInboxUIItemMetadata `codec:"localMetadata,omitempty" json:"localMetadata,omitempty"`
|
|
|
|
Draft *string `codec:"draft,omitempty" json:"draft,omitempty"`
|
|
|
|
FinalizeInfo *ConversationFinalizeInfo `codec:"finalizeInfo,omitempty" json:"finalizeInfo,omitempty"`
|
|
|
|
Supersedes []ConversationMetadata `codec:"supersedes" json:"supersedes"`
|
|
|
|
SupersededBy []ConversationMetadata `codec:"supersededBy" json:"supersededBy"`
|
|
|
|
Commands ConversationCommandGroups `codec:"commands" json:"commands"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UnverifiedInboxUIItem) DeepCopy() UnverifiedInboxUIItem {
|
|
|
|
return UnverifiedInboxUIItem{
|
|
|
|
ConvID: o.ConvID.DeepCopy(),
|
|
|
|
TlfID: o.TlfID.DeepCopy(),
|
|
|
|
TopicType: o.TopicType.DeepCopy(),
|
|
|
|
IsPublic: o.IsPublic,
|
|
|
|
IsDefaultConv: o.IsDefaultConv,
|
|
|
|
Name: o.Name,
|
|
|
|
Visibility: o.Visibility.DeepCopy(),
|
|
|
|
Status: o.Status.DeepCopy(),
|
|
|
|
MembersType: o.MembersType.DeepCopy(),
|
|
|
|
MemberStatus: o.MemberStatus.DeepCopy(),
|
|
|
|
TeamType: o.TeamType.DeepCopy(),
|
|
|
|
Notifications: (func(x *ConversationNotificationInfo) *ConversationNotificationInfo {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Notifications),
|
|
|
|
Time: o.Time.DeepCopy(),
|
|
|
|
Version: o.Version.DeepCopy(),
|
|
|
|
LocalVersion: o.LocalVersion.DeepCopy(),
|
|
|
|
ConvRetention: (func(x *RetentionPolicy) *RetentionPolicy {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.ConvRetention),
|
|
|
|
TeamRetention: (func(x *RetentionPolicy) *RetentionPolicy {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.TeamRetention),
|
|
|
|
MaxMsgID: o.MaxMsgID.DeepCopy(),
|
|
|
|
MaxVisibleMsgID: o.MaxVisibleMsgID.DeepCopy(),
|
|
|
|
ReadMsgID: o.ReadMsgID.DeepCopy(),
|
|
|
|
LocalMetadata: (func(x *UnverifiedInboxUIItemMetadata) *UnverifiedInboxUIItemMetadata {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.LocalMetadata),
|
|
|
|
Draft: (func(x *string) *string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x)
|
|
|
|
return &tmp
|
|
|
|
})(o.Draft),
|
|
|
|
FinalizeInfo: (func(x *ConversationFinalizeInfo) *ConversationFinalizeInfo {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.FinalizeInfo),
|
|
|
|
Supersedes: (func(x []ConversationMetadata) []ConversationMetadata {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]ConversationMetadata, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.Supersedes),
|
|
|
|
SupersededBy: (func(x []ConversationMetadata) []ConversationMetadata {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]ConversationMetadata, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.SupersededBy),
|
|
|
|
Commands: o.Commands.DeepCopy(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UnverifiedInboxUIItems struct {
|
|
|
|
Items []UnverifiedInboxUIItem `codec:"items" json:"items"`
|
|
|
|
Offline bool `codec:"offline" json:"offline"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UnverifiedInboxUIItems) DeepCopy() UnverifiedInboxUIItems {
|
|
|
|
return UnverifiedInboxUIItems{
|
|
|
|
Items: (func(x []UnverifiedInboxUIItem) []UnverifiedInboxUIItem {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]UnverifiedInboxUIItem, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.Items),
|
|
|
|
Offline: o.Offline,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIParticipantType int
|
|
|
|
|
|
|
|
const (
|
|
|
|
UIParticipantType_NONE UIParticipantType = 0
|
|
|
|
UIParticipantType_USER UIParticipantType = 1
|
|
|
|
UIParticipantType_PHONENO UIParticipantType = 2
|
|
|
|
UIParticipantType_EMAIL UIParticipantType = 3
|
|
|
|
)
|
|
|
|
|
|
|
|
func (o UIParticipantType) DeepCopy() UIParticipantType { return o }
|
|
|
|
|
|
|
|
var UIParticipantTypeMap = map[string]UIParticipantType{
|
|
|
|
"NONE": 0,
|
|
|
|
"USER": 1,
|
|
|
|
"PHONENO": 2,
|
|
|
|
"EMAIL": 3,
|
|
|
|
}
|
|
|
|
|
|
|
|
var UIParticipantTypeRevMap = map[UIParticipantType]string{
|
|
|
|
0: "NONE",
|
|
|
|
1: "USER",
|
|
|
|
2: "PHONENO",
|
|
|
|
3: "EMAIL",
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e UIParticipantType) String() string {
|
|
|
|
if v, ok := UIParticipantTypeRevMap[e]; ok {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
return fmt.Sprintf("%v", int(e))
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIParticipant struct {
|
|
|
|
Type UIParticipantType `codec:"type" json:"type"`
|
|
|
|
Assertion string `codec:"assertion" json:"assertion"`
|
|
|
|
InConvName bool `codec:"inConvName" json:"inConvName"`
|
|
|
|
FullName *string `codec:"fullName,omitempty" json:"fullName,omitempty"`
|
|
|
|
ContactName *string `codec:"contactName,omitempty" json:"contactName,omitempty"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIParticipant) DeepCopy() UIParticipant {
|
|
|
|
return UIParticipant{
|
|
|
|
Type: o.Type.DeepCopy(),
|
|
|
|
Assertion: o.Assertion,
|
|
|
|
InConvName: o.InConvName,
|
|
|
|
FullName: (func(x *string) *string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x)
|
|
|
|
return &tmp
|
|
|
|
})(o.FullName),
|
|
|
|
ContactName: (func(x *string) *string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x)
|
|
|
|
return &tmp
|
|
|
|
})(o.ContactName),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIPinnedMessage struct {
|
|
|
|
Message UIMessage `codec:"message" json:"message"`
|
|
|
|
PinnerUsername string `codec:"pinnerUsername" json:"pinnerUsername"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIPinnedMessage) DeepCopy() UIPinnedMessage {
|
|
|
|
return UIPinnedMessage{
|
|
|
|
Message: o.Message.DeepCopy(),
|
|
|
|
PinnerUsername: o.PinnerUsername,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type InboxUIItem struct {
|
|
|
|
ConvID ConvIDStr `codec:"convID" json:"convID"`
|
|
|
|
TlfID TLFIDStr `codec:"tlfID" json:"tlfID"`
|
|
|
|
TopicType TopicType `codec:"topicType" json:"topicType"`
|
|
|
|
IsPublic bool `codec:"isPublic" json:"isPublic"`
|
|
|
|
IsEmpty bool `codec:"isEmpty" json:"isEmpty"`
|
|
|
|
IsDefaultConv bool `codec:"isDefaultConv" json:"isDefaultConv"`
|
|
|
|
Name string `codec:"name" json:"name"`
|
|
|
|
Snippet string `codec:"snippet" json:"snippet"`
|
|
|
|
SnippetDecorated string `codec:"snippetDecorated" json:"snippetDecorated"`
|
|
|
|
SnippetDecoration SnippetDecoration `codec:"snippetDecoration" json:"snippetDecoration"`
|
|
|
|
Channel string `codec:"channel" json:"channel"`
|
|
|
|
Headline string `codec:"headline" json:"headline"`
|
|
|
|
HeadlineDecorated string `codec:"headlineDecorated" json:"headlineDecorated"`
|
|
|
|
Draft *string `codec:"draft,omitempty" json:"draft,omitempty"`
|
|
|
|
Visibility keybase1.TLFVisibility `codec:"visibility" json:"visibility"`
|
|
|
|
Participants []UIParticipant `codec:"participants" json:"participants"`
|
|
|
|
ResetParticipants []string `codec:"resetParticipants" json:"resetParticipants"`
|
|
|
|
Status ConversationStatus `codec:"status" json:"status"`
|
|
|
|
MembersType ConversationMembersType `codec:"membersType" json:"membersType"`
|
|
|
|
MemberStatus ConversationMemberStatus `codec:"memberStatus" json:"memberStatus"`
|
|
|
|
TeamType TeamType `codec:"teamType" json:"teamType"`
|
|
|
|
Time gregor1.Time `codec:"time" json:"time"`
|
|
|
|
Notifications *ConversationNotificationInfo `codec:"notifications,omitempty" json:"notifications,omitempty"`
|
|
|
|
CreatorInfo *ConversationCreatorInfoLocal `codec:"creatorInfo,omitempty" json:"creatorInfo,omitempty"`
|
|
|
|
Version ConversationVers `codec:"version" json:"version"`
|
|
|
|
LocalVersion LocalConversationVers `codec:"localVersion" json:"localVersion"`
|
|
|
|
MaxMsgID MessageID `codec:"maxMsgID" json:"maxMsgID"`
|
|
|
|
MaxVisibleMsgID MessageID `codec:"maxVisibleMsgID" json:"maxVisibleMsgID"`
|
|
|
|
ReadMsgID MessageID `codec:"readMsgID" json:"readMsgID"`
|
|
|
|
ConvRetention *RetentionPolicy `codec:"convRetention,omitempty" json:"convRetention,omitempty"`
|
|
|
|
TeamRetention *RetentionPolicy `codec:"teamRetention,omitempty" json:"teamRetention,omitempty"`
|
|
|
|
ConvSettings *ConversationSettingsLocal `codec:"convSettings,omitempty" json:"convSettings,omitempty"`
|
|
|
|
FinalizeInfo *ConversationFinalizeInfo `codec:"finalizeInfo,omitempty" json:"finalizeInfo,omitempty"`
|
|
|
|
Supersedes []ConversationMetadata `codec:"supersedes" json:"supersedes"`
|
|
|
|
SupersededBy []ConversationMetadata `codec:"supersededBy" json:"supersededBy"`
|
|
|
|
Commands ConversationCommandGroups `codec:"commands" json:"commands"`
|
|
|
|
BotCommands ConversationCommandGroups `codec:"botCommands" json:"botCommands"`
|
|
|
|
BotAliases map[string]string `codec:"botAliases" json:"botAliases"`
|
|
|
|
PinnedMsg *UIPinnedMessage `codec:"pinnedMsg,omitempty" json:"pinnedMsg,omitempty"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o InboxUIItem) DeepCopy() InboxUIItem {
|
|
|
|
return InboxUIItem{
|
|
|
|
ConvID: o.ConvID.DeepCopy(),
|
|
|
|
TlfID: o.TlfID.DeepCopy(),
|
|
|
|
TopicType: o.TopicType.DeepCopy(),
|
|
|
|
IsPublic: o.IsPublic,
|
|
|
|
IsEmpty: o.IsEmpty,
|
|
|
|
IsDefaultConv: o.IsDefaultConv,
|
|
|
|
Name: o.Name,
|
|
|
|
Snippet: o.Snippet,
|
|
|
|
SnippetDecorated: o.SnippetDecorated,
|
|
|
|
SnippetDecoration: o.SnippetDecoration.DeepCopy(),
|
|
|
|
Channel: o.Channel,
|
|
|
|
Headline: o.Headline,
|
|
|
|
HeadlineDecorated: o.HeadlineDecorated,
|
|
|
|
Draft: (func(x *string) *string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x)
|
|
|
|
return &tmp
|
|
|
|
})(o.Draft),
|
|
|
|
Visibility: o.Visibility.DeepCopy(),
|
|
|
|
Participants: (func(x []UIParticipant) []UIParticipant {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]UIParticipant, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.Participants),
|
|
|
|
ResetParticipants: (func(x []string) []string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]string, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.ResetParticipants),
|
|
|
|
Status: o.Status.DeepCopy(),
|
|
|
|
MembersType: o.MembersType.DeepCopy(),
|
|
|
|
MemberStatus: o.MemberStatus.DeepCopy(),
|
|
|
|
TeamType: o.TeamType.DeepCopy(),
|
|
|
|
Time: o.Time.DeepCopy(),
|
|
|
|
Notifications: (func(x *ConversationNotificationInfo) *ConversationNotificationInfo {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Notifications),
|
|
|
|
CreatorInfo: (func(x *ConversationCreatorInfoLocal) *ConversationCreatorInfoLocal {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.CreatorInfo),
|
|
|
|
Version: o.Version.DeepCopy(),
|
|
|
|
LocalVersion: o.LocalVersion.DeepCopy(),
|
|
|
|
MaxMsgID: o.MaxMsgID.DeepCopy(),
|
|
|
|
MaxVisibleMsgID: o.MaxVisibleMsgID.DeepCopy(),
|
|
|
|
ReadMsgID: o.ReadMsgID.DeepCopy(),
|
|
|
|
ConvRetention: (func(x *RetentionPolicy) *RetentionPolicy {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.ConvRetention),
|
|
|
|
TeamRetention: (func(x *RetentionPolicy) *RetentionPolicy {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.TeamRetention),
|
|
|
|
ConvSettings: (func(x *ConversationSettingsLocal) *ConversationSettingsLocal {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.ConvSettings),
|
|
|
|
FinalizeInfo: (func(x *ConversationFinalizeInfo) *ConversationFinalizeInfo {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.FinalizeInfo),
|
|
|
|
Supersedes: (func(x []ConversationMetadata) []ConversationMetadata {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]ConversationMetadata, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.Supersedes),
|
|
|
|
SupersededBy: (func(x []ConversationMetadata) []ConversationMetadata {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]ConversationMetadata, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.SupersededBy),
|
|
|
|
Commands: o.Commands.DeepCopy(),
|
|
|
|
BotCommands: o.BotCommands.DeepCopy(),
|
|
|
|
BotAliases: (func(x map[string]string) map[string]string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make(map[string]string, len(x))
|
|
|
|
for k, v := range x {
|
|
|
|
kCopy := k
|
|
|
|
vCopy := v
|
|
|
|
ret[kCopy] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.BotAliases),
|
|
|
|
PinnedMsg: (func(x *UIPinnedMessage) *UIPinnedMessage {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.PinnedMsg),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type InboxUIItemError struct {
|
|
|
|
Typ ConversationErrorType `codec:"typ" json:"typ"`
|
|
|
|
Message string `codec:"message" json:"message"`
|
|
|
|
UnverifiedTLFName string `codec:"unverifiedTLFName" json:"unverifiedTLFName"`
|
|
|
|
RekeyInfo *ConversationErrorRekey `codec:"rekeyInfo,omitempty" json:"rekeyInfo,omitempty"`
|
|
|
|
RemoteConv UnverifiedInboxUIItem `codec:"remoteConv" json:"remoteConv"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o InboxUIItemError) DeepCopy() InboxUIItemError {
|
|
|
|
return InboxUIItemError{
|
|
|
|
Typ: o.Typ.DeepCopy(),
|
|
|
|
Message: o.Message,
|
|
|
|
UnverifiedTLFName: o.UnverifiedTLFName,
|
|
|
|
RekeyInfo: (func(x *ConversationErrorRekey) *ConversationErrorRekey {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.RekeyInfo),
|
|
|
|
RemoteConv: o.RemoteConv.DeepCopy(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type InboxUIItems struct {
|
|
|
|
Items []InboxUIItem `codec:"items" json:"items"`
|
|
|
|
Offline bool `codec:"offline" json:"offline"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o InboxUIItems) DeepCopy() InboxUIItems {
|
|
|
|
return InboxUIItems{
|
|
|
|
Items: (func(x []InboxUIItem) []InboxUIItem {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]InboxUIItem, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.Items),
|
|
|
|
Offline: o.Offline,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIChannelNameMention struct {
|
|
|
|
Name string `codec:"name" json:"name"`
|
|
|
|
ConvID ConvIDStr `codec:"convID" json:"convID"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIChannelNameMention) DeepCopy() UIChannelNameMention {
|
|
|
|
return UIChannelNameMention{
|
|
|
|
Name: o.Name,
|
|
|
|
ConvID: o.ConvID.DeepCopy(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIAssetUrlInfo struct {
|
|
|
|
PreviewUrl string `codec:"previewUrl" json:"previewUrl"`
|
|
|
|
FullUrl string `codec:"fullUrl" json:"fullUrl"`
|
|
|
|
FullUrlCached bool `codec:"fullUrlCached" json:"fullUrlCached"`
|
|
|
|
MimeType string `codec:"mimeType" json:"mimeType"`
|
|
|
|
VideoDuration *string `codec:"videoDuration,omitempty" json:"videoDuration,omitempty"`
|
|
|
|
InlineVideoPlayable bool `codec:"inlineVideoPlayable" json:"inlineVideoPlayable"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIAssetUrlInfo) DeepCopy() UIAssetUrlInfo {
|
|
|
|
return UIAssetUrlInfo{
|
|
|
|
PreviewUrl: o.PreviewUrl,
|
|
|
|
FullUrl: o.FullUrl,
|
|
|
|
FullUrlCached: o.FullUrlCached,
|
|
|
|
MimeType: o.MimeType,
|
|
|
|
VideoDuration: (func(x *string) *string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x)
|
|
|
|
return &tmp
|
|
|
|
})(o.VideoDuration),
|
|
|
|
InlineVideoPlayable: o.InlineVideoPlayable,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIPaymentInfo struct {
|
|
|
|
AccountID *stellar1.AccountID `codec:"accountID,omitempty" json:"accountID,omitempty"`
|
|
|
|
AmountDescription string `codec:"amountDescription" json:"amountDescription"`
|
|
|
|
Worth string `codec:"worth" json:"worth"`
|
|
|
|
WorthAtSendTime string `codec:"worthAtSendTime" json:"worthAtSendTime"`
|
|
|
|
Delta stellar1.BalanceDelta `codec:"delta" json:"delta"`
|
|
|
|
Note string `codec:"note" json:"note"`
|
|
|
|
PaymentID stellar1.PaymentID `codec:"paymentID" json:"paymentID"`
|
|
|
|
Status stellar1.PaymentStatus `codec:"status" json:"status"`
|
|
|
|
StatusDescription string `codec:"statusDescription" json:"statusDescription"`
|
|
|
|
StatusDetail string `codec:"statusDetail" json:"statusDetail"`
|
|
|
|
ShowCancel bool `codec:"showCancel" json:"showCancel"`
|
|
|
|
FromUsername string `codec:"fromUsername" json:"fromUsername"`
|
|
|
|
ToUsername string `codec:"toUsername" json:"toUsername"`
|
|
|
|
SourceAmount string `codec:"sourceAmount" json:"sourceAmount"`
|
|
|
|
SourceAsset stellar1.Asset `codec:"sourceAsset" json:"sourceAsset"`
|
|
|
|
IssuerDescription string `codec:"issuerDescription" json:"issuerDescription"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIPaymentInfo) DeepCopy() UIPaymentInfo {
|
|
|
|
return UIPaymentInfo{
|
|
|
|
AccountID: (func(x *stellar1.AccountID) *stellar1.AccountID {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.AccountID),
|
|
|
|
AmountDescription: o.AmountDescription,
|
|
|
|
Worth: o.Worth,
|
|
|
|
WorthAtSendTime: o.WorthAtSendTime,
|
|
|
|
Delta: o.Delta.DeepCopy(),
|
|
|
|
Note: o.Note,
|
|
|
|
PaymentID: o.PaymentID.DeepCopy(),
|
|
|
|
Status: o.Status.DeepCopy(),
|
|
|
|
StatusDescription: o.StatusDescription,
|
|
|
|
StatusDetail: o.StatusDetail,
|
|
|
|
ShowCancel: o.ShowCancel,
|
|
|
|
FromUsername: o.FromUsername,
|
|
|
|
ToUsername: o.ToUsername,
|
|
|
|
SourceAmount: o.SourceAmount,
|
|
|
|
SourceAsset: o.SourceAsset.DeepCopy(),
|
|
|
|
IssuerDescription: o.IssuerDescription,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIRequestInfo struct {
|
|
|
|
Amount string `codec:"amount" json:"amount"`
|
|
|
|
AmountDescription string `codec:"amountDescription" json:"amountDescription"`
|
|
|
|
Asset *stellar1.Asset `codec:"asset,omitempty" json:"asset,omitempty"`
|
|
|
|
Currency *stellar1.OutsideCurrencyCode `codec:"currency,omitempty" json:"currency,omitempty"`
|
|
|
|
WorthAtRequestTime string `codec:"worthAtRequestTime" json:"worthAtRequestTime"`
|
|
|
|
Status stellar1.RequestStatus `codec:"status" json:"status"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIRequestInfo) DeepCopy() UIRequestInfo {
|
|
|
|
return UIRequestInfo{
|
|
|
|
Amount: o.Amount,
|
|
|
|
AmountDescription: o.AmountDescription,
|
|
|
|
Asset: (func(x *stellar1.Asset) *stellar1.Asset {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Asset),
|
|
|
|
Currency: (func(x *stellar1.OutsideCurrencyCode) *stellar1.OutsideCurrencyCode {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Currency),
|
|
|
|
WorthAtRequestTime: o.WorthAtRequestTime,
|
|
|
|
Status: o.Status.DeepCopy(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIMessageUnfurlInfo struct {
|
|
|
|
UnfurlMessageID MessageID `codec:"unfurlMessageID" json:"unfurlMessageID"`
|
|
|
|
Url string `codec:"url" json:"url"`
|
|
|
|
Unfurl UnfurlDisplay `codec:"unfurl" json:"unfurl"`
|
|
|
|
IsCollapsed bool `codec:"isCollapsed" json:"isCollapsed"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIMessageUnfurlInfo) DeepCopy() UIMessageUnfurlInfo {
|
|
|
|
return UIMessageUnfurlInfo{
|
|
|
|
UnfurlMessageID: o.UnfurlMessageID.DeepCopy(),
|
|
|
|
Url: o.Url,
|
|
|
|
Unfurl: o.Unfurl.DeepCopy(),
|
|
|
|
IsCollapsed: o.IsCollapsed,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIReactionDesc struct {
|
|
|
|
Decorated string `codec:"decorated" json:"decorated"`
|
|
|
|
Users map[string]Reaction `codec:"users" json:"users"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIReactionDesc) DeepCopy() UIReactionDesc {
|
|
|
|
return UIReactionDesc{
|
|
|
|
Decorated: o.Decorated,
|
|
|
|
Users: (func(x map[string]Reaction) map[string]Reaction {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make(map[string]Reaction, len(x))
|
|
|
|
for k, v := range x {
|
|
|
|
kCopy := k
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[kCopy] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.Users),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIReactionMap struct {
|
|
|
|
Reactions map[string]UIReactionDesc `codec:"reactions" json:"reactions"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIReactionMap) DeepCopy() UIReactionMap {
|
|
|
|
return UIReactionMap{
|
|
|
|
Reactions: (func(x map[string]UIReactionDesc) map[string]UIReactionDesc {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make(map[string]UIReactionDesc, len(x))
|
|
|
|
for k, v := range x {
|
|
|
|
kCopy := k
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[kCopy] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.Reactions),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIMessageValid struct {
|
|
|
|
MessageID MessageID `codec:"messageID" json:"messageID"`
|
|
|
|
Ctime gregor1.Time `codec:"ctime" json:"ctime"`
|
|
|
|
OutboxID *string `codec:"outboxID,omitempty" json:"outboxID,omitempty"`
|
|
|
|
MessageBody MessageBody `codec:"messageBody" json:"messageBody"`
|
|
|
|
DecoratedTextBody *string `codec:"decoratedTextBody,omitempty" json:"decoratedTextBody,omitempty"`
|
|
|
|
BodySummary string `codec:"bodySummary" json:"bodySummary"`
|
|
|
|
SenderUsername string `codec:"senderUsername" json:"senderUsername"`
|
|
|
|
SenderDeviceName string `codec:"senderDeviceName" json:"senderDeviceName"`
|
|
|
|
SenderDeviceType keybase1.DeviceTypeV2 `codec:"senderDeviceType" json:"senderDeviceType"`
|
|
|
|
SenderUID gregor1.UID `codec:"senderUID" json:"senderUID"`
|
|
|
|
SenderDeviceID gregor1.DeviceID `codec:"senderDeviceID" json:"senderDeviceID"`
|
|
|
|
Superseded bool `codec:"superseded" json:"superseded"`
|
|
|
|
AssetUrlInfo *UIAssetUrlInfo `codec:"assetUrlInfo,omitempty" json:"assetUrlInfo,omitempty"`
|
|
|
|
SenderDeviceRevokedAt *gregor1.Time `codec:"senderDeviceRevokedAt,omitempty" json:"senderDeviceRevokedAt,omitempty"`
|
|
|
|
AtMentions []string `codec:"atMentions" json:"atMentions"`
|
|
|
|
ChannelMention ChannelMention `codec:"channelMention" json:"channelMention"`
|
|
|
|
ChannelNameMentions []UIChannelNameMention `codec:"channelNameMentions" json:"channelNameMentions"`
|
|
|
|
IsEphemeral bool `codec:"isEphemeral" json:"isEphemeral"`
|
|
|
|
IsEphemeralExpired bool `codec:"isEphemeralExpired" json:"isEphemeralExpired"`
|
|
|
|
ExplodedBy *string `codec:"explodedBy,omitempty" json:"explodedBy,omitempty"`
|
|
|
|
Etime gregor1.Time `codec:"etime" json:"etime"`
|
|
|
|
Reactions UIReactionMap `codec:"reactions" json:"reactions"`
|
|
|
|
HasPairwiseMacs bool `codec:"hasPairwiseMacs" json:"hasPairwiseMacs"`
|
|
|
|
PaymentInfos []UIPaymentInfo `codec:"paymentInfos" json:"paymentInfos"`
|
|
|
|
RequestInfo *UIRequestInfo `codec:"requestInfo,omitempty" json:"requestInfo,omitempty"`
|
|
|
|
Unfurls []UIMessageUnfurlInfo `codec:"unfurls" json:"unfurls"`
|
|
|
|
IsCollapsed bool `codec:"isCollapsed" json:"isCollapsed"`
|
|
|
|
FlipGameID *FlipGameIDStr `codec:"flipGameID,omitempty" json:"flipGameID,omitempty"`
|
|
|
|
IsDeleteable bool `codec:"isDeleteable" json:"isDeleteable"`
|
|
|
|
IsEditable bool `codec:"isEditable" json:"isEditable"`
|
|
|
|
ReplyTo *UIMessage `codec:"replyTo,omitempty" json:"replyTo,omitempty"`
|
|
|
|
PinnedMessageID *MessageID `codec:"pinnedMessageID,omitempty" json:"pinnedMessageID,omitempty"`
|
|
|
|
BotUsername string `codec:"botUsername" json:"botUsername"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIMessageValid) DeepCopy() UIMessageValid {
|
|
|
|
return UIMessageValid{
|
|
|
|
MessageID: o.MessageID.DeepCopy(),
|
|
|
|
Ctime: o.Ctime.DeepCopy(),
|
|
|
|
OutboxID: (func(x *string) *string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x)
|
|
|
|
return &tmp
|
|
|
|
})(o.OutboxID),
|
|
|
|
MessageBody: o.MessageBody.DeepCopy(),
|
|
|
|
DecoratedTextBody: (func(x *string) *string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x)
|
|
|
|
return &tmp
|
|
|
|
})(o.DecoratedTextBody),
|
|
|
|
BodySummary: o.BodySummary,
|
|
|
|
SenderUsername: o.SenderUsername,
|
|
|
|
SenderDeviceName: o.SenderDeviceName,
|
|
|
|
SenderDeviceType: o.SenderDeviceType.DeepCopy(),
|
|
|
|
SenderUID: o.SenderUID.DeepCopy(),
|
|
|
|
SenderDeviceID: o.SenderDeviceID.DeepCopy(),
|
|
|
|
Superseded: o.Superseded,
|
|
|
|
AssetUrlInfo: (func(x *UIAssetUrlInfo) *UIAssetUrlInfo {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.AssetUrlInfo),
|
|
|
|
SenderDeviceRevokedAt: (func(x *gregor1.Time) *gregor1.Time {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.SenderDeviceRevokedAt),
|
|
|
|
AtMentions: (func(x []string) []string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]string, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.AtMentions),
|
|
|
|
ChannelMention: o.ChannelMention.DeepCopy(),
|
|
|
|
ChannelNameMentions: (func(x []UIChannelNameMention) []UIChannelNameMention {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]UIChannelNameMention, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.ChannelNameMentions),
|
|
|
|
IsEphemeral: o.IsEphemeral,
|
|
|
|
IsEphemeralExpired: o.IsEphemeralExpired,
|
|
|
|
ExplodedBy: (func(x *string) *string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x)
|
|
|
|
return &tmp
|
|
|
|
})(o.ExplodedBy),
|
|
|
|
Etime: o.Etime.DeepCopy(),
|
|
|
|
Reactions: o.Reactions.DeepCopy(),
|
|
|
|
HasPairwiseMacs: o.HasPairwiseMacs,
|
|
|
|
PaymentInfos: (func(x []UIPaymentInfo) []UIPaymentInfo {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]UIPaymentInfo, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.PaymentInfos),
|
|
|
|
RequestInfo: (func(x *UIRequestInfo) *UIRequestInfo {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.RequestInfo),
|
|
|
|
Unfurls: (func(x []UIMessageUnfurlInfo) []UIMessageUnfurlInfo {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]UIMessageUnfurlInfo, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.Unfurls),
|
|
|
|
IsCollapsed: o.IsCollapsed,
|
|
|
|
FlipGameID: (func(x *FlipGameIDStr) *FlipGameIDStr {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.FlipGameID),
|
|
|
|
IsDeleteable: o.IsDeleteable,
|
|
|
|
IsEditable: o.IsEditable,
|
|
|
|
ReplyTo: (func(x *UIMessage) *UIMessage {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.ReplyTo),
|
|
|
|
PinnedMessageID: (func(x *MessageID) *MessageID {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.PinnedMessageID),
|
|
|
|
BotUsername: o.BotUsername,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIMessageOutbox struct {
|
|
|
|
State OutboxState `codec:"state" json:"state"`
|
|
|
|
OutboxID string `codec:"outboxID" json:"outboxID"`
|
|
|
|
MessageType MessageType `codec:"messageType" json:"messageType"`
|
|
|
|
Body string `codec:"body" json:"body"`
|
|
|
|
DecoratedTextBody *string `codec:"decoratedTextBody,omitempty" json:"decoratedTextBody,omitempty"`
|
|
|
|
Ctime gregor1.Time `codec:"ctime" json:"ctime"`
|
|
|
|
Ordinal float64 `codec:"ordinal" json:"ordinal"`
|
|
|
|
IsEphemeral bool `codec:"isEphemeral" json:"isEphemeral"`
|
|
|
|
FlipGameID *FlipGameIDStr `codec:"flipGameID,omitempty" json:"flipGameID,omitempty"`
|
|
|
|
ReplyTo *UIMessage `codec:"replyTo,omitempty" json:"replyTo,omitempty"`
|
|
|
|
Supersedes MessageID `codec:"supersedes" json:"supersedes"`
|
|
|
|
Filename string `codec:"filename" json:"filename"`
|
|
|
|
Title string `codec:"title" json:"title"`
|
|
|
|
Preview *MakePreviewRes `codec:"preview,omitempty" json:"preview,omitempty"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIMessageOutbox) DeepCopy() UIMessageOutbox {
|
|
|
|
return UIMessageOutbox{
|
|
|
|
State: o.State.DeepCopy(),
|
|
|
|
OutboxID: o.OutboxID,
|
|
|
|
MessageType: o.MessageType.DeepCopy(),
|
|
|
|
Body: o.Body,
|
|
|
|
DecoratedTextBody: (func(x *string) *string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x)
|
|
|
|
return &tmp
|
|
|
|
})(o.DecoratedTextBody),
|
|
|
|
Ctime: o.Ctime.DeepCopy(),
|
|
|
|
Ordinal: o.Ordinal,
|
|
|
|
IsEphemeral: o.IsEphemeral,
|
|
|
|
FlipGameID: (func(x *FlipGameIDStr) *FlipGameIDStr {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.FlipGameID),
|
|
|
|
ReplyTo: (func(x *UIMessage) *UIMessage {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.ReplyTo),
|
|
|
|
Supersedes: o.Supersedes.DeepCopy(),
|
|
|
|
Filename: o.Filename,
|
|
|
|
Title: o.Title,
|
|
|
|
Preview: (func(x *MakePreviewRes) *MakePreviewRes {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Preview),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIMessageJourneycard struct {
|
|
|
|
Ordinal float64 `codec:"ordinal" json:"ordinal"`
|
|
|
|
CardType JourneycardType `codec:"cardType" json:"cardType"`
|
|
|
|
HighlightMsgID MessageID `codec:"highlightMsgID" json:"highlightMsgID"`
|
|
|
|
OpenTeam bool `codec:"openTeam" json:"openTeam"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIMessageJourneycard) DeepCopy() UIMessageJourneycard {
|
|
|
|
return UIMessageJourneycard{
|
|
|
|
Ordinal: o.Ordinal,
|
|
|
|
CardType: o.CardType.DeepCopy(),
|
|
|
|
HighlightMsgID: o.HighlightMsgID.DeepCopy(),
|
|
|
|
OpenTeam: o.OpenTeam,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type MessageUnboxedState int
|
|
|
|
|
|
|
|
const (
|
|
|
|
MessageUnboxedState_VALID MessageUnboxedState = 1
|
|
|
|
MessageUnboxedState_ERROR MessageUnboxedState = 2
|
|
|
|
MessageUnboxedState_OUTBOX MessageUnboxedState = 3
|
|
|
|
MessageUnboxedState_PLACEHOLDER MessageUnboxedState = 4
|
|
|
|
MessageUnboxedState_JOURNEYCARD MessageUnboxedState = 5
|
|
|
|
)
|
|
|
|
|
|
|
|
func (o MessageUnboxedState) DeepCopy() MessageUnboxedState { return o }
|
|
|
|
|
|
|
|
var MessageUnboxedStateMap = map[string]MessageUnboxedState{
|
|
|
|
"VALID": 1,
|
|
|
|
"ERROR": 2,
|
|
|
|
"OUTBOX": 3,
|
|
|
|
"PLACEHOLDER": 4,
|
|
|
|
"JOURNEYCARD": 5,
|
|
|
|
}
|
|
|
|
|
|
|
|
var MessageUnboxedStateRevMap = map[MessageUnboxedState]string{
|
|
|
|
1: "VALID",
|
|
|
|
2: "ERROR",
|
|
|
|
3: "OUTBOX",
|
|
|
|
4: "PLACEHOLDER",
|
|
|
|
5: "JOURNEYCARD",
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e MessageUnboxedState) String() string {
|
|
|
|
if v, ok := MessageUnboxedStateRevMap[e]; ok {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
return fmt.Sprintf("%v", int(e))
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIMessage struct {
|
|
|
|
State__ MessageUnboxedState `codec:"state" json:"state"`
|
|
|
|
Valid__ *UIMessageValid `codec:"valid,omitempty" json:"valid,omitempty"`
|
|
|
|
Error__ *MessageUnboxedError `codec:"error,omitempty" json:"error,omitempty"`
|
|
|
|
Outbox__ *UIMessageOutbox `codec:"outbox,omitempty" json:"outbox,omitempty"`
|
|
|
|
Placeholder__ *MessageUnboxedPlaceholder `codec:"placeholder,omitempty" json:"placeholder,omitempty"`
|
|
|
|
Journeycard__ *UIMessageJourneycard `codec:"journeycard,omitempty" json:"journeycard,omitempty"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o *UIMessage) State() (ret MessageUnboxedState, err error) {
|
|
|
|
switch o.State__ {
|
|
|
|
case MessageUnboxedState_VALID:
|
|
|
|
if o.Valid__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Valid__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
case MessageUnboxedState_ERROR:
|
|
|
|
if o.Error__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Error__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
case MessageUnboxedState_OUTBOX:
|
|
|
|
if o.Outbox__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Outbox__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
case MessageUnboxedState_PLACEHOLDER:
|
|
|
|
if o.Placeholder__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Placeholder__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
case MessageUnboxedState_JOURNEYCARD:
|
|
|
|
if o.Journeycard__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Journeycard__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return o.State__, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIMessage) Valid() (res UIMessageValid) {
|
|
|
|
if o.State__ != MessageUnboxedState_VALID {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Valid__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Valid__
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIMessage) Error() (res MessageUnboxedError) {
|
|
|
|
if o.State__ != MessageUnboxedState_ERROR {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Error__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Error__
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIMessage) Outbox() (res UIMessageOutbox) {
|
|
|
|
if o.State__ != MessageUnboxedState_OUTBOX {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Outbox__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Outbox__
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIMessage) Placeholder() (res MessageUnboxedPlaceholder) {
|
|
|
|
if o.State__ != MessageUnboxedState_PLACEHOLDER {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Placeholder__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Placeholder__
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIMessage) Journeycard() (res UIMessageJourneycard) {
|
|
|
|
if o.State__ != MessageUnboxedState_JOURNEYCARD {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Journeycard__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Journeycard__
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUIMessageWithValid(v UIMessageValid) UIMessage {
|
|
|
|
return UIMessage{
|
|
|
|
State__: MessageUnboxedState_VALID,
|
|
|
|
Valid__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUIMessageWithError(v MessageUnboxedError) UIMessage {
|
|
|
|
return UIMessage{
|
|
|
|
State__: MessageUnboxedState_ERROR,
|
|
|
|
Error__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUIMessageWithOutbox(v UIMessageOutbox) UIMessage {
|
|
|
|
return UIMessage{
|
|
|
|
State__: MessageUnboxedState_OUTBOX,
|
|
|
|
Outbox__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUIMessageWithPlaceholder(v MessageUnboxedPlaceholder) UIMessage {
|
|
|
|
return UIMessage{
|
|
|
|
State__: MessageUnboxedState_PLACEHOLDER,
|
|
|
|
Placeholder__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUIMessageWithJourneycard(v UIMessageJourneycard) UIMessage {
|
|
|
|
return UIMessage{
|
|
|
|
State__: MessageUnboxedState_JOURNEYCARD,
|
|
|
|
Journeycard__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIMessage) DeepCopy() UIMessage {
|
|
|
|
return UIMessage{
|
|
|
|
State__: o.State__.DeepCopy(),
|
|
|
|
Valid__: (func(x *UIMessageValid) *UIMessageValid {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Valid__),
|
|
|
|
Error__: (func(x *MessageUnboxedError) *MessageUnboxedError {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Error__),
|
|
|
|
Outbox__: (func(x *UIMessageOutbox) *UIMessageOutbox {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Outbox__),
|
|
|
|
Placeholder__: (func(x *MessageUnboxedPlaceholder) *MessageUnboxedPlaceholder {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Placeholder__),
|
|
|
|
Journeycard__: (func(x *UIMessageJourneycard) *UIMessageJourneycard {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Journeycard__),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIMessages struct {
|
|
|
|
Messages []UIMessage `codec:"messages" json:"messages"`
|
|
|
|
Pagination *UIPagination `codec:"pagination,omitempty" json:"pagination,omitempty"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIMessages) DeepCopy() UIMessages {
|
|
|
|
return UIMessages{
|
|
|
|
Messages: (func(x []UIMessage) []UIMessage {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]UIMessage, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.Messages),
|
|
|
|
Pagination: (func(x *UIPagination) *UIPagination {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Pagination),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UITeamMention struct {
|
|
|
|
InTeam bool `codec:"inTeam" json:"inTeam"`
|
|
|
|
Open bool `codec:"open" json:"open"`
|
|
|
|
Description *string `codec:"description,omitempty" json:"description,omitempty"`
|
|
|
|
NumMembers *int `codec:"numMembers,omitempty" json:"numMembers,omitempty"`
|
|
|
|
PublicAdmins []string `codec:"publicAdmins" json:"publicAdmins"`
|
|
|
|
ConvID *ConvIDStr `codec:"convID,omitempty" json:"convID,omitempty"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UITeamMention) DeepCopy() UITeamMention {
|
|
|
|
return UITeamMention{
|
|
|
|
InTeam: o.InTeam,
|
|
|
|
Open: o.Open,
|
|
|
|
Description: (func(x *string) *string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x)
|
|
|
|
return &tmp
|
|
|
|
})(o.Description),
|
|
|
|
NumMembers: (func(x *int) *int {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x)
|
|
|
|
return &tmp
|
|
|
|
})(o.NumMembers),
|
|
|
|
PublicAdmins: (func(x []string) []string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]string, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.PublicAdmins),
|
|
|
|
ConvID: (func(x *ConvIDStr) *ConvIDStr {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.ConvID),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UITextDecorationTyp int
|
|
|
|
|
|
|
|
const (
|
|
|
|
UITextDecorationTyp_PAYMENT UITextDecorationTyp = 0
|
|
|
|
UITextDecorationTyp_ATMENTION UITextDecorationTyp = 1
|
|
|
|
UITextDecorationTyp_CHANNELNAMEMENTION UITextDecorationTyp = 2
|
|
|
|
UITextDecorationTyp_MAYBEMENTION UITextDecorationTyp = 3
|
|
|
|
UITextDecorationTyp_LINK UITextDecorationTyp = 4
|
|
|
|
UITextDecorationTyp_MAILTO UITextDecorationTyp = 5
|
|
|
|
UITextDecorationTyp_KBFSPATH UITextDecorationTyp = 6
|
|
|
|
UITextDecorationTyp_EMOJI UITextDecorationTyp = 7
|
|
|
|
)
|
|
|
|
|
|
|
|
func (o UITextDecorationTyp) DeepCopy() UITextDecorationTyp { return o }
|
|
|
|
|
|
|
|
var UITextDecorationTypMap = map[string]UITextDecorationTyp{
|
|
|
|
"PAYMENT": 0,
|
|
|
|
"ATMENTION": 1,
|
|
|
|
"CHANNELNAMEMENTION": 2,
|
|
|
|
"MAYBEMENTION": 3,
|
|
|
|
"LINK": 4,
|
|
|
|
"MAILTO": 5,
|
|
|
|
"KBFSPATH": 6,
|
|
|
|
"EMOJI": 7,
|
|
|
|
}
|
|
|
|
|
|
|
|
var UITextDecorationTypRevMap = map[UITextDecorationTyp]string{
|
|
|
|
0: "PAYMENT",
|
|
|
|
1: "ATMENTION",
|
|
|
|
2: "CHANNELNAMEMENTION",
|
|
|
|
3: "MAYBEMENTION",
|
|
|
|
4: "LINK",
|
|
|
|
5: "MAILTO",
|
|
|
|
6: "KBFSPATH",
|
|
|
|
7: "EMOJI",
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e UITextDecorationTyp) String() string {
|
|
|
|
if v, ok := UITextDecorationTypRevMap[e]; ok {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
return fmt.Sprintf("%v", int(e))
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIMaybeMentionStatus int
|
|
|
|
|
|
|
|
const (
|
|
|
|
UIMaybeMentionStatus_UNKNOWN UIMaybeMentionStatus = 0
|
|
|
|
UIMaybeMentionStatus_USER UIMaybeMentionStatus = 1
|
|
|
|
UIMaybeMentionStatus_TEAM UIMaybeMentionStatus = 2
|
|
|
|
UIMaybeMentionStatus_NOTHING UIMaybeMentionStatus = 3
|
|
|
|
)
|
|
|
|
|
|
|
|
func (o UIMaybeMentionStatus) DeepCopy() UIMaybeMentionStatus { return o }
|
|
|
|
|
|
|
|
var UIMaybeMentionStatusMap = map[string]UIMaybeMentionStatus{
|
|
|
|
"UNKNOWN": 0,
|
|
|
|
"USER": 1,
|
|
|
|
"TEAM": 2,
|
|
|
|
"NOTHING": 3,
|
|
|
|
}
|
|
|
|
|
|
|
|
var UIMaybeMentionStatusRevMap = map[UIMaybeMentionStatus]string{
|
|
|
|
0: "UNKNOWN",
|
|
|
|
1: "USER",
|
|
|
|
2: "TEAM",
|
|
|
|
3: "NOTHING",
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e UIMaybeMentionStatus) String() string {
|
|
|
|
if v, ok := UIMaybeMentionStatusRevMap[e]; ok {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
return fmt.Sprintf("%v", int(e))
|
|
|
|
}
|
|
|
|
|
|
|
|
type UILinkDecoration struct {
|
|
|
|
Url string `codec:"url" json:"url"`
|
|
|
|
Punycode string `codec:"punycode" json:"punycode"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UILinkDecoration) DeepCopy() UILinkDecoration {
|
|
|
|
return UILinkDecoration{
|
|
|
|
Url: o.Url,
|
|
|
|
Punycode: o.Punycode,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIMaybeMentionInfo struct {
|
|
|
|
Status__ UIMaybeMentionStatus `codec:"status" json:"status"`
|
|
|
|
Team__ *UITeamMention `codec:"team,omitempty" json:"team,omitempty"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o *UIMaybeMentionInfo) Status() (ret UIMaybeMentionStatus, err error) {
|
|
|
|
switch o.Status__ {
|
|
|
|
case UIMaybeMentionStatus_TEAM:
|
|
|
|
if o.Team__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Team__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return o.Status__, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIMaybeMentionInfo) Team() (res UITeamMention) {
|
|
|
|
if o.Status__ != UIMaybeMentionStatus_TEAM {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Team__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Team__
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUIMaybeMentionInfoWithUnknown() UIMaybeMentionInfo {
|
|
|
|
return UIMaybeMentionInfo{
|
|
|
|
Status__: UIMaybeMentionStatus_UNKNOWN,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUIMaybeMentionInfoWithUser() UIMaybeMentionInfo {
|
|
|
|
return UIMaybeMentionInfo{
|
|
|
|
Status__: UIMaybeMentionStatus_USER,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUIMaybeMentionInfoWithTeam(v UITeamMention) UIMaybeMentionInfo {
|
|
|
|
return UIMaybeMentionInfo{
|
|
|
|
Status__: UIMaybeMentionStatus_TEAM,
|
|
|
|
Team__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUIMaybeMentionInfoWithNothing() UIMaybeMentionInfo {
|
|
|
|
return UIMaybeMentionInfo{
|
|
|
|
Status__: UIMaybeMentionStatus_NOTHING,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIMaybeMentionInfo) DeepCopy() UIMaybeMentionInfo {
|
|
|
|
return UIMaybeMentionInfo{
|
|
|
|
Status__: o.Status__.DeepCopy(),
|
|
|
|
Team__: (func(x *UITeamMention) *UITeamMention {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Team__),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UITextDecoration struct {
|
|
|
|
Typ__ UITextDecorationTyp `codec:"typ" json:"typ"`
|
|
|
|
Payment__ *TextPayment `codec:"payment,omitempty" json:"payment,omitempty"`
|
|
|
|
Atmention__ *string `codec:"atmention,omitempty" json:"atmention,omitempty"`
|
|
|
|
Channelnamemention__ *UIChannelNameMention `codec:"channelnamemention,omitempty" json:"channelnamemention,omitempty"`
|
|
|
|
Maybemention__ *MaybeMention `codec:"maybemention,omitempty" json:"maybemention,omitempty"`
|
|
|
|
Link__ *UILinkDecoration `codec:"link,omitempty" json:"link,omitempty"`
|
|
|
|
Mailto__ *UILinkDecoration `codec:"mailto,omitempty" json:"mailto,omitempty"`
|
|
|
|
Kbfspath__ *KBFSPath `codec:"kbfspath,omitempty" json:"kbfspath,omitempty"`
|
|
|
|
Emoji__ *Emoji `codec:"emoji,omitempty" json:"emoji,omitempty"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o *UITextDecoration) Typ() (ret UITextDecorationTyp, err error) {
|
|
|
|
switch o.Typ__ {
|
|
|
|
case UITextDecorationTyp_PAYMENT:
|
|
|
|
if o.Payment__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Payment__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
case UITextDecorationTyp_ATMENTION:
|
|
|
|
if o.Atmention__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Atmention__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
case UITextDecorationTyp_CHANNELNAMEMENTION:
|
|
|
|
if o.Channelnamemention__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Channelnamemention__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
case UITextDecorationTyp_MAYBEMENTION:
|
|
|
|
if o.Maybemention__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Maybemention__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
case UITextDecorationTyp_LINK:
|
|
|
|
if o.Link__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Link__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
case UITextDecorationTyp_MAILTO:
|
|
|
|
if o.Mailto__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Mailto__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
case UITextDecorationTyp_KBFSPATH:
|
|
|
|
if o.Kbfspath__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Kbfspath__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
case UITextDecorationTyp_EMOJI:
|
|
|
|
if o.Emoji__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Emoji__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return o.Typ__, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UITextDecoration) Payment() (res TextPayment) {
|
|
|
|
if o.Typ__ != UITextDecorationTyp_PAYMENT {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Payment__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Payment__
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UITextDecoration) Atmention() (res string) {
|
|
|
|
if o.Typ__ != UITextDecorationTyp_ATMENTION {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Atmention__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Atmention__
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UITextDecoration) Channelnamemention() (res UIChannelNameMention) {
|
|
|
|
if o.Typ__ != UITextDecorationTyp_CHANNELNAMEMENTION {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Channelnamemention__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Channelnamemention__
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UITextDecoration) Maybemention() (res MaybeMention) {
|
|
|
|
if o.Typ__ != UITextDecorationTyp_MAYBEMENTION {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Maybemention__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Maybemention__
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UITextDecoration) Link() (res UILinkDecoration) {
|
|
|
|
if o.Typ__ != UITextDecorationTyp_LINK {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Link__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Link__
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UITextDecoration) Mailto() (res UILinkDecoration) {
|
|
|
|
if o.Typ__ != UITextDecorationTyp_MAILTO {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Mailto__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Mailto__
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UITextDecoration) Kbfspath() (res KBFSPath) {
|
|
|
|
if o.Typ__ != UITextDecorationTyp_KBFSPATH {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Kbfspath__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Kbfspath__
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UITextDecoration) Emoji() (res Emoji) {
|
|
|
|
if o.Typ__ != UITextDecorationTyp_EMOJI {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Emoji__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Emoji__
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUITextDecorationWithPayment(v TextPayment) UITextDecoration {
|
|
|
|
return UITextDecoration{
|
|
|
|
Typ__: UITextDecorationTyp_PAYMENT,
|
|
|
|
Payment__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUITextDecorationWithAtmention(v string) UITextDecoration {
|
|
|
|
return UITextDecoration{
|
|
|
|
Typ__: UITextDecorationTyp_ATMENTION,
|
|
|
|
Atmention__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUITextDecorationWithChannelnamemention(v UIChannelNameMention) UITextDecoration {
|
|
|
|
return UITextDecoration{
|
|
|
|
Typ__: UITextDecorationTyp_CHANNELNAMEMENTION,
|
|
|
|
Channelnamemention__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUITextDecorationWithMaybemention(v MaybeMention) UITextDecoration {
|
|
|
|
return UITextDecoration{
|
|
|
|
Typ__: UITextDecorationTyp_MAYBEMENTION,
|
|
|
|
Maybemention__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUITextDecorationWithLink(v UILinkDecoration) UITextDecoration {
|
|
|
|
return UITextDecoration{
|
|
|
|
Typ__: UITextDecorationTyp_LINK,
|
|
|
|
Link__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUITextDecorationWithMailto(v UILinkDecoration) UITextDecoration {
|
|
|
|
return UITextDecoration{
|
|
|
|
Typ__: UITextDecorationTyp_MAILTO,
|
|
|
|
Mailto__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUITextDecorationWithKbfspath(v KBFSPath) UITextDecoration {
|
|
|
|
return UITextDecoration{
|
|
|
|
Typ__: UITextDecorationTyp_KBFSPATH,
|
|
|
|
Kbfspath__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUITextDecorationWithEmoji(v Emoji) UITextDecoration {
|
|
|
|
return UITextDecoration{
|
|
|
|
Typ__: UITextDecorationTyp_EMOJI,
|
|
|
|
Emoji__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UITextDecoration) DeepCopy() UITextDecoration {
|
|
|
|
return UITextDecoration{
|
|
|
|
Typ__: o.Typ__.DeepCopy(),
|
|
|
|
Payment__: (func(x *TextPayment) *TextPayment {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Payment__),
|
|
|
|
Atmention__: (func(x *string) *string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x)
|
|
|
|
return &tmp
|
|
|
|
})(o.Atmention__),
|
|
|
|
Channelnamemention__: (func(x *UIChannelNameMention) *UIChannelNameMention {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Channelnamemention__),
|
|
|
|
Maybemention__: (func(x *MaybeMention) *MaybeMention {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Maybemention__),
|
|
|
|
Link__: (func(x *UILinkDecoration) *UILinkDecoration {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Link__),
|
|
|
|
Mailto__: (func(x *UILinkDecoration) *UILinkDecoration {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Mailto__),
|
|
|
|
Kbfspath__: (func(x *KBFSPath) *KBFSPath {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Kbfspath__),
|
|
|
|
Emoji__: (func(x *Emoji) *Emoji {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Emoji__),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIChatThreadStatusTyp int
|
|
|
|
|
|
|
|
const (
|
|
|
|
UIChatThreadStatusTyp_NONE UIChatThreadStatusTyp = 0
|
|
|
|
UIChatThreadStatusTyp_SERVER UIChatThreadStatusTyp = 1
|
|
|
|
UIChatThreadStatusTyp_VALIDATING UIChatThreadStatusTyp = 2
|
|
|
|
UIChatThreadStatusTyp_VALIDATED UIChatThreadStatusTyp = 3
|
|
|
|
)
|
|
|
|
|
|
|
|
func (o UIChatThreadStatusTyp) DeepCopy() UIChatThreadStatusTyp { return o }
|
|
|
|
|
|
|
|
var UIChatThreadStatusTypMap = map[string]UIChatThreadStatusTyp{
|
|
|
|
"NONE": 0,
|
|
|
|
"SERVER": 1,
|
|
|
|
"VALIDATING": 2,
|
|
|
|
"VALIDATED": 3,
|
|
|
|
}
|
|
|
|
|
|
|
|
var UIChatThreadStatusTypRevMap = map[UIChatThreadStatusTyp]string{
|
|
|
|
0: "NONE",
|
|
|
|
1: "SERVER",
|
|
|
|
2: "VALIDATING",
|
|
|
|
3: "VALIDATED",
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e UIChatThreadStatusTyp) String() string {
|
|
|
|
if v, ok := UIChatThreadStatusTypRevMap[e]; ok {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
return fmt.Sprintf("%v", int(e))
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIChatThreadStatus struct {
|
|
|
|
Typ__ UIChatThreadStatusTyp `codec:"typ" json:"typ"`
|
|
|
|
Validating__ *int `codec:"validating,omitempty" json:"validating,omitempty"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o *UIChatThreadStatus) Typ() (ret UIChatThreadStatusTyp, err error) {
|
|
|
|
switch o.Typ__ {
|
|
|
|
case UIChatThreadStatusTyp_VALIDATING:
|
|
|
|
if o.Validating__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Validating__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return o.Typ__, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIChatThreadStatus) Validating() (res int) {
|
|
|
|
if o.Typ__ != UIChatThreadStatusTyp_VALIDATING {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Validating__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Validating__
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUIChatThreadStatusWithNone() UIChatThreadStatus {
|
|
|
|
return UIChatThreadStatus{
|
|
|
|
Typ__: UIChatThreadStatusTyp_NONE,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUIChatThreadStatusWithServer() UIChatThreadStatus {
|
|
|
|
return UIChatThreadStatus{
|
|
|
|
Typ__: UIChatThreadStatusTyp_SERVER,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUIChatThreadStatusWithValidating(v int) UIChatThreadStatus {
|
|
|
|
return UIChatThreadStatus{
|
|
|
|
Typ__: UIChatThreadStatusTyp_VALIDATING,
|
|
|
|
Validating__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUIChatThreadStatusWithValidated() UIChatThreadStatus {
|
|
|
|
return UIChatThreadStatus{
|
|
|
|
Typ__: UIChatThreadStatusTyp_VALIDATED,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIChatThreadStatus) DeepCopy() UIChatThreadStatus {
|
|
|
|
return UIChatThreadStatus{
|
|
|
|
Typ__: o.Typ__.DeepCopy(),
|
|
|
|
Validating__: (func(x *int) *int {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x)
|
|
|
|
return &tmp
|
|
|
|
})(o.Validating__),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIChatSearchConvHit struct {
|
|
|
|
ConvID ConvIDStr `codec:"convID" json:"convID"`
|
|
|
|
TeamType TeamType `codec:"teamType" json:"teamType"`
|
|
|
|
Name string `codec:"name" json:"name"`
|
|
|
|
Mtime gregor1.Time `codec:"mtime" json:"mtime"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIChatSearchConvHit) DeepCopy() UIChatSearchConvHit {
|
|
|
|
return UIChatSearchConvHit{
|
|
|
|
ConvID: o.ConvID.DeepCopy(),
|
|
|
|
TeamType: o.TeamType.DeepCopy(),
|
|
|
|
Name: o.Name,
|
|
|
|
Mtime: o.Mtime.DeepCopy(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIChatSearchConvHits struct {
|
|
|
|
Hits []UIChatSearchConvHit `codec:"hits" json:"hits"`
|
|
|
|
UnreadMatches bool `codec:"unreadMatches" json:"unreadMatches"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIChatSearchConvHits) DeepCopy() UIChatSearchConvHits {
|
|
|
|
return UIChatSearchConvHits{
|
|
|
|
Hits: (func(x []UIChatSearchConvHit) []UIChatSearchConvHit {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]UIChatSearchConvHit, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.Hits),
|
|
|
|
UnreadMatches: o.UnreadMatches,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIChatSearchTeamHits struct {
|
|
|
|
Hits []keybase1.TeamSearchItem `codec:"hits" json:"hits"`
|
|
|
|
SuggestedMatches bool `codec:"suggestedMatches" json:"suggestedMatches"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIChatSearchTeamHits) DeepCopy() UIChatSearchTeamHits {
|
|
|
|
return UIChatSearchTeamHits{
|
|
|
|
Hits: (func(x []keybase1.TeamSearchItem) []keybase1.TeamSearchItem {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]keybase1.TeamSearchItem, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.Hits),
|
|
|
|
SuggestedMatches: o.SuggestedMatches,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIChatSearchBotHits struct {
|
|
|
|
Hits []keybase1.FeaturedBot `codec:"hits" json:"hits"`
|
|
|
|
SuggestedMatches bool `codec:"suggestedMatches" json:"suggestedMatches"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIChatSearchBotHits) DeepCopy() UIChatSearchBotHits {
|
|
|
|
return UIChatSearchBotHits{
|
|
|
|
Hits: (func(x []keybase1.FeaturedBot) []keybase1.FeaturedBot {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]keybase1.FeaturedBot, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.Hits),
|
|
|
|
SuggestedMatches: o.SuggestedMatches,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIChatPayment struct {
|
|
|
|
Username string `codec:"username" json:"username"`
|
|
|
|
FullName string `codec:"fullName" json:"fullName"`
|
|
|
|
XlmAmount string `codec:"xlmAmount" json:"xlmAmount"`
|
|
|
|
Error *string `codec:"error,omitempty" json:"error,omitempty"`
|
|
|
|
DisplayAmount *string `codec:"displayAmount,omitempty" json:"displayAmount,omitempty"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIChatPayment) DeepCopy() UIChatPayment {
|
|
|
|
return UIChatPayment{
|
|
|
|
Username: o.Username,
|
|
|
|
FullName: o.FullName,
|
|
|
|
XlmAmount: o.XlmAmount,
|
|
|
|
Error: (func(x *string) *string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x)
|
|
|
|
return &tmp
|
|
|
|
})(o.Error),
|
|
|
|
DisplayAmount: (func(x *string) *string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x)
|
|
|
|
return &tmp
|
|
|
|
})(o.DisplayAmount),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIChatPaymentSummary struct {
|
|
|
|
XlmTotal string `codec:"xlmTotal" json:"xlmTotal"`
|
|
|
|
DisplayTotal string `codec:"displayTotal" json:"displayTotal"`
|
|
|
|
Payments []UIChatPayment `codec:"payments" json:"payments"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIChatPaymentSummary) DeepCopy() UIChatPaymentSummary {
|
|
|
|
return UIChatPaymentSummary{
|
|
|
|
XlmTotal: o.XlmTotal,
|
|
|
|
DisplayTotal: o.DisplayTotal,
|
|
|
|
Payments: (func(x []UIChatPayment) []UIChatPayment {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]UIChatPayment, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.Payments),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type GiphySearchResult struct {
|
|
|
|
TargetUrl string `codec:"targetUrl" json:"targetUrl"`
|
|
|
|
PreviewUrl string `codec:"previewUrl" json:"previewUrl"`
|
|
|
|
PreviewWidth int `codec:"previewWidth" json:"previewWidth"`
|
|
|
|
PreviewHeight int `codec:"previewHeight" json:"previewHeight"`
|
|
|
|
PreviewIsVideo bool `codec:"previewIsVideo" json:"previewIsVideo"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o GiphySearchResult) DeepCopy() GiphySearchResult {
|
|
|
|
return GiphySearchResult{
|
|
|
|
TargetUrl: o.TargetUrl,
|
|
|
|
PreviewUrl: o.PreviewUrl,
|
|
|
|
PreviewWidth: o.PreviewWidth,
|
|
|
|
PreviewHeight: o.PreviewHeight,
|
|
|
|
PreviewIsVideo: o.PreviewIsVideo,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type GiphySearchResults struct {
|
|
|
|
Results []GiphySearchResult `codec:"results" json:"results"`
|
|
|
|
GalleryUrl string `codec:"galleryUrl" json:"galleryUrl"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o GiphySearchResults) DeepCopy() GiphySearchResults {
|
|
|
|
return GiphySearchResults{
|
|
|
|
Results: (func(x []GiphySearchResult) []GiphySearchResult {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]GiphySearchResult, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.Results),
|
|
|
|
GalleryUrl: o.GalleryUrl,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UICoinFlipPhase int
|
|
|
|
|
|
|
|
const (
|
|
|
|
UICoinFlipPhase_COMMITMENT UICoinFlipPhase = 0
|
|
|
|
UICoinFlipPhase_REVEALS UICoinFlipPhase = 1
|
|
|
|
UICoinFlipPhase_COMPLETE UICoinFlipPhase = 2
|
|
|
|
UICoinFlipPhase_ERROR UICoinFlipPhase = 3
|
|
|
|
)
|
|
|
|
|
|
|
|
func (o UICoinFlipPhase) DeepCopy() UICoinFlipPhase { return o }
|
|
|
|
|
|
|
|
var UICoinFlipPhaseMap = map[string]UICoinFlipPhase{
|
|
|
|
"COMMITMENT": 0,
|
|
|
|
"REVEALS": 1,
|
|
|
|
"COMPLETE": 2,
|
|
|
|
"ERROR": 3,
|
|
|
|
}
|
|
|
|
|
|
|
|
var UICoinFlipPhaseRevMap = map[UICoinFlipPhase]string{
|
|
|
|
0: "COMMITMENT",
|
|
|
|
1: "REVEALS",
|
|
|
|
2: "COMPLETE",
|
|
|
|
3: "ERROR",
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e UICoinFlipPhase) String() string {
|
|
|
|
if v, ok := UICoinFlipPhaseRevMap[e]; ok {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
return fmt.Sprintf("%v", int(e))
|
|
|
|
}
|
|
|
|
|
|
|
|
type UICoinFlipErrorParticipant struct {
|
|
|
|
User string `codec:"user" json:"user"`
|
|
|
|
Device string `codec:"device" json:"device"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UICoinFlipErrorParticipant) DeepCopy() UICoinFlipErrorParticipant {
|
|
|
|
return UICoinFlipErrorParticipant{
|
|
|
|
User: o.User,
|
|
|
|
Device: o.Device,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UICoinFlipAbsenteeError struct {
|
|
|
|
Absentees []UICoinFlipErrorParticipant `codec:"absentees" json:"absentees"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UICoinFlipAbsenteeError) DeepCopy() UICoinFlipAbsenteeError {
|
|
|
|
return UICoinFlipAbsenteeError{
|
|
|
|
Absentees: (func(x []UICoinFlipErrorParticipant) []UICoinFlipErrorParticipant {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]UICoinFlipErrorParticipant, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.Absentees),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UICoinFlipErrorTyp int
|
|
|
|
|
|
|
|
const (
|
|
|
|
UICoinFlipErrorTyp_GENERIC UICoinFlipErrorTyp = 0
|
|
|
|
UICoinFlipErrorTyp_ABSENTEE UICoinFlipErrorTyp = 1
|
|
|
|
UICoinFlipErrorTyp_TIMEOUT UICoinFlipErrorTyp = 2
|
|
|
|
UICoinFlipErrorTyp_ABORTED UICoinFlipErrorTyp = 3
|
|
|
|
UICoinFlipErrorTyp_DUPREG UICoinFlipErrorTyp = 4
|
|
|
|
UICoinFlipErrorTyp_DUPCOMMITCOMPLETE UICoinFlipErrorTyp = 5
|
|
|
|
UICoinFlipErrorTyp_DUPREVEAL UICoinFlipErrorTyp = 6
|
|
|
|
UICoinFlipErrorTyp_COMMITMISMATCH UICoinFlipErrorTyp = 7
|
|
|
|
)
|
|
|
|
|
|
|
|
func (o UICoinFlipErrorTyp) DeepCopy() UICoinFlipErrorTyp { return o }
|
|
|
|
|
|
|
|
var UICoinFlipErrorTypMap = map[string]UICoinFlipErrorTyp{
|
|
|
|
"GENERIC": 0,
|
|
|
|
"ABSENTEE": 1,
|
|
|
|
"TIMEOUT": 2,
|
|
|
|
"ABORTED": 3,
|
|
|
|
"DUPREG": 4,
|
|
|
|
"DUPCOMMITCOMPLETE": 5,
|
|
|
|
"DUPREVEAL": 6,
|
|
|
|
"COMMITMISMATCH": 7,
|
|
|
|
}
|
|
|
|
|
|
|
|
var UICoinFlipErrorTypRevMap = map[UICoinFlipErrorTyp]string{
|
|
|
|
0: "GENERIC",
|
|
|
|
1: "ABSENTEE",
|
|
|
|
2: "TIMEOUT",
|
|
|
|
3: "ABORTED",
|
|
|
|
4: "DUPREG",
|
|
|
|
5: "DUPCOMMITCOMPLETE",
|
|
|
|
6: "DUPREVEAL",
|
|
|
|
7: "COMMITMISMATCH",
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e UICoinFlipErrorTyp) String() string {
|
|
|
|
if v, ok := UICoinFlipErrorTypRevMap[e]; ok {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
return fmt.Sprintf("%v", int(e))
|
|
|
|
}
|
|
|
|
|
|
|
|
type UICoinFlipError struct {
|
|
|
|
Typ__ UICoinFlipErrorTyp `codec:"typ" json:"typ"`
|
|
|
|
Generic__ *string `codec:"generic,omitempty" json:"generic,omitempty"`
|
|
|
|
Absentee__ *UICoinFlipAbsenteeError `codec:"absentee,omitempty" json:"absentee,omitempty"`
|
|
|
|
Dupreg__ *UICoinFlipErrorParticipant `codec:"dupreg,omitempty" json:"dupreg,omitempty"`
|
|
|
|
Dupcommitcomplete__ *UICoinFlipErrorParticipant `codec:"dupcommitcomplete,omitempty" json:"dupcommitcomplete,omitempty"`
|
|
|
|
Dupreveal__ *UICoinFlipErrorParticipant `codec:"dupreveal,omitempty" json:"dupreveal,omitempty"`
|
|
|
|
Commitmismatch__ *UICoinFlipErrorParticipant `codec:"commitmismatch,omitempty" json:"commitmismatch,omitempty"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o *UICoinFlipError) Typ() (ret UICoinFlipErrorTyp, err error) {
|
|
|
|
switch o.Typ__ {
|
|
|
|
case UICoinFlipErrorTyp_GENERIC:
|
|
|
|
if o.Generic__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Generic__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
case UICoinFlipErrorTyp_ABSENTEE:
|
|
|
|
if o.Absentee__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Absentee__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
case UICoinFlipErrorTyp_DUPREG:
|
|
|
|
if o.Dupreg__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Dupreg__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
case UICoinFlipErrorTyp_DUPCOMMITCOMPLETE:
|
|
|
|
if o.Dupcommitcomplete__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Dupcommitcomplete__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
case UICoinFlipErrorTyp_DUPREVEAL:
|
|
|
|
if o.Dupreveal__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Dupreveal__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
case UICoinFlipErrorTyp_COMMITMISMATCH:
|
|
|
|
if o.Commitmismatch__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Commitmismatch__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return o.Typ__, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UICoinFlipError) Generic() (res string) {
|
|
|
|
if o.Typ__ != UICoinFlipErrorTyp_GENERIC {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Generic__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Generic__
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UICoinFlipError) Absentee() (res UICoinFlipAbsenteeError) {
|
|
|
|
if o.Typ__ != UICoinFlipErrorTyp_ABSENTEE {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Absentee__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Absentee__
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UICoinFlipError) Dupreg() (res UICoinFlipErrorParticipant) {
|
|
|
|
if o.Typ__ != UICoinFlipErrorTyp_DUPREG {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Dupreg__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Dupreg__
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UICoinFlipError) Dupcommitcomplete() (res UICoinFlipErrorParticipant) {
|
|
|
|
if o.Typ__ != UICoinFlipErrorTyp_DUPCOMMITCOMPLETE {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Dupcommitcomplete__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Dupcommitcomplete__
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UICoinFlipError) Dupreveal() (res UICoinFlipErrorParticipant) {
|
|
|
|
if o.Typ__ != UICoinFlipErrorTyp_DUPREVEAL {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Dupreveal__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Dupreveal__
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UICoinFlipError) Commitmismatch() (res UICoinFlipErrorParticipant) {
|
|
|
|
if o.Typ__ != UICoinFlipErrorTyp_COMMITMISMATCH {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Commitmismatch__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Commitmismatch__
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUICoinFlipErrorWithGeneric(v string) UICoinFlipError {
|
|
|
|
return UICoinFlipError{
|
|
|
|
Typ__: UICoinFlipErrorTyp_GENERIC,
|
|
|
|
Generic__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUICoinFlipErrorWithAbsentee(v UICoinFlipAbsenteeError) UICoinFlipError {
|
|
|
|
return UICoinFlipError{
|
|
|
|
Typ__: UICoinFlipErrorTyp_ABSENTEE,
|
|
|
|
Absentee__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUICoinFlipErrorWithTimeout() UICoinFlipError {
|
|
|
|
return UICoinFlipError{
|
|
|
|
Typ__: UICoinFlipErrorTyp_TIMEOUT,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUICoinFlipErrorWithAborted() UICoinFlipError {
|
|
|
|
return UICoinFlipError{
|
|
|
|
Typ__: UICoinFlipErrorTyp_ABORTED,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUICoinFlipErrorWithDupreg(v UICoinFlipErrorParticipant) UICoinFlipError {
|
|
|
|
return UICoinFlipError{
|
|
|
|
Typ__: UICoinFlipErrorTyp_DUPREG,
|
|
|
|
Dupreg__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUICoinFlipErrorWithDupcommitcomplete(v UICoinFlipErrorParticipant) UICoinFlipError {
|
|
|
|
return UICoinFlipError{
|
|
|
|
Typ__: UICoinFlipErrorTyp_DUPCOMMITCOMPLETE,
|
|
|
|
Dupcommitcomplete__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUICoinFlipErrorWithDupreveal(v UICoinFlipErrorParticipant) UICoinFlipError {
|
|
|
|
return UICoinFlipError{
|
|
|
|
Typ__: UICoinFlipErrorTyp_DUPREVEAL,
|
|
|
|
Dupreveal__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUICoinFlipErrorWithCommitmismatch(v UICoinFlipErrorParticipant) UICoinFlipError {
|
|
|
|
return UICoinFlipError{
|
|
|
|
Typ__: UICoinFlipErrorTyp_COMMITMISMATCH,
|
|
|
|
Commitmismatch__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UICoinFlipError) DeepCopy() UICoinFlipError {
|
|
|
|
return UICoinFlipError{
|
|
|
|
Typ__: o.Typ__.DeepCopy(),
|
|
|
|
Generic__: (func(x *string) *string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x)
|
|
|
|
return &tmp
|
|
|
|
})(o.Generic__),
|
|
|
|
Absentee__: (func(x *UICoinFlipAbsenteeError) *UICoinFlipAbsenteeError {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Absentee__),
|
|
|
|
Dupreg__: (func(x *UICoinFlipErrorParticipant) *UICoinFlipErrorParticipant {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Dupreg__),
|
|
|
|
Dupcommitcomplete__: (func(x *UICoinFlipErrorParticipant) *UICoinFlipErrorParticipant {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Dupcommitcomplete__),
|
|
|
|
Dupreveal__: (func(x *UICoinFlipErrorParticipant) *UICoinFlipErrorParticipant {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Dupreveal__),
|
|
|
|
Commitmismatch__: (func(x *UICoinFlipErrorParticipant) *UICoinFlipErrorParticipant {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Commitmismatch__),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UICoinFlipResultTyp int
|
|
|
|
|
|
|
|
const (
|
|
|
|
UICoinFlipResultTyp_NUMBER UICoinFlipResultTyp = 0
|
|
|
|
UICoinFlipResultTyp_SHUFFLE UICoinFlipResultTyp = 1
|
|
|
|
UICoinFlipResultTyp_DECK UICoinFlipResultTyp = 2
|
|
|
|
UICoinFlipResultTyp_HANDS UICoinFlipResultTyp = 3
|
|
|
|
UICoinFlipResultTyp_COIN UICoinFlipResultTyp = 4
|
|
|
|
)
|
|
|
|
|
|
|
|
func (o UICoinFlipResultTyp) DeepCopy() UICoinFlipResultTyp { return o }
|
|
|
|
|
|
|
|
var UICoinFlipResultTypMap = map[string]UICoinFlipResultTyp{
|
|
|
|
"NUMBER": 0,
|
|
|
|
"SHUFFLE": 1,
|
|
|
|
"DECK": 2,
|
|
|
|
"HANDS": 3,
|
|
|
|
"COIN": 4,
|
|
|
|
}
|
|
|
|
|
|
|
|
var UICoinFlipResultTypRevMap = map[UICoinFlipResultTyp]string{
|
|
|
|
0: "NUMBER",
|
|
|
|
1: "SHUFFLE",
|
|
|
|
2: "DECK",
|
|
|
|
3: "HANDS",
|
|
|
|
4: "COIN",
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e UICoinFlipResultTyp) String() string {
|
|
|
|
if v, ok := UICoinFlipResultTypRevMap[e]; ok {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
return fmt.Sprintf("%v", int(e))
|
|
|
|
}
|
|
|
|
|
|
|
|
type UICoinFlipHand struct {
|
|
|
|
Target string `codec:"target" json:"target"`
|
|
|
|
Hand []int `codec:"hand" json:"hand"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UICoinFlipHand) DeepCopy() UICoinFlipHand {
|
|
|
|
return UICoinFlipHand{
|
|
|
|
Target: o.Target,
|
|
|
|
Hand: (func(x []int) []int {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]int, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.Hand),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UICoinFlipResult struct {
|
|
|
|
Typ__ UICoinFlipResultTyp `codec:"typ" json:"typ"`
|
|
|
|
Number__ *string `codec:"number,omitempty" json:"number,omitempty"`
|
|
|
|
Shuffle__ *[]string `codec:"shuffle,omitempty" json:"shuffle,omitempty"`
|
|
|
|
Deck__ *[]int `codec:"deck,omitempty" json:"deck,omitempty"`
|
|
|
|
Hands__ *[]UICoinFlipHand `codec:"hands,omitempty" json:"hands,omitempty"`
|
|
|
|
Coin__ *bool `codec:"coin,omitempty" json:"coin,omitempty"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o *UICoinFlipResult) Typ() (ret UICoinFlipResultTyp, err error) {
|
|
|
|
switch o.Typ__ {
|
|
|
|
case UICoinFlipResultTyp_NUMBER:
|
|
|
|
if o.Number__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Number__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
case UICoinFlipResultTyp_SHUFFLE:
|
|
|
|
if o.Shuffle__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Shuffle__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
case UICoinFlipResultTyp_DECK:
|
|
|
|
if o.Deck__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Deck__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
case UICoinFlipResultTyp_HANDS:
|
|
|
|
if o.Hands__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Hands__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
case UICoinFlipResultTyp_COIN:
|
|
|
|
if o.Coin__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Coin__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return o.Typ__, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UICoinFlipResult) Number() (res string) {
|
|
|
|
if o.Typ__ != UICoinFlipResultTyp_NUMBER {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Number__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Number__
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UICoinFlipResult) Shuffle() (res []string) {
|
|
|
|
if o.Typ__ != UICoinFlipResultTyp_SHUFFLE {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Shuffle__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Shuffle__
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UICoinFlipResult) Deck() (res []int) {
|
|
|
|
if o.Typ__ != UICoinFlipResultTyp_DECK {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Deck__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Deck__
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UICoinFlipResult) Hands() (res []UICoinFlipHand) {
|
|
|
|
if o.Typ__ != UICoinFlipResultTyp_HANDS {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Hands__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Hands__
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UICoinFlipResult) Coin() (res bool) {
|
|
|
|
if o.Typ__ != UICoinFlipResultTyp_COIN {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Coin__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Coin__
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUICoinFlipResultWithNumber(v string) UICoinFlipResult {
|
|
|
|
return UICoinFlipResult{
|
|
|
|
Typ__: UICoinFlipResultTyp_NUMBER,
|
|
|
|
Number__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUICoinFlipResultWithShuffle(v []string) UICoinFlipResult {
|
|
|
|
return UICoinFlipResult{
|
|
|
|
Typ__: UICoinFlipResultTyp_SHUFFLE,
|
|
|
|
Shuffle__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUICoinFlipResultWithDeck(v []int) UICoinFlipResult {
|
|
|
|
return UICoinFlipResult{
|
|
|
|
Typ__: UICoinFlipResultTyp_DECK,
|
|
|
|
Deck__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUICoinFlipResultWithHands(v []UICoinFlipHand) UICoinFlipResult {
|
|
|
|
return UICoinFlipResult{
|
|
|
|
Typ__: UICoinFlipResultTyp_HANDS,
|
|
|
|
Hands__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUICoinFlipResultWithCoin(v bool) UICoinFlipResult {
|
|
|
|
return UICoinFlipResult{
|
|
|
|
Typ__: UICoinFlipResultTyp_COIN,
|
|
|
|
Coin__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UICoinFlipResult) DeepCopy() UICoinFlipResult {
|
|
|
|
return UICoinFlipResult{
|
|
|
|
Typ__: o.Typ__.DeepCopy(),
|
|
|
|
Number__: (func(x *string) *string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x)
|
|
|
|
return &tmp
|
|
|
|
})(o.Number__),
|
|
|
|
Shuffle__: (func(x *[]string) *[]string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (func(x []string) []string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]string, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})((*x))
|
|
|
|
return &tmp
|
|
|
|
})(o.Shuffle__),
|
|
|
|
Deck__: (func(x *[]int) *[]int {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (func(x []int) []int {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]int, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})((*x))
|
|
|
|
return &tmp
|
|
|
|
})(o.Deck__),
|
|
|
|
Hands__: (func(x *[]UICoinFlipHand) *[]UICoinFlipHand {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (func(x []UICoinFlipHand) []UICoinFlipHand {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]UICoinFlipHand, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})((*x))
|
|
|
|
return &tmp
|
|
|
|
})(o.Hands__),
|
|
|
|
Coin__: (func(x *bool) *bool {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x)
|
|
|
|
return &tmp
|
|
|
|
})(o.Coin__),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UICoinFlipParticipant struct {
|
|
|
|
Uid string `codec:"uid" json:"uid"`
|
|
|
|
DeviceID string `codec:"deviceID" json:"deviceID"`
|
|
|
|
Username string `codec:"username" json:"username"`
|
|
|
|
DeviceName string `codec:"deviceName" json:"deviceName"`
|
|
|
|
Commitment string `codec:"commitment" json:"commitment"`
|
|
|
|
Reveal *string `codec:"reveal,omitempty" json:"reveal,omitempty"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UICoinFlipParticipant) DeepCopy() UICoinFlipParticipant {
|
|
|
|
return UICoinFlipParticipant{
|
|
|
|
Uid: o.Uid,
|
|
|
|
DeviceID: o.DeviceID,
|
|
|
|
Username: o.Username,
|
|
|
|
DeviceName: o.DeviceName,
|
|
|
|
Commitment: o.Commitment,
|
|
|
|
Reveal: (func(x *string) *string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x)
|
|
|
|
return &tmp
|
|
|
|
})(o.Reveal),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UICoinFlipStatus struct {
|
|
|
|
GameID FlipGameIDStr `codec:"gameID" json:"gameID"`
|
|
|
|
Phase UICoinFlipPhase `codec:"phase" json:"phase"`
|
|
|
|
ProgressText string `codec:"progressText" json:"progressText"`
|
|
|
|
ResultText string `codec:"resultText" json:"resultText"`
|
|
|
|
CommitmentVisualization string `codec:"commitmentVisualization" json:"commitmentVisualization"`
|
|
|
|
RevealVisualization string `codec:"revealVisualization" json:"revealVisualization"`
|
|
|
|
Participants []UICoinFlipParticipant `codec:"participants" json:"participants"`
|
|
|
|
ErrorInfo *UICoinFlipError `codec:"errorInfo,omitempty" json:"errorInfo,omitempty"`
|
|
|
|
ResultInfo *UICoinFlipResult `codec:"resultInfo,omitempty" json:"resultInfo,omitempty"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UICoinFlipStatus) DeepCopy() UICoinFlipStatus {
|
|
|
|
return UICoinFlipStatus{
|
|
|
|
GameID: o.GameID.DeepCopy(),
|
|
|
|
Phase: o.Phase.DeepCopy(),
|
|
|
|
ProgressText: o.ProgressText,
|
|
|
|
ResultText: o.ResultText,
|
|
|
|
CommitmentVisualization: o.CommitmentVisualization,
|
|
|
|
RevealVisualization: o.RevealVisualization,
|
|
|
|
Participants: (func(x []UICoinFlipParticipant) []UICoinFlipParticipant {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make([]UICoinFlipParticipant, len(x))
|
|
|
|
for i, v := range x {
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[i] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.Participants),
|
|
|
|
ErrorInfo: (func(x *UICoinFlipError) *UICoinFlipError {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.ErrorInfo),
|
|
|
|
ResultInfo: (func(x *UICoinFlipResult) *UICoinFlipResult {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.ResultInfo),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UICommandMarkdown struct {
|
|
|
|
Body string `codec:"body" json:"body"`
|
|
|
|
Title *string `codec:"title,omitempty" json:"title,omitempty"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UICommandMarkdown) DeepCopy() UICommandMarkdown {
|
|
|
|
return UICommandMarkdown{
|
|
|
|
Body: o.Body,
|
|
|
|
Title: (func(x *string) *string {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x)
|
|
|
|
return &tmp
|
|
|
|
})(o.Title),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type LocationWatchID uint64
|
|
|
|
|
|
|
|
func (o LocationWatchID) DeepCopy() LocationWatchID {
|
|
|
|
return o
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIWatchPositionPerm int
|
|
|
|
|
|
|
|
const (
|
|
|
|
UIWatchPositionPerm_BASE UIWatchPositionPerm = 0
|
|
|
|
UIWatchPositionPerm_ALWAYS UIWatchPositionPerm = 1
|
|
|
|
)
|
|
|
|
|
|
|
|
func (o UIWatchPositionPerm) DeepCopy() UIWatchPositionPerm { return o }
|
|
|
|
|
|
|
|
var UIWatchPositionPermMap = map[string]UIWatchPositionPerm{
|
|
|
|
"BASE": 0,
|
|
|
|
"ALWAYS": 1,
|
|
|
|
}
|
|
|
|
|
|
|
|
var UIWatchPositionPermRevMap = map[UIWatchPositionPerm]string{
|
|
|
|
0: "BASE",
|
|
|
|
1: "ALWAYS",
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e UIWatchPositionPerm) String() string {
|
|
|
|
if v, ok := UIWatchPositionPermRevMap[e]; ok {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
return fmt.Sprintf("%v", int(e))
|
|
|
|
}
|
|
|
|
|
|
|
|
type UICommandStatusDisplayTyp int
|
|
|
|
|
|
|
|
const (
|
|
|
|
UICommandStatusDisplayTyp_STATUS UICommandStatusDisplayTyp = 0
|
|
|
|
UICommandStatusDisplayTyp_WARNING UICommandStatusDisplayTyp = 1
|
|
|
|
UICommandStatusDisplayTyp_ERROR UICommandStatusDisplayTyp = 2
|
|
|
|
)
|
|
|
|
|
|
|
|
func (o UICommandStatusDisplayTyp) DeepCopy() UICommandStatusDisplayTyp { return o }
|
|
|
|
|
|
|
|
var UICommandStatusDisplayTypMap = map[string]UICommandStatusDisplayTyp{
|
|
|
|
"STATUS": 0,
|
|
|
|
"WARNING": 1,
|
|
|
|
"ERROR": 2,
|
|
|
|
}
|
|
|
|
|
|
|
|
var UICommandStatusDisplayTypRevMap = map[UICommandStatusDisplayTyp]string{
|
|
|
|
0: "STATUS",
|
|
|
|
1: "WARNING",
|
|
|
|
2: "ERROR",
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e UICommandStatusDisplayTyp) String() string {
|
|
|
|
if v, ok := UICommandStatusDisplayTypRevMap[e]; ok {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
return fmt.Sprintf("%v", int(e))
|
|
|
|
}
|
|
|
|
|
|
|
|
type UICommandStatusActionTyp int
|
|
|
|
|
|
|
|
const (
|
|
|
|
UICommandStatusActionTyp_APPSETTINGS UICommandStatusActionTyp = 0
|
|
|
|
)
|
|
|
|
|
|
|
|
func (o UICommandStatusActionTyp) DeepCopy() UICommandStatusActionTyp { return o }
|
|
|
|
|
|
|
|
var UICommandStatusActionTypMap = map[string]UICommandStatusActionTyp{
|
|
|
|
"APPSETTINGS": 0,
|
|
|
|
}
|
|
|
|
|
|
|
|
var UICommandStatusActionTypRevMap = map[UICommandStatusActionTyp]string{
|
|
|
|
0: "APPSETTINGS",
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e UICommandStatusActionTyp) String() string {
|
|
|
|
if v, ok := UICommandStatusActionTypRevMap[e]; ok {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
return fmt.Sprintf("%v", int(e))
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIBotCommandsUpdateStatusTyp int
|
|
|
|
|
|
|
|
const (
|
|
|
|
UIBotCommandsUpdateStatusTyp_UPTODATE UIBotCommandsUpdateStatusTyp = 0
|
|
|
|
UIBotCommandsUpdateStatusTyp_UPDATING UIBotCommandsUpdateStatusTyp = 1
|
|
|
|
UIBotCommandsUpdateStatusTyp_FAILED UIBotCommandsUpdateStatusTyp = 2
|
|
|
|
UIBotCommandsUpdateStatusTyp_BLANK UIBotCommandsUpdateStatusTyp = 3
|
|
|
|
)
|
|
|
|
|
|
|
|
func (o UIBotCommandsUpdateStatusTyp) DeepCopy() UIBotCommandsUpdateStatusTyp { return o }
|
|
|
|
|
|
|
|
var UIBotCommandsUpdateStatusTypMap = map[string]UIBotCommandsUpdateStatusTyp{
|
|
|
|
"UPTODATE": 0,
|
|
|
|
"UPDATING": 1,
|
|
|
|
"FAILED": 2,
|
|
|
|
"BLANK": 3,
|
|
|
|
}
|
|
|
|
|
|
|
|
var UIBotCommandsUpdateStatusTypRevMap = map[UIBotCommandsUpdateStatusTyp]string{
|
|
|
|
0: "UPTODATE",
|
|
|
|
1: "UPDATING",
|
|
|
|
2: "FAILED",
|
|
|
|
3: "BLANK",
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e UIBotCommandsUpdateStatusTyp) String() string {
|
|
|
|
if v, ok := UIBotCommandsUpdateStatusTypRevMap[e]; ok {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
return fmt.Sprintf("%v", int(e))
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIBotCommandsUpdateSettings struct {
|
|
|
|
Settings map[string]keybase1.TeamBotSettings `codec:"settings" json:"settings"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIBotCommandsUpdateSettings) DeepCopy() UIBotCommandsUpdateSettings {
|
|
|
|
return UIBotCommandsUpdateSettings{
|
|
|
|
Settings: (func(x map[string]keybase1.TeamBotSettings) map[string]keybase1.TeamBotSettings {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ret := make(map[string]keybase1.TeamBotSettings, len(x))
|
|
|
|
for k, v := range x {
|
|
|
|
kCopy := k
|
|
|
|
vCopy := v.DeepCopy()
|
|
|
|
ret[kCopy] = vCopy
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
})(o.Settings),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type UIBotCommandsUpdateStatus struct {
|
|
|
|
Typ__ UIBotCommandsUpdateStatusTyp `codec:"typ" json:"typ"`
|
|
|
|
Uptodate__ *UIBotCommandsUpdateSettings `codec:"uptodate,omitempty" json:"uptodate,omitempty"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o *UIBotCommandsUpdateStatus) Typ() (ret UIBotCommandsUpdateStatusTyp, err error) {
|
|
|
|
switch o.Typ__ {
|
|
|
|
case UIBotCommandsUpdateStatusTyp_UPTODATE:
|
|
|
|
if o.Uptodate__ == nil {
|
|
|
|
err = errors.New("unexpected nil value for Uptodate__")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return o.Typ__, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIBotCommandsUpdateStatus) Uptodate() (res UIBotCommandsUpdateSettings) {
|
|
|
|
if o.Typ__ != UIBotCommandsUpdateStatusTyp_UPTODATE {
|
|
|
|
panic("wrong case accessed")
|
|
|
|
}
|
|
|
|
if o.Uptodate__ == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
return *o.Uptodate__
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUIBotCommandsUpdateStatusWithUptodate(v UIBotCommandsUpdateSettings) UIBotCommandsUpdateStatus {
|
|
|
|
return UIBotCommandsUpdateStatus{
|
|
|
|
Typ__: UIBotCommandsUpdateStatusTyp_UPTODATE,
|
|
|
|
Uptodate__: &v,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUIBotCommandsUpdateStatusWithUpdating() UIBotCommandsUpdateStatus {
|
|
|
|
return UIBotCommandsUpdateStatus{
|
|
|
|
Typ__: UIBotCommandsUpdateStatusTyp_UPDATING,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUIBotCommandsUpdateStatusWithFailed() UIBotCommandsUpdateStatus {
|
|
|
|
return UIBotCommandsUpdateStatus{
|
|
|
|
Typ__: UIBotCommandsUpdateStatusTyp_FAILED,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUIBotCommandsUpdateStatusWithBlank() UIBotCommandsUpdateStatus {
|
|
|
|
return UIBotCommandsUpdateStatus{
|
|
|
|
Typ__: UIBotCommandsUpdateStatusTyp_BLANK,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o UIBotCommandsUpdateStatus) DeepCopy() UIBotCommandsUpdateStatus {
|
|
|
|
return UIBotCommandsUpdateStatus{
|
|
|
|
Typ__: o.Typ__.DeepCopy(),
|
|
|
|
Uptodate__: (func(x *UIBotCommandsUpdateSettings) *UIBotCommandsUpdateSettings {
|
|
|
|
if x == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
tmp := (*x).DeepCopy()
|
|
|
|
return &tmp
|
|
|
|
})(o.Uptodate__),
|
|
|
|
}
|
|
|
|
}
|