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 AttachMenuPeerTypeSameBotPM struct {
}
const AttachMenuPeerTypeSameBotPMTypeID = 0x7d6be90e
func (a AttachMenuPeerTypeSameBotPM ) construct () AttachMenuPeerTypeClass { return &a }
var (
_ bin .Encoder = &AttachMenuPeerTypeSameBotPM {}
_ bin .Decoder = &AttachMenuPeerTypeSameBotPM {}
_ bin .BareEncoder = &AttachMenuPeerTypeSameBotPM {}
_ bin .BareDecoder = &AttachMenuPeerTypeSameBotPM {}
_ AttachMenuPeerTypeClass = &AttachMenuPeerTypeSameBotPM {}
)
func (a *AttachMenuPeerTypeSameBotPM ) Zero () bool {
if a == nil {
return true
}
return true
}
func (a *AttachMenuPeerTypeSameBotPM ) String () string {
if a == nil {
return "AttachMenuPeerTypeSameBotPM(nil)"
}
type Alias AttachMenuPeerTypeSameBotPM
return fmt .Sprintf ("AttachMenuPeerTypeSameBotPM%+v" , Alias (*a ))
}
func (*AttachMenuPeerTypeSameBotPM ) TypeID () uint32 {
return AttachMenuPeerTypeSameBotPMTypeID
}
func (*AttachMenuPeerTypeSameBotPM ) TypeName () string {
return "attachMenuPeerTypeSameBotPM"
}
func (a *AttachMenuPeerTypeSameBotPM ) TypeInfo () tdp .Type {
typ := tdp .Type {
Name : "attachMenuPeerTypeSameBotPM" ,
ID : AttachMenuPeerTypeSameBotPMTypeID ,
}
if a == nil {
typ .Null = true
return typ
}
typ .Fields = []tdp .Field {}
return typ
}
func (a *AttachMenuPeerTypeSameBotPM ) Encode (b *bin .Buffer ) error {
if a == nil {
return fmt .Errorf ("can't encode attachMenuPeerTypeSameBotPM#7d6be90e as nil" )
}
b .PutID (AttachMenuPeerTypeSameBotPMTypeID )
return a .EncodeBare (b )
}
func (a *AttachMenuPeerTypeSameBotPM ) EncodeBare (b *bin .Buffer ) error {
if a == nil {
return fmt .Errorf ("can't encode attachMenuPeerTypeSameBotPM#7d6be90e as nil" )
}
return nil
}
func (a *AttachMenuPeerTypeSameBotPM ) Decode (b *bin .Buffer ) error {
if a == nil {
return fmt .Errorf ("can't decode attachMenuPeerTypeSameBotPM#7d6be90e to nil" )
}
if err := b .ConsumeID (AttachMenuPeerTypeSameBotPMTypeID ); err != nil {
return fmt .Errorf ("unable to decode attachMenuPeerTypeSameBotPM#7d6be90e: %w" , err )
}
return a .DecodeBare (b )
}
func (a *AttachMenuPeerTypeSameBotPM ) DecodeBare (b *bin .Buffer ) error {
if a == nil {
return fmt .Errorf ("can't decode attachMenuPeerTypeSameBotPM#7d6be90e to nil" )
}
return nil
}
type AttachMenuPeerTypeBotPM struct {
}
const AttachMenuPeerTypeBotPMTypeID = 0xc32bfa1a
func (a AttachMenuPeerTypeBotPM ) construct () AttachMenuPeerTypeClass { return &a }
var (
_ bin .Encoder = &AttachMenuPeerTypeBotPM {}
_ bin .Decoder = &AttachMenuPeerTypeBotPM {}
_ bin .BareEncoder = &AttachMenuPeerTypeBotPM {}
_ bin .BareDecoder = &AttachMenuPeerTypeBotPM {}
_ AttachMenuPeerTypeClass = &AttachMenuPeerTypeBotPM {}
)
func (a *AttachMenuPeerTypeBotPM ) Zero () bool {
if a == nil {
return true
}
return true
}
func (a *AttachMenuPeerTypeBotPM ) String () string {
if a == nil {
return "AttachMenuPeerTypeBotPM(nil)"
}
type Alias AttachMenuPeerTypeBotPM
return fmt .Sprintf ("AttachMenuPeerTypeBotPM%+v" , Alias (*a ))
}
func (*AttachMenuPeerTypeBotPM ) TypeID () uint32 {
return AttachMenuPeerTypeBotPMTypeID
}
func (*AttachMenuPeerTypeBotPM ) TypeName () string {
return "attachMenuPeerTypeBotPM"
}
func (a *AttachMenuPeerTypeBotPM ) TypeInfo () tdp .Type {
typ := tdp .Type {
Name : "attachMenuPeerTypeBotPM" ,
ID : AttachMenuPeerTypeBotPMTypeID ,
}
if a == nil {
typ .Null = true
return typ
}
typ .Fields = []tdp .Field {}
return typ
}
func (a *AttachMenuPeerTypeBotPM ) Encode (b *bin .Buffer ) error {
if a == nil {
return fmt .Errorf ("can't encode attachMenuPeerTypeBotPM#c32bfa1a as nil" )
}
b .PutID (AttachMenuPeerTypeBotPMTypeID )
return a .EncodeBare (b )
}
func (a *AttachMenuPeerTypeBotPM ) EncodeBare (b *bin .Buffer ) error {
if a == nil {
return fmt .Errorf ("can't encode attachMenuPeerTypeBotPM#c32bfa1a as nil" )
}
return nil
}
func (a *AttachMenuPeerTypeBotPM ) Decode (b *bin .Buffer ) error {
if a == nil {
return fmt .Errorf ("can't decode attachMenuPeerTypeBotPM#c32bfa1a to nil" )
}
if err := b .ConsumeID (AttachMenuPeerTypeBotPMTypeID ); err != nil {
return fmt .Errorf ("unable to decode attachMenuPeerTypeBotPM#c32bfa1a: %w" , err )
}
return a .DecodeBare (b )
}
func (a *AttachMenuPeerTypeBotPM ) DecodeBare (b *bin .Buffer ) error {
if a == nil {
return fmt .Errorf ("can't decode attachMenuPeerTypeBotPM#c32bfa1a to nil" )
}
return nil
}
type AttachMenuPeerTypePM struct {
}
const AttachMenuPeerTypePMTypeID = 0xf146d31f
func (a AttachMenuPeerTypePM ) construct () AttachMenuPeerTypeClass { return &a }
var (
_ bin .Encoder = &AttachMenuPeerTypePM {}
_ bin .Decoder = &AttachMenuPeerTypePM {}
_ bin .BareEncoder = &AttachMenuPeerTypePM {}
_ bin .BareDecoder = &AttachMenuPeerTypePM {}
_ AttachMenuPeerTypeClass = &AttachMenuPeerTypePM {}
)
func (a *AttachMenuPeerTypePM ) Zero () bool {
if a == nil {
return true
}
return true
}
func (a *AttachMenuPeerTypePM ) String () string {
if a == nil {
return "AttachMenuPeerTypePM(nil)"
}
type Alias AttachMenuPeerTypePM
return fmt .Sprintf ("AttachMenuPeerTypePM%+v" , Alias (*a ))
}
func (*AttachMenuPeerTypePM ) TypeID () uint32 {
return AttachMenuPeerTypePMTypeID
}
func (*AttachMenuPeerTypePM ) TypeName () string {
return "attachMenuPeerTypePM"
}
func (a *AttachMenuPeerTypePM ) TypeInfo () tdp .Type {
typ := tdp .Type {
Name : "attachMenuPeerTypePM" ,
ID : AttachMenuPeerTypePMTypeID ,
}
if a == nil {
typ .Null = true
return typ
}
typ .Fields = []tdp .Field {}
return typ
}
func (a *AttachMenuPeerTypePM ) Encode (b *bin .Buffer ) error {
if a == nil {
return fmt .Errorf ("can't encode attachMenuPeerTypePM#f146d31f as nil" )
}
b .PutID (AttachMenuPeerTypePMTypeID )
return a .EncodeBare (b )
}
func (a *AttachMenuPeerTypePM ) EncodeBare (b *bin .Buffer ) error {
if a == nil {
return fmt .Errorf ("can't encode attachMenuPeerTypePM#f146d31f as nil" )
}
return nil
}
func (a *AttachMenuPeerTypePM ) Decode (b *bin .Buffer ) error {
if a == nil {
return fmt .Errorf ("can't decode attachMenuPeerTypePM#f146d31f to nil" )
}
if err := b .ConsumeID (AttachMenuPeerTypePMTypeID ); err != nil {
return fmt .Errorf ("unable to decode attachMenuPeerTypePM#f146d31f: %w" , err )
}
return a .DecodeBare (b )
}
func (a *AttachMenuPeerTypePM ) DecodeBare (b *bin .Buffer ) error {
if a == nil {
return fmt .Errorf ("can't decode attachMenuPeerTypePM#f146d31f to nil" )
}
return nil
}
type AttachMenuPeerTypeChat struct {
}
const AttachMenuPeerTypeChatTypeID = 0x509113f
func (a AttachMenuPeerTypeChat ) construct () AttachMenuPeerTypeClass { return &a }
var (
_ bin .Encoder = &AttachMenuPeerTypeChat {}
_ bin .Decoder = &AttachMenuPeerTypeChat {}
_ bin .BareEncoder = &AttachMenuPeerTypeChat {}
_ bin .BareDecoder = &AttachMenuPeerTypeChat {}
_ AttachMenuPeerTypeClass = &AttachMenuPeerTypeChat {}
)
func (a *AttachMenuPeerTypeChat ) Zero () bool {
if a == nil {
return true
}
return true
}
func (a *AttachMenuPeerTypeChat ) String () string {
if a == nil {
return "AttachMenuPeerTypeChat(nil)"
}
type Alias AttachMenuPeerTypeChat
return fmt .Sprintf ("AttachMenuPeerTypeChat%+v" , Alias (*a ))
}
func (*AttachMenuPeerTypeChat ) TypeID () uint32 {
return AttachMenuPeerTypeChatTypeID
}
func (*AttachMenuPeerTypeChat ) TypeName () string {
return "attachMenuPeerTypeChat"
}
func (a *AttachMenuPeerTypeChat ) TypeInfo () tdp .Type {
typ := tdp .Type {
Name : "attachMenuPeerTypeChat" ,
ID : AttachMenuPeerTypeChatTypeID ,
}
if a == nil {
typ .Null = true
return typ
}
typ .Fields = []tdp .Field {}
return typ
}
func (a *AttachMenuPeerTypeChat ) Encode (b *bin .Buffer ) error {
if a == nil {
return fmt .Errorf ("can't encode attachMenuPeerTypeChat#509113f as nil" )
}
b .PutID (AttachMenuPeerTypeChatTypeID )
return a .EncodeBare (b )
}
func (a *AttachMenuPeerTypeChat ) EncodeBare (b *bin .Buffer ) error {
if a == nil {
return fmt .Errorf ("can't encode attachMenuPeerTypeChat#509113f as nil" )
}
return nil
}
func (a *AttachMenuPeerTypeChat ) Decode (b *bin .Buffer ) error {
if a == nil {
return fmt .Errorf ("can't decode attachMenuPeerTypeChat#509113f to nil" )
}
if err := b .ConsumeID (AttachMenuPeerTypeChatTypeID ); err != nil {
return fmt .Errorf ("unable to decode attachMenuPeerTypeChat#509113f: %w" , err )
}
return a .DecodeBare (b )
}
func (a *AttachMenuPeerTypeChat ) DecodeBare (b *bin .Buffer ) error {
if a == nil {
return fmt .Errorf ("can't decode attachMenuPeerTypeChat#509113f to nil" )
}
return nil
}
type AttachMenuPeerTypeBroadcast struct {
}
const AttachMenuPeerTypeBroadcastTypeID = 0x7bfbdefc
func (a AttachMenuPeerTypeBroadcast ) construct () AttachMenuPeerTypeClass { return &a }
var (
_ bin .Encoder = &AttachMenuPeerTypeBroadcast {}
_ bin .Decoder = &AttachMenuPeerTypeBroadcast {}
_ bin .BareEncoder = &AttachMenuPeerTypeBroadcast {}
_ bin .BareDecoder = &AttachMenuPeerTypeBroadcast {}
_ AttachMenuPeerTypeClass = &AttachMenuPeerTypeBroadcast {}
)
func (a *AttachMenuPeerTypeBroadcast ) Zero () bool {
if a == nil {
return true
}
return true
}
func (a *AttachMenuPeerTypeBroadcast ) String () string {
if a == nil {
return "AttachMenuPeerTypeBroadcast(nil)"
}
type Alias AttachMenuPeerTypeBroadcast
return fmt .Sprintf ("AttachMenuPeerTypeBroadcast%+v" , Alias (*a ))
}
func (*AttachMenuPeerTypeBroadcast ) TypeID () uint32 {
return AttachMenuPeerTypeBroadcastTypeID
}
func (*AttachMenuPeerTypeBroadcast ) TypeName () string {
return "attachMenuPeerTypeBroadcast"
}
func (a *AttachMenuPeerTypeBroadcast ) TypeInfo () tdp .Type {
typ := tdp .Type {
Name : "attachMenuPeerTypeBroadcast" ,
ID : AttachMenuPeerTypeBroadcastTypeID ,
}
if a == nil {
typ .Null = true
return typ
}
typ .Fields = []tdp .Field {}
return typ
}
func (a *AttachMenuPeerTypeBroadcast ) Encode (b *bin .Buffer ) error {
if a == nil {
return fmt .Errorf ("can't encode attachMenuPeerTypeBroadcast#7bfbdefc as nil" )
}
b .PutID (AttachMenuPeerTypeBroadcastTypeID )
return a .EncodeBare (b )
}
func (a *AttachMenuPeerTypeBroadcast ) EncodeBare (b *bin .Buffer ) error {
if a == nil {
return fmt .Errorf ("can't encode attachMenuPeerTypeBroadcast#7bfbdefc as nil" )
}
return nil
}
func (a *AttachMenuPeerTypeBroadcast ) Decode (b *bin .Buffer ) error {
if a == nil {
return fmt .Errorf ("can't decode attachMenuPeerTypeBroadcast#7bfbdefc to nil" )
}
if err := b .ConsumeID (AttachMenuPeerTypeBroadcastTypeID ); err != nil {
return fmt .Errorf ("unable to decode attachMenuPeerTypeBroadcast#7bfbdefc: %w" , err )
}
return a .DecodeBare (b )
}
func (a *AttachMenuPeerTypeBroadcast ) DecodeBare (b *bin .Buffer ) error {
if a == nil {
return fmt .Errorf ("can't decode attachMenuPeerTypeBroadcast#7bfbdefc to nil" )
}
return nil
}
const AttachMenuPeerTypeClassName = "AttachMenuPeerType"
type AttachMenuPeerTypeClass interface {
bin .Encoder
bin .Decoder
bin .BareEncoder
bin .BareDecoder
construct () AttachMenuPeerTypeClass
TypeID () uint32
TypeName () string
String () string
Zero () bool
}
func DecodeAttachMenuPeerType (buf *bin .Buffer ) (AttachMenuPeerTypeClass , error ) {
id , err := buf .PeekID ()
if err != nil {
return nil , err
}
switch id {
case AttachMenuPeerTypeSameBotPMTypeID :
v := AttachMenuPeerTypeSameBotPM {}
if err := v .Decode (buf ); err != nil {
return nil , fmt .Errorf ("unable to decode AttachMenuPeerTypeClass: %w" , err )
}
return &v , nil
case AttachMenuPeerTypeBotPMTypeID :
v := AttachMenuPeerTypeBotPM {}
if err := v .Decode (buf ); err != nil {
return nil , fmt .Errorf ("unable to decode AttachMenuPeerTypeClass: %w" , err )
}
return &v , nil
case AttachMenuPeerTypePMTypeID :
v := AttachMenuPeerTypePM {}
if err := v .Decode (buf ); err != nil {
return nil , fmt .Errorf ("unable to decode AttachMenuPeerTypeClass: %w" , err )
}
return &v , nil
case AttachMenuPeerTypeChatTypeID :
v := AttachMenuPeerTypeChat {}
if err := v .Decode (buf ); err != nil {
return nil , fmt .Errorf ("unable to decode AttachMenuPeerTypeClass: %w" , err )
}
return &v , nil
case AttachMenuPeerTypeBroadcastTypeID :
v := AttachMenuPeerTypeBroadcast {}
if err := v .Decode (buf ); err != nil {
return nil , fmt .Errorf ("unable to decode AttachMenuPeerTypeClass: %w" , err )
}
return &v , nil
default :
return nil , fmt .Errorf ("unable to decode AttachMenuPeerTypeClass: %w" , bin .NewUnexpectedID (id ))
}
}
type AttachMenuPeerTypeBox struct {
AttachMenuPeerType AttachMenuPeerTypeClass
}
func (b *AttachMenuPeerTypeBox ) Decode (buf *bin .Buffer ) error {
if b == nil {
return fmt .Errorf ("unable to decode AttachMenuPeerTypeBox to nil" )
}
v , err := DecodeAttachMenuPeerType (buf )
if err != nil {
return fmt .Errorf ("unable to decode boxed value: %w" , err )
}
b .AttachMenuPeerType = v
return nil
}
func (b *AttachMenuPeerTypeBox ) Encode (buf *bin .Buffer ) error {
if b == nil || b .AttachMenuPeerType == nil {
return fmt .Errorf ("unable to encode AttachMenuPeerTypeClass as nil" )
}
return b .AttachMenuPeerType .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 .