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 AuthCodeTypeSMS struct {
}
const AuthCodeTypeSMSTypeID = 0x72a3158c
func (c AuthCodeTypeSMS ) construct () AuthCodeTypeClass { return &c }
var (
_ bin .Encoder = &AuthCodeTypeSMS {}
_ bin .Decoder = &AuthCodeTypeSMS {}
_ bin .BareEncoder = &AuthCodeTypeSMS {}
_ bin .BareDecoder = &AuthCodeTypeSMS {}
_ AuthCodeTypeClass = &AuthCodeTypeSMS {}
)
func (c *AuthCodeTypeSMS ) Zero () bool {
if c == nil {
return true
}
return true
}
func (c *AuthCodeTypeSMS ) String () string {
if c == nil {
return "AuthCodeTypeSMS(nil)"
}
type Alias AuthCodeTypeSMS
return fmt .Sprintf ("AuthCodeTypeSMS%+v" , Alias (*c ))
}
func (*AuthCodeTypeSMS ) TypeID () uint32 {
return AuthCodeTypeSMSTypeID
}
func (*AuthCodeTypeSMS ) TypeName () string {
return "auth.codeTypeSms"
}
func (c *AuthCodeTypeSMS ) TypeInfo () tdp .Type {
typ := tdp .Type {
Name : "auth.codeTypeSms" ,
ID : AuthCodeTypeSMSTypeID ,
}
if c == nil {
typ .Null = true
return typ
}
typ .Fields = []tdp .Field {}
return typ
}
func (c *AuthCodeTypeSMS ) Encode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode auth.codeTypeSms#72a3158c as nil" )
}
b .PutID (AuthCodeTypeSMSTypeID )
return c .EncodeBare (b )
}
func (c *AuthCodeTypeSMS ) EncodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode auth.codeTypeSms#72a3158c as nil" )
}
return nil
}
func (c *AuthCodeTypeSMS ) Decode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode auth.codeTypeSms#72a3158c to nil" )
}
if err := b .ConsumeID (AuthCodeTypeSMSTypeID ); err != nil {
return fmt .Errorf ("unable to decode auth.codeTypeSms#72a3158c: %w" , err )
}
return c .DecodeBare (b )
}
func (c *AuthCodeTypeSMS ) DecodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode auth.codeTypeSms#72a3158c to nil" )
}
return nil
}
type AuthCodeTypeCall struct {
}
const AuthCodeTypeCallTypeID = 0x741cd3e3
func (c AuthCodeTypeCall ) construct () AuthCodeTypeClass { return &c }
var (
_ bin .Encoder = &AuthCodeTypeCall {}
_ bin .Decoder = &AuthCodeTypeCall {}
_ bin .BareEncoder = &AuthCodeTypeCall {}
_ bin .BareDecoder = &AuthCodeTypeCall {}
_ AuthCodeTypeClass = &AuthCodeTypeCall {}
)
func (c *AuthCodeTypeCall ) Zero () bool {
if c == nil {
return true
}
return true
}
func (c *AuthCodeTypeCall ) String () string {
if c == nil {
return "AuthCodeTypeCall(nil)"
}
type Alias AuthCodeTypeCall
return fmt .Sprintf ("AuthCodeTypeCall%+v" , Alias (*c ))
}
func (*AuthCodeTypeCall ) TypeID () uint32 {
return AuthCodeTypeCallTypeID
}
func (*AuthCodeTypeCall ) TypeName () string {
return "auth.codeTypeCall"
}
func (c *AuthCodeTypeCall ) TypeInfo () tdp .Type {
typ := tdp .Type {
Name : "auth.codeTypeCall" ,
ID : AuthCodeTypeCallTypeID ,
}
if c == nil {
typ .Null = true
return typ
}
typ .Fields = []tdp .Field {}
return typ
}
func (c *AuthCodeTypeCall ) Encode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode auth.codeTypeCall#741cd3e3 as nil" )
}
b .PutID (AuthCodeTypeCallTypeID )
return c .EncodeBare (b )
}
func (c *AuthCodeTypeCall ) EncodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode auth.codeTypeCall#741cd3e3 as nil" )
}
return nil
}
func (c *AuthCodeTypeCall ) Decode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode auth.codeTypeCall#741cd3e3 to nil" )
}
if err := b .ConsumeID (AuthCodeTypeCallTypeID ); err != nil {
return fmt .Errorf ("unable to decode auth.codeTypeCall#741cd3e3: %w" , err )
}
return c .DecodeBare (b )
}
func (c *AuthCodeTypeCall ) DecodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode auth.codeTypeCall#741cd3e3 to nil" )
}
return nil
}
type AuthCodeTypeFlashCall struct {
}
const AuthCodeTypeFlashCallTypeID = 0x226ccefb
func (c AuthCodeTypeFlashCall ) construct () AuthCodeTypeClass { return &c }
var (
_ bin .Encoder = &AuthCodeTypeFlashCall {}
_ bin .Decoder = &AuthCodeTypeFlashCall {}
_ bin .BareEncoder = &AuthCodeTypeFlashCall {}
_ bin .BareDecoder = &AuthCodeTypeFlashCall {}
_ AuthCodeTypeClass = &AuthCodeTypeFlashCall {}
)
func (c *AuthCodeTypeFlashCall ) Zero () bool {
if c == nil {
return true
}
return true
}
func (c *AuthCodeTypeFlashCall ) String () string {
if c == nil {
return "AuthCodeTypeFlashCall(nil)"
}
type Alias AuthCodeTypeFlashCall
return fmt .Sprintf ("AuthCodeTypeFlashCall%+v" , Alias (*c ))
}
func (*AuthCodeTypeFlashCall ) TypeID () uint32 {
return AuthCodeTypeFlashCallTypeID
}
func (*AuthCodeTypeFlashCall ) TypeName () string {
return "auth.codeTypeFlashCall"
}
func (c *AuthCodeTypeFlashCall ) TypeInfo () tdp .Type {
typ := tdp .Type {
Name : "auth.codeTypeFlashCall" ,
ID : AuthCodeTypeFlashCallTypeID ,
}
if c == nil {
typ .Null = true
return typ
}
typ .Fields = []tdp .Field {}
return typ
}
func (c *AuthCodeTypeFlashCall ) Encode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode auth.codeTypeFlashCall#226ccefb as nil" )
}
b .PutID (AuthCodeTypeFlashCallTypeID )
return c .EncodeBare (b )
}
func (c *AuthCodeTypeFlashCall ) EncodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode auth.codeTypeFlashCall#226ccefb as nil" )
}
return nil
}
func (c *AuthCodeTypeFlashCall ) Decode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode auth.codeTypeFlashCall#226ccefb to nil" )
}
if err := b .ConsumeID (AuthCodeTypeFlashCallTypeID ); err != nil {
return fmt .Errorf ("unable to decode auth.codeTypeFlashCall#226ccefb: %w" , err )
}
return c .DecodeBare (b )
}
func (c *AuthCodeTypeFlashCall ) DecodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode auth.codeTypeFlashCall#226ccefb to nil" )
}
return nil
}
type AuthCodeTypeMissedCall struct {
}
const AuthCodeTypeMissedCallTypeID = 0xd61ad6ee
func (c AuthCodeTypeMissedCall ) construct () AuthCodeTypeClass { return &c }
var (
_ bin .Encoder = &AuthCodeTypeMissedCall {}
_ bin .Decoder = &AuthCodeTypeMissedCall {}
_ bin .BareEncoder = &AuthCodeTypeMissedCall {}
_ bin .BareDecoder = &AuthCodeTypeMissedCall {}
_ AuthCodeTypeClass = &AuthCodeTypeMissedCall {}
)
func (c *AuthCodeTypeMissedCall ) Zero () bool {
if c == nil {
return true
}
return true
}
func (c *AuthCodeTypeMissedCall ) String () string {
if c == nil {
return "AuthCodeTypeMissedCall(nil)"
}
type Alias AuthCodeTypeMissedCall
return fmt .Sprintf ("AuthCodeTypeMissedCall%+v" , Alias (*c ))
}
func (*AuthCodeTypeMissedCall ) TypeID () uint32 {
return AuthCodeTypeMissedCallTypeID
}
func (*AuthCodeTypeMissedCall ) TypeName () string {
return "auth.codeTypeMissedCall"
}
func (c *AuthCodeTypeMissedCall ) TypeInfo () tdp .Type {
typ := tdp .Type {
Name : "auth.codeTypeMissedCall" ,
ID : AuthCodeTypeMissedCallTypeID ,
}
if c == nil {
typ .Null = true
return typ
}
typ .Fields = []tdp .Field {}
return typ
}
func (c *AuthCodeTypeMissedCall ) Encode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode auth.codeTypeMissedCall#d61ad6ee as nil" )
}
b .PutID (AuthCodeTypeMissedCallTypeID )
return c .EncodeBare (b )
}
func (c *AuthCodeTypeMissedCall ) EncodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode auth.codeTypeMissedCall#d61ad6ee as nil" )
}
return nil
}
func (c *AuthCodeTypeMissedCall ) Decode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode auth.codeTypeMissedCall#d61ad6ee to nil" )
}
if err := b .ConsumeID (AuthCodeTypeMissedCallTypeID ); err != nil {
return fmt .Errorf ("unable to decode auth.codeTypeMissedCall#d61ad6ee: %w" , err )
}
return c .DecodeBare (b )
}
func (c *AuthCodeTypeMissedCall ) DecodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode auth.codeTypeMissedCall#d61ad6ee to nil" )
}
return nil
}
type AuthCodeTypeFragmentSMS struct {
}
const AuthCodeTypeFragmentSMSTypeID = 0x6ed998c
func (c AuthCodeTypeFragmentSMS ) construct () AuthCodeTypeClass { return &c }
var (
_ bin .Encoder = &AuthCodeTypeFragmentSMS {}
_ bin .Decoder = &AuthCodeTypeFragmentSMS {}
_ bin .BareEncoder = &AuthCodeTypeFragmentSMS {}
_ bin .BareDecoder = &AuthCodeTypeFragmentSMS {}
_ AuthCodeTypeClass = &AuthCodeTypeFragmentSMS {}
)
func (c *AuthCodeTypeFragmentSMS ) Zero () bool {
if c == nil {
return true
}
return true
}
func (c *AuthCodeTypeFragmentSMS ) String () string {
if c == nil {
return "AuthCodeTypeFragmentSMS(nil)"
}
type Alias AuthCodeTypeFragmentSMS
return fmt .Sprintf ("AuthCodeTypeFragmentSMS%+v" , Alias (*c ))
}
func (*AuthCodeTypeFragmentSMS ) TypeID () uint32 {
return AuthCodeTypeFragmentSMSTypeID
}
func (*AuthCodeTypeFragmentSMS ) TypeName () string {
return "auth.codeTypeFragmentSms"
}
func (c *AuthCodeTypeFragmentSMS ) TypeInfo () tdp .Type {
typ := tdp .Type {
Name : "auth.codeTypeFragmentSms" ,
ID : AuthCodeTypeFragmentSMSTypeID ,
}
if c == nil {
typ .Null = true
return typ
}
typ .Fields = []tdp .Field {}
return typ
}
func (c *AuthCodeTypeFragmentSMS ) Encode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode auth.codeTypeFragmentSms#6ed998c as nil" )
}
b .PutID (AuthCodeTypeFragmentSMSTypeID )
return c .EncodeBare (b )
}
func (c *AuthCodeTypeFragmentSMS ) EncodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't encode auth.codeTypeFragmentSms#6ed998c as nil" )
}
return nil
}
func (c *AuthCodeTypeFragmentSMS ) Decode (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode auth.codeTypeFragmentSms#6ed998c to nil" )
}
if err := b .ConsumeID (AuthCodeTypeFragmentSMSTypeID ); err != nil {
return fmt .Errorf ("unable to decode auth.codeTypeFragmentSms#6ed998c: %w" , err )
}
return c .DecodeBare (b )
}
func (c *AuthCodeTypeFragmentSMS ) DecodeBare (b *bin .Buffer ) error {
if c == nil {
return fmt .Errorf ("can't decode auth.codeTypeFragmentSms#6ed998c to nil" )
}
return nil
}
const AuthCodeTypeClassName = "auth.CodeType"
type AuthCodeTypeClass interface {
bin .Encoder
bin .Decoder
bin .BareEncoder
bin .BareDecoder
construct () AuthCodeTypeClass
TypeID () uint32
TypeName () string
String () string
Zero () bool
}
func DecodeAuthCodeType (buf *bin .Buffer ) (AuthCodeTypeClass , error ) {
id , err := buf .PeekID ()
if err != nil {
return nil , err
}
switch id {
case AuthCodeTypeSMSTypeID :
v := AuthCodeTypeSMS {}
if err := v .Decode (buf ); err != nil {
return nil , fmt .Errorf ("unable to decode AuthCodeTypeClass: %w" , err )
}
return &v , nil
case AuthCodeTypeCallTypeID :
v := AuthCodeTypeCall {}
if err := v .Decode (buf ); err != nil {
return nil , fmt .Errorf ("unable to decode AuthCodeTypeClass: %w" , err )
}
return &v , nil
case AuthCodeTypeFlashCallTypeID :
v := AuthCodeTypeFlashCall {}
if err := v .Decode (buf ); err != nil {
return nil , fmt .Errorf ("unable to decode AuthCodeTypeClass: %w" , err )
}
return &v , nil
case AuthCodeTypeMissedCallTypeID :
v := AuthCodeTypeMissedCall {}
if err := v .Decode (buf ); err != nil {
return nil , fmt .Errorf ("unable to decode AuthCodeTypeClass: %w" , err )
}
return &v , nil
case AuthCodeTypeFragmentSMSTypeID :
v := AuthCodeTypeFragmentSMS {}
if err := v .Decode (buf ); err != nil {
return nil , fmt .Errorf ("unable to decode AuthCodeTypeClass: %w" , err )
}
return &v , nil
default :
return nil , fmt .Errorf ("unable to decode AuthCodeTypeClass: %w" , bin .NewUnexpectedID (id ))
}
}
type AuthCodeTypeBox struct {
CodeType AuthCodeTypeClass
}
func (b *AuthCodeTypeBox ) Decode (buf *bin .Buffer ) error {
if b == nil {
return fmt .Errorf ("unable to decode AuthCodeTypeBox to nil" )
}
v , err := DecodeAuthCodeType (buf )
if err != nil {
return fmt .Errorf ("unable to decode boxed value: %w" , err )
}
b .CodeType = v
return nil
}
func (b *AuthCodeTypeBox ) Encode (buf *bin .Buffer ) error {
if b == nil || b .CodeType == nil {
return fmt .Errorf ("unable to encode AuthCodeTypeClass as nil" )
}
return b .CodeType .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 .