Source File
	tl_phone_call_gen.go

Belonging Package
	github.com/gotd/td/tg

// Code generated by gotdgen, DO NOT EDIT.

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"
)

// No-op definition for keeping imports.
var (
	_ = bin.Buffer{}
	_ = context.Background()
	_ = fmt.Stringer(nil)
	_ = strings.Builder{}
	_ = errors.Is
	_ = multierr.AppendInto
	_ = sort.Ints
	_ = tdp.Format
	_ = tgerr.Error{}
	_ = tdjson.Encoder{}
)

// PhoneCallEmpty represents TL type `phoneCallEmpty#5366c915`.
// Empty constructor
//
// See https://core.telegram.org/constructor/phoneCallEmpty for reference.
type PhoneCallEmpty struct {
	// Call ID
	ID int64
}

// PhoneCallEmptyTypeID is TL type id of PhoneCallEmpty.
const PhoneCallEmptyTypeID = 0x5366c915

// construct implements constructor of PhoneCallClass.
func (p PhoneCallEmpty) construct() PhoneCallClass { return &p }

// Ensuring interfaces in compile-time for PhoneCallEmpty.
var (
	_ bin.Encoder     = &PhoneCallEmpty{}
	_ bin.Decoder     = &PhoneCallEmpty{}
	_ bin.BareEncoder = &PhoneCallEmpty{}
	_ bin.BareDecoder = &PhoneCallEmpty{}

	_ PhoneCallClass = &PhoneCallEmpty{}
)

func (p *PhoneCallEmpty) Zero() bool {
	if p == nil {
		return true
	}
	if !(p.ID == 0) {
		return false
	}

	return true
}

// String implements fmt.Stringer.
func (p *PhoneCallEmpty) String() string {
	if p == nil {
		return "PhoneCallEmpty(nil)"
	}
	type Alias PhoneCallEmpty
	return fmt.Sprintf("PhoneCallEmpty%+v", Alias(*p))
}

// FillFrom fills PhoneCallEmpty from given interface.
func (p *PhoneCallEmpty) FillFrom(from interface {
	GetID() (value int64)
}) {
	p.ID = from.GetID()
}

// TypeID returns type id in TL schema.
//
// See https://core.telegram.org/mtproto/TL-tl#remarks.
func (*PhoneCallEmpty) TypeID() uint32 {
	return PhoneCallEmptyTypeID
}

// TypeName returns name of type in TL schema.
func (*PhoneCallEmpty) TypeName() string {
	return "phoneCallEmpty"
}

// TypeInfo returns info about TL type.
func (p *PhoneCallEmpty) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "phoneCallEmpty",
		ID:   PhoneCallEmptyTypeID,
	}
	if p == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "ID",
			SchemaName: "id",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (p *PhoneCallEmpty) Encode(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't encode phoneCallEmpty#5366c915 as nil")
	}
	b.PutID(PhoneCallEmptyTypeID)
	return p.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (p *PhoneCallEmpty) EncodeBare(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't encode phoneCallEmpty#5366c915 as nil")
	}
	b.PutLong(p.ID)
	return nil
}

// Decode implements bin.Decoder.
func (p *PhoneCallEmpty) Decode(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't decode phoneCallEmpty#5366c915 to nil")
	}
	if err := b.ConsumeID(PhoneCallEmptyTypeID); err != nil {
		return fmt.Errorf("unable to decode phoneCallEmpty#5366c915: %w", err)
	}
	return p.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (p *PhoneCallEmpty) DecodeBare(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't decode phoneCallEmpty#5366c915 to nil")
	}
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCallEmpty#5366c915: field id: %w", err)
		}
		p.ID = value
	}
	return nil
}

// GetID returns value of ID field.
func (p *PhoneCallEmpty) GetID() (value int64) {
	if p == nil {
		return
	}
	return p.ID
}

// PhoneCallWaiting represents TL type `phoneCallWaiting#c5226f17`.
// Incoming phone call
//
// See https://core.telegram.org/constructor/phoneCallWaiting for reference.
type PhoneCallWaiting struct {
	// Flags, see TL conditional fields¹
	//
	// Links:
	//  1) https://core.telegram.org/mtproto/TL-combinators#conditional-fields
	Flags bin.Fields
	// Is this a video call
	Video bool
	// Call ID
	ID int64
	// Access hash
	AccessHash int64
	// Date
	Date int
	// Admin ID
	AdminID int64
	// Participant ID
	ParticipantID int64
	// Phone call protocol info
	Protocol PhoneCallProtocol
	// When was the phone call received
	//
	// Use SetReceiveDate and GetReceiveDate helpers.
	ReceiveDate int
}

// PhoneCallWaitingTypeID is TL type id of PhoneCallWaiting.
const PhoneCallWaitingTypeID = 0xc5226f17

// construct implements constructor of PhoneCallClass.
func (p PhoneCallWaiting) construct() PhoneCallClass { return &p }

// Ensuring interfaces in compile-time for PhoneCallWaiting.
var (
	_ bin.Encoder     = &PhoneCallWaiting{}
	_ bin.Decoder     = &PhoneCallWaiting{}
	_ bin.BareEncoder = &PhoneCallWaiting{}
	_ bin.BareDecoder = &PhoneCallWaiting{}

	_ PhoneCallClass = &PhoneCallWaiting{}
)

func (p *PhoneCallWaiting) Zero() bool {
	if p == nil {
		return true
	}
	if !(p.Flags.Zero()) {
		return false
	}
	if !(p.Video == false) {
		return false
	}
	if !(p.ID == 0) {
		return false
	}
	if !(p.AccessHash == 0) {
		return false
	}
	if !(p.Date == 0) {
		return false
	}
	if !(p.AdminID == 0) {
		return false
	}
	if !(p.ParticipantID == 0) {
		return false
	}
	if !(p.Protocol.Zero()) {
		return false
	}
	if !(p.ReceiveDate == 0) {
		return false
	}

	return true
}

// String implements fmt.Stringer.
func (p *PhoneCallWaiting) String() string {
	if p == nil {
		return "PhoneCallWaiting(nil)"
	}
	type Alias PhoneCallWaiting
	return fmt.Sprintf("PhoneCallWaiting%+v", Alias(*p))
}

// FillFrom fills PhoneCallWaiting from given interface.
func (p *PhoneCallWaiting) FillFrom(from interface {
	GetVideo() (value bool)
	GetID() (value int64)
	GetAccessHash() (value int64)
	GetDate() (value int)
	GetAdminID() (value int64)
	GetParticipantID() (value int64)
	GetProtocol() (value PhoneCallProtocol)
	GetReceiveDate() (value int, ok bool)
}) {
	p.Video = from.GetVideo()
	p.ID = from.GetID()
	p.AccessHash = from.GetAccessHash()
	p.Date = from.GetDate()
	p.AdminID = from.GetAdminID()
	p.ParticipantID = from.GetParticipantID()
	p.Protocol = from.GetProtocol()
	if val, ok := from.GetReceiveDate(); ok {
		p.ReceiveDate = val
	}

}

// TypeID returns type id in TL schema.
//
// See https://core.telegram.org/mtproto/TL-tl#remarks.
func (*PhoneCallWaiting) TypeID() uint32 {
	return PhoneCallWaitingTypeID
}

// TypeName returns name of type in TL schema.
func (*PhoneCallWaiting) TypeName() string {
	return "phoneCallWaiting"
}

// TypeInfo returns info about TL type.
func (p *PhoneCallWaiting) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "phoneCallWaiting",
		ID:   PhoneCallWaitingTypeID,
	}
	if p == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Video",
			SchemaName: "video",
			Null:       !p.Flags.Has(6),
		},
		{
			Name:       "ID",
			SchemaName: "id",
		},
		{
			Name:       "AccessHash",
			SchemaName: "access_hash",
		},
		{
			Name:       "Date",
			SchemaName: "date",
		},
		{
			Name:       "AdminID",
			SchemaName: "admin_id",
		},
		{
			Name:       "ParticipantID",
			SchemaName: "participant_id",
		},
		{
			Name:       "Protocol",
			SchemaName: "protocol",
		},
		{
			Name:       "ReceiveDate",
			SchemaName: "receive_date",
			Null:       !p.Flags.Has(0),
		},
	}
	return typ
}

// SetFlags sets flags for non-zero fields.
func (p *PhoneCallWaiting) SetFlags() {
	if !(p.Video == false) {
		p.Flags.Set(6)
	}
	if !(p.ReceiveDate == 0) {
		p.Flags.Set(0)
	}
}

// Encode implements bin.Encoder.
func (p *PhoneCallWaiting) Encode(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't encode phoneCallWaiting#c5226f17 as nil")
	}
	b.PutID(PhoneCallWaitingTypeID)
	return p.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (p *PhoneCallWaiting) EncodeBare(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't encode phoneCallWaiting#c5226f17 as nil")
	}
	p.SetFlags()
	if err := p.Flags.Encode(b); err != nil {
		return fmt.Errorf("unable to encode phoneCallWaiting#c5226f17: field flags: %w", err)
	}
	b.PutLong(p.ID)
	b.PutLong(p.AccessHash)
	b.PutInt(p.Date)
	b.PutLong(p.AdminID)
	b.PutLong(p.ParticipantID)
	if err := p.Protocol.Encode(b); err != nil {
		return fmt.Errorf("unable to encode phoneCallWaiting#c5226f17: field protocol: %w", err)
	}
	if p.Flags.Has(0) {
		b.PutInt(p.ReceiveDate)
	}
	return nil
}

// Decode implements bin.Decoder.
func (p *PhoneCallWaiting) Decode(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't decode phoneCallWaiting#c5226f17 to nil")
	}
	if err := b.ConsumeID(PhoneCallWaitingTypeID); err != nil {
		return fmt.Errorf("unable to decode phoneCallWaiting#c5226f17: %w", err)
	}
	return p.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (p *PhoneCallWaiting) DecodeBare(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't decode phoneCallWaiting#c5226f17 to nil")
	}
	{
		if err := p.Flags.Decode(b); err != nil {
			return fmt.Errorf("unable to decode phoneCallWaiting#c5226f17: field flags: %w", err)
		}
	}
	p.Video = p.Flags.Has(6)
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCallWaiting#c5226f17: field id: %w", err)
		}
		p.ID = value
	}
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCallWaiting#c5226f17: field access_hash: %w", err)
		}
		p.AccessHash = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCallWaiting#c5226f17: field date: %w", err)
		}
		p.Date = value
	}
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCallWaiting#c5226f17: field admin_id: %w", err)
		}
		p.AdminID = value
	}
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCallWaiting#c5226f17: field participant_id: %w", err)
		}
		p.ParticipantID = value
	}
	{
		if err := p.Protocol.Decode(b); err != nil {
			return fmt.Errorf("unable to decode phoneCallWaiting#c5226f17: field protocol: %w", err)
		}
	}
	if p.Flags.Has(0) {
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCallWaiting#c5226f17: field receive_date: %w", err)
		}
		p.ReceiveDate = value
	}
	return nil
}

// SetVideo sets value of Video conditional field.
func (p *PhoneCallWaiting) SetVideo(value bool) {
	if value {
		p.Flags.Set(6)
		p.Video = true
	} else {
		p.Flags.Unset(6)
		p.Video = false
	}
}

// GetVideo returns value of Video conditional field.
func (p *PhoneCallWaiting) GetVideo() (value bool) {
	if p == nil {
		return
	}
	return p.Flags.Has(6)
}

// GetID returns value of ID field.
func (p *PhoneCallWaiting) GetID() (value int64) {
	if p == nil {
		return
	}
	return p.ID
}

// GetAccessHash returns value of AccessHash field.
func (p *PhoneCallWaiting) GetAccessHash() (value int64) {
	if p == nil {
		return
	}
	return p.AccessHash
}

// GetDate returns value of Date field.
func (p *PhoneCallWaiting) GetDate() (value int) {
	if p == nil {
		return
	}
	return p.Date
}

// GetAdminID returns value of AdminID field.
func (p *PhoneCallWaiting) GetAdminID() (value int64) {
	if p == nil {
		return
	}
	return p.AdminID
}

// GetParticipantID returns value of ParticipantID field.
func (p *PhoneCallWaiting) GetParticipantID() (value int64) {
	if p == nil {
		return
	}
	return p.ParticipantID
}

// GetProtocol returns value of Protocol field.
func (p *PhoneCallWaiting) GetProtocol() (value PhoneCallProtocol) {
	if p == nil {
		return
	}
	return p.Protocol
}

// SetReceiveDate sets value of ReceiveDate conditional field.
func (p *PhoneCallWaiting) SetReceiveDate(value int) {
	p.Flags.Set(0)
	p.ReceiveDate = value
}

// GetReceiveDate returns value of ReceiveDate conditional field and
// boolean which is true if field was set.
func (p *PhoneCallWaiting) GetReceiveDate() (value int, ok bool) {
	if p == nil {
		return
	}
	if !p.Flags.Has(0) {
		return value, false
	}
	return p.ReceiveDate, true
}

// PhoneCallRequested represents TL type `phoneCallRequested#14b0ed0c`.
// Requested phone call
//
// See https://core.telegram.org/constructor/phoneCallRequested for reference.
type PhoneCallRequested struct {
	// Flags, see TL conditional fields¹
	//
	// Links:
	//  1) https://core.telegram.org/mtproto/TL-combinators#conditional-fields
	Flags bin.Fields
	// Whether this is a video call
	Video bool
	// Phone call ID
	ID int64
	// Access hash
	AccessHash int64
	// When was the phone call created
	Date int
	// ID of the creator of the phone call
	AdminID int64
	// ID of the other participant of the phone call
	ParticipantID int64
	// Parameter for key exchange¹
	//
	// Links:
	//  1) https://core.telegram.org/api/end-to-end/voice-calls
	GAHash []byte
	// Call protocol info to be passed to libtgvoip
	Protocol PhoneCallProtocol
}

// PhoneCallRequestedTypeID is TL type id of PhoneCallRequested.
const PhoneCallRequestedTypeID = 0x14b0ed0c

// construct implements constructor of PhoneCallClass.
func (p PhoneCallRequested) construct() PhoneCallClass { return &p }

// Ensuring interfaces in compile-time for PhoneCallRequested.
var (
	_ bin.Encoder     = &PhoneCallRequested{}
	_ bin.Decoder     = &PhoneCallRequested{}
	_ bin.BareEncoder = &PhoneCallRequested{}
	_ bin.BareDecoder = &PhoneCallRequested{}

	_ PhoneCallClass = &PhoneCallRequested{}
)

func (p *PhoneCallRequested) Zero() bool {
	if p == nil {
		return true
	}
	if !(p.Flags.Zero()) {
		return false
	}
	if !(p.Video == false) {
		return false
	}
	if !(p.ID == 0) {
		return false
	}
	if !(p.AccessHash == 0) {
		return false
	}
	if !(p.Date == 0) {
		return false
	}
	if !(p.AdminID == 0) {
		return false
	}
	if !(p.ParticipantID == 0) {
		return false
	}
	if !(p.GAHash == nil) {
		return false
	}
	if !(p.Protocol.Zero()) {
		return false
	}

	return true
}

// String implements fmt.Stringer.
func (p *PhoneCallRequested) String() string {
	if p == nil {
		return "PhoneCallRequested(nil)"
	}
	type Alias PhoneCallRequested
	return fmt.Sprintf("PhoneCallRequested%+v", Alias(*p))
}

// FillFrom fills PhoneCallRequested from given interface.
func (p *PhoneCallRequested) FillFrom(from interface {
	GetVideo() (value bool)
	GetID() (value int64)
	GetAccessHash() (value int64)
	GetDate() (value int)
	GetAdminID() (value int64)
	GetParticipantID() (value int64)
	GetGAHash() (value []byte)
	GetProtocol() (value PhoneCallProtocol)
}) {
	p.Video = from.GetVideo()
	p.ID = from.GetID()
	p.AccessHash = from.GetAccessHash()
	p.Date = from.GetDate()
	p.AdminID = from.GetAdminID()
	p.ParticipantID = from.GetParticipantID()
	p.GAHash = from.GetGAHash()
	p.Protocol = from.GetProtocol()
}

// TypeID returns type id in TL schema.
//
// See https://core.telegram.org/mtproto/TL-tl#remarks.
func (*PhoneCallRequested) TypeID() uint32 {
	return PhoneCallRequestedTypeID
}

// TypeName returns name of type in TL schema.
func (*PhoneCallRequested) TypeName() string {
	return "phoneCallRequested"
}

// TypeInfo returns info about TL type.
func (p *PhoneCallRequested) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "phoneCallRequested",
		ID:   PhoneCallRequestedTypeID,
	}
	if p == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Video",
			SchemaName: "video",
			Null:       !p.Flags.Has(6),
		},
		{
			Name:       "ID",
			SchemaName: "id",
		},
		{
			Name:       "AccessHash",
			SchemaName: "access_hash",
		},
		{
			Name:       "Date",
			SchemaName: "date",
		},
		{
			Name:       "AdminID",
			SchemaName: "admin_id",
		},
		{
			Name:       "ParticipantID",
			SchemaName: "participant_id",
		},
		{
			Name:       "GAHash",
			SchemaName: "g_a_hash",
		},
		{
			Name:       "Protocol",
			SchemaName: "protocol",
		},
	}
	return typ
}

// SetFlags sets flags for non-zero fields.
func (p *PhoneCallRequested) SetFlags() {
	if !(p.Video == false) {
		p.Flags.Set(6)
	}
}

// Encode implements bin.Encoder.
func (p *PhoneCallRequested) Encode(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't encode phoneCallRequested#14b0ed0c as nil")
	}
	b.PutID(PhoneCallRequestedTypeID)
	return p.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (p *PhoneCallRequested) EncodeBare(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't encode phoneCallRequested#14b0ed0c as nil")
	}
	p.SetFlags()
	if err := p.Flags.Encode(b); err != nil {
		return fmt.Errorf("unable to encode phoneCallRequested#14b0ed0c: field flags: %w", err)
	}
	b.PutLong(p.ID)
	b.PutLong(p.AccessHash)
	b.PutInt(p.Date)
	b.PutLong(p.AdminID)
	b.PutLong(p.ParticipantID)
	b.PutBytes(p.GAHash)
	if err := p.Protocol.Encode(b); err != nil {
		return fmt.Errorf("unable to encode phoneCallRequested#14b0ed0c: field protocol: %w", err)
	}
	return nil
}

// Decode implements bin.Decoder.
func (p *PhoneCallRequested) Decode(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't decode phoneCallRequested#14b0ed0c to nil")
	}
	if err := b.ConsumeID(PhoneCallRequestedTypeID); err != nil {
		return fmt.Errorf("unable to decode phoneCallRequested#14b0ed0c: %w", err)
	}
	return p.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (p *PhoneCallRequested) DecodeBare(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't decode phoneCallRequested#14b0ed0c to nil")
	}
	{
		if err := p.Flags.Decode(b); err != nil {
			return fmt.Errorf("unable to decode phoneCallRequested#14b0ed0c: field flags: %w", err)
		}
	}
	p.Video = p.Flags.Has(6)
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCallRequested#14b0ed0c: field id: %w", err)
		}
		p.ID = value
	}
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCallRequested#14b0ed0c: field access_hash: %w", err)
		}
		p.AccessHash = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCallRequested#14b0ed0c: field date: %w", err)
		}
		p.Date = value
	}
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCallRequested#14b0ed0c: field admin_id: %w", err)
		}
		p.AdminID = value
	}
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCallRequested#14b0ed0c: field participant_id: %w", err)
		}
		p.ParticipantID = value
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCallRequested#14b0ed0c: field g_a_hash: %w", err)
		}
		p.GAHash = value
	}
	{
		if err := p.Protocol.Decode(b); err != nil {
			return fmt.Errorf("unable to decode phoneCallRequested#14b0ed0c: field protocol: %w", err)
		}
	}
	return nil
}

// SetVideo sets value of Video conditional field.
func (p *PhoneCallRequested) SetVideo(value bool) {
	if value {
		p.Flags.Set(6)
		p.Video = true
	} else {
		p.Flags.Unset(6)
		p.Video = false
	}
}

// GetVideo returns value of Video conditional field.
func (p *PhoneCallRequested) GetVideo() (value bool) {
	if p == nil {
		return
	}
	return p.Flags.Has(6)
}

// GetID returns value of ID field.
func (p *PhoneCallRequested) GetID() (value int64) {
	if p == nil {
		return
	}
	return p.ID
}

// GetAccessHash returns value of AccessHash field.
func (p *PhoneCallRequested) GetAccessHash() (value int64) {
	if p == nil {
		return
	}
	return p.AccessHash
}

// GetDate returns value of Date field.
func (p *PhoneCallRequested) GetDate() (value int) {
	if p == nil {
		return
	}
	return p.Date
}

// GetAdminID returns value of AdminID field.
func (p *PhoneCallRequested) GetAdminID() (value int64) {
	if p == nil {
		return
	}
	return p.AdminID
}

// GetParticipantID returns value of ParticipantID field.
func (p *PhoneCallRequested) GetParticipantID() (value int64) {
	if p == nil {
		return
	}
	return p.ParticipantID
}

// GetGAHash returns value of GAHash field.
func (p *PhoneCallRequested) GetGAHash() (value []byte) {
	if p == nil {
		return
	}
	return p.GAHash
}

// GetProtocol returns value of Protocol field.
func (p *PhoneCallRequested) GetProtocol() (value PhoneCallProtocol) {
	if p == nil {
		return
	}
	return p.Protocol
}

// PhoneCallAccepted represents TL type `phoneCallAccepted#3660c311`.
// An accepted phone call
//
// See https://core.telegram.org/constructor/phoneCallAccepted for reference.
type PhoneCallAccepted struct {
	// Flags, see TL conditional fields¹
	//
	// Links:
	//  1) https://core.telegram.org/mtproto/TL-combinators#conditional-fields
	Flags bin.Fields
	// Whether this is a video call
	Video bool
	// ID of accepted phone call
	ID int64
	// Access hash of phone call
	AccessHash int64
	// When was the call accepted
	Date int
	// ID of the call creator
	AdminID int64
	// ID of the other user in the call
	ParticipantID int64
	// B parameter for secure E2E phone call key exchange¹
	//
	// Links:
	//  1) https://core.telegram.org/api/end-to-end/voice-calls
	GB []byte
	// Protocol to use for phone call
	Protocol PhoneCallProtocol
}

// PhoneCallAcceptedTypeID is TL type id of PhoneCallAccepted.
const PhoneCallAcceptedTypeID = 0x3660c311

// construct implements constructor of PhoneCallClass.
func (p PhoneCallAccepted) construct() PhoneCallClass { return &p }

// Ensuring interfaces in compile-time for PhoneCallAccepted.
var (
	_ bin.Encoder     = &PhoneCallAccepted{}
	_ bin.Decoder     = &PhoneCallAccepted{}
	_ bin.BareEncoder = &PhoneCallAccepted{}
	_ bin.BareDecoder = &PhoneCallAccepted{}

	_ PhoneCallClass = &PhoneCallAccepted{}
)

func (p *PhoneCallAccepted) Zero() bool {
	if p == nil {
		return true
	}
	if !(p.Flags.Zero()) {
		return false
	}
	if !(p.Video == false) {
		return false
	}
	if !(p.ID == 0) {
		return false
	}
	if !(p.AccessHash == 0) {
		return false
	}
	if !(p.Date == 0) {
		return false
	}
	if !(p.AdminID == 0) {
		return false
	}
	if !(p.ParticipantID == 0) {
		return false
	}
	if !(p.GB == nil) {
		return false
	}
	if !(p.Protocol.Zero()) {
		return false
	}

	return true
}

// String implements fmt.Stringer.
func (p *PhoneCallAccepted) String() string {
	if p == nil {
		return "PhoneCallAccepted(nil)"
	}
	type Alias PhoneCallAccepted
	return fmt.Sprintf("PhoneCallAccepted%+v", Alias(*p))
}

// FillFrom fills PhoneCallAccepted from given interface.
func (p *PhoneCallAccepted) FillFrom(from interface {
	GetVideo() (value bool)
	GetID() (value int64)
	GetAccessHash() (value int64)
	GetDate() (value int)
	GetAdminID() (value int64)
	GetParticipantID() (value int64)
	GetGB() (value []byte)
	GetProtocol() (value PhoneCallProtocol)
}) {
	p.Video = from.GetVideo()
	p.ID = from.GetID()
	p.AccessHash = from.GetAccessHash()
	p.Date = from.GetDate()
	p.AdminID = from.GetAdminID()
	p.ParticipantID = from.GetParticipantID()
	p.GB = from.GetGB()
	p.Protocol = from.GetProtocol()
}

// TypeID returns type id in TL schema.
//
// See https://core.telegram.org/mtproto/TL-tl#remarks.
func (*PhoneCallAccepted) TypeID() uint32 {
	return PhoneCallAcceptedTypeID
}

// TypeName returns name of type in TL schema.
func (*PhoneCallAccepted) TypeName() string {
	return "phoneCallAccepted"
}

// TypeInfo returns info about TL type.
func (p *PhoneCallAccepted) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "phoneCallAccepted",
		ID:   PhoneCallAcceptedTypeID,
	}
	if p == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Video",
			SchemaName: "video",
			Null:       !p.Flags.Has(6),
		},
		{
			Name:       "ID",
			SchemaName: "id",
		},
		{
			Name:       "AccessHash",
			SchemaName: "access_hash",
		},
		{
			Name:       "Date",
			SchemaName: "date",
		},
		{
			Name:       "AdminID",
			SchemaName: "admin_id",
		},
		{
			Name:       "ParticipantID",
			SchemaName: "participant_id",
		},
		{
			Name:       "GB",
			SchemaName: "g_b",
		},
		{
			Name:       "Protocol",
			SchemaName: "protocol",
		},
	}
	return typ
}

// SetFlags sets flags for non-zero fields.
func (p *PhoneCallAccepted) SetFlags() {
	if !(p.Video == false) {
		p.Flags.Set(6)
	}
}

// Encode implements bin.Encoder.
func (p *PhoneCallAccepted) Encode(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't encode phoneCallAccepted#3660c311 as nil")
	}
	b.PutID(PhoneCallAcceptedTypeID)
	return p.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (p *PhoneCallAccepted) EncodeBare(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't encode phoneCallAccepted#3660c311 as nil")
	}
	p.SetFlags()
	if err := p.Flags.Encode(b); err != nil {
		return fmt.Errorf("unable to encode phoneCallAccepted#3660c311: field flags: %w", err)
	}
	b.PutLong(p.ID)
	b.PutLong(p.AccessHash)
	b.PutInt(p.Date)
	b.PutLong(p.AdminID)
	b.PutLong(p.ParticipantID)
	b.PutBytes(p.GB)
	if err := p.Protocol.Encode(b); err != nil {
		return fmt.Errorf("unable to encode phoneCallAccepted#3660c311: field protocol: %w", err)
	}
	return nil
}

// Decode implements bin.Decoder.
func (p *PhoneCallAccepted) Decode(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't decode phoneCallAccepted#3660c311 to nil")
	}
	if err := b.ConsumeID(PhoneCallAcceptedTypeID); err != nil {
		return fmt.Errorf("unable to decode phoneCallAccepted#3660c311: %w", err)
	}
	return p.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (p *PhoneCallAccepted) DecodeBare(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't decode phoneCallAccepted#3660c311 to nil")
	}
	{
		if err := p.Flags.Decode(b); err != nil {
			return fmt.Errorf("unable to decode phoneCallAccepted#3660c311: field flags: %w", err)
		}
	}
	p.Video = p.Flags.Has(6)
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCallAccepted#3660c311: field id: %w", err)
		}
		p.ID = value
	}
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCallAccepted#3660c311: field access_hash: %w", err)
		}
		p.AccessHash = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCallAccepted#3660c311: field date: %w", err)
		}
		p.Date = value
	}
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCallAccepted#3660c311: field admin_id: %w", err)
		}
		p.AdminID = value
	}
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCallAccepted#3660c311: field participant_id: %w", err)
		}
		p.ParticipantID = value
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCallAccepted#3660c311: field g_b: %w", err)
		}
		p.GB = value
	}
	{
		if err := p.Protocol.Decode(b); err != nil {
			return fmt.Errorf("unable to decode phoneCallAccepted#3660c311: field protocol: %w", err)
		}
	}
	return nil
}

// SetVideo sets value of Video conditional field.
func (p *PhoneCallAccepted) SetVideo(value bool) {
	if value {
		p.Flags.Set(6)
		p.Video = true
	} else {
		p.Flags.Unset(6)
		p.Video = false
	}
}

// GetVideo returns value of Video conditional field.
func (p *PhoneCallAccepted) GetVideo() (value bool) {
	if p == nil {
		return
	}
	return p.Flags.Has(6)
}

// GetID returns value of ID field.
func (p *PhoneCallAccepted) GetID() (value int64) {
	if p == nil {
		return
	}
	return p.ID
}

// GetAccessHash returns value of AccessHash field.
func (p *PhoneCallAccepted) GetAccessHash() (value int64) {
	if p == nil {
		return
	}
	return p.AccessHash
}

// GetDate returns value of Date field.
func (p *PhoneCallAccepted) GetDate() (value int) {
	if p == nil {
		return
	}
	return p.Date
}

// GetAdminID returns value of AdminID field.
func (p *PhoneCallAccepted) GetAdminID() (value int64) {
	if p == nil {
		return
	}
	return p.AdminID
}

// GetParticipantID returns value of ParticipantID field.
func (p *PhoneCallAccepted) GetParticipantID() (value int64) {
	if p == nil {
		return
	}
	return p.ParticipantID
}

// GetGB returns value of GB field.
func (p *PhoneCallAccepted) GetGB() (value []byte) {
	if p == nil {
		return
	}
	return p.GB
}

// GetProtocol returns value of Protocol field.
func (p *PhoneCallAccepted) GetProtocol() (value PhoneCallProtocol) {
	if p == nil {
		return
	}
	return p.Protocol
}

// PhoneCall represents TL type `phoneCall#967f7c67`.
// Phone call
//
// See https://core.telegram.org/constructor/phoneCall for reference.
type PhoneCall struct {
	// Flags, see TL conditional fields¹
	//
	// Links:
	//  1) https://core.telegram.org/mtproto/TL-combinators#conditional-fields
	Flags bin.Fields
	// Whether P2P connection to the other peer is allowed
	P2PAllowed bool
	// Whether this is a video call
	Video bool
	// Call ID
	ID int64
	// Access hash
	AccessHash int64
	// Date of creation of the call
	Date int
	// User ID of the creator of the call
	AdminID int64
	// User ID of the other participant in the call
	ParticipantID int64
	// Parameter for key exchange¹
	//
	// Links:
	//  1) https://core.telegram.org/api/end-to-end/voice-calls
	GAOrB []byte
	// Key fingerprint¹
	//
	// Links:
	//  1) https://core.telegram.org/api/end-to-end/voice-calls
	KeyFingerprint int64
	// Call protocol info to be passed to libtgvoip
	Protocol PhoneCallProtocol
	// List of endpoints the user can connect to to exchange call data
	Connections []PhoneConnectionClass
	// When was the call actually started
	StartDate int
}

// PhoneCallTypeID is TL type id of PhoneCall.
const PhoneCallTypeID = 0x967f7c67

// construct implements constructor of PhoneCallClass.
func (p PhoneCall) construct() PhoneCallClass { return &p }

// Ensuring interfaces in compile-time for PhoneCall.
var (
	_ bin.Encoder     = &PhoneCall{}
	_ bin.Decoder     = &PhoneCall{}
	_ bin.BareEncoder = &PhoneCall{}
	_ bin.BareDecoder = &PhoneCall{}

	_ PhoneCallClass = &PhoneCall{}
)

func (p *PhoneCall) Zero() bool {
	if p == nil {
		return true
	}
	if !(p.Flags.Zero()) {
		return false
	}
	if !(p.P2PAllowed == false) {
		return false
	}
	if !(p.Video == false) {
		return false
	}
	if !(p.ID == 0) {
		return false
	}
	if !(p.AccessHash == 0) {
		return false
	}
	if !(p.Date == 0) {
		return false
	}
	if !(p.AdminID == 0) {
		return false
	}
	if !(p.ParticipantID == 0) {
		return false
	}
	if !(p.GAOrB == nil) {
		return false
	}
	if !(p.KeyFingerprint == 0) {
		return false
	}
	if !(p.Protocol.Zero()) {
		return false
	}
	if !(p.Connections == nil) {
		return false
	}
	if !(p.StartDate == 0) {
		return false
	}

	return true
}

// String implements fmt.Stringer.
func (p *PhoneCall) String() string {
	if p == nil {
		return "PhoneCall(nil)"
	}
	type Alias PhoneCall
	return fmt.Sprintf("PhoneCall%+v", Alias(*p))
}

// FillFrom fills PhoneCall from given interface.
func (p *PhoneCall) FillFrom(from interface {
	GetP2PAllowed() (value bool)
	GetVideo() (value bool)
	GetID() (value int64)
	GetAccessHash() (value int64)
	GetDate() (value int)
	GetAdminID() (value int64)
	GetParticipantID() (value int64)
	GetGAOrB() (value []byte)
	GetKeyFingerprint() (value int64)
	GetProtocol() (value PhoneCallProtocol)
	GetConnections() (value []PhoneConnectionClass)
	GetStartDate() (value int)
}) {
	p.P2PAllowed = from.GetP2PAllowed()
	p.Video = from.GetVideo()
	p.ID = from.GetID()
	p.AccessHash = from.GetAccessHash()
	p.Date = from.GetDate()
	p.AdminID = from.GetAdminID()
	p.ParticipantID = from.GetParticipantID()
	p.GAOrB = from.GetGAOrB()
	p.KeyFingerprint = from.GetKeyFingerprint()
	p.Protocol = from.GetProtocol()
	p.Connections = from.GetConnections()
	p.StartDate = from.GetStartDate()
}

// TypeID returns type id in TL schema.
//
// See https://core.telegram.org/mtproto/TL-tl#remarks.
func (*PhoneCall) TypeID() uint32 {
	return PhoneCallTypeID
}

// TypeName returns name of type in TL schema.
func (*PhoneCall) TypeName() string {
	return "phoneCall"
}

// TypeInfo returns info about TL type.
func (p *PhoneCall) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "phoneCall",
		ID:   PhoneCallTypeID,
	}
	if p == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "P2PAllowed",
			SchemaName: "p2p_allowed",
			Null:       !p.Flags.Has(5),
		},
		{
			Name:       "Video",
			SchemaName: "video",
			Null:       !p.Flags.Has(6),
		},
		{
			Name:       "ID",
			SchemaName: "id",
		},
		{
			Name:       "AccessHash",
			SchemaName: "access_hash",
		},
		{
			Name:       "Date",
			SchemaName: "date",
		},
		{
			Name:       "AdminID",
			SchemaName: "admin_id",
		},
		{
			Name:       "ParticipantID",
			SchemaName: "participant_id",
		},
		{
			Name:       "GAOrB",
			SchemaName: "g_a_or_b",
		},
		{
			Name:       "KeyFingerprint",
			SchemaName: "key_fingerprint",
		},
		{
			Name:       "Protocol",
			SchemaName: "protocol",
		},
		{
			Name:       "Connections",
			SchemaName: "connections",
		},
		{
			Name:       "StartDate",
			SchemaName: "start_date",
		},
	}
	return typ
}

// SetFlags sets flags for non-zero fields.
func (p *PhoneCall) SetFlags() {
	if !(p.P2PAllowed == false) {
		p.Flags.Set(5)
	}
	if !(p.Video == false) {
		p.Flags.Set(6)
	}
}

// Encode implements bin.Encoder.
func (p *PhoneCall) Encode(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't encode phoneCall#967f7c67 as nil")
	}
	b.PutID(PhoneCallTypeID)
	return p.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (p *PhoneCall) EncodeBare(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't encode phoneCall#967f7c67 as nil")
	}
	p.SetFlags()
	if err := p.Flags.Encode(b); err != nil {
		return fmt.Errorf("unable to encode phoneCall#967f7c67: field flags: %w", err)
	}
	b.PutLong(p.ID)
	b.PutLong(p.AccessHash)
	b.PutInt(p.Date)
	b.PutLong(p.AdminID)
	b.PutLong(p.ParticipantID)
	b.PutBytes(p.GAOrB)
	b.PutLong(p.KeyFingerprint)
	if err := p.Protocol.Encode(b); err != nil {
		return fmt.Errorf("unable to encode phoneCall#967f7c67: field protocol: %w", err)
	}
	b.PutVectorHeader(len(p.Connections))
	for idx, v := range p.Connections {
		if v == nil {
			return fmt.Errorf("unable to encode phoneCall#967f7c67: field connections element with index %d is nil", idx)
		}
		if err := v.Encode(b); err != nil {
			return fmt.Errorf("unable to encode phoneCall#967f7c67: field connections element with index %d: %w", idx, err)
		}
	}
	b.PutInt(p.StartDate)
	return nil
}

// Decode implements bin.Decoder.
func (p *PhoneCall) Decode(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't decode phoneCall#967f7c67 to nil")
	}
	if err := b.ConsumeID(PhoneCallTypeID); err != nil {
		return fmt.Errorf("unable to decode phoneCall#967f7c67: %w", err)
	}
	return p.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (p *PhoneCall) DecodeBare(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't decode phoneCall#967f7c67 to nil")
	}
	{
		if err := p.Flags.Decode(b); err != nil {
			return fmt.Errorf("unable to decode phoneCall#967f7c67: field flags: %w", err)
		}
	}
	p.P2PAllowed = p.Flags.Has(5)
	p.Video = p.Flags.Has(6)
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCall#967f7c67: field id: %w", err)
		}
		p.ID = value
	}
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCall#967f7c67: field access_hash: %w", err)
		}
		p.AccessHash = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCall#967f7c67: field date: %w", err)
		}
		p.Date = value
	}
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCall#967f7c67: field admin_id: %w", err)
		}
		p.AdminID = value
	}
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCall#967f7c67: field participant_id: %w", err)
		}
		p.ParticipantID = value
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCall#967f7c67: field g_a_or_b: %w", err)
		}
		p.GAOrB = value
	}
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCall#967f7c67: field key_fingerprint: %w", err)
		}
		p.KeyFingerprint = value
	}
	{
		if err := p.Protocol.Decode(b); err != nil {
			return fmt.Errorf("unable to decode phoneCall#967f7c67: field protocol: %w", err)
		}
	}
	{
		headerLen, err := b.VectorHeader()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCall#967f7c67: field connections: %w", err)
		}

		if headerLen > 0 {
			p.Connections = make([]PhoneConnectionClass, 0, headerLen%bin.PreallocateLimit)
		}
		for idx := 0; idx < headerLen; idx++ {
			value, err := DecodePhoneConnection(b)
			if err != nil {
				return fmt.Errorf("unable to decode phoneCall#967f7c67: field connections: %w", err)
			}
			p.Connections = append(p.Connections, value)
		}
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCall#967f7c67: field start_date: %w", err)
		}
		p.StartDate = value
	}
	return nil
}

// SetP2PAllowed sets value of P2PAllowed conditional field.
func (p *PhoneCall) SetP2PAllowed(value bool) {
	if value {
		p.Flags.Set(5)
		p.P2PAllowed = true
	} else {
		p.Flags.Unset(5)
		p.P2PAllowed = false
	}
}

// GetP2PAllowed returns value of P2PAllowed conditional field.
func (p *PhoneCall) GetP2PAllowed() (value bool) {
	if p == nil {
		return
	}
	return p.Flags.Has(5)
}

// SetVideo sets value of Video conditional field.
func (p *PhoneCall) SetVideo(value bool) {
	if value {
		p.Flags.Set(6)
		p.Video = true
	} else {
		p.Flags.Unset(6)
		p.Video = false
	}
}

// GetVideo returns value of Video conditional field.
func (p *PhoneCall) GetVideo() (value bool) {
	if p == nil {
		return
	}
	return p.Flags.Has(6)
}

// GetID returns value of ID field.
func (p *PhoneCall) GetID() (value int64) {
	if p == nil {
		return
	}
	return p.ID
}

// GetAccessHash returns value of AccessHash field.
func (p *PhoneCall) GetAccessHash() (value int64) {
	if p == nil {
		return
	}
	return p.AccessHash
}

// GetDate returns value of Date field.
func (p *PhoneCall) GetDate() (value int) {
	if p == nil {
		return
	}
	return p.Date
}

// GetAdminID returns value of AdminID field.
func (p *PhoneCall) GetAdminID() (value int64) {
	if p == nil {
		return
	}
	return p.AdminID
}

// GetParticipantID returns value of ParticipantID field.
func (p *PhoneCall) GetParticipantID() (value int64) {
	if p == nil {
		return
	}
	return p.ParticipantID
}

// GetGAOrB returns value of GAOrB field.
func (p *PhoneCall) GetGAOrB() (value []byte) {
	if p == nil {
		return
	}
	return p.GAOrB
}

// GetKeyFingerprint returns value of KeyFingerprint field.
func (p *PhoneCall) GetKeyFingerprint() (value int64) {
	if p == nil {
		return
	}
	return p.KeyFingerprint
}

// GetProtocol returns value of Protocol field.
func (p *PhoneCall) GetProtocol() (value PhoneCallProtocol) {
	if p == nil {
		return
	}
	return p.Protocol
}

// GetConnections returns value of Connections field.
func (p *PhoneCall) GetConnections() (value []PhoneConnectionClass) {
	if p == nil {
		return
	}
	return p.Connections
}

// GetStartDate returns value of StartDate field.
func (p *PhoneCall) GetStartDate() (value int) {
	if p == nil {
		return
	}
	return p.StartDate
}

// MapConnections returns field Connections wrapped in PhoneConnectionClassArray helper.
func (p *PhoneCall) MapConnections() (value PhoneConnectionClassArray) {
	return PhoneConnectionClassArray(p.Connections)
}

// PhoneCallDiscarded represents TL type `phoneCallDiscarded#50ca4de1`.
// Indicates a discarded phone call
//
// See https://core.telegram.org/constructor/phoneCallDiscarded for reference.
type PhoneCallDiscarded struct {
	// Flags, see TL conditional fields¹
	//
	// Links:
	//  1) https://core.telegram.org/mtproto/TL-combinators#conditional-fields
	Flags bin.Fields
	// Whether the server required the user to rate¹ the call
	//
	// Links:
	//  1) https://core.telegram.org/method/phone.setCallRating
	NeedRating bool
	// Whether the server required the client to send¹ the libtgvoip call debug data
	//
	// Links:
	//  1) https://core.telegram.org/method/phone.saveCallDebug
	NeedDebug bool
	// Whether the call was a video call
	Video bool
	// Call ID
	ID int64
	// Why was the phone call discarded
	//
	// Use SetReason and GetReason helpers.
	Reason PhoneCallDiscardReasonClass
	// Duration of the phone call in seconds
	//
	// Use SetDuration and GetDuration helpers.
	Duration int
}

// PhoneCallDiscardedTypeID is TL type id of PhoneCallDiscarded.
const PhoneCallDiscardedTypeID = 0x50ca4de1

// construct implements constructor of PhoneCallClass.
func (p PhoneCallDiscarded) construct() PhoneCallClass { return &p }

// Ensuring interfaces in compile-time for PhoneCallDiscarded.
var (
	_ bin.Encoder     = &PhoneCallDiscarded{}
	_ bin.Decoder     = &PhoneCallDiscarded{}
	_ bin.BareEncoder = &PhoneCallDiscarded{}
	_ bin.BareDecoder = &PhoneCallDiscarded{}

	_ PhoneCallClass = &PhoneCallDiscarded{}
)

func (p *PhoneCallDiscarded) Zero() bool {
	if p == nil {
		return true
	}
	if !(p.Flags.Zero()) {
		return false
	}
	if !(p.NeedRating == false) {
		return false
	}
	if !(p.NeedDebug == false) {
		return false
	}
	if !(p.Video == false) {
		return false
	}
	if !(p.ID == 0) {
		return false
	}
	if !(p.Reason == nil) {
		return false
	}
	if !(p.Duration == 0) {
		return false
	}

	return true
}

// String implements fmt.Stringer.
func (p *PhoneCallDiscarded) String() string {
	if p == nil {
		return "PhoneCallDiscarded(nil)"
	}
	type Alias PhoneCallDiscarded
	return fmt.Sprintf("PhoneCallDiscarded%+v", Alias(*p))
}

// FillFrom fills PhoneCallDiscarded from given interface.
func (p *PhoneCallDiscarded) FillFrom(from interface {
	GetNeedRating() (value bool)
	GetNeedDebug() (value bool)
	GetVideo() (value bool)
	GetID() (value int64)
	GetReason() (value PhoneCallDiscardReasonClass, ok bool)
	GetDuration() (value int, ok bool)
}) {
	p.NeedRating = from.GetNeedRating()
	p.NeedDebug = from.GetNeedDebug()
	p.Video = from.GetVideo()
	p.ID = from.GetID()
	if val, ok := from.GetReason(); ok {
		p.Reason = val
	}

	if val, ok := from.GetDuration(); ok {
		p.Duration = val
	}

}

// TypeID returns type id in TL schema.
//
// See https://core.telegram.org/mtproto/TL-tl#remarks.
func (*PhoneCallDiscarded) TypeID() uint32 {
	return PhoneCallDiscardedTypeID
}

// TypeName returns name of type in TL schema.
func (*PhoneCallDiscarded) TypeName() string {
	return "phoneCallDiscarded"
}

// TypeInfo returns info about TL type.
func (p *PhoneCallDiscarded) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "phoneCallDiscarded",
		ID:   PhoneCallDiscardedTypeID,
	}
	if p == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "NeedRating",
			SchemaName: "need_rating",
			Null:       !p.Flags.Has(2),
		},
		{
			Name:       "NeedDebug",
			SchemaName: "need_debug",
			Null:       !p.Flags.Has(3),
		},
		{
			Name:       "Video",
			SchemaName: "video",
			Null:       !p.Flags.Has(6),
		},
		{
			Name:       "ID",
			SchemaName: "id",
		},
		{
			Name:       "Reason",
			SchemaName: "reason",
			Null:       !p.Flags.Has(0),
		},
		{
			Name:       "Duration",
			SchemaName: "duration",
			Null:       !p.Flags.Has(1),
		},
	}
	return typ
}

// SetFlags sets flags for non-zero fields.
func (p *PhoneCallDiscarded) SetFlags() {
	if !(p.NeedRating == false) {
		p.Flags.Set(2)
	}
	if !(p.NeedDebug == false) {
		p.Flags.Set(3)
	}
	if !(p.Video == false) {
		p.Flags.Set(6)
	}
	if !(p.Reason == nil) {
		p.Flags.Set(0)
	}
	if !(p.Duration == 0) {
		p.Flags.Set(1)
	}
}

// Encode implements bin.Encoder.
func (p *PhoneCallDiscarded) Encode(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't encode phoneCallDiscarded#50ca4de1 as nil")
	}
	b.PutID(PhoneCallDiscardedTypeID)
	return p.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (p *PhoneCallDiscarded) EncodeBare(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't encode phoneCallDiscarded#50ca4de1 as nil")
	}
	p.SetFlags()
	if err := p.Flags.Encode(b); err != nil {
		return fmt.Errorf("unable to encode phoneCallDiscarded#50ca4de1: field flags: %w", err)
	}
	b.PutLong(p.ID)
	if p.Flags.Has(0) {
		if p.Reason == nil {
			return fmt.Errorf("unable to encode phoneCallDiscarded#50ca4de1: field reason is nil")
		}
		if err := p.Reason.Encode(b); err != nil {
			return fmt.Errorf("unable to encode phoneCallDiscarded#50ca4de1: field reason: %w", err)
		}
	}
	if p.Flags.Has(1) {
		b.PutInt(p.Duration)
	}
	return nil
}

// Decode implements bin.Decoder.
func (p *PhoneCallDiscarded) Decode(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't decode phoneCallDiscarded#50ca4de1 to nil")
	}
	if err := b.ConsumeID(PhoneCallDiscardedTypeID); err != nil {
		return fmt.Errorf("unable to decode phoneCallDiscarded#50ca4de1: %w", err)
	}
	return p.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (p *PhoneCallDiscarded) DecodeBare(b *bin.Buffer) error {
	if p == nil {
		return fmt.Errorf("can't decode phoneCallDiscarded#50ca4de1 to nil")
	}
	{
		if err := p.Flags.Decode(b); err != nil {
			return fmt.Errorf("unable to decode phoneCallDiscarded#50ca4de1: field flags: %w", err)
		}
	}
	p.NeedRating = p.Flags.Has(2)
	p.NeedDebug = p.Flags.Has(3)
	p.Video = p.Flags.Has(6)
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCallDiscarded#50ca4de1: field id: %w", err)
		}
		p.ID = value
	}
	if p.Flags.Has(0) {
		value, err := DecodePhoneCallDiscardReason(b)
		if err != nil {
			return fmt.Errorf("unable to decode phoneCallDiscarded#50ca4de1: field reason: %w", err)
		}
		p.Reason = value
	}
	if p.Flags.Has(1) {
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode phoneCallDiscarded#50ca4de1: field duration: %w", err)
		}
		p.Duration = value
	}
	return nil
}

// SetNeedRating sets value of NeedRating conditional field.
func (p *PhoneCallDiscarded) SetNeedRating(value bool) {
	if value {
		p.Flags.Set(2)
		p.NeedRating = true
	} else {
		p.Flags.Unset(2)
		p.NeedRating = false
	}
}

// GetNeedRating returns value of NeedRating conditional field.
func (p *PhoneCallDiscarded) GetNeedRating() (value bool) {
	if p == nil {
		return
	}
	return p.Flags.Has(2)
}

// SetNeedDebug sets value of NeedDebug conditional field.
func (p *PhoneCallDiscarded) SetNeedDebug(value bool) {
	if value {
		p.Flags.Set(3)
		p.NeedDebug = true
	} else {
		p.Flags.Unset(3)
		p.NeedDebug = false
	}
}

// GetNeedDebug returns value of NeedDebug conditional field.
func (p *PhoneCallDiscarded) GetNeedDebug() (value bool) {
	if p == nil {
		return
	}
	return p.Flags.Has(3)
}

// SetVideo sets value of Video conditional field.
func (p *PhoneCallDiscarded) SetVideo(value bool) {
	if value {
		p.Flags.Set(6)
		p.Video = true
	} else {
		p.Flags.Unset(6)
		p.Video = false
	}
}

// GetVideo returns value of Video conditional field.
func (p *PhoneCallDiscarded) GetVideo() (value bool) {
	if p == nil {
		return
	}
	return p.Flags.Has(6)
}

// GetID returns value of ID field.
func (p *PhoneCallDiscarded) GetID() (value int64) {
	if p == nil {
		return
	}
	return p.ID
}

// SetReason sets value of Reason conditional field.
func (p *PhoneCallDiscarded) SetReason(value PhoneCallDiscardReasonClass) {
	p.Flags.Set(0)
	p.Reason = value
}

// GetReason returns value of Reason conditional field and
// boolean which is true if field was set.
func (p *PhoneCallDiscarded) GetReason() (value PhoneCallDiscardReasonClass, ok bool) {
	if p == nil {
		return
	}
	if !p.Flags.Has(0) {
		return value, false
	}
	return p.Reason, true
}

// SetDuration sets value of Duration conditional field.
func (p *PhoneCallDiscarded) SetDuration(value int) {
	p.Flags.Set(1)
	p.Duration = value
}

// GetDuration returns value of Duration conditional field and
// boolean which is true if field was set.
func (p *PhoneCallDiscarded) GetDuration() (value int, ok bool) {
	if p == nil {
		return
	}
	if !p.Flags.Has(1) {
		return value, false
	}
	return p.Duration, true
}

// PhoneCallClassName is schema name of PhoneCallClass.
const PhoneCallClassName = "PhoneCall"

// PhoneCallClass represents PhoneCall generic type.
//
// See https://core.telegram.org/type/PhoneCall for reference.
//
// Example:
//
//	g, err := tg.DecodePhoneCall(buf)
//	if err != nil {
//	    panic(err)
//	}
//	switch v := g.(type) {
//	case *tg.PhoneCallEmpty: // phoneCallEmpty#5366c915
//	case *tg.PhoneCallWaiting: // phoneCallWaiting#c5226f17
//	case *tg.PhoneCallRequested: // phoneCallRequested#14b0ed0c
//	case *tg.PhoneCallAccepted: // phoneCallAccepted#3660c311
//	case *tg.PhoneCall: // phoneCall#967f7c67
//	case *tg.PhoneCallDiscarded: // phoneCallDiscarded#50ca4de1
//	default: panic(v)
//	}
type PhoneCallClass interface {
	bin.Encoder
	bin.Decoder
	bin.BareEncoder
	bin.BareDecoder
	construct() PhoneCallClass

	// TypeID returns type id in TL schema.
	//
	// See https://core.telegram.org/mtproto/TL-tl#remarks.
	TypeID() uint32
	// TypeName returns name of type in TL schema.
	TypeName() string
	// String implements fmt.Stringer.
	String() string
	// Zero returns true if current object has a zero value.
	Zero() bool

	// Call ID
	GetID() (value int64)

	// AsNotEmpty tries to map PhoneCallClass to NotEmptyPhoneCall.
	AsNotEmpty() (NotEmptyPhoneCall, bool)
}

// AsInput tries to map PhoneCall to InputPhoneCall.
func (p *PhoneCall) AsInput() *InputPhoneCall {
	value := new(InputPhoneCall)
	value.ID = p.GetID()
	value.AccessHash = p.GetAccessHash()

	return value
}

// NotEmptyPhoneCall represents NotEmpty subset of PhoneCallClass.
type NotEmptyPhoneCall interface {
	bin.Encoder
	bin.Decoder
	bin.BareEncoder
	bin.BareDecoder
	construct() PhoneCallClass

	// TypeID returns type id in TL schema.
	//
	// See https://core.telegram.org/mtproto/TL-tl#remarks.
	TypeID() uint32
	// TypeName returns name of type in TL schema.
	TypeName() string
	// String implements fmt.Stringer.
	String() string
	// Zero returns true if current object has a zero value.
	Zero() bool

	// Is this a video call
	GetVideo() (value bool)

	// Call ID
	GetID() (value int64)
}

// AsNotEmpty tries to map PhoneCallEmpty to NotEmptyPhoneCall.
func (p *PhoneCallEmpty) AsNotEmpty() (NotEmptyPhoneCall, bool) {
	value, ok := (PhoneCallClass(p)).(NotEmptyPhoneCall)
	return value, ok
}

// AsNotEmpty tries to map PhoneCallWaiting to NotEmptyPhoneCall.
func (p *PhoneCallWaiting) AsNotEmpty() (NotEmptyPhoneCall, bool) {
	value, ok := (PhoneCallClass(p)).(NotEmptyPhoneCall)
	return value, ok
}

// AsNotEmpty tries to map PhoneCallRequested to NotEmptyPhoneCall.
func (p *PhoneCallRequested) AsNotEmpty() (NotEmptyPhoneCall, bool) {
	value, ok := (PhoneCallClass(p)).(NotEmptyPhoneCall)
	return value, ok
}

// AsNotEmpty tries to map PhoneCallAccepted to NotEmptyPhoneCall.
func (p *PhoneCallAccepted) AsNotEmpty() (NotEmptyPhoneCall, bool) {
	value, ok := (PhoneCallClass(p)).(NotEmptyPhoneCall)
	return value, ok
}

// AsNotEmpty tries to map PhoneCall to NotEmptyPhoneCall.
func (p *PhoneCall) AsNotEmpty() (NotEmptyPhoneCall, bool) {
	value, ok := (PhoneCallClass(p)).(NotEmptyPhoneCall)
	return value, ok
}

// AsNotEmpty tries to map PhoneCallDiscarded to NotEmptyPhoneCall.
func (p *PhoneCallDiscarded) AsNotEmpty() (NotEmptyPhoneCall, bool) {
	value, ok := (PhoneCallClass(p)).(NotEmptyPhoneCall)
	return value, ok
}

// DecodePhoneCall implements binary de-serialization for PhoneCallClass.
func DecodePhoneCall(buf *bin.Buffer) (PhoneCallClass, error) {
	id, err := buf.PeekID()
	if err != nil {
		return nil, err
	}
	switch id {
	case PhoneCallEmptyTypeID:
		// Decoding phoneCallEmpty#5366c915.
		v := PhoneCallEmpty{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode PhoneCallClass: %w", err)
		}
		return &v, nil
	case PhoneCallWaitingTypeID:
		// Decoding phoneCallWaiting#c5226f17.
		v := PhoneCallWaiting{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode PhoneCallClass: %w", err)
		}
		return &v, nil
	case PhoneCallRequestedTypeID:
		// Decoding phoneCallRequested#14b0ed0c.
		v := PhoneCallRequested{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode PhoneCallClass: %w", err)
		}
		return &v, nil
	case PhoneCallAcceptedTypeID:
		// Decoding phoneCallAccepted#3660c311.
		v := PhoneCallAccepted{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode PhoneCallClass: %w", err)
		}
		return &v, nil
	case PhoneCallTypeID:
		// Decoding phoneCall#967f7c67.
		v := PhoneCall{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode PhoneCallClass: %w", err)
		}
		return &v, nil
	case PhoneCallDiscardedTypeID:
		// Decoding phoneCallDiscarded#50ca4de1.
		v := PhoneCallDiscarded{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode PhoneCallClass: %w", err)
		}
		return &v, nil
	default:
		return nil, fmt.Errorf("unable to decode PhoneCallClass: %w", bin.NewUnexpectedID(id))
	}
}

// PhoneCall boxes the PhoneCallClass providing a helper.
type PhoneCallBox struct {
	PhoneCall PhoneCallClass
}

// Decode implements bin.Decoder for PhoneCallBox.
func (b *PhoneCallBox) Decode(buf *bin.Buffer) error {
	if b == nil {
		return fmt.Errorf("unable to decode PhoneCallBox to nil")
	}
	v, err := DecodePhoneCall(buf)
	if err != nil {
		return fmt.Errorf("unable to decode boxed value: %w", err)
	}
	b.PhoneCall = v
	return nil
}

// Encode implements bin.Encode for PhoneCallBox.
func (b *PhoneCallBox) Encode(buf *bin.Buffer) error {
	if b == nil || b.PhoneCall == nil {
		return fmt.Errorf("unable to encode PhoneCallClass as nil")
	}
	return b.PhoneCall.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.