package tg
import (
"context"
"errors"
"fmt"
"sort"
"strings"
"go.uber.org/multierr"
"github.com/gotd/td/bin"
"github.com/gotd/td/tdjson"
"github.com/gotd/td/tdp"
"github.com/gotd/td/tgerr"
)
var (
_ = bin .Buffer {}
_ = context .Background ()
_ = fmt .Stringer (nil )
_ = strings .Builder {}
_ = errors .Is
_ = multierr .AppendInto
_ = sort .Ints
_ = tdp .Format
_ = tgerr .Error {}
_ = tdjson .Encoder {}
)
type ChannelParticipantsRecent struct {
}
const ChannelParticipantsRecentTypeID = 0xde3f3c79
func (c ChannelParticipantsRecent ) construct () ChannelParticipantsFilterClass { return &c }
var (
_ bin .Encoder = &ChannelParticipantsRecent {}
_ bin .Decoder = &ChannelParticipantsRecent {}
_ bin .BareEncoder = &ChannelParticipantsRecent {}
_ bin .BareDecoder = &ChannelParticipantsRecent {}
_ ChannelParticipantsFilterClass = &ChannelParticipantsRecent {}
)
func (c *ChannelParticipantsRecent ) Zero () bool {
if c == nil {
return true
}
return true
}
func (c *ChannelParticipantsRecent ) String () string {
if c == nil {
return "ChannelParticipantsRecent(nil)"
}
type Alias ChannelParticipantsRecent
return fmt .Sprintf ("ChannelParticipantsRecent%+v" , Alias (*c ))
}
func (*ChannelParticipantsRecent ) TypeID () uint32 {
return ChannelParticipantsRecentTypeID
}
func (*ChannelParticipantsRecent ) TypeName () string {
return "channelParticipantsRecent"
}
func (c *ChannelParticipantsRecent ) TypeInfo () tdp .Type {
typ := tdp .Type {
Name : "channelParticipantsRecent" ,
ID : ChannelParticipantsRecentTypeID ,
}
if c == nil {
typ .Null = true
return typ
}
typ .Fields = []tdp .Field {}
return typ
}
func (c *ChannelParticipantsRecent ) Encode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode channelParticipantsRecent#de3f3c79 as nil" )
}
b .PutID (ChannelParticipantsRecentTypeID )
return c .EncodeBare (b )
}
func (c *ChannelParticipantsRecent ) EncodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode channelParticipantsRecent#de3f3c79 as nil" )
}
return nil
}
func (c *ChannelParticipantsRecent ) Decode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode channelParticipantsRecent#de3f3c79 to nil" )
}
if err := b .ConsumeID (ChannelParticipantsRecentTypeID ); err != nil {
return fmt .Errorf ("unable to decode channelParticipantsRecent#de3f3c79: %w" , err )
}
return c .DecodeBare (b )
}
func (c *ChannelParticipantsRecent ) DecodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode channelParticipantsRecent#de3f3c79 to nil" )
}
return nil
}
type ChannelParticipantsAdmins struct {
}
const ChannelParticipantsAdminsTypeID = 0xb4608969
func (c ChannelParticipantsAdmins ) construct () ChannelParticipantsFilterClass { return &c }
var (
_ bin .Encoder = &ChannelParticipantsAdmins {}
_ bin .Decoder = &ChannelParticipantsAdmins {}
_ bin .BareEncoder = &ChannelParticipantsAdmins {}
_ bin .BareDecoder = &ChannelParticipantsAdmins {}
_ ChannelParticipantsFilterClass = &ChannelParticipantsAdmins {}
)
func (c *ChannelParticipantsAdmins ) Zero () bool {
if c == nil {
return true
}
return true
}
func (c *ChannelParticipantsAdmins ) String () string {
if c == nil {
return "ChannelParticipantsAdmins(nil)"
}
type Alias ChannelParticipantsAdmins
return fmt .Sprintf ("ChannelParticipantsAdmins%+v" , Alias (*c ))
}
func (*ChannelParticipantsAdmins ) TypeID () uint32 {
return ChannelParticipantsAdminsTypeID
}
func (*ChannelParticipantsAdmins ) TypeName () string {
return "channelParticipantsAdmins"
}
func (c *ChannelParticipantsAdmins ) TypeInfo () tdp .Type {
typ := tdp .Type {
Name : "channelParticipantsAdmins" ,
ID : ChannelParticipantsAdminsTypeID ,
}
if c == nil {
typ .Null = true
return typ
}
typ .Fields = []tdp .Field {}
return typ
}
func (c *ChannelParticipantsAdmins ) Encode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode channelParticipantsAdmins#b4608969 as nil" )
}
b .PutID (ChannelParticipantsAdminsTypeID )
return c .EncodeBare (b )
}
func (c *ChannelParticipantsAdmins ) EncodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode channelParticipantsAdmins#b4608969 as nil" )
}
return nil
}
func (c *ChannelParticipantsAdmins ) Decode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode channelParticipantsAdmins#b4608969 to nil" )
}
if err := b .ConsumeID (ChannelParticipantsAdminsTypeID ); err != nil {
return fmt .Errorf ("unable to decode channelParticipantsAdmins#b4608969: %w" , err )
}
return c .DecodeBare (b )
}
func (c *ChannelParticipantsAdmins ) DecodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode channelParticipantsAdmins#b4608969 to nil" )
}
return nil
}
type ChannelParticipantsKicked struct {
Q string
}
const ChannelParticipantsKickedTypeID = 0xa3b54985
func (c ChannelParticipantsKicked ) construct () ChannelParticipantsFilterClass { return &c }
var (
_ bin .Encoder = &ChannelParticipantsKicked {}
_ bin .Decoder = &ChannelParticipantsKicked {}
_ bin .BareEncoder = &ChannelParticipantsKicked {}
_ bin .BareDecoder = &ChannelParticipantsKicked {}
_ ChannelParticipantsFilterClass = &ChannelParticipantsKicked {}
)
func (c *ChannelParticipantsKicked ) Zero () bool {
if c == nil {
return true
}
if !(c .Q == "" ) {
return false
}
return true
}
func (c *ChannelParticipantsKicked ) String () string {
if c == nil {
return "ChannelParticipantsKicked(nil)"
}
type Alias ChannelParticipantsKicked
return fmt .Sprintf ("ChannelParticipantsKicked%+v" , Alias (*c ))
}
func (c *ChannelParticipantsKicked ) FillFrom (from interface {
GetQ () (value string )
}) {
c .Q = from .GetQ ()
}
func (*ChannelParticipantsKicked ) TypeID () uint32 {
return ChannelParticipantsKickedTypeID
}
func (*ChannelParticipantsKicked ) TypeName () string {
return "channelParticipantsKicked"
}
func (c *ChannelParticipantsKicked ) TypeInfo () tdp .Type {
typ := tdp .Type {
Name : "channelParticipantsKicked" ,
ID : ChannelParticipantsKickedTypeID ,
}
if c == nil {
typ .Null = true
return typ
}
typ .Fields = []tdp .Field {
{
Name : "Q" ,
SchemaName : "q" ,
},
}
return typ
}
func (c *ChannelParticipantsKicked ) Encode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode channelParticipantsKicked#a3b54985 as nil" )
}
b .PutID (ChannelParticipantsKickedTypeID )
return c .EncodeBare (b )
}
func (c *ChannelParticipantsKicked ) EncodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode channelParticipantsKicked#a3b54985 as nil" )
}
b .PutString (c .Q )
return nil
}
func (c *ChannelParticipantsKicked ) Decode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode channelParticipantsKicked#a3b54985 to nil" )
}
if err := b .ConsumeID (ChannelParticipantsKickedTypeID ); err != nil {
return fmt .Errorf ("unable to decode channelParticipantsKicked#a3b54985: %w" , err )
}
return c .DecodeBare (b )
}
func (c *ChannelParticipantsKicked ) DecodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode channelParticipantsKicked#a3b54985 to nil" )
}
{
value , err := b .String ()
if err != nil {
return fmt .Errorf ("unable to decode channelParticipantsKicked#a3b54985: field q: %w" , err )
}
c .Q = value
}
return nil
}
func (c *ChannelParticipantsKicked ) GetQ () (value string ) {
if c == nil {
return
}
return c .Q
}
type ChannelParticipantsBots struct {
}
const ChannelParticipantsBotsTypeID = 0xb0d1865b
func (c ChannelParticipantsBots ) construct () ChannelParticipantsFilterClass { return &c }
var (
_ bin .Encoder = &ChannelParticipantsBots {}
_ bin .Decoder = &ChannelParticipantsBots {}
_ bin .BareEncoder = &ChannelParticipantsBots {}
_ bin .BareDecoder = &ChannelParticipantsBots {}
_ ChannelParticipantsFilterClass = &ChannelParticipantsBots {}
)
func (c *ChannelParticipantsBots ) Zero () bool {
if c == nil {
return true
}
return true
}
func (c *ChannelParticipantsBots ) String () string {
if c == nil {
return "ChannelParticipantsBots(nil)"
}
type Alias ChannelParticipantsBots
return fmt .Sprintf ("ChannelParticipantsBots%+v" , Alias (*c ))
}
func (*ChannelParticipantsBots ) TypeID () uint32 {
return ChannelParticipantsBotsTypeID
}
func (*ChannelParticipantsBots ) TypeName () string {
return "channelParticipantsBots"
}
func (c *ChannelParticipantsBots ) TypeInfo () tdp .Type {
typ := tdp .Type {
Name : "channelParticipantsBots" ,
ID : ChannelParticipantsBotsTypeID ,
}
if c == nil {
typ .Null = true
return typ
}
typ .Fields = []tdp .Field {}
return typ
}
func (c *ChannelParticipantsBots ) Encode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode channelParticipantsBots#b0d1865b as nil" )
}
b .PutID (ChannelParticipantsBotsTypeID )
return c .EncodeBare (b )
}
func (c *ChannelParticipantsBots ) EncodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode channelParticipantsBots#b0d1865b as nil" )
}
return nil
}
func (c *ChannelParticipantsBots ) Decode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode channelParticipantsBots#b0d1865b to nil" )
}
if err := b .ConsumeID (ChannelParticipantsBotsTypeID ); err != nil {
return fmt .Errorf ("unable to decode channelParticipantsBots#b0d1865b: %w" , err )
}
return c .DecodeBare (b )
}
func (c *ChannelParticipantsBots ) DecodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode channelParticipantsBots#b0d1865b to nil" )
}
return nil
}
type ChannelParticipantsBanned struct {
Q string
}
const ChannelParticipantsBannedTypeID = 0x1427a5e1
func (c ChannelParticipantsBanned ) construct () ChannelParticipantsFilterClass { return &c }
var (
_ bin .Encoder = &ChannelParticipantsBanned {}
_ bin .Decoder = &ChannelParticipantsBanned {}
_ bin .BareEncoder = &ChannelParticipantsBanned {}
_ bin .BareDecoder = &ChannelParticipantsBanned {}
_ ChannelParticipantsFilterClass = &ChannelParticipantsBanned {}
)
func (c *ChannelParticipantsBanned ) Zero () bool {
if c == nil {
return true
}
if !(c .Q == "" ) {
return false
}
return true
}
func (c *ChannelParticipantsBanned ) String () string {
if c == nil {
return "ChannelParticipantsBanned(nil)"
}
type Alias ChannelParticipantsBanned
return fmt .Sprintf ("ChannelParticipantsBanned%+v" , Alias (*c ))
}
func (c *ChannelParticipantsBanned ) FillFrom (from interface {
GetQ () (value string )
}) {
c .Q = from .GetQ ()
}
func (*ChannelParticipantsBanned ) TypeID () uint32 {
return ChannelParticipantsBannedTypeID
}
func (*ChannelParticipantsBanned ) TypeName () string {
return "channelParticipantsBanned"
}
func (c *ChannelParticipantsBanned ) TypeInfo () tdp .Type {
typ := tdp .Type {
Name : "channelParticipantsBanned" ,
ID : ChannelParticipantsBannedTypeID ,
}
if c == nil {
typ .Null = true
return typ
}
typ .Fields = []tdp .Field {
{
Name : "Q" ,
SchemaName : "q" ,
},
}
return typ
}
func (c *ChannelParticipantsBanned ) Encode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode channelParticipantsBanned#1427a5e1 as nil" )
}
b .PutID (ChannelParticipantsBannedTypeID )
return c .EncodeBare (b )
}
func (c *ChannelParticipantsBanned ) EncodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode channelParticipantsBanned#1427a5e1 as nil" )
}
b .PutString (c .Q )
return nil
}
func (c *ChannelParticipantsBanned ) Decode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode channelParticipantsBanned#1427a5e1 to nil" )
}
if err := b .ConsumeID (ChannelParticipantsBannedTypeID ); err != nil {
return fmt .Errorf ("unable to decode channelParticipantsBanned#1427a5e1: %w" , err )
}
return c .DecodeBare (b )
}
func (c *ChannelParticipantsBanned ) DecodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode channelParticipantsBanned#1427a5e1 to nil" )
}
{
value , err := b .String ()
if err != nil {
return fmt .Errorf ("unable to decode channelParticipantsBanned#1427a5e1: field q: %w" , err )
}
c .Q = value
}
return nil
}
func (c *ChannelParticipantsBanned ) GetQ () (value string ) {
if c == nil {
return
}
return c .Q
}
type ChannelParticipantsSearch struct {
Q string
}
const ChannelParticipantsSearchTypeID = 0x656ac4b
func (c ChannelParticipantsSearch ) construct () ChannelParticipantsFilterClass { return &c }
var (
_ bin .Encoder = &ChannelParticipantsSearch {}
_ bin .Decoder = &ChannelParticipantsSearch {}
_ bin .BareEncoder = &ChannelParticipantsSearch {}
_ bin .BareDecoder = &ChannelParticipantsSearch {}
_ ChannelParticipantsFilterClass = &ChannelParticipantsSearch {}
)
func (c *ChannelParticipantsSearch ) Zero () bool {
if c == nil {
return true
}
if !(c .Q == "" ) {
return false
}
return true
}
func (c *ChannelParticipantsSearch ) String () string {
if c == nil {
return "ChannelParticipantsSearch(nil)"
}
type Alias ChannelParticipantsSearch
return fmt .Sprintf ("ChannelParticipantsSearch%+v" , Alias (*c ))
}
func (c *ChannelParticipantsSearch ) FillFrom (from interface {
GetQ () (value string )
}) {
c .Q = from .GetQ ()
}
func (*ChannelParticipantsSearch ) TypeID () uint32 {
return ChannelParticipantsSearchTypeID
}
func (*ChannelParticipantsSearch ) TypeName () string {
return "channelParticipantsSearch"
}
func (c *ChannelParticipantsSearch ) TypeInfo () tdp .Type {
typ := tdp .Type {
Name : "channelParticipantsSearch" ,
ID : ChannelParticipantsSearchTypeID ,
}
if c == nil {
typ .Null = true
return typ
}
typ .Fields = []tdp .Field {
{
Name : "Q" ,
SchemaName : "q" ,
},
}
return typ
}
func (c *ChannelParticipantsSearch ) Encode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode channelParticipantsSearch#656ac4b as nil" )
}
b .PutID (ChannelParticipantsSearchTypeID )
return c .EncodeBare (b )
}
func (c *ChannelParticipantsSearch ) EncodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode channelParticipantsSearch#656ac4b as nil" )
}
b .PutString (c .Q )
return nil
}
func (c *ChannelParticipantsSearch ) Decode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode channelParticipantsSearch#656ac4b to nil" )
}
if err := b .ConsumeID (ChannelParticipantsSearchTypeID ); err != nil {
return fmt .Errorf ("unable to decode channelParticipantsSearch#656ac4b: %w" , err )
}
return c .DecodeBare (b )
}
func (c *ChannelParticipantsSearch ) DecodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode channelParticipantsSearch#656ac4b to nil" )
}
{
value , err := b .String ()
if err != nil {
return fmt .Errorf ("unable to decode channelParticipantsSearch#656ac4b: field q: %w" , err )
}
c .Q = value
}
return nil
}
func (c *ChannelParticipantsSearch ) GetQ () (value string ) {
if c == nil {
return
}
return c .Q
}
type ChannelParticipantsContacts struct {
Q string
}
const ChannelParticipantsContactsTypeID = 0xbb6ae88d
func (c ChannelParticipantsContacts ) construct () ChannelParticipantsFilterClass { return &c }
var (
_ bin .Encoder = &ChannelParticipantsContacts {}
_ bin .Decoder = &ChannelParticipantsContacts {}
_ bin .BareEncoder = &ChannelParticipantsContacts {}
_ bin .BareDecoder = &ChannelParticipantsContacts {}
_ ChannelParticipantsFilterClass = &ChannelParticipantsContacts {}
)
func (c *ChannelParticipantsContacts ) Zero () bool {
if c == nil {
return true
}
if !(c .Q == "" ) {
return false
}
return true
}
func (c *ChannelParticipantsContacts ) String () string {
if c == nil {
return "ChannelParticipantsContacts(nil)"
}
type Alias ChannelParticipantsContacts
return fmt .Sprintf ("ChannelParticipantsContacts%+v" , Alias (*c ))
}
func (c *ChannelParticipantsContacts ) FillFrom (from interface {
GetQ () (value string )
}) {
c .Q = from .GetQ ()
}
func (*ChannelParticipantsContacts ) TypeID () uint32 {
return ChannelParticipantsContactsTypeID
}
func (*ChannelParticipantsContacts ) TypeName () string {
return "channelParticipantsContacts"
}
func (c *ChannelParticipantsContacts ) TypeInfo () tdp .Type {
typ := tdp .Type {
Name : "channelParticipantsContacts" ,
ID : ChannelParticipantsContactsTypeID ,
}
if c == nil {
typ .Null = true
return typ
}
typ .Fields = []tdp .Field {
{
Name : "Q" ,
SchemaName : "q" ,
},
}
return typ
}
func (c *ChannelParticipantsContacts ) Encode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode channelParticipantsContacts#bb6ae88d as nil" )
}
b .PutID (ChannelParticipantsContactsTypeID )
return c .EncodeBare (b )
}
func (c *ChannelParticipantsContacts ) EncodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode channelParticipantsContacts#bb6ae88d as nil" )
}
b .PutString (c .Q )
return nil
}
func (c *ChannelParticipantsContacts ) Decode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode channelParticipantsContacts#bb6ae88d to nil" )
}
if err := b .ConsumeID (ChannelParticipantsContactsTypeID ); err != nil {
return fmt .Errorf ("unable to decode channelParticipantsContacts#bb6ae88d: %w" , err )
}
return c .DecodeBare (b )
}
func (c *ChannelParticipantsContacts ) DecodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode channelParticipantsContacts#bb6ae88d to nil" )
}
{
value , err := b .String ()
if err != nil {
return fmt .Errorf ("unable to decode channelParticipantsContacts#bb6ae88d: field q: %w" , err )
}
c .Q = value
}
return nil
}
func (c *ChannelParticipantsContacts ) GetQ () (value string ) {
if c == nil {
return
}
return c .Q
}
type ChannelParticipantsMentions struct {
Flags bin .Fields
Q string
TopMsgID int
}
const ChannelParticipantsMentionsTypeID = 0xe04b5ceb
func (c ChannelParticipantsMentions ) construct () ChannelParticipantsFilterClass { return &c }
var (
_ bin .Encoder = &ChannelParticipantsMentions {}
_ bin .Decoder = &ChannelParticipantsMentions {}
_ bin .BareEncoder = &ChannelParticipantsMentions {}
_ bin .BareDecoder = &ChannelParticipantsMentions {}
_ ChannelParticipantsFilterClass = &ChannelParticipantsMentions {}
)
func (c *ChannelParticipantsMentions ) Zero () bool {
if c == nil {
return true
}
if !(c .Flags .Zero ()) {
return false
}
if !(c .Q == "" ) {
return false
}
if !(c .TopMsgID == 0 ) {
return false
}
return true
}
func (c *ChannelParticipantsMentions ) String () string {
if c == nil {
return "ChannelParticipantsMentions(nil)"
}
type Alias ChannelParticipantsMentions
return fmt .Sprintf ("ChannelParticipantsMentions%+v" , Alias (*c ))
}
func (c *ChannelParticipantsMentions ) FillFrom (from interface {
GetQ () (value string , ok bool )
GetTopMsgID () (value int , ok bool )
}) {
if val , ok := from .GetQ (); ok {
c .Q = val
}
if val , ok := from .GetTopMsgID (); ok {
c .TopMsgID = val
}
}
func (*ChannelParticipantsMentions ) TypeID () uint32 {
return ChannelParticipantsMentionsTypeID
}
func (*ChannelParticipantsMentions ) TypeName () string {
return "channelParticipantsMentions"
}
func (c *ChannelParticipantsMentions ) TypeInfo () tdp .Type {
typ := tdp .Type {
Name : "channelParticipantsMentions" ,
ID : ChannelParticipantsMentionsTypeID ,
}
if c == nil {
typ .Null = true
return typ
}
typ .Fields = []tdp .Field {
{
Name : "Q" ,
SchemaName : "q" ,
Null : !c .Flags .Has (0 ),
},
{
Name : "TopMsgID" ,
SchemaName : "top_msg_id" ,
Null : !c .Flags .Has (1 ),
},
}
return typ
}
func (c *ChannelParticipantsMentions ) SetFlags () {
if !(c .Q == "" ) {
c .Flags .Set (0 )
}
if !(c .TopMsgID == 0 ) {
c .Flags .Set (1 )
}
}
func (c *ChannelParticipantsMentions ) Encode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode channelParticipantsMentions#e04b5ceb as nil" )
}
b .PutID (ChannelParticipantsMentionsTypeID )
return c .EncodeBare (b )
}
func (c *ChannelParticipantsMentions ) EncodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode channelParticipantsMentions#e04b5ceb as nil" )
}
c .SetFlags ()
if err := c .Flags .Encode (b ); err != nil {
return fmt .Errorf ("unable to encode channelParticipantsMentions#e04b5ceb: field flags: %w" , err )
}
if c .Flags .Has (0 ) {
b .PutString (c .Q )
}
if c .Flags .Has (1 ) {
b .PutInt (c .TopMsgID )
}
return nil
}
func (c *ChannelParticipantsMentions ) Decode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode channelParticipantsMentions#e04b5ceb to nil" )
}
if err := b .ConsumeID (ChannelParticipantsMentionsTypeID ); err != nil {
return fmt .Errorf ("unable to decode channelParticipantsMentions#e04b5ceb: %w" , err )
}
return c .DecodeBare (b )
}
func (c *ChannelParticipantsMentions ) DecodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode channelParticipantsMentions#e04b5ceb to nil" )
}
{
if err := c .Flags .Decode (b ); err != nil {
return fmt .Errorf ("unable to decode channelParticipantsMentions#e04b5ceb: field flags: %w" , err )
}
}
if c .Flags .Has (0 ) {
value , err := b .String ()
if err != nil {
return fmt .Errorf ("unable to decode channelParticipantsMentions#e04b5ceb: field q: %w" , err )
}
c .Q = value
}
if c .Flags .Has (1 ) {
value , err := b .Int ()
if err != nil {
return fmt .Errorf ("unable to decode channelParticipantsMentions#e04b5ceb: field top_msg_id: %w" , err )
}
c .TopMsgID = value
}
return nil
}
func (c *ChannelParticipantsMentions ) SetQ (value string ) {
c .Flags .Set (0 )
c .Q = value
}
func (c *ChannelParticipantsMentions ) GetQ () (value string , ok bool ) {
if c == nil {
return
}
if !c .Flags .Has (0 ) {
return value , false
}
return c .Q , true
}
func (c *ChannelParticipantsMentions ) SetTopMsgID (value int ) {
c .Flags .Set (1 )
c .TopMsgID = value
}
func (c *ChannelParticipantsMentions ) GetTopMsgID () (value int , ok bool ) {
if c == nil {
return
}
if !c .Flags .Has (1 ) {
return value , false
}
return c .TopMsgID , true
}
const ChannelParticipantsFilterClassName = "ChannelParticipantsFilter"
type ChannelParticipantsFilterClass interface {
bin .Encoder
bin .Decoder
bin .BareEncoder
bin .BareDecoder
construct () ChannelParticipantsFilterClass
TypeID () uint32
TypeName () string
String () string
Zero () bool
}
func DecodeChannelParticipantsFilter (buf *bin .Buffer ) (ChannelParticipantsFilterClass , error ) {
id , err := buf .PeekID ()
if err != nil {
return nil , err
}
switch id {
case ChannelParticipantsRecentTypeID :
v := ChannelParticipantsRecent {}
if err := v .Decode (buf ); err != nil {
return nil , fmt .Errorf ("unable to decode ChannelParticipantsFilterClass: %w" , err )
}
return &v , nil
case ChannelParticipantsAdminsTypeID :
v := ChannelParticipantsAdmins {}
if err := v .Decode (buf ); err != nil {
return nil , fmt .Errorf ("unable to decode ChannelParticipantsFilterClass: %w" , err )
}
return &v , nil
case ChannelParticipantsKickedTypeID :
v := ChannelParticipantsKicked {}
if err := v .Decode (buf ); err != nil {
return nil , fmt .Errorf ("unable to decode ChannelParticipantsFilterClass: %w" , err )
}
return &v , nil
case ChannelParticipantsBotsTypeID :
v := ChannelParticipantsBots {}
if err := v .Decode (buf ); err != nil {
return nil , fmt .Errorf ("unable to decode ChannelParticipantsFilterClass: %w" , err )
}
return &v , nil
case ChannelParticipantsBannedTypeID :
v := ChannelParticipantsBanned {}
if err := v .Decode (buf ); err != nil {
return nil , fmt .Errorf ("unable to decode ChannelParticipantsFilterClass: %w" , err )
}
return &v , nil
case ChannelParticipantsSearchTypeID :
v := ChannelParticipantsSearch {}
if err := v .Decode (buf ); err != nil {
return nil , fmt .Errorf ("unable to decode ChannelParticipantsFilterClass: %w" , err )
}
return &v , nil
case ChannelParticipantsContactsTypeID :
v := ChannelParticipantsContacts {}
if err := v .Decode (buf ); err != nil {
return nil , fmt .Errorf ("unable to decode ChannelParticipantsFilterClass: %w" , err )
}
return &v , nil
case ChannelParticipantsMentionsTypeID :
v := ChannelParticipantsMentions {}
if err := v .Decode (buf ); err != nil {
return nil , fmt .Errorf ("unable to decode ChannelParticipantsFilterClass: %w" , err )
}
return &v , nil
default :
return nil , fmt .Errorf ("unable to decode ChannelParticipantsFilterClass: %w" , bin .NewUnexpectedID (id ))
}
}
type ChannelParticipantsFilterBox struct {
ChannelParticipantsFilter ChannelParticipantsFilterClass
}
func (b *ChannelParticipantsFilterBox ) Decode (buf *bin .Buffer ) error {
if b == nil {
return fmt .Errorf ("unable to decode ChannelParticipantsFilterBox to nil" )
}
v , err := DecodeChannelParticipantsFilter (buf )
if err != nil {
return fmt .Errorf ("unable to decode boxed value: %w" , err )
}
b .ChannelParticipantsFilter = v
return nil
}
func (b *ChannelParticipantsFilterBox ) Encode (buf *bin .Buffer ) error {
if b == nil || b .ChannelParticipantsFilter == nil {
return fmt .Errorf ("unable to encode ChannelParticipantsFilterClass as nil" )
}
return b .ChannelParticipantsFilter .Encode (buf )
}
The pages are generated with Golds v0.6.7 . (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu .
PR and bug reports are welcome and can be submitted to the issue list .
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds .