tl_decrypted_message_media_gen.go

// Code generated by gotdgen, DO NOT EDIT.

package e2e

import (
	"context"
	"errors"
	"fmt"
	"sort"
	"strings"

	"go.uber.org/multierr"

	"github.com/gotd/td/bin"
	"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{}
)

// DecryptedMessageMediaEmpty represents TL type `decryptedMessageMediaEmpty#89f5c4a`.
//
// See https://core.telegram.org/constructor/decryptedMessageMediaEmpty for reference.
type DecryptedMessageMediaEmpty struct {
}

// DecryptedMessageMediaEmptyTypeID is TL type id of DecryptedMessageMediaEmpty.
const DecryptedMessageMediaEmptyTypeID = 0x89f5c4a

func (d *DecryptedMessageMediaEmpty) Zero() bool {
	if d == nil {
		return true
	}

	return true
}

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

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

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

// TypeInfo returns info about TL type.
func (d *DecryptedMessageMediaEmpty) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "decryptedMessageMediaEmpty",
		ID:   DecryptedMessageMediaEmptyTypeID,
	}
	if d == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{}
	return typ
}

// Encode implements bin.Encoder.
func (d *DecryptedMessageMediaEmpty) Encode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaEmpty#89f5c4a as nil")
	}
	b.PutID(DecryptedMessageMediaEmptyTypeID)
	return d.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (d *DecryptedMessageMediaEmpty) EncodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaEmpty#89f5c4a as nil")
	}
	return nil
}

// Decode implements bin.Decoder.
func (d *DecryptedMessageMediaEmpty) Decode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaEmpty#89f5c4a to nil")
	}
	if err := b.ConsumeID(DecryptedMessageMediaEmptyTypeID); err != nil {
		return fmt.Errorf("unable to decode decryptedMessageMediaEmpty#89f5c4a: %w", err)
	}
	return d.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (d *DecryptedMessageMediaEmpty) DecodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaEmpty#89f5c4a to nil")
	}
	return nil
}

// construct implements constructor of DecryptedMessageMediaClass.
func (d DecryptedMessageMediaEmpty) construct() DecryptedMessageMediaClass { return &d }

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

	_ DecryptedMessageMediaClass = &DecryptedMessageMediaEmpty{}
)

// DecryptedMessageMediaPhoto23 represents TL type `decryptedMessageMediaPhoto23#32798a8c`.
//
// See https://core.telegram.org/constructor/decryptedMessageMediaPhoto23 for reference.
type DecryptedMessageMediaPhoto23 struct {
	// Thumb field of DecryptedMessageMediaPhoto23.
	Thumb []byte
	// ThumbW field of DecryptedMessageMediaPhoto23.
	ThumbW int
	// ThumbH field of DecryptedMessageMediaPhoto23.
	ThumbH int
	// W field of DecryptedMessageMediaPhoto23.
	W int
	// H field of DecryptedMessageMediaPhoto23.
	H int
	// Size field of DecryptedMessageMediaPhoto23.
	Size int
	// Key field of DecryptedMessageMediaPhoto23.
	Key []byte
	// Iv field of DecryptedMessageMediaPhoto23.
	Iv []byte
}

// DecryptedMessageMediaPhoto23TypeID is TL type id of DecryptedMessageMediaPhoto23.
const DecryptedMessageMediaPhoto23TypeID = 0x32798a8c

func (d *DecryptedMessageMediaPhoto23) Zero() bool {
	if d == nil {
		return true
	}
	if !(d.Thumb == nil) {
		return false
	}
	if !(d.ThumbW == 0) {
		return false
	}
	if !(d.ThumbH == 0) {
		return false
	}
	if !(d.W == 0) {
		return false
	}
	if !(d.H == 0) {
		return false
	}
	if !(d.Size == 0) {
		return false
	}
	if !(d.Key == nil) {
		return false
	}
	if !(d.Iv == nil) {
		return false
	}

	return true
}

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

// FillFrom fills DecryptedMessageMediaPhoto23 from given interface.
func (d *DecryptedMessageMediaPhoto23) FillFrom(from interface {
	GetThumb() (value []byte)
	GetThumbW() (value int)
	GetThumbH() (value int)
	GetW() (value int)
	GetH() (value int)
	GetSize() (value int)
	GetKey() (value []byte)
	GetIv() (value []byte)
}) {
	d.Thumb = from.GetThumb()
	d.ThumbW = from.GetThumbW()
	d.ThumbH = from.GetThumbH()
	d.W = from.GetW()
	d.H = from.GetH()
	d.Size = from.GetSize()
	d.Key = from.GetKey()
	d.Iv = from.GetIv()
}

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

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

// TypeInfo returns info about TL type.
func (d *DecryptedMessageMediaPhoto23) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "decryptedMessageMediaPhoto23",
		ID:   DecryptedMessageMediaPhoto23TypeID,
	}
	if d == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Thumb",
			SchemaName: "thumb",
		},
		{
			Name:       "ThumbW",
			SchemaName: "thumb_w",
		},
		{
			Name:       "ThumbH",
			SchemaName: "thumb_h",
		},
		{
			Name:       "W",
			SchemaName: "w",
		},
		{
			Name:       "H",
			SchemaName: "h",
		},
		{
			Name:       "Size",
			SchemaName: "size",
		},
		{
			Name:       "Key",
			SchemaName: "key",
		},
		{
			Name:       "Iv",
			SchemaName: "iv",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (d *DecryptedMessageMediaPhoto23) Encode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaPhoto23#32798a8c as nil")
	}
	b.PutID(DecryptedMessageMediaPhoto23TypeID)
	return d.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (d *DecryptedMessageMediaPhoto23) EncodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaPhoto23#32798a8c as nil")
	}
	b.PutBytes(d.Thumb)
	b.PutInt(d.ThumbW)
	b.PutInt(d.ThumbH)
	b.PutInt(d.W)
	b.PutInt(d.H)
	b.PutInt(d.Size)
	b.PutBytes(d.Key)
	b.PutBytes(d.Iv)
	return nil
}

// GetThumb returns value of Thumb field.
func (d *DecryptedMessageMediaPhoto23) GetThumb() (value []byte) {
	return d.Thumb
}

// GetThumbW returns value of ThumbW field.
func (d *DecryptedMessageMediaPhoto23) GetThumbW() (value int) {
	return d.ThumbW
}

// GetThumbH returns value of ThumbH field.
func (d *DecryptedMessageMediaPhoto23) GetThumbH() (value int) {
	return d.ThumbH
}

// GetW returns value of W field.
func (d *DecryptedMessageMediaPhoto23) GetW() (value int) {
	return d.W
}

// GetH returns value of H field.
func (d *DecryptedMessageMediaPhoto23) GetH() (value int) {
	return d.H
}

// GetSize returns value of Size field.
func (d *DecryptedMessageMediaPhoto23) GetSize() (value int) {
	return d.Size
}

// GetKey returns value of Key field.
func (d *DecryptedMessageMediaPhoto23) GetKey() (value []byte) {
	return d.Key
}

// GetIv returns value of Iv field.
func (d *DecryptedMessageMediaPhoto23) GetIv() (value []byte) {
	return d.Iv
}

// Decode implements bin.Decoder.
func (d *DecryptedMessageMediaPhoto23) Decode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaPhoto23#32798a8c to nil")
	}
	if err := b.ConsumeID(DecryptedMessageMediaPhoto23TypeID); err != nil {
		return fmt.Errorf("unable to decode decryptedMessageMediaPhoto23#32798a8c: %w", err)
	}
	return d.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (d *DecryptedMessageMediaPhoto23) DecodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaPhoto23#32798a8c to nil")
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaPhoto23#32798a8c: field thumb: %w", err)
		}
		d.Thumb = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaPhoto23#32798a8c: field thumb_w: %w", err)
		}
		d.ThumbW = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaPhoto23#32798a8c: field thumb_h: %w", err)
		}
		d.ThumbH = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaPhoto23#32798a8c: field w: %w", err)
		}
		d.W = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaPhoto23#32798a8c: field h: %w", err)
		}
		d.H = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaPhoto23#32798a8c: field size: %w", err)
		}
		d.Size = value
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaPhoto23#32798a8c: field key: %w", err)
		}
		d.Key = value
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaPhoto23#32798a8c: field iv: %w", err)
		}
		d.Iv = value
	}
	return nil
}

// construct implements constructor of DecryptedMessageMediaClass.
func (d DecryptedMessageMediaPhoto23) construct() DecryptedMessageMediaClass { return &d }

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

	_ DecryptedMessageMediaClass = &DecryptedMessageMediaPhoto23{}
)

// DecryptedMessageMediaVideo8 represents TL type `decryptedMessageMediaVideo8#4cee6ef3`.
//
// See https://core.telegram.org/constructor/decryptedMessageMediaVideo8 for reference.
type DecryptedMessageMediaVideo8 struct {
	// Thumb field of DecryptedMessageMediaVideo8.
	Thumb []byte
	// ThumbW field of DecryptedMessageMediaVideo8.
	ThumbW int
	// ThumbH field of DecryptedMessageMediaVideo8.
	ThumbH int
	// Duration field of DecryptedMessageMediaVideo8.
	Duration int
	// W field of DecryptedMessageMediaVideo8.
	W int
	// H field of DecryptedMessageMediaVideo8.
	H int
	// Size field of DecryptedMessageMediaVideo8.
	Size int
	// Key field of DecryptedMessageMediaVideo8.
	Key []byte
	// Iv field of DecryptedMessageMediaVideo8.
	Iv []byte
}

// DecryptedMessageMediaVideo8TypeID is TL type id of DecryptedMessageMediaVideo8.
const DecryptedMessageMediaVideo8TypeID = 0x4cee6ef3

func (d *DecryptedMessageMediaVideo8) Zero() bool {
	if d == nil {
		return true
	}
	if !(d.Thumb == nil) {
		return false
	}
	if !(d.ThumbW == 0) {
		return false
	}
	if !(d.ThumbH == 0) {
		return false
	}
	if !(d.Duration == 0) {
		return false
	}
	if !(d.W == 0) {
		return false
	}
	if !(d.H == 0) {
		return false
	}
	if !(d.Size == 0) {
		return false
	}
	if !(d.Key == nil) {
		return false
	}
	if !(d.Iv == nil) {
		return false
	}

	return true
}

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

// FillFrom fills DecryptedMessageMediaVideo8 from given interface.
func (d *DecryptedMessageMediaVideo8) FillFrom(from interface {
	GetThumb() (value []byte)
	GetThumbW() (value int)
	GetThumbH() (value int)
	GetDuration() (value int)
	GetW() (value int)
	GetH() (value int)
	GetSize() (value int)
	GetKey() (value []byte)
	GetIv() (value []byte)
}) {
	d.Thumb = from.GetThumb()
	d.ThumbW = from.GetThumbW()
	d.ThumbH = from.GetThumbH()
	d.Duration = from.GetDuration()
	d.W = from.GetW()
	d.H = from.GetH()
	d.Size = from.GetSize()
	d.Key = from.GetKey()
	d.Iv = from.GetIv()
}

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

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

// TypeInfo returns info about TL type.
func (d *DecryptedMessageMediaVideo8) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "decryptedMessageMediaVideo8",
		ID:   DecryptedMessageMediaVideo8TypeID,
	}
	if d == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Thumb",
			SchemaName: "thumb",
		},
		{
			Name:       "ThumbW",
			SchemaName: "thumb_w",
		},
		{
			Name:       "ThumbH",
			SchemaName: "thumb_h",
		},
		{
			Name:       "Duration",
			SchemaName: "duration",
		},
		{
			Name:       "W",
			SchemaName: "w",
		},
		{
			Name:       "H",
			SchemaName: "h",
		},
		{
			Name:       "Size",
			SchemaName: "size",
		},
		{
			Name:       "Key",
			SchemaName: "key",
		},
		{
			Name:       "Iv",
			SchemaName: "iv",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (d *DecryptedMessageMediaVideo8) Encode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaVideo8#4cee6ef3 as nil")
	}
	b.PutID(DecryptedMessageMediaVideo8TypeID)
	return d.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (d *DecryptedMessageMediaVideo8) EncodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaVideo8#4cee6ef3 as nil")
	}
	b.PutBytes(d.Thumb)
	b.PutInt(d.ThumbW)
	b.PutInt(d.ThumbH)
	b.PutInt(d.Duration)
	b.PutInt(d.W)
	b.PutInt(d.H)
	b.PutInt(d.Size)
	b.PutBytes(d.Key)
	b.PutBytes(d.Iv)
	return nil
}

// GetThumb returns value of Thumb field.
func (d *DecryptedMessageMediaVideo8) GetThumb() (value []byte) {
	return d.Thumb
}

// GetThumbW returns value of ThumbW field.
func (d *DecryptedMessageMediaVideo8) GetThumbW() (value int) {
	return d.ThumbW
}

// GetThumbH returns value of ThumbH field.
func (d *DecryptedMessageMediaVideo8) GetThumbH() (value int) {
	return d.ThumbH
}

// GetDuration returns value of Duration field.
func (d *DecryptedMessageMediaVideo8) GetDuration() (value int) {
	return d.Duration
}

// GetW returns value of W field.
func (d *DecryptedMessageMediaVideo8) GetW() (value int) {
	return d.W
}

// GetH returns value of H field.
func (d *DecryptedMessageMediaVideo8) GetH() (value int) {
	return d.H
}

// GetSize returns value of Size field.
func (d *DecryptedMessageMediaVideo8) GetSize() (value int) {
	return d.Size
}

// GetKey returns value of Key field.
func (d *DecryptedMessageMediaVideo8) GetKey() (value []byte) {
	return d.Key
}

// GetIv returns value of Iv field.
func (d *DecryptedMessageMediaVideo8) GetIv() (value []byte) {
	return d.Iv
}

// Decode implements bin.Decoder.
func (d *DecryptedMessageMediaVideo8) Decode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaVideo8#4cee6ef3 to nil")
	}
	if err := b.ConsumeID(DecryptedMessageMediaVideo8TypeID); err != nil {
		return fmt.Errorf("unable to decode decryptedMessageMediaVideo8#4cee6ef3: %w", err)
	}
	return d.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (d *DecryptedMessageMediaVideo8) DecodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaVideo8#4cee6ef3 to nil")
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo8#4cee6ef3: field thumb: %w", err)
		}
		d.Thumb = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo8#4cee6ef3: field thumb_w: %w", err)
		}
		d.ThumbW = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo8#4cee6ef3: field thumb_h: %w", err)
		}
		d.ThumbH = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo8#4cee6ef3: field duration: %w", err)
		}
		d.Duration = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo8#4cee6ef3: field w: %w", err)
		}
		d.W = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo8#4cee6ef3: field h: %w", err)
		}
		d.H = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo8#4cee6ef3: field size: %w", err)
		}
		d.Size = value
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo8#4cee6ef3: field key: %w", err)
		}
		d.Key = value
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo8#4cee6ef3: field iv: %w", err)
		}
		d.Iv = value
	}
	return nil
}

// construct implements constructor of DecryptedMessageMediaClass.
func (d DecryptedMessageMediaVideo8) construct() DecryptedMessageMediaClass { return &d }

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

	_ DecryptedMessageMediaClass = &DecryptedMessageMediaVideo8{}
)

// DecryptedMessageMediaGeoPoint represents TL type `decryptedMessageMediaGeoPoint#35480a59`.
//
// See https://core.telegram.org/constructor/decryptedMessageMediaGeoPoint for reference.
type DecryptedMessageMediaGeoPoint struct {
	// Lat field of DecryptedMessageMediaGeoPoint.
	Lat float64
	// Long field of DecryptedMessageMediaGeoPoint.
	Long float64
}

// DecryptedMessageMediaGeoPointTypeID is TL type id of DecryptedMessageMediaGeoPoint.
const DecryptedMessageMediaGeoPointTypeID = 0x35480a59

func (d *DecryptedMessageMediaGeoPoint) Zero() bool {
	if d == nil {
		return true
	}
	if !(d.Lat == 0) {
		return false
	}
	if !(d.Long == 0) {
		return false
	}

	return true
}

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

// FillFrom fills DecryptedMessageMediaGeoPoint from given interface.
func (d *DecryptedMessageMediaGeoPoint) FillFrom(from interface {
	GetLat() (value float64)
	GetLong() (value float64)
}) {
	d.Lat = from.GetLat()
	d.Long = from.GetLong()
}

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

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

// TypeInfo returns info about TL type.
func (d *DecryptedMessageMediaGeoPoint) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "decryptedMessageMediaGeoPoint",
		ID:   DecryptedMessageMediaGeoPointTypeID,
	}
	if d == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Lat",
			SchemaName: "lat",
		},
		{
			Name:       "Long",
			SchemaName: "long",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (d *DecryptedMessageMediaGeoPoint) Encode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaGeoPoint#35480a59 as nil")
	}
	b.PutID(DecryptedMessageMediaGeoPointTypeID)
	return d.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (d *DecryptedMessageMediaGeoPoint) EncodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaGeoPoint#35480a59 as nil")
	}
	b.PutDouble(d.Lat)
	b.PutDouble(d.Long)
	return nil
}

// GetLat returns value of Lat field.
func (d *DecryptedMessageMediaGeoPoint) GetLat() (value float64) {
	return d.Lat
}

// GetLong returns value of Long field.
func (d *DecryptedMessageMediaGeoPoint) GetLong() (value float64) {
	return d.Long
}

// Decode implements bin.Decoder.
func (d *DecryptedMessageMediaGeoPoint) Decode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaGeoPoint#35480a59 to nil")
	}
	if err := b.ConsumeID(DecryptedMessageMediaGeoPointTypeID); err != nil {
		return fmt.Errorf("unable to decode decryptedMessageMediaGeoPoint#35480a59: %w", err)
	}
	return d.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (d *DecryptedMessageMediaGeoPoint) DecodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaGeoPoint#35480a59 to nil")
	}
	{
		value, err := b.Double()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaGeoPoint#35480a59: field lat: %w", err)
		}
		d.Lat = value
	}
	{
		value, err := b.Double()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaGeoPoint#35480a59: field long: %w", err)
		}
		d.Long = value
	}
	return nil
}

// construct implements constructor of DecryptedMessageMediaClass.
func (d DecryptedMessageMediaGeoPoint) construct() DecryptedMessageMediaClass { return &d }

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

	_ DecryptedMessageMediaClass = &DecryptedMessageMediaGeoPoint{}
)

// DecryptedMessageMediaContact represents TL type `decryptedMessageMediaContact#588a0a97`.
//
// See https://core.telegram.org/constructor/decryptedMessageMediaContact for reference.
type DecryptedMessageMediaContact struct {
	// PhoneNumber field of DecryptedMessageMediaContact.
	PhoneNumber string
	// FirstName field of DecryptedMessageMediaContact.
	FirstName string
	// LastName field of DecryptedMessageMediaContact.
	LastName string
	// UserID field of DecryptedMessageMediaContact.
	UserID int
}

// DecryptedMessageMediaContactTypeID is TL type id of DecryptedMessageMediaContact.
const DecryptedMessageMediaContactTypeID = 0x588a0a97

func (d *DecryptedMessageMediaContact) Zero() bool {
	if d == nil {
		return true
	}
	if !(d.PhoneNumber == "") {
		return false
	}
	if !(d.FirstName == "") {
		return false
	}
	if !(d.LastName == "") {
		return false
	}
	if !(d.UserID == 0) {
		return false
	}

	return true
}

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

// FillFrom fills DecryptedMessageMediaContact from given interface.
func (d *DecryptedMessageMediaContact) FillFrom(from interface {
	GetPhoneNumber() (value string)
	GetFirstName() (value string)
	GetLastName() (value string)
	GetUserID() (value int)
}) {
	d.PhoneNumber = from.GetPhoneNumber()
	d.FirstName = from.GetFirstName()
	d.LastName = from.GetLastName()
	d.UserID = from.GetUserID()
}

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

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

// TypeInfo returns info about TL type.
func (d *DecryptedMessageMediaContact) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "decryptedMessageMediaContact",
		ID:   DecryptedMessageMediaContactTypeID,
	}
	if d == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "PhoneNumber",
			SchemaName: "phone_number",
		},
		{
			Name:       "FirstName",
			SchemaName: "first_name",
		},
		{
			Name:       "LastName",
			SchemaName: "last_name",
		},
		{
			Name:       "UserID",
			SchemaName: "user_id",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (d *DecryptedMessageMediaContact) Encode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaContact#588a0a97 as nil")
	}
	b.PutID(DecryptedMessageMediaContactTypeID)
	return d.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (d *DecryptedMessageMediaContact) EncodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaContact#588a0a97 as nil")
	}
	b.PutString(d.PhoneNumber)
	b.PutString(d.FirstName)
	b.PutString(d.LastName)
	b.PutInt(d.UserID)
	return nil
}

// GetPhoneNumber returns value of PhoneNumber field.
func (d *DecryptedMessageMediaContact) GetPhoneNumber() (value string) {
	return d.PhoneNumber
}

// GetFirstName returns value of FirstName field.
func (d *DecryptedMessageMediaContact) GetFirstName() (value string) {
	return d.FirstName
}

// GetLastName returns value of LastName field.
func (d *DecryptedMessageMediaContact) GetLastName() (value string) {
	return d.LastName
}

// GetUserID returns value of UserID field.
func (d *DecryptedMessageMediaContact) GetUserID() (value int) {
	return d.UserID
}

// Decode implements bin.Decoder.
func (d *DecryptedMessageMediaContact) Decode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaContact#588a0a97 to nil")
	}
	if err := b.ConsumeID(DecryptedMessageMediaContactTypeID); err != nil {
		return fmt.Errorf("unable to decode decryptedMessageMediaContact#588a0a97: %w", err)
	}
	return d.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (d *DecryptedMessageMediaContact) DecodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaContact#588a0a97 to nil")
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaContact#588a0a97: field phone_number: %w", err)
		}
		d.PhoneNumber = value
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaContact#588a0a97: field first_name: %w", err)
		}
		d.FirstName = value
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaContact#588a0a97: field last_name: %w", err)
		}
		d.LastName = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaContact#588a0a97: field user_id: %w", err)
		}
		d.UserID = value
	}
	return nil
}

// construct implements constructor of DecryptedMessageMediaClass.
func (d DecryptedMessageMediaContact) construct() DecryptedMessageMediaClass { return &d }

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

	_ DecryptedMessageMediaClass = &DecryptedMessageMediaContact{}
)

// DecryptedMessageMediaDocument23 represents TL type `decryptedMessageMediaDocument23#b095434b`.
//
// See https://core.telegram.org/constructor/decryptedMessageMediaDocument23 for reference.
type DecryptedMessageMediaDocument23 struct {
	// Thumb field of DecryptedMessageMediaDocument23.
	Thumb []byte
	// ThumbW field of DecryptedMessageMediaDocument23.
	ThumbW int
	// ThumbH field of DecryptedMessageMediaDocument23.
	ThumbH int
	// FileName field of DecryptedMessageMediaDocument23.
	FileName string
	// MimeType field of DecryptedMessageMediaDocument23.
	MimeType string
	// Size field of DecryptedMessageMediaDocument23.
	Size int
	// Key field of DecryptedMessageMediaDocument23.
	Key []byte
	// Iv field of DecryptedMessageMediaDocument23.
	Iv []byte
}

// DecryptedMessageMediaDocument23TypeID is TL type id of DecryptedMessageMediaDocument23.
const DecryptedMessageMediaDocument23TypeID = 0xb095434b

func (d *DecryptedMessageMediaDocument23) Zero() bool {
	if d == nil {
		return true
	}
	if !(d.Thumb == nil) {
		return false
	}
	if !(d.ThumbW == 0) {
		return false
	}
	if !(d.ThumbH == 0) {
		return false
	}
	if !(d.FileName == "") {
		return false
	}
	if !(d.MimeType == "") {
		return false
	}
	if !(d.Size == 0) {
		return false
	}
	if !(d.Key == nil) {
		return false
	}
	if !(d.Iv == nil) {
		return false
	}

	return true
}

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

// FillFrom fills DecryptedMessageMediaDocument23 from given interface.
func (d *DecryptedMessageMediaDocument23) FillFrom(from interface {
	GetThumb() (value []byte)
	GetThumbW() (value int)
	GetThumbH() (value int)
	GetFileName() (value string)
	GetMimeType() (value string)
	GetSize() (value int)
	GetKey() (value []byte)
	GetIv() (value []byte)
}) {
	d.Thumb = from.GetThumb()
	d.ThumbW = from.GetThumbW()
	d.ThumbH = from.GetThumbH()
	d.FileName = from.GetFileName()
	d.MimeType = from.GetMimeType()
	d.Size = from.GetSize()
	d.Key = from.GetKey()
	d.Iv = from.GetIv()
}

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

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

// TypeInfo returns info about TL type.
func (d *DecryptedMessageMediaDocument23) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "decryptedMessageMediaDocument23",
		ID:   DecryptedMessageMediaDocument23TypeID,
	}
	if d == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Thumb",
			SchemaName: "thumb",
		},
		{
			Name:       "ThumbW",
			SchemaName: "thumb_w",
		},
		{
			Name:       "ThumbH",
			SchemaName: "thumb_h",
		},
		{
			Name:       "FileName",
			SchemaName: "file_name",
		},
		{
			Name:       "MimeType",
			SchemaName: "mime_type",
		},
		{
			Name:       "Size",
			SchemaName: "size",
		},
		{
			Name:       "Key",
			SchemaName: "key",
		},
		{
			Name:       "Iv",
			SchemaName: "iv",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (d *DecryptedMessageMediaDocument23) Encode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaDocument23#b095434b as nil")
	}
	b.PutID(DecryptedMessageMediaDocument23TypeID)
	return d.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (d *DecryptedMessageMediaDocument23) EncodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaDocument23#b095434b as nil")
	}
	b.PutBytes(d.Thumb)
	b.PutInt(d.ThumbW)
	b.PutInt(d.ThumbH)
	b.PutString(d.FileName)
	b.PutString(d.MimeType)
	b.PutInt(d.Size)
	b.PutBytes(d.Key)
	b.PutBytes(d.Iv)
	return nil
}

// GetThumb returns value of Thumb field.
func (d *DecryptedMessageMediaDocument23) GetThumb() (value []byte) {
	return d.Thumb
}

// GetThumbW returns value of ThumbW field.
func (d *DecryptedMessageMediaDocument23) GetThumbW() (value int) {
	return d.ThumbW
}

// GetThumbH returns value of ThumbH field.
func (d *DecryptedMessageMediaDocument23) GetThumbH() (value int) {
	return d.ThumbH
}

// GetFileName returns value of FileName field.
func (d *DecryptedMessageMediaDocument23) GetFileName() (value string) {
	return d.FileName
}

// GetMimeType returns value of MimeType field.
func (d *DecryptedMessageMediaDocument23) GetMimeType() (value string) {
	return d.MimeType
}

// GetSize returns value of Size field.
func (d *DecryptedMessageMediaDocument23) GetSize() (value int) {
	return d.Size
}

// GetKey returns value of Key field.
func (d *DecryptedMessageMediaDocument23) GetKey() (value []byte) {
	return d.Key
}

// GetIv returns value of Iv field.
func (d *DecryptedMessageMediaDocument23) GetIv() (value []byte) {
	return d.Iv
}

// Decode implements bin.Decoder.
func (d *DecryptedMessageMediaDocument23) Decode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaDocument23#b095434b to nil")
	}
	if err := b.ConsumeID(DecryptedMessageMediaDocument23TypeID); err != nil {
		return fmt.Errorf("unable to decode decryptedMessageMediaDocument23#b095434b: %w", err)
	}
	return d.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (d *DecryptedMessageMediaDocument23) DecodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaDocument23#b095434b to nil")
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaDocument23#b095434b: field thumb: %w", err)
		}
		d.Thumb = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaDocument23#b095434b: field thumb_w: %w", err)
		}
		d.ThumbW = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaDocument23#b095434b: field thumb_h: %w", err)
		}
		d.ThumbH = value
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaDocument23#b095434b: field file_name: %w", err)
		}
		d.FileName = value
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaDocument23#b095434b: field mime_type: %w", err)
		}
		d.MimeType = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaDocument23#b095434b: field size: %w", err)
		}
		d.Size = value
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaDocument23#b095434b: field key: %w", err)
		}
		d.Key = value
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaDocument23#b095434b: field iv: %w", err)
		}
		d.Iv = value
	}
	return nil
}

// construct implements constructor of DecryptedMessageMediaClass.
func (d DecryptedMessageMediaDocument23) construct() DecryptedMessageMediaClass { return &d }

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

	_ DecryptedMessageMediaClass = &DecryptedMessageMediaDocument23{}
)

// DecryptedMessageMediaAudio8 represents TL type `decryptedMessageMediaAudio8#6080758f`.
//
// See https://core.telegram.org/constructor/decryptedMessageMediaAudio8 for reference.
type DecryptedMessageMediaAudio8 struct {
	// Duration field of DecryptedMessageMediaAudio8.
	Duration int
	// Size field of DecryptedMessageMediaAudio8.
	Size int
	// Key field of DecryptedMessageMediaAudio8.
	Key []byte
	// Iv field of DecryptedMessageMediaAudio8.
	Iv []byte
}

// DecryptedMessageMediaAudio8TypeID is TL type id of DecryptedMessageMediaAudio8.
const DecryptedMessageMediaAudio8TypeID = 0x6080758f

func (d *DecryptedMessageMediaAudio8) Zero() bool {
	if d == nil {
		return true
	}
	if !(d.Duration == 0) {
		return false
	}
	if !(d.Size == 0) {
		return false
	}
	if !(d.Key == nil) {
		return false
	}
	if !(d.Iv == nil) {
		return false
	}

	return true
}

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

// FillFrom fills DecryptedMessageMediaAudio8 from given interface.
func (d *DecryptedMessageMediaAudio8) FillFrom(from interface {
	GetDuration() (value int)
	GetSize() (value int)
	GetKey() (value []byte)
	GetIv() (value []byte)
}) {
	d.Duration = from.GetDuration()
	d.Size = from.GetSize()
	d.Key = from.GetKey()
	d.Iv = from.GetIv()
}

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

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

// TypeInfo returns info about TL type.
func (d *DecryptedMessageMediaAudio8) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "decryptedMessageMediaAudio8",
		ID:   DecryptedMessageMediaAudio8TypeID,
	}
	if d == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Duration",
			SchemaName: "duration",
		},
		{
			Name:       "Size",
			SchemaName: "size",
		},
		{
			Name:       "Key",
			SchemaName: "key",
		},
		{
			Name:       "Iv",
			SchemaName: "iv",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (d *DecryptedMessageMediaAudio8) Encode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaAudio8#6080758f as nil")
	}
	b.PutID(DecryptedMessageMediaAudio8TypeID)
	return d.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (d *DecryptedMessageMediaAudio8) EncodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaAudio8#6080758f as nil")
	}
	b.PutInt(d.Duration)
	b.PutInt(d.Size)
	b.PutBytes(d.Key)
	b.PutBytes(d.Iv)
	return nil
}

// GetDuration returns value of Duration field.
func (d *DecryptedMessageMediaAudio8) GetDuration() (value int) {
	return d.Duration
}

// GetSize returns value of Size field.
func (d *DecryptedMessageMediaAudio8) GetSize() (value int) {
	return d.Size
}

// GetKey returns value of Key field.
func (d *DecryptedMessageMediaAudio8) GetKey() (value []byte) {
	return d.Key
}

// GetIv returns value of Iv field.
func (d *DecryptedMessageMediaAudio8) GetIv() (value []byte) {
	return d.Iv
}

// Decode implements bin.Decoder.
func (d *DecryptedMessageMediaAudio8) Decode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaAudio8#6080758f to nil")
	}
	if err := b.ConsumeID(DecryptedMessageMediaAudio8TypeID); err != nil {
		return fmt.Errorf("unable to decode decryptedMessageMediaAudio8#6080758f: %w", err)
	}
	return d.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (d *DecryptedMessageMediaAudio8) DecodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaAudio8#6080758f to nil")
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaAudio8#6080758f: field duration: %w", err)
		}
		d.Duration = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaAudio8#6080758f: field size: %w", err)
		}
		d.Size = value
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaAudio8#6080758f: field key: %w", err)
		}
		d.Key = value
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaAudio8#6080758f: field iv: %w", err)
		}
		d.Iv = value
	}
	return nil
}

// construct implements constructor of DecryptedMessageMediaClass.
func (d DecryptedMessageMediaAudio8) construct() DecryptedMessageMediaClass { return &d }

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

	_ DecryptedMessageMediaClass = &DecryptedMessageMediaAudio8{}
)

// DecryptedMessageMediaVideo23 represents TL type `decryptedMessageMediaVideo23#524a415d`.
//
// See https://core.telegram.org/constructor/decryptedMessageMediaVideo23 for reference.
type DecryptedMessageMediaVideo23 struct {
	// Thumb field of DecryptedMessageMediaVideo23.
	Thumb []byte
	// ThumbW field of DecryptedMessageMediaVideo23.
	ThumbW int
	// ThumbH field of DecryptedMessageMediaVideo23.
	ThumbH int
	// Duration field of DecryptedMessageMediaVideo23.
	Duration int
	// MimeType field of DecryptedMessageMediaVideo23.
	MimeType string
	// W field of DecryptedMessageMediaVideo23.
	W int
	// H field of DecryptedMessageMediaVideo23.
	H int
	// Size field of DecryptedMessageMediaVideo23.
	Size int
	// Key field of DecryptedMessageMediaVideo23.
	Key []byte
	// Iv field of DecryptedMessageMediaVideo23.
	Iv []byte
}

// DecryptedMessageMediaVideo23TypeID is TL type id of DecryptedMessageMediaVideo23.
const DecryptedMessageMediaVideo23TypeID = 0x524a415d

func (d *DecryptedMessageMediaVideo23) Zero() bool {
	if d == nil {
		return true
	}
	if !(d.Thumb == nil) {
		return false
	}
	if !(d.ThumbW == 0) {
		return false
	}
	if !(d.ThumbH == 0) {
		return false
	}
	if !(d.Duration == 0) {
		return false
	}
	if !(d.MimeType == "") {
		return false
	}
	if !(d.W == 0) {
		return false
	}
	if !(d.H == 0) {
		return false
	}
	if !(d.Size == 0) {
		return false
	}
	if !(d.Key == nil) {
		return false
	}
	if !(d.Iv == nil) {
		return false
	}

	return true
}

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

// FillFrom fills DecryptedMessageMediaVideo23 from given interface.
func (d *DecryptedMessageMediaVideo23) FillFrom(from interface {
	GetThumb() (value []byte)
	GetThumbW() (value int)
	GetThumbH() (value int)
	GetDuration() (value int)
	GetMimeType() (value string)
	GetW() (value int)
	GetH() (value int)
	GetSize() (value int)
	GetKey() (value []byte)
	GetIv() (value []byte)
}) {
	d.Thumb = from.GetThumb()
	d.ThumbW = from.GetThumbW()
	d.ThumbH = from.GetThumbH()
	d.Duration = from.GetDuration()
	d.MimeType = from.GetMimeType()
	d.W = from.GetW()
	d.H = from.GetH()
	d.Size = from.GetSize()
	d.Key = from.GetKey()
	d.Iv = from.GetIv()
}

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

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

// TypeInfo returns info about TL type.
func (d *DecryptedMessageMediaVideo23) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "decryptedMessageMediaVideo23",
		ID:   DecryptedMessageMediaVideo23TypeID,
	}
	if d == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Thumb",
			SchemaName: "thumb",
		},
		{
			Name:       "ThumbW",
			SchemaName: "thumb_w",
		},
		{
			Name:       "ThumbH",
			SchemaName: "thumb_h",
		},
		{
			Name:       "Duration",
			SchemaName: "duration",
		},
		{
			Name:       "MimeType",
			SchemaName: "mime_type",
		},
		{
			Name:       "W",
			SchemaName: "w",
		},
		{
			Name:       "H",
			SchemaName: "h",
		},
		{
			Name:       "Size",
			SchemaName: "size",
		},
		{
			Name:       "Key",
			SchemaName: "key",
		},
		{
			Name:       "Iv",
			SchemaName: "iv",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (d *DecryptedMessageMediaVideo23) Encode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaVideo23#524a415d as nil")
	}
	b.PutID(DecryptedMessageMediaVideo23TypeID)
	return d.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (d *DecryptedMessageMediaVideo23) EncodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaVideo23#524a415d as nil")
	}
	b.PutBytes(d.Thumb)
	b.PutInt(d.ThumbW)
	b.PutInt(d.ThumbH)
	b.PutInt(d.Duration)
	b.PutString(d.MimeType)
	b.PutInt(d.W)
	b.PutInt(d.H)
	b.PutInt(d.Size)
	b.PutBytes(d.Key)
	b.PutBytes(d.Iv)
	return nil
}

// GetThumb returns value of Thumb field.
func (d *DecryptedMessageMediaVideo23) GetThumb() (value []byte) {
	return d.Thumb
}

// GetThumbW returns value of ThumbW field.
func (d *DecryptedMessageMediaVideo23) GetThumbW() (value int) {
	return d.ThumbW
}

// GetThumbH returns value of ThumbH field.
func (d *DecryptedMessageMediaVideo23) GetThumbH() (value int) {
	return d.ThumbH
}

// GetDuration returns value of Duration field.
func (d *DecryptedMessageMediaVideo23) GetDuration() (value int) {
	return d.Duration
}

// GetMimeType returns value of MimeType field.
func (d *DecryptedMessageMediaVideo23) GetMimeType() (value string) {
	return d.MimeType
}

// GetW returns value of W field.
func (d *DecryptedMessageMediaVideo23) GetW() (value int) {
	return d.W
}

// GetH returns value of H field.
func (d *DecryptedMessageMediaVideo23) GetH() (value int) {
	return d.H
}

// GetSize returns value of Size field.
func (d *DecryptedMessageMediaVideo23) GetSize() (value int) {
	return d.Size
}

// GetKey returns value of Key field.
func (d *DecryptedMessageMediaVideo23) GetKey() (value []byte) {
	return d.Key
}

// GetIv returns value of Iv field.
func (d *DecryptedMessageMediaVideo23) GetIv() (value []byte) {
	return d.Iv
}

// Decode implements bin.Decoder.
func (d *DecryptedMessageMediaVideo23) Decode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaVideo23#524a415d to nil")
	}
	if err := b.ConsumeID(DecryptedMessageMediaVideo23TypeID); err != nil {
		return fmt.Errorf("unable to decode decryptedMessageMediaVideo23#524a415d: %w", err)
	}
	return d.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (d *DecryptedMessageMediaVideo23) DecodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaVideo23#524a415d to nil")
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo23#524a415d: field thumb: %w", err)
		}
		d.Thumb = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo23#524a415d: field thumb_w: %w", err)
		}
		d.ThumbW = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo23#524a415d: field thumb_h: %w", err)
		}
		d.ThumbH = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo23#524a415d: field duration: %w", err)
		}
		d.Duration = value
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo23#524a415d: field mime_type: %w", err)
		}
		d.MimeType = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo23#524a415d: field w: %w", err)
		}
		d.W = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo23#524a415d: field h: %w", err)
		}
		d.H = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo23#524a415d: field size: %w", err)
		}
		d.Size = value
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo23#524a415d: field key: %w", err)
		}
		d.Key = value
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo23#524a415d: field iv: %w", err)
		}
		d.Iv = value
	}
	return nil
}

// construct implements constructor of DecryptedMessageMediaClass.
func (d DecryptedMessageMediaVideo23) construct() DecryptedMessageMediaClass { return &d }

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

	_ DecryptedMessageMediaClass = &DecryptedMessageMediaVideo23{}
)

// DecryptedMessageMediaAudio represents TL type `decryptedMessageMediaAudio#57e0a9cb`.
//
// See https://core.telegram.org/constructor/decryptedMessageMediaAudio for reference.
type DecryptedMessageMediaAudio struct {
	// Duration field of DecryptedMessageMediaAudio.
	Duration int
	// MimeType field of DecryptedMessageMediaAudio.
	MimeType string
	// Size field of DecryptedMessageMediaAudio.
	Size int
	// Key field of DecryptedMessageMediaAudio.
	Key []byte
	// Iv field of DecryptedMessageMediaAudio.
	Iv []byte
}

// DecryptedMessageMediaAudioTypeID is TL type id of DecryptedMessageMediaAudio.
const DecryptedMessageMediaAudioTypeID = 0x57e0a9cb

func (d *DecryptedMessageMediaAudio) Zero() bool {
	if d == nil {
		return true
	}
	if !(d.Duration == 0) {
		return false
	}
	if !(d.MimeType == "") {
		return false
	}
	if !(d.Size == 0) {
		return false
	}
	if !(d.Key == nil) {
		return false
	}
	if !(d.Iv == nil) {
		return false
	}

	return true
}

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

// FillFrom fills DecryptedMessageMediaAudio from given interface.
func (d *DecryptedMessageMediaAudio) FillFrom(from interface {
	GetDuration() (value int)
	GetMimeType() (value string)
	GetSize() (value int)
	GetKey() (value []byte)
	GetIv() (value []byte)
}) {
	d.Duration = from.GetDuration()
	d.MimeType = from.GetMimeType()
	d.Size = from.GetSize()
	d.Key = from.GetKey()
	d.Iv = from.GetIv()
}

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

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

// TypeInfo returns info about TL type.
func (d *DecryptedMessageMediaAudio) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "decryptedMessageMediaAudio",
		ID:   DecryptedMessageMediaAudioTypeID,
	}
	if d == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Duration",
			SchemaName: "duration",
		},
		{
			Name:       "MimeType",
			SchemaName: "mime_type",
		},
		{
			Name:       "Size",
			SchemaName: "size",
		},
		{
			Name:       "Key",
			SchemaName: "key",
		},
		{
			Name:       "Iv",
			SchemaName: "iv",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (d *DecryptedMessageMediaAudio) Encode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaAudio#57e0a9cb as nil")
	}
	b.PutID(DecryptedMessageMediaAudioTypeID)
	return d.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (d *DecryptedMessageMediaAudio) EncodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaAudio#57e0a9cb as nil")
	}
	b.PutInt(d.Duration)
	b.PutString(d.MimeType)
	b.PutInt(d.Size)
	b.PutBytes(d.Key)
	b.PutBytes(d.Iv)
	return nil
}

// GetDuration returns value of Duration field.
func (d *DecryptedMessageMediaAudio) GetDuration() (value int) {
	return d.Duration
}

// GetMimeType returns value of MimeType field.
func (d *DecryptedMessageMediaAudio) GetMimeType() (value string) {
	return d.MimeType
}

// GetSize returns value of Size field.
func (d *DecryptedMessageMediaAudio) GetSize() (value int) {
	return d.Size
}

// GetKey returns value of Key field.
func (d *DecryptedMessageMediaAudio) GetKey() (value []byte) {
	return d.Key
}

// GetIv returns value of Iv field.
func (d *DecryptedMessageMediaAudio) GetIv() (value []byte) {
	return d.Iv
}

// Decode implements bin.Decoder.
func (d *DecryptedMessageMediaAudio) Decode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaAudio#57e0a9cb to nil")
	}
	if err := b.ConsumeID(DecryptedMessageMediaAudioTypeID); err != nil {
		return fmt.Errorf("unable to decode decryptedMessageMediaAudio#57e0a9cb: %w", err)
	}
	return d.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (d *DecryptedMessageMediaAudio) DecodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaAudio#57e0a9cb to nil")
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaAudio#57e0a9cb: field duration: %w", err)
		}
		d.Duration = value
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaAudio#57e0a9cb: field mime_type: %w", err)
		}
		d.MimeType = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaAudio#57e0a9cb: field size: %w", err)
		}
		d.Size = value
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaAudio#57e0a9cb: field key: %w", err)
		}
		d.Key = value
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaAudio#57e0a9cb: field iv: %w", err)
		}
		d.Iv = value
	}
	return nil
}

// construct implements constructor of DecryptedMessageMediaClass.
func (d DecryptedMessageMediaAudio) construct() DecryptedMessageMediaClass { return &d }

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

	_ DecryptedMessageMediaClass = &DecryptedMessageMediaAudio{}
)

// DecryptedMessageMediaExternalDocument represents TL type `decryptedMessageMediaExternalDocument#fa95b0dd`.
//
// See https://core.telegram.org/constructor/decryptedMessageMediaExternalDocument for reference.
type DecryptedMessageMediaExternalDocument struct {
	// ID field of DecryptedMessageMediaExternalDocument.
	ID int64
	// AccessHash field of DecryptedMessageMediaExternalDocument.
	AccessHash int64
	// Date field of DecryptedMessageMediaExternalDocument.
	Date int
	// MimeType field of DecryptedMessageMediaExternalDocument.
	MimeType string
	// Size field of DecryptedMessageMediaExternalDocument.
	Size int
	// Thumb field of DecryptedMessageMediaExternalDocument.
	Thumb PhotoSizeClass
	// DCID field of DecryptedMessageMediaExternalDocument.
	DCID int
	// Attributes field of DecryptedMessageMediaExternalDocument.
	Attributes []DocumentAttributeClass
}

// DecryptedMessageMediaExternalDocumentTypeID is TL type id of DecryptedMessageMediaExternalDocument.
const DecryptedMessageMediaExternalDocumentTypeID = 0xfa95b0dd

func (d *DecryptedMessageMediaExternalDocument) Zero() bool {
	if d == nil {
		return true
	}
	if !(d.ID == 0) {
		return false
	}
	if !(d.AccessHash == 0) {
		return false
	}
	if !(d.Date == 0) {
		return false
	}
	if !(d.MimeType == "") {
		return false
	}
	if !(d.Size == 0) {
		return false
	}
	if !(d.Thumb == nil) {
		return false
	}
	if !(d.DCID == 0) {
		return false
	}
	if !(d.Attributes == nil) {
		return false
	}

	return true
}

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

// FillFrom fills DecryptedMessageMediaExternalDocument from given interface.
func (d *DecryptedMessageMediaExternalDocument) FillFrom(from interface {
	GetID() (value int64)
	GetAccessHash() (value int64)
	GetDate() (value int)
	GetMimeType() (value string)
	GetSize() (value int)
	GetThumb() (value PhotoSizeClass)
	GetDCID() (value int)
	GetAttributes() (value []DocumentAttributeClass)
}) {
	d.ID = from.GetID()
	d.AccessHash = from.GetAccessHash()
	d.Date = from.GetDate()
	d.MimeType = from.GetMimeType()
	d.Size = from.GetSize()
	d.Thumb = from.GetThumb()
	d.DCID = from.GetDCID()
	d.Attributes = from.GetAttributes()
}

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

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

// TypeInfo returns info about TL type.
func (d *DecryptedMessageMediaExternalDocument) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "decryptedMessageMediaExternalDocument",
		ID:   DecryptedMessageMediaExternalDocumentTypeID,
	}
	if d == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "ID",
			SchemaName: "id",
		},
		{
			Name:       "AccessHash",
			SchemaName: "access_hash",
		},
		{
			Name:       "Date",
			SchemaName: "date",
		},
		{
			Name:       "MimeType",
			SchemaName: "mime_type",
		},
		{
			Name:       "Size",
			SchemaName: "size",
		},
		{
			Name:       "Thumb",
			SchemaName: "thumb",
		},
		{
			Name:       "DCID",
			SchemaName: "dc_id",
		},
		{
			Name:       "Attributes",
			SchemaName: "attributes",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (d *DecryptedMessageMediaExternalDocument) Encode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaExternalDocument#fa95b0dd as nil")
	}
	b.PutID(DecryptedMessageMediaExternalDocumentTypeID)
	return d.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (d *DecryptedMessageMediaExternalDocument) EncodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaExternalDocument#fa95b0dd as nil")
	}
	b.PutLong(d.ID)
	b.PutLong(d.AccessHash)
	b.PutInt(d.Date)
	b.PutString(d.MimeType)
	b.PutInt(d.Size)
	if d.Thumb == nil {
		return fmt.Errorf("unable to encode decryptedMessageMediaExternalDocument#fa95b0dd: field thumb is nil")
	}
	if err := d.Thumb.Encode(b); err != nil {
		return fmt.Errorf("unable to encode decryptedMessageMediaExternalDocument#fa95b0dd: field thumb: %w", err)
	}
	b.PutInt(d.DCID)
	b.PutVectorHeader(len(d.Attributes))
	for idx, v := range d.Attributes {
		if v == nil {
			return fmt.Errorf("unable to encode decryptedMessageMediaExternalDocument#fa95b0dd: field attributes element with index %d is nil", idx)
		}
		if err := v.Encode(b); err != nil {
			return fmt.Errorf("unable to encode decryptedMessageMediaExternalDocument#fa95b0dd: field attributes element with index %d: %w", idx, err)
		}
	}
	return nil
}

// GetID returns value of ID field.
func (d *DecryptedMessageMediaExternalDocument) GetID() (value int64) {
	return d.ID
}

// GetAccessHash returns value of AccessHash field.
func (d *DecryptedMessageMediaExternalDocument) GetAccessHash() (value int64) {
	return d.AccessHash
}

// GetDate returns value of Date field.
func (d *DecryptedMessageMediaExternalDocument) GetDate() (value int) {
	return d.Date
}

// GetMimeType returns value of MimeType field.
func (d *DecryptedMessageMediaExternalDocument) GetMimeType() (value string) {
	return d.MimeType
}

// GetSize returns value of Size field.
func (d *DecryptedMessageMediaExternalDocument) GetSize() (value int) {
	return d.Size
}

// GetThumb returns value of Thumb field.
func (d *DecryptedMessageMediaExternalDocument) GetThumb() (value PhotoSizeClass) {
	return d.Thumb
}

// GetDCID returns value of DCID field.
func (d *DecryptedMessageMediaExternalDocument) GetDCID() (value int) {
	return d.DCID
}

// GetAttributes returns value of Attributes field.
func (d *DecryptedMessageMediaExternalDocument) GetAttributes() (value []DocumentAttributeClass) {
	return d.Attributes
}

// MapAttributes returns field Attributes wrapped in DocumentAttributeClassArray helper.
func (d *DecryptedMessageMediaExternalDocument) MapAttributes() (value DocumentAttributeClassArray) {
	return DocumentAttributeClassArray(d.Attributes)
}

// Decode implements bin.Decoder.
func (d *DecryptedMessageMediaExternalDocument) Decode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaExternalDocument#fa95b0dd to nil")
	}
	if err := b.ConsumeID(DecryptedMessageMediaExternalDocumentTypeID); err != nil {
		return fmt.Errorf("unable to decode decryptedMessageMediaExternalDocument#fa95b0dd: %w", err)
	}
	return d.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (d *DecryptedMessageMediaExternalDocument) DecodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaExternalDocument#fa95b0dd to nil")
	}
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaExternalDocument#fa95b0dd: field id: %w", err)
		}
		d.ID = value
	}
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaExternalDocument#fa95b0dd: field access_hash: %w", err)
		}
		d.AccessHash = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaExternalDocument#fa95b0dd: field date: %w", err)
		}
		d.Date = value
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaExternalDocument#fa95b0dd: field mime_type: %w", err)
		}
		d.MimeType = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaExternalDocument#fa95b0dd: field size: %w", err)
		}
		d.Size = value
	}
	{
		value, err := DecodePhotoSize(b)
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaExternalDocument#fa95b0dd: field thumb: %w", err)
		}
		d.Thumb = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaExternalDocument#fa95b0dd: field dc_id: %w", err)
		}
		d.DCID = value
	}
	{
		headerLen, err := b.VectorHeader()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaExternalDocument#fa95b0dd: field attributes: %w", err)
		}
		for idx := 0; idx < headerLen; idx++ {
			value, err := DecodeDocumentAttribute(b)
			if err != nil {
				return fmt.Errorf("unable to decode decryptedMessageMediaExternalDocument#fa95b0dd: field attributes: %w", err)
			}
			d.Attributes = append(d.Attributes, value)
		}
	}
	return nil
}

// construct implements constructor of DecryptedMessageMediaClass.
func (d DecryptedMessageMediaExternalDocument) construct() DecryptedMessageMediaClass { return &d }

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

	_ DecryptedMessageMediaClass = &DecryptedMessageMediaExternalDocument{}
)

// DecryptedMessageMediaPhoto represents TL type `decryptedMessageMediaPhoto#f1fa8d78`.
//
// See https://core.telegram.org/constructor/decryptedMessageMediaPhoto for reference.
type DecryptedMessageMediaPhoto struct {
	// Thumb field of DecryptedMessageMediaPhoto.
	Thumb []byte
	// ThumbW field of DecryptedMessageMediaPhoto.
	ThumbW int
	// ThumbH field of DecryptedMessageMediaPhoto.
	ThumbH int
	// W field of DecryptedMessageMediaPhoto.
	W int
	// H field of DecryptedMessageMediaPhoto.
	H int
	// Size field of DecryptedMessageMediaPhoto.
	Size int
	// Key field of DecryptedMessageMediaPhoto.
	Key []byte
	// Iv field of DecryptedMessageMediaPhoto.
	Iv []byte
	// Caption field of DecryptedMessageMediaPhoto.
	Caption string
}

// DecryptedMessageMediaPhotoTypeID is TL type id of DecryptedMessageMediaPhoto.
const DecryptedMessageMediaPhotoTypeID = 0xf1fa8d78

func (d *DecryptedMessageMediaPhoto) Zero() bool {
	if d == nil {
		return true
	}
	if !(d.Thumb == nil) {
		return false
	}
	if !(d.ThumbW == 0) {
		return false
	}
	if !(d.ThumbH == 0) {
		return false
	}
	if !(d.W == 0) {
		return false
	}
	if !(d.H == 0) {
		return false
	}
	if !(d.Size == 0) {
		return false
	}
	if !(d.Key == nil) {
		return false
	}
	if !(d.Iv == nil) {
		return false
	}
	if !(d.Caption == "") {
		return false
	}

	return true
}

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

// FillFrom fills DecryptedMessageMediaPhoto from given interface.
func (d *DecryptedMessageMediaPhoto) FillFrom(from interface {
	GetThumb() (value []byte)
	GetThumbW() (value int)
	GetThumbH() (value int)
	GetW() (value int)
	GetH() (value int)
	GetSize() (value int)
	GetKey() (value []byte)
	GetIv() (value []byte)
	GetCaption() (value string)
}) {
	d.Thumb = from.GetThumb()
	d.ThumbW = from.GetThumbW()
	d.ThumbH = from.GetThumbH()
	d.W = from.GetW()
	d.H = from.GetH()
	d.Size = from.GetSize()
	d.Key = from.GetKey()
	d.Iv = from.GetIv()
	d.Caption = from.GetCaption()
}

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

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

// TypeInfo returns info about TL type.
func (d *DecryptedMessageMediaPhoto) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "decryptedMessageMediaPhoto",
		ID:   DecryptedMessageMediaPhotoTypeID,
	}
	if d == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Thumb",
			SchemaName: "thumb",
		},
		{
			Name:       "ThumbW",
			SchemaName: "thumb_w",
		},
		{
			Name:       "ThumbH",
			SchemaName: "thumb_h",
		},
		{
			Name:       "W",
			SchemaName: "w",
		},
		{
			Name:       "H",
			SchemaName: "h",
		},
		{
			Name:       "Size",
			SchemaName: "size",
		},
		{
			Name:       "Key",
			SchemaName: "key",
		},
		{
			Name:       "Iv",
			SchemaName: "iv",
		},
		{
			Name:       "Caption",
			SchemaName: "caption",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (d *DecryptedMessageMediaPhoto) Encode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaPhoto#f1fa8d78 as nil")
	}
	b.PutID(DecryptedMessageMediaPhotoTypeID)
	return d.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (d *DecryptedMessageMediaPhoto) EncodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaPhoto#f1fa8d78 as nil")
	}
	b.PutBytes(d.Thumb)
	b.PutInt(d.ThumbW)
	b.PutInt(d.ThumbH)
	b.PutInt(d.W)
	b.PutInt(d.H)
	b.PutInt(d.Size)
	b.PutBytes(d.Key)
	b.PutBytes(d.Iv)
	b.PutString(d.Caption)
	return nil
}

// GetThumb returns value of Thumb field.
func (d *DecryptedMessageMediaPhoto) GetThumb() (value []byte) {
	return d.Thumb
}

// GetThumbW returns value of ThumbW field.
func (d *DecryptedMessageMediaPhoto) GetThumbW() (value int) {
	return d.ThumbW
}

// GetThumbH returns value of ThumbH field.
func (d *DecryptedMessageMediaPhoto) GetThumbH() (value int) {
	return d.ThumbH
}

// GetW returns value of W field.
func (d *DecryptedMessageMediaPhoto) GetW() (value int) {
	return d.W
}

// GetH returns value of H field.
func (d *DecryptedMessageMediaPhoto) GetH() (value int) {
	return d.H
}

// GetSize returns value of Size field.
func (d *DecryptedMessageMediaPhoto) GetSize() (value int) {
	return d.Size
}

// GetKey returns value of Key field.
func (d *DecryptedMessageMediaPhoto) GetKey() (value []byte) {
	return d.Key
}

// GetIv returns value of Iv field.
func (d *DecryptedMessageMediaPhoto) GetIv() (value []byte) {
	return d.Iv
}

// GetCaption returns value of Caption field.
func (d *DecryptedMessageMediaPhoto) GetCaption() (value string) {
	return d.Caption
}

// Decode implements bin.Decoder.
func (d *DecryptedMessageMediaPhoto) Decode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaPhoto#f1fa8d78 to nil")
	}
	if err := b.ConsumeID(DecryptedMessageMediaPhotoTypeID); err != nil {
		return fmt.Errorf("unable to decode decryptedMessageMediaPhoto#f1fa8d78: %w", err)
	}
	return d.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (d *DecryptedMessageMediaPhoto) DecodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaPhoto#f1fa8d78 to nil")
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaPhoto#f1fa8d78: field thumb: %w", err)
		}
		d.Thumb = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaPhoto#f1fa8d78: field thumb_w: %w", err)
		}
		d.ThumbW = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaPhoto#f1fa8d78: field thumb_h: %w", err)
		}
		d.ThumbH = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaPhoto#f1fa8d78: field w: %w", err)
		}
		d.W = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaPhoto#f1fa8d78: field h: %w", err)
		}
		d.H = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaPhoto#f1fa8d78: field size: %w", err)
		}
		d.Size = value
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaPhoto#f1fa8d78: field key: %w", err)
		}
		d.Key = value
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaPhoto#f1fa8d78: field iv: %w", err)
		}
		d.Iv = value
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaPhoto#f1fa8d78: field caption: %w", err)
		}
		d.Caption = value
	}
	return nil
}

// construct implements constructor of DecryptedMessageMediaClass.
func (d DecryptedMessageMediaPhoto) construct() DecryptedMessageMediaClass { return &d }

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

	_ DecryptedMessageMediaClass = &DecryptedMessageMediaPhoto{}
)

// DecryptedMessageMediaVideo represents TL type `decryptedMessageMediaVideo#970c8c0e`.
//
// See https://core.telegram.org/constructor/decryptedMessageMediaVideo for reference.
type DecryptedMessageMediaVideo struct {
	// Thumb field of DecryptedMessageMediaVideo.
	Thumb []byte
	// ThumbW field of DecryptedMessageMediaVideo.
	ThumbW int
	// ThumbH field of DecryptedMessageMediaVideo.
	ThumbH int
	// Duration field of DecryptedMessageMediaVideo.
	Duration int
	// MimeType field of DecryptedMessageMediaVideo.
	MimeType string
	// W field of DecryptedMessageMediaVideo.
	W int
	// H field of DecryptedMessageMediaVideo.
	H int
	// Size field of DecryptedMessageMediaVideo.
	Size int
	// Key field of DecryptedMessageMediaVideo.
	Key []byte
	// Iv field of DecryptedMessageMediaVideo.
	Iv []byte
	// Caption field of DecryptedMessageMediaVideo.
	Caption string
}

// DecryptedMessageMediaVideoTypeID is TL type id of DecryptedMessageMediaVideo.
const DecryptedMessageMediaVideoTypeID = 0x970c8c0e

func (d *DecryptedMessageMediaVideo) Zero() bool {
	if d == nil {
		return true
	}
	if !(d.Thumb == nil) {
		return false
	}
	if !(d.ThumbW == 0) {
		return false
	}
	if !(d.ThumbH == 0) {
		return false
	}
	if !(d.Duration == 0) {
		return false
	}
	if !(d.MimeType == "") {
		return false
	}
	if !(d.W == 0) {
		return false
	}
	if !(d.H == 0) {
		return false
	}
	if !(d.Size == 0) {
		return false
	}
	if !(d.Key == nil) {
		return false
	}
	if !(d.Iv == nil) {
		return false
	}
	if !(d.Caption == "") {
		return false
	}

	return true
}

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

// FillFrom fills DecryptedMessageMediaVideo from given interface.
func (d *DecryptedMessageMediaVideo) FillFrom(from interface {
	GetThumb() (value []byte)
	GetThumbW() (value int)
	GetThumbH() (value int)
	GetDuration() (value int)
	GetMimeType() (value string)
	GetW() (value int)
	GetH() (value int)
	GetSize() (value int)
	GetKey() (value []byte)
	GetIv() (value []byte)
	GetCaption() (value string)
}) {
	d.Thumb = from.GetThumb()
	d.ThumbW = from.GetThumbW()
	d.ThumbH = from.GetThumbH()
	d.Duration = from.GetDuration()
	d.MimeType = from.GetMimeType()
	d.W = from.GetW()
	d.H = from.GetH()
	d.Size = from.GetSize()
	d.Key = from.GetKey()
	d.Iv = from.GetIv()
	d.Caption = from.GetCaption()
}

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

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

// TypeInfo returns info about TL type.
func (d *DecryptedMessageMediaVideo) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "decryptedMessageMediaVideo",
		ID:   DecryptedMessageMediaVideoTypeID,
	}
	if d == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Thumb",
			SchemaName: "thumb",
		},
		{
			Name:       "ThumbW",
			SchemaName: "thumb_w",
		},
		{
			Name:       "ThumbH",
			SchemaName: "thumb_h",
		},
		{
			Name:       "Duration",
			SchemaName: "duration",
		},
		{
			Name:       "MimeType",
			SchemaName: "mime_type",
		},
		{
			Name:       "W",
			SchemaName: "w",
		},
		{
			Name:       "H",
			SchemaName: "h",
		},
		{
			Name:       "Size",
			SchemaName: "size",
		},
		{
			Name:       "Key",
			SchemaName: "key",
		},
		{
			Name:       "Iv",
			SchemaName: "iv",
		},
		{
			Name:       "Caption",
			SchemaName: "caption",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (d *DecryptedMessageMediaVideo) Encode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaVideo#970c8c0e as nil")
	}
	b.PutID(DecryptedMessageMediaVideoTypeID)
	return d.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (d *DecryptedMessageMediaVideo) EncodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaVideo#970c8c0e as nil")
	}
	b.PutBytes(d.Thumb)
	b.PutInt(d.ThumbW)
	b.PutInt(d.ThumbH)
	b.PutInt(d.Duration)
	b.PutString(d.MimeType)
	b.PutInt(d.W)
	b.PutInt(d.H)
	b.PutInt(d.Size)
	b.PutBytes(d.Key)
	b.PutBytes(d.Iv)
	b.PutString(d.Caption)
	return nil
}

// GetThumb returns value of Thumb field.
func (d *DecryptedMessageMediaVideo) GetThumb() (value []byte) {
	return d.Thumb
}

// GetThumbW returns value of ThumbW field.
func (d *DecryptedMessageMediaVideo) GetThumbW() (value int) {
	return d.ThumbW
}

// GetThumbH returns value of ThumbH field.
func (d *DecryptedMessageMediaVideo) GetThumbH() (value int) {
	return d.ThumbH
}

// GetDuration returns value of Duration field.
func (d *DecryptedMessageMediaVideo) GetDuration() (value int) {
	return d.Duration
}

// GetMimeType returns value of MimeType field.
func (d *DecryptedMessageMediaVideo) GetMimeType() (value string) {
	return d.MimeType
}

// GetW returns value of W field.
func (d *DecryptedMessageMediaVideo) GetW() (value int) {
	return d.W
}

// GetH returns value of H field.
func (d *DecryptedMessageMediaVideo) GetH() (value int) {
	return d.H
}

// GetSize returns value of Size field.
func (d *DecryptedMessageMediaVideo) GetSize() (value int) {
	return d.Size
}

// GetKey returns value of Key field.
func (d *DecryptedMessageMediaVideo) GetKey() (value []byte) {
	return d.Key
}

// GetIv returns value of Iv field.
func (d *DecryptedMessageMediaVideo) GetIv() (value []byte) {
	return d.Iv
}

// GetCaption returns value of Caption field.
func (d *DecryptedMessageMediaVideo) GetCaption() (value string) {
	return d.Caption
}

// Decode implements bin.Decoder.
func (d *DecryptedMessageMediaVideo) Decode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaVideo#970c8c0e to nil")
	}
	if err := b.ConsumeID(DecryptedMessageMediaVideoTypeID); err != nil {
		return fmt.Errorf("unable to decode decryptedMessageMediaVideo#970c8c0e: %w", err)
	}
	return d.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (d *DecryptedMessageMediaVideo) DecodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaVideo#970c8c0e to nil")
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo#970c8c0e: field thumb: %w", err)
		}
		d.Thumb = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo#970c8c0e: field thumb_w: %w", err)
		}
		d.ThumbW = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo#970c8c0e: field thumb_h: %w", err)
		}
		d.ThumbH = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo#970c8c0e: field duration: %w", err)
		}
		d.Duration = value
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo#970c8c0e: field mime_type: %w", err)
		}
		d.MimeType = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo#970c8c0e: field w: %w", err)
		}
		d.W = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo#970c8c0e: field h: %w", err)
		}
		d.H = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo#970c8c0e: field size: %w", err)
		}
		d.Size = value
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo#970c8c0e: field key: %w", err)
		}
		d.Key = value
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo#970c8c0e: field iv: %w", err)
		}
		d.Iv = value
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVideo#970c8c0e: field caption: %w", err)
		}
		d.Caption = value
	}
	return nil
}

// construct implements constructor of DecryptedMessageMediaClass.
func (d DecryptedMessageMediaVideo) construct() DecryptedMessageMediaClass { return &d }

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

	_ DecryptedMessageMediaClass = &DecryptedMessageMediaVideo{}
)

// DecryptedMessageMediaDocument represents TL type `decryptedMessageMediaDocument#7afe8ae2`.
//
// See https://core.telegram.org/constructor/decryptedMessageMediaDocument for reference.
type DecryptedMessageMediaDocument struct {
	// Thumb field of DecryptedMessageMediaDocument.
	Thumb []byte
	// ThumbW field of DecryptedMessageMediaDocument.
	ThumbW int
	// ThumbH field of DecryptedMessageMediaDocument.
	ThumbH int
	// MimeType field of DecryptedMessageMediaDocument.
	MimeType string
	// Size field of DecryptedMessageMediaDocument.
	Size int
	// Key field of DecryptedMessageMediaDocument.
	Key []byte
	// Iv field of DecryptedMessageMediaDocument.
	Iv []byte
	// Attributes field of DecryptedMessageMediaDocument.
	Attributes []DocumentAttributeClass
	// Caption field of DecryptedMessageMediaDocument.
	Caption string
}

// DecryptedMessageMediaDocumentTypeID is TL type id of DecryptedMessageMediaDocument.
const DecryptedMessageMediaDocumentTypeID = 0x7afe8ae2

func (d *DecryptedMessageMediaDocument) Zero() bool {
	if d == nil {
		return true
	}
	if !(d.Thumb == nil) {
		return false
	}
	if !(d.ThumbW == 0) {
		return false
	}
	if !(d.ThumbH == 0) {
		return false
	}
	if !(d.MimeType == "") {
		return false
	}
	if !(d.Size == 0) {
		return false
	}
	if !(d.Key == nil) {
		return false
	}
	if !(d.Iv == nil) {
		return false
	}
	if !(d.Attributes == nil) {
		return false
	}
	if !(d.Caption == "") {
		return false
	}

	return true
}

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

// FillFrom fills DecryptedMessageMediaDocument from given interface.
func (d *DecryptedMessageMediaDocument) FillFrom(from interface {
	GetThumb() (value []byte)
	GetThumbW() (value int)
	GetThumbH() (value int)
	GetMimeType() (value string)
	GetSize() (value int)
	GetKey() (value []byte)
	GetIv() (value []byte)
	GetAttributes() (value []DocumentAttributeClass)
	GetCaption() (value string)
}) {
	d.Thumb = from.GetThumb()
	d.ThumbW = from.GetThumbW()
	d.ThumbH = from.GetThumbH()
	d.MimeType = from.GetMimeType()
	d.Size = from.GetSize()
	d.Key = from.GetKey()
	d.Iv = from.GetIv()
	d.Attributes = from.GetAttributes()
	d.Caption = from.GetCaption()
}

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

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

// TypeInfo returns info about TL type.
func (d *DecryptedMessageMediaDocument) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "decryptedMessageMediaDocument",
		ID:   DecryptedMessageMediaDocumentTypeID,
	}
	if d == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Thumb",
			SchemaName: "thumb",
		},
		{
			Name:       "ThumbW",
			SchemaName: "thumb_w",
		},
		{
			Name:       "ThumbH",
			SchemaName: "thumb_h",
		},
		{
			Name:       "MimeType",
			SchemaName: "mime_type",
		},
		{
			Name:       "Size",
			SchemaName: "size",
		},
		{
			Name:       "Key",
			SchemaName: "key",
		},
		{
			Name:       "Iv",
			SchemaName: "iv",
		},
		{
			Name:       "Attributes",
			SchemaName: "attributes",
		},
		{
			Name:       "Caption",
			SchemaName: "caption",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (d *DecryptedMessageMediaDocument) Encode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaDocument#7afe8ae2 as nil")
	}
	b.PutID(DecryptedMessageMediaDocumentTypeID)
	return d.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (d *DecryptedMessageMediaDocument) EncodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaDocument#7afe8ae2 as nil")
	}
	b.PutBytes(d.Thumb)
	b.PutInt(d.ThumbW)
	b.PutInt(d.ThumbH)
	b.PutString(d.MimeType)
	b.PutInt(d.Size)
	b.PutBytes(d.Key)
	b.PutBytes(d.Iv)
	b.PutVectorHeader(len(d.Attributes))
	for idx, v := range d.Attributes {
		if v == nil {
			return fmt.Errorf("unable to encode decryptedMessageMediaDocument#7afe8ae2: field attributes element with index %d is nil", idx)
		}
		if err := v.Encode(b); err != nil {
			return fmt.Errorf("unable to encode decryptedMessageMediaDocument#7afe8ae2: field attributes element with index %d: %w", idx, err)
		}
	}
	b.PutString(d.Caption)
	return nil
}

// GetThumb returns value of Thumb field.
func (d *DecryptedMessageMediaDocument) GetThumb() (value []byte) {
	return d.Thumb
}

// GetThumbW returns value of ThumbW field.
func (d *DecryptedMessageMediaDocument) GetThumbW() (value int) {
	return d.ThumbW
}

// GetThumbH returns value of ThumbH field.
func (d *DecryptedMessageMediaDocument) GetThumbH() (value int) {
	return d.ThumbH
}

// GetMimeType returns value of MimeType field.
func (d *DecryptedMessageMediaDocument) GetMimeType() (value string) {
	return d.MimeType
}

// GetSize returns value of Size field.
func (d *DecryptedMessageMediaDocument) GetSize() (value int) {
	return d.Size
}

// GetKey returns value of Key field.
func (d *DecryptedMessageMediaDocument) GetKey() (value []byte) {
	return d.Key
}

// GetIv returns value of Iv field.
func (d *DecryptedMessageMediaDocument) GetIv() (value []byte) {
	return d.Iv
}

// GetAttributes returns value of Attributes field.
func (d *DecryptedMessageMediaDocument) GetAttributes() (value []DocumentAttributeClass) {
	return d.Attributes
}

// MapAttributes returns field Attributes wrapped in DocumentAttributeClassArray helper.
func (d *DecryptedMessageMediaDocument) MapAttributes() (value DocumentAttributeClassArray) {
	return DocumentAttributeClassArray(d.Attributes)
}

// GetCaption returns value of Caption field.
func (d *DecryptedMessageMediaDocument) GetCaption() (value string) {
	return d.Caption
}

// Decode implements bin.Decoder.
func (d *DecryptedMessageMediaDocument) Decode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaDocument#7afe8ae2 to nil")
	}
	if err := b.ConsumeID(DecryptedMessageMediaDocumentTypeID); err != nil {
		return fmt.Errorf("unable to decode decryptedMessageMediaDocument#7afe8ae2: %w", err)
	}
	return d.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (d *DecryptedMessageMediaDocument) DecodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaDocument#7afe8ae2 to nil")
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaDocument#7afe8ae2: field thumb: %w", err)
		}
		d.Thumb = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaDocument#7afe8ae2: field thumb_w: %w", err)
		}
		d.ThumbW = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaDocument#7afe8ae2: field thumb_h: %w", err)
		}
		d.ThumbH = value
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaDocument#7afe8ae2: field mime_type: %w", err)
		}
		d.MimeType = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaDocument#7afe8ae2: field size: %w", err)
		}
		d.Size = value
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaDocument#7afe8ae2: field key: %w", err)
		}
		d.Key = value
	}
	{
		value, err := b.Bytes()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaDocument#7afe8ae2: field iv: %w", err)
		}
		d.Iv = value
	}
	{
		headerLen, err := b.VectorHeader()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaDocument#7afe8ae2: field attributes: %w", err)
		}
		for idx := 0; idx < headerLen; idx++ {
			value, err := DecodeDocumentAttribute(b)
			if err != nil {
				return fmt.Errorf("unable to decode decryptedMessageMediaDocument#7afe8ae2: field attributes: %w", err)
			}
			d.Attributes = append(d.Attributes, value)
		}
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaDocument#7afe8ae2: field caption: %w", err)
		}
		d.Caption = value
	}
	return nil
}

// construct implements constructor of DecryptedMessageMediaClass.
func (d DecryptedMessageMediaDocument) construct() DecryptedMessageMediaClass { return &d }

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

	_ DecryptedMessageMediaClass = &DecryptedMessageMediaDocument{}
)

// DecryptedMessageMediaVenue represents TL type `decryptedMessageMediaVenue#8a0df56f`.
//
// See https://core.telegram.org/constructor/decryptedMessageMediaVenue for reference.
type DecryptedMessageMediaVenue struct {
	// Lat field of DecryptedMessageMediaVenue.
	Lat float64
	// Long field of DecryptedMessageMediaVenue.
	Long float64
	// Title field of DecryptedMessageMediaVenue.
	Title string
	// Address field of DecryptedMessageMediaVenue.
	Address string
	// Provider field of DecryptedMessageMediaVenue.
	Provider string
	// VenueID field of DecryptedMessageMediaVenue.
	VenueID string
}

// DecryptedMessageMediaVenueTypeID is TL type id of DecryptedMessageMediaVenue.
const DecryptedMessageMediaVenueTypeID = 0x8a0df56f

func (d *DecryptedMessageMediaVenue) Zero() bool {
	if d == nil {
		return true
	}
	if !(d.Lat == 0) {
		return false
	}
	if !(d.Long == 0) {
		return false
	}
	if !(d.Title == "") {
		return false
	}
	if !(d.Address == "") {
		return false
	}
	if !(d.Provider == "") {
		return false
	}
	if !(d.VenueID == "") {
		return false
	}

	return true
}

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

// FillFrom fills DecryptedMessageMediaVenue from given interface.
func (d *DecryptedMessageMediaVenue) FillFrom(from interface {
	GetLat() (value float64)
	GetLong() (value float64)
	GetTitle() (value string)
	GetAddress() (value string)
	GetProvider() (value string)
	GetVenueID() (value string)
}) {
	d.Lat = from.GetLat()
	d.Long = from.GetLong()
	d.Title = from.GetTitle()
	d.Address = from.GetAddress()
	d.Provider = from.GetProvider()
	d.VenueID = from.GetVenueID()
}

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

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

// TypeInfo returns info about TL type.
func (d *DecryptedMessageMediaVenue) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "decryptedMessageMediaVenue",
		ID:   DecryptedMessageMediaVenueTypeID,
	}
	if d == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Lat",
			SchemaName: "lat",
		},
		{
			Name:       "Long",
			SchemaName: "long",
		},
		{
			Name:       "Title",
			SchemaName: "title",
		},
		{
			Name:       "Address",
			SchemaName: "address",
		},
		{
			Name:       "Provider",
			SchemaName: "provider",
		},
		{
			Name:       "VenueID",
			SchemaName: "venue_id",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (d *DecryptedMessageMediaVenue) Encode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaVenue#8a0df56f as nil")
	}
	b.PutID(DecryptedMessageMediaVenueTypeID)
	return d.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (d *DecryptedMessageMediaVenue) EncodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaVenue#8a0df56f as nil")
	}
	b.PutDouble(d.Lat)
	b.PutDouble(d.Long)
	b.PutString(d.Title)
	b.PutString(d.Address)
	b.PutString(d.Provider)
	b.PutString(d.VenueID)
	return nil
}

// GetLat returns value of Lat field.
func (d *DecryptedMessageMediaVenue) GetLat() (value float64) {
	return d.Lat
}

// GetLong returns value of Long field.
func (d *DecryptedMessageMediaVenue) GetLong() (value float64) {
	return d.Long
}

// GetTitle returns value of Title field.
func (d *DecryptedMessageMediaVenue) GetTitle() (value string) {
	return d.Title
}

// GetAddress returns value of Address field.
func (d *DecryptedMessageMediaVenue) GetAddress() (value string) {
	return d.Address
}

// GetProvider returns value of Provider field.
func (d *DecryptedMessageMediaVenue) GetProvider() (value string) {
	return d.Provider
}

// GetVenueID returns value of VenueID field.
func (d *DecryptedMessageMediaVenue) GetVenueID() (value string) {
	return d.VenueID
}

// Decode implements bin.Decoder.
func (d *DecryptedMessageMediaVenue) Decode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaVenue#8a0df56f to nil")
	}
	if err := b.ConsumeID(DecryptedMessageMediaVenueTypeID); err != nil {
		return fmt.Errorf("unable to decode decryptedMessageMediaVenue#8a0df56f: %w", err)
	}
	return d.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (d *DecryptedMessageMediaVenue) DecodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaVenue#8a0df56f to nil")
	}
	{
		value, err := b.Double()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVenue#8a0df56f: field lat: %w", err)
		}
		d.Lat = value
	}
	{
		value, err := b.Double()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVenue#8a0df56f: field long: %w", err)
		}
		d.Long = value
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVenue#8a0df56f: field title: %w", err)
		}
		d.Title = value
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVenue#8a0df56f: field address: %w", err)
		}
		d.Address = value
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVenue#8a0df56f: field provider: %w", err)
		}
		d.Provider = value
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaVenue#8a0df56f: field venue_id: %w", err)
		}
		d.VenueID = value
	}
	return nil
}

// construct implements constructor of DecryptedMessageMediaClass.
func (d DecryptedMessageMediaVenue) construct() DecryptedMessageMediaClass { return &d }

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

	_ DecryptedMessageMediaClass = &DecryptedMessageMediaVenue{}
)

// DecryptedMessageMediaWebPage represents TL type `decryptedMessageMediaWebPage#e50511d8`.
//
// See https://core.telegram.org/constructor/decryptedMessageMediaWebPage for reference.
type DecryptedMessageMediaWebPage struct {
	// URL field of DecryptedMessageMediaWebPage.
	URL string
}

// DecryptedMessageMediaWebPageTypeID is TL type id of DecryptedMessageMediaWebPage.
const DecryptedMessageMediaWebPageTypeID = 0xe50511d8

func (d *DecryptedMessageMediaWebPage) Zero() bool {
	if d == nil {
		return true
	}
	if !(d.URL == "") {
		return false
	}

	return true
}

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

// FillFrom fills DecryptedMessageMediaWebPage from given interface.
func (d *DecryptedMessageMediaWebPage) FillFrom(from interface {
	GetURL() (value string)
}) {
	d.URL = from.GetURL()
}

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

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

// TypeInfo returns info about TL type.
func (d *DecryptedMessageMediaWebPage) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "decryptedMessageMediaWebPage",
		ID:   DecryptedMessageMediaWebPageTypeID,
	}
	if d == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "URL",
			SchemaName: "url",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (d *DecryptedMessageMediaWebPage) Encode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaWebPage#e50511d8 as nil")
	}
	b.PutID(DecryptedMessageMediaWebPageTypeID)
	return d.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (d *DecryptedMessageMediaWebPage) EncodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't encode decryptedMessageMediaWebPage#e50511d8 as nil")
	}
	b.PutString(d.URL)
	return nil
}

// GetURL returns value of URL field.
func (d *DecryptedMessageMediaWebPage) GetURL() (value string) {
	return d.URL
}

// Decode implements bin.Decoder.
func (d *DecryptedMessageMediaWebPage) Decode(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaWebPage#e50511d8 to nil")
	}
	if err := b.ConsumeID(DecryptedMessageMediaWebPageTypeID); err != nil {
		return fmt.Errorf("unable to decode decryptedMessageMediaWebPage#e50511d8: %w", err)
	}
	return d.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (d *DecryptedMessageMediaWebPage) DecodeBare(b *bin.Buffer) error {
	if d == nil {
		return fmt.Errorf("can't decode decryptedMessageMediaWebPage#e50511d8 to nil")
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode decryptedMessageMediaWebPage#e50511d8: field url: %w", err)
		}
		d.URL = value
	}
	return nil
}

// construct implements constructor of DecryptedMessageMediaClass.
func (d DecryptedMessageMediaWebPage) construct() DecryptedMessageMediaClass { return &d }

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

	_ DecryptedMessageMediaClass = &DecryptedMessageMediaWebPage{}
)

// DecryptedMessageMediaClass represents DecryptedMessageMedia generic type.
//
// See https://core.telegram.org/type/DecryptedMessageMedia for reference.
//
// Example:
//  g, err := e2e.DecodeDecryptedMessageMedia(buf)
//  if err != nil {
//      panic(err)
//  }
//  switch v := g.(type) {
//  case *e2e.DecryptedMessageMediaEmpty: // decryptedMessageMediaEmpty#89f5c4a
//  case *e2e.DecryptedMessageMediaPhoto23: // decryptedMessageMediaPhoto23#32798a8c
//  case *e2e.DecryptedMessageMediaVideo8: // decryptedMessageMediaVideo8#4cee6ef3
//  case *e2e.DecryptedMessageMediaGeoPoint: // decryptedMessageMediaGeoPoint#35480a59
//  case *e2e.DecryptedMessageMediaContact: // decryptedMessageMediaContact#588a0a97
//  case *e2e.DecryptedMessageMediaDocument23: // decryptedMessageMediaDocument23#b095434b
//  case *e2e.DecryptedMessageMediaAudio8: // decryptedMessageMediaAudio8#6080758f
//  case *e2e.DecryptedMessageMediaVideo23: // decryptedMessageMediaVideo23#524a415d
//  case *e2e.DecryptedMessageMediaAudio: // decryptedMessageMediaAudio#57e0a9cb
//  case *e2e.DecryptedMessageMediaExternalDocument: // decryptedMessageMediaExternalDocument#fa95b0dd
//  case *e2e.DecryptedMessageMediaPhoto: // decryptedMessageMediaPhoto#f1fa8d78
//  case *e2e.DecryptedMessageMediaVideo: // decryptedMessageMediaVideo#970c8c0e
//  case *e2e.DecryptedMessageMediaDocument: // decryptedMessageMediaDocument#7afe8ae2
//  case *e2e.DecryptedMessageMediaVenue: // decryptedMessageMediaVenue#8a0df56f
//  case *e2e.DecryptedMessageMediaWebPage: // decryptedMessageMediaWebPage#e50511d8
//  default: panic(v)
//  }
type DecryptedMessageMediaClass interface {
	bin.Encoder
	bin.Decoder
	bin.BareEncoder
	bin.BareDecoder
	construct() DecryptedMessageMediaClass

	// 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
}

// DecodeDecryptedMessageMedia implements binary de-serialization for DecryptedMessageMediaClass.
func DecodeDecryptedMessageMedia(buf *bin.Buffer) (DecryptedMessageMediaClass, error) {
	id, err := buf.PeekID()
	if err != nil {
		return nil, err
	}
	switch id {
	case DecryptedMessageMediaEmptyTypeID:
		// Decoding decryptedMessageMediaEmpty#89f5c4a.
		v := DecryptedMessageMediaEmpty{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode DecryptedMessageMediaClass: %w", err)
		}
		return &v, nil
	case DecryptedMessageMediaPhoto23TypeID:
		// Decoding decryptedMessageMediaPhoto23#32798a8c.
		v := DecryptedMessageMediaPhoto23{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode DecryptedMessageMediaClass: %w", err)
		}
		return &v, nil
	case DecryptedMessageMediaVideo8TypeID:
		// Decoding decryptedMessageMediaVideo8#4cee6ef3.
		v := DecryptedMessageMediaVideo8{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode DecryptedMessageMediaClass: %w", err)
		}
		return &v, nil
	case DecryptedMessageMediaGeoPointTypeID:
		// Decoding decryptedMessageMediaGeoPoint#35480a59.
		v := DecryptedMessageMediaGeoPoint{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode DecryptedMessageMediaClass: %w", err)
		}
		return &v, nil
	case DecryptedMessageMediaContactTypeID:
		// Decoding decryptedMessageMediaContact#588a0a97.
		v := DecryptedMessageMediaContact{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode DecryptedMessageMediaClass: %w", err)
		}
		return &v, nil
	case DecryptedMessageMediaDocument23TypeID:
		// Decoding decryptedMessageMediaDocument23#b095434b.
		v := DecryptedMessageMediaDocument23{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode DecryptedMessageMediaClass: %w", err)
		}
		return &v, nil
	case DecryptedMessageMediaAudio8TypeID:
		// Decoding decryptedMessageMediaAudio8#6080758f.
		v := DecryptedMessageMediaAudio8{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode DecryptedMessageMediaClass: %w", err)
		}
		return &v, nil
	case DecryptedMessageMediaVideo23TypeID:
		// Decoding decryptedMessageMediaVideo23#524a415d.
		v := DecryptedMessageMediaVideo23{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode DecryptedMessageMediaClass: %w", err)
		}
		return &v, nil
	case DecryptedMessageMediaAudioTypeID:
		// Decoding decryptedMessageMediaAudio#57e0a9cb.
		v := DecryptedMessageMediaAudio{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode DecryptedMessageMediaClass: %w", err)
		}
		return &v, nil
	case DecryptedMessageMediaExternalDocumentTypeID:
		// Decoding decryptedMessageMediaExternalDocument#fa95b0dd.
		v := DecryptedMessageMediaExternalDocument{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode DecryptedMessageMediaClass: %w", err)
		}
		return &v, nil
	case DecryptedMessageMediaPhotoTypeID:
		// Decoding decryptedMessageMediaPhoto#f1fa8d78.
		v := DecryptedMessageMediaPhoto{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode DecryptedMessageMediaClass: %w", err)
		}
		return &v, nil
	case DecryptedMessageMediaVideoTypeID:
		// Decoding decryptedMessageMediaVideo#970c8c0e.
		v := DecryptedMessageMediaVideo{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode DecryptedMessageMediaClass: %w", err)
		}
		return &v, nil
	case DecryptedMessageMediaDocumentTypeID:
		// Decoding decryptedMessageMediaDocument#7afe8ae2.
		v := DecryptedMessageMediaDocument{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode DecryptedMessageMediaClass: %w", err)
		}
		return &v, nil
	case DecryptedMessageMediaVenueTypeID:
		// Decoding decryptedMessageMediaVenue#8a0df56f.
		v := DecryptedMessageMediaVenue{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode DecryptedMessageMediaClass: %w", err)
		}
		return &v, nil
	case DecryptedMessageMediaWebPageTypeID:
		// Decoding decryptedMessageMediaWebPage#e50511d8.
		v := DecryptedMessageMediaWebPage{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode DecryptedMessageMediaClass: %w", err)
		}
		return &v, nil
	default:
		return nil, fmt.Errorf("unable to decode DecryptedMessageMediaClass: %w", bin.NewUnexpectedID(id))
	}
}

// DecryptedMessageMedia boxes the DecryptedMessageMediaClass providing a helper.
type DecryptedMessageMediaBox struct {
	DecryptedMessageMedia DecryptedMessageMediaClass
}

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

// Encode implements bin.Encode for DecryptedMessageMediaBox.
func (b *DecryptedMessageMediaBox) Encode(buf *bin.Buffer) error {
	if b == nil || b.DecryptedMessageMedia == nil {
		return fmt.Errorf("unable to encode DecryptedMessageMediaClass as nil")
	}
	return b.DecryptedMessageMedia.Encode(buf)
}

// DecryptedMessageMediaClassArray is adapter for slice of DecryptedMessageMediaClass.
type DecryptedMessageMediaClassArray []DecryptedMessageMediaClass

// Sort sorts slice of DecryptedMessageMediaClass.
func (s DecryptedMessageMediaClassArray) Sort(less func(a, b DecryptedMessageMediaClass) bool) DecryptedMessageMediaClassArray {
	sort.Slice(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// SortStable sorts slice of DecryptedMessageMediaClass.
func (s DecryptedMessageMediaClassArray) SortStable(less func(a, b DecryptedMessageMediaClass) bool) DecryptedMessageMediaClassArray {
	sort.SliceStable(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// Retain filters in-place slice of DecryptedMessageMediaClass.
func (s DecryptedMessageMediaClassArray) Retain(keep func(x DecryptedMessageMediaClass) bool) DecryptedMessageMediaClassArray {
	n := 0
	for _, x := range s {
		if keep(x) {
			s[n] = x
			n++
		}
	}
	s = s[:n]

	return s
}

// First returns first element of slice (if exists).
func (s DecryptedMessageMediaClassArray) First() (v DecryptedMessageMediaClass, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[0], true
}

// Last returns last element of slice (if exists).
func (s DecryptedMessageMediaClassArray) Last() (v DecryptedMessageMediaClass, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[len(s)-1], true
}

// PopFirst returns first element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaClassArray) PopFirst() (v DecryptedMessageMediaClass, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[0]

	// Delete by index from SliceTricks.
	copy(a[0:], a[1:])
	var zero DecryptedMessageMediaClass
	a[len(a)-1] = zero
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// Pop returns last element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaClassArray) Pop() (v DecryptedMessageMediaClass, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[len(a)-1]
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// AsDecryptedMessageMediaPhoto23 returns copy with only DecryptedMessageMediaPhoto23 constructors.
func (s DecryptedMessageMediaClassArray) AsDecryptedMessageMediaPhoto23() (to DecryptedMessageMediaPhoto23Array) {
	for _, elem := range s {
		value, ok := elem.(*DecryptedMessageMediaPhoto23)
		if !ok {
			continue
		}
		to = append(to, *value)
	}

	return to
}

// AsDecryptedMessageMediaVideo8 returns copy with only DecryptedMessageMediaVideo8 constructors.
func (s DecryptedMessageMediaClassArray) AsDecryptedMessageMediaVideo8() (to DecryptedMessageMediaVideo8Array) {
	for _, elem := range s {
		value, ok := elem.(*DecryptedMessageMediaVideo8)
		if !ok {
			continue
		}
		to = append(to, *value)
	}

	return to
}

// AsDecryptedMessageMediaGeoPoint returns copy with only DecryptedMessageMediaGeoPoint constructors.
func (s DecryptedMessageMediaClassArray) AsDecryptedMessageMediaGeoPoint() (to DecryptedMessageMediaGeoPointArray) {
	for _, elem := range s {
		value, ok := elem.(*DecryptedMessageMediaGeoPoint)
		if !ok {
			continue
		}
		to = append(to, *value)
	}

	return to
}

// AsDecryptedMessageMediaContact returns copy with only DecryptedMessageMediaContact constructors.
func (s DecryptedMessageMediaClassArray) AsDecryptedMessageMediaContact() (to DecryptedMessageMediaContactArray) {
	for _, elem := range s {
		value, ok := elem.(*DecryptedMessageMediaContact)
		if !ok {
			continue
		}
		to = append(to, *value)
	}

	return to
}

// AsDecryptedMessageMediaDocument23 returns copy with only DecryptedMessageMediaDocument23 constructors.
func (s DecryptedMessageMediaClassArray) AsDecryptedMessageMediaDocument23() (to DecryptedMessageMediaDocument23Array) {
	for _, elem := range s {
		value, ok := elem.(*DecryptedMessageMediaDocument23)
		if !ok {
			continue
		}
		to = append(to, *value)
	}

	return to
}

// AsDecryptedMessageMediaAudio8 returns copy with only DecryptedMessageMediaAudio8 constructors.
func (s DecryptedMessageMediaClassArray) AsDecryptedMessageMediaAudio8() (to DecryptedMessageMediaAudio8Array) {
	for _, elem := range s {
		value, ok := elem.(*DecryptedMessageMediaAudio8)
		if !ok {
			continue
		}
		to = append(to, *value)
	}

	return to
}

// AsDecryptedMessageMediaVideo23 returns copy with only DecryptedMessageMediaVideo23 constructors.
func (s DecryptedMessageMediaClassArray) AsDecryptedMessageMediaVideo23() (to DecryptedMessageMediaVideo23Array) {
	for _, elem := range s {
		value, ok := elem.(*DecryptedMessageMediaVideo23)
		if !ok {
			continue
		}
		to = append(to, *value)
	}

	return to
}

// AsDecryptedMessageMediaAudio returns copy with only DecryptedMessageMediaAudio constructors.
func (s DecryptedMessageMediaClassArray) AsDecryptedMessageMediaAudio() (to DecryptedMessageMediaAudioArray) {
	for _, elem := range s {
		value, ok := elem.(*DecryptedMessageMediaAudio)
		if !ok {
			continue
		}
		to = append(to, *value)
	}

	return to
}

// AsDecryptedMessageMediaExternalDocument returns copy with only DecryptedMessageMediaExternalDocument constructors.
func (s DecryptedMessageMediaClassArray) AsDecryptedMessageMediaExternalDocument() (to DecryptedMessageMediaExternalDocumentArray) {
	for _, elem := range s {
		value, ok := elem.(*DecryptedMessageMediaExternalDocument)
		if !ok {
			continue
		}
		to = append(to, *value)
	}

	return to
}

// AsDecryptedMessageMediaPhoto returns copy with only DecryptedMessageMediaPhoto constructors.
func (s DecryptedMessageMediaClassArray) AsDecryptedMessageMediaPhoto() (to DecryptedMessageMediaPhotoArray) {
	for _, elem := range s {
		value, ok := elem.(*DecryptedMessageMediaPhoto)
		if !ok {
			continue
		}
		to = append(to, *value)
	}

	return to
}

// AsDecryptedMessageMediaVideo returns copy with only DecryptedMessageMediaVideo constructors.
func (s DecryptedMessageMediaClassArray) AsDecryptedMessageMediaVideo() (to DecryptedMessageMediaVideoArray) {
	for _, elem := range s {
		value, ok := elem.(*DecryptedMessageMediaVideo)
		if !ok {
			continue
		}
		to = append(to, *value)
	}

	return to
}

// AsDecryptedMessageMediaDocument returns copy with only DecryptedMessageMediaDocument constructors.
func (s DecryptedMessageMediaClassArray) AsDecryptedMessageMediaDocument() (to DecryptedMessageMediaDocumentArray) {
	for _, elem := range s {
		value, ok := elem.(*DecryptedMessageMediaDocument)
		if !ok {
			continue
		}
		to = append(to, *value)
	}

	return to
}

// AsDecryptedMessageMediaVenue returns copy with only DecryptedMessageMediaVenue constructors.
func (s DecryptedMessageMediaClassArray) AsDecryptedMessageMediaVenue() (to DecryptedMessageMediaVenueArray) {
	for _, elem := range s {
		value, ok := elem.(*DecryptedMessageMediaVenue)
		if !ok {
			continue
		}
		to = append(to, *value)
	}

	return to
}

// AsDecryptedMessageMediaWebPage returns copy with only DecryptedMessageMediaWebPage constructors.
func (s DecryptedMessageMediaClassArray) AsDecryptedMessageMediaWebPage() (to DecryptedMessageMediaWebPageArray) {
	for _, elem := range s {
		value, ok := elem.(*DecryptedMessageMediaWebPage)
		if !ok {
			continue
		}
		to = append(to, *value)
	}

	return to
}

// DecryptedMessageMediaPhoto23Array is adapter for slice of DecryptedMessageMediaPhoto23.
type DecryptedMessageMediaPhoto23Array []DecryptedMessageMediaPhoto23

// Sort sorts slice of DecryptedMessageMediaPhoto23.
func (s DecryptedMessageMediaPhoto23Array) Sort(less func(a, b DecryptedMessageMediaPhoto23) bool) DecryptedMessageMediaPhoto23Array {
	sort.Slice(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// SortStable sorts slice of DecryptedMessageMediaPhoto23.
func (s DecryptedMessageMediaPhoto23Array) SortStable(less func(a, b DecryptedMessageMediaPhoto23) bool) DecryptedMessageMediaPhoto23Array {
	sort.SliceStable(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// Retain filters in-place slice of DecryptedMessageMediaPhoto23.
func (s DecryptedMessageMediaPhoto23Array) Retain(keep func(x DecryptedMessageMediaPhoto23) bool) DecryptedMessageMediaPhoto23Array {
	n := 0
	for _, x := range s {
		if keep(x) {
			s[n] = x
			n++
		}
	}
	s = s[:n]

	return s
}

// First returns first element of slice (if exists).
func (s DecryptedMessageMediaPhoto23Array) First() (v DecryptedMessageMediaPhoto23, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[0], true
}

// Last returns last element of slice (if exists).
func (s DecryptedMessageMediaPhoto23Array) Last() (v DecryptedMessageMediaPhoto23, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[len(s)-1], true
}

// PopFirst returns first element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaPhoto23Array) PopFirst() (v DecryptedMessageMediaPhoto23, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[0]

	// Delete by index from SliceTricks.
	copy(a[0:], a[1:])
	var zero DecryptedMessageMediaPhoto23
	a[len(a)-1] = zero
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// Pop returns last element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaPhoto23Array) Pop() (v DecryptedMessageMediaPhoto23, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[len(a)-1]
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// DecryptedMessageMediaVideo8Array is adapter for slice of DecryptedMessageMediaVideo8.
type DecryptedMessageMediaVideo8Array []DecryptedMessageMediaVideo8

// Sort sorts slice of DecryptedMessageMediaVideo8.
func (s DecryptedMessageMediaVideo8Array) Sort(less func(a, b DecryptedMessageMediaVideo8) bool) DecryptedMessageMediaVideo8Array {
	sort.Slice(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// SortStable sorts slice of DecryptedMessageMediaVideo8.
func (s DecryptedMessageMediaVideo8Array) SortStable(less func(a, b DecryptedMessageMediaVideo8) bool) DecryptedMessageMediaVideo8Array {
	sort.SliceStable(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// Retain filters in-place slice of DecryptedMessageMediaVideo8.
func (s DecryptedMessageMediaVideo8Array) Retain(keep func(x DecryptedMessageMediaVideo8) bool) DecryptedMessageMediaVideo8Array {
	n := 0
	for _, x := range s {
		if keep(x) {
			s[n] = x
			n++
		}
	}
	s = s[:n]

	return s
}

// First returns first element of slice (if exists).
func (s DecryptedMessageMediaVideo8Array) First() (v DecryptedMessageMediaVideo8, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[0], true
}

// Last returns last element of slice (if exists).
func (s DecryptedMessageMediaVideo8Array) Last() (v DecryptedMessageMediaVideo8, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[len(s)-1], true
}

// PopFirst returns first element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaVideo8Array) PopFirst() (v DecryptedMessageMediaVideo8, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[0]

	// Delete by index from SliceTricks.
	copy(a[0:], a[1:])
	var zero DecryptedMessageMediaVideo8
	a[len(a)-1] = zero
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// Pop returns last element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaVideo8Array) Pop() (v DecryptedMessageMediaVideo8, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[len(a)-1]
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// DecryptedMessageMediaGeoPointArray is adapter for slice of DecryptedMessageMediaGeoPoint.
type DecryptedMessageMediaGeoPointArray []DecryptedMessageMediaGeoPoint

// Sort sorts slice of DecryptedMessageMediaGeoPoint.
func (s DecryptedMessageMediaGeoPointArray) Sort(less func(a, b DecryptedMessageMediaGeoPoint) bool) DecryptedMessageMediaGeoPointArray {
	sort.Slice(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// SortStable sorts slice of DecryptedMessageMediaGeoPoint.
func (s DecryptedMessageMediaGeoPointArray) SortStable(less func(a, b DecryptedMessageMediaGeoPoint) bool) DecryptedMessageMediaGeoPointArray {
	sort.SliceStable(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// Retain filters in-place slice of DecryptedMessageMediaGeoPoint.
func (s DecryptedMessageMediaGeoPointArray) Retain(keep func(x DecryptedMessageMediaGeoPoint) bool) DecryptedMessageMediaGeoPointArray {
	n := 0
	for _, x := range s {
		if keep(x) {
			s[n] = x
			n++
		}
	}
	s = s[:n]

	return s
}

// First returns first element of slice (if exists).
func (s DecryptedMessageMediaGeoPointArray) First() (v DecryptedMessageMediaGeoPoint, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[0], true
}

// Last returns last element of slice (if exists).
func (s DecryptedMessageMediaGeoPointArray) Last() (v DecryptedMessageMediaGeoPoint, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[len(s)-1], true
}

// PopFirst returns first element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaGeoPointArray) PopFirst() (v DecryptedMessageMediaGeoPoint, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[0]

	// Delete by index from SliceTricks.
	copy(a[0:], a[1:])
	var zero DecryptedMessageMediaGeoPoint
	a[len(a)-1] = zero
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// Pop returns last element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaGeoPointArray) Pop() (v DecryptedMessageMediaGeoPoint, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[len(a)-1]
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// DecryptedMessageMediaContactArray is adapter for slice of DecryptedMessageMediaContact.
type DecryptedMessageMediaContactArray []DecryptedMessageMediaContact

// Sort sorts slice of DecryptedMessageMediaContact.
func (s DecryptedMessageMediaContactArray) Sort(less func(a, b DecryptedMessageMediaContact) bool) DecryptedMessageMediaContactArray {
	sort.Slice(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// SortStable sorts slice of DecryptedMessageMediaContact.
func (s DecryptedMessageMediaContactArray) SortStable(less func(a, b DecryptedMessageMediaContact) bool) DecryptedMessageMediaContactArray {
	sort.SliceStable(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// Retain filters in-place slice of DecryptedMessageMediaContact.
func (s DecryptedMessageMediaContactArray) Retain(keep func(x DecryptedMessageMediaContact) bool) DecryptedMessageMediaContactArray {
	n := 0
	for _, x := range s {
		if keep(x) {
			s[n] = x
			n++
		}
	}
	s = s[:n]

	return s
}

// First returns first element of slice (if exists).
func (s DecryptedMessageMediaContactArray) First() (v DecryptedMessageMediaContact, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[0], true
}

// Last returns last element of slice (if exists).
func (s DecryptedMessageMediaContactArray) Last() (v DecryptedMessageMediaContact, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[len(s)-1], true
}

// PopFirst returns first element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaContactArray) PopFirst() (v DecryptedMessageMediaContact, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[0]

	// Delete by index from SliceTricks.
	copy(a[0:], a[1:])
	var zero DecryptedMessageMediaContact
	a[len(a)-1] = zero
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// Pop returns last element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaContactArray) Pop() (v DecryptedMessageMediaContact, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[len(a)-1]
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// DecryptedMessageMediaDocument23Array is adapter for slice of DecryptedMessageMediaDocument23.
type DecryptedMessageMediaDocument23Array []DecryptedMessageMediaDocument23

// Sort sorts slice of DecryptedMessageMediaDocument23.
func (s DecryptedMessageMediaDocument23Array) Sort(less func(a, b DecryptedMessageMediaDocument23) bool) DecryptedMessageMediaDocument23Array {
	sort.Slice(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// SortStable sorts slice of DecryptedMessageMediaDocument23.
func (s DecryptedMessageMediaDocument23Array) SortStable(less func(a, b DecryptedMessageMediaDocument23) bool) DecryptedMessageMediaDocument23Array {
	sort.SliceStable(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// Retain filters in-place slice of DecryptedMessageMediaDocument23.
func (s DecryptedMessageMediaDocument23Array) Retain(keep func(x DecryptedMessageMediaDocument23) bool) DecryptedMessageMediaDocument23Array {
	n := 0
	for _, x := range s {
		if keep(x) {
			s[n] = x
			n++
		}
	}
	s = s[:n]

	return s
}

// First returns first element of slice (if exists).
func (s DecryptedMessageMediaDocument23Array) First() (v DecryptedMessageMediaDocument23, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[0], true
}

// Last returns last element of slice (if exists).
func (s DecryptedMessageMediaDocument23Array) Last() (v DecryptedMessageMediaDocument23, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[len(s)-1], true
}

// PopFirst returns first element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaDocument23Array) PopFirst() (v DecryptedMessageMediaDocument23, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[0]

	// Delete by index from SliceTricks.
	copy(a[0:], a[1:])
	var zero DecryptedMessageMediaDocument23
	a[len(a)-1] = zero
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// Pop returns last element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaDocument23Array) Pop() (v DecryptedMessageMediaDocument23, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[len(a)-1]
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// DecryptedMessageMediaAudio8Array is adapter for slice of DecryptedMessageMediaAudio8.
type DecryptedMessageMediaAudio8Array []DecryptedMessageMediaAudio8

// Sort sorts slice of DecryptedMessageMediaAudio8.
func (s DecryptedMessageMediaAudio8Array) Sort(less func(a, b DecryptedMessageMediaAudio8) bool) DecryptedMessageMediaAudio8Array {
	sort.Slice(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// SortStable sorts slice of DecryptedMessageMediaAudio8.
func (s DecryptedMessageMediaAudio8Array) SortStable(less func(a, b DecryptedMessageMediaAudio8) bool) DecryptedMessageMediaAudio8Array {
	sort.SliceStable(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// Retain filters in-place slice of DecryptedMessageMediaAudio8.
func (s DecryptedMessageMediaAudio8Array) Retain(keep func(x DecryptedMessageMediaAudio8) bool) DecryptedMessageMediaAudio8Array {
	n := 0
	for _, x := range s {
		if keep(x) {
			s[n] = x
			n++
		}
	}
	s = s[:n]

	return s
}

// First returns first element of slice (if exists).
func (s DecryptedMessageMediaAudio8Array) First() (v DecryptedMessageMediaAudio8, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[0], true
}

// Last returns last element of slice (if exists).
func (s DecryptedMessageMediaAudio8Array) Last() (v DecryptedMessageMediaAudio8, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[len(s)-1], true
}

// PopFirst returns first element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaAudio8Array) PopFirst() (v DecryptedMessageMediaAudio8, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[0]

	// Delete by index from SliceTricks.
	copy(a[0:], a[1:])
	var zero DecryptedMessageMediaAudio8
	a[len(a)-1] = zero
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// Pop returns last element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaAudio8Array) Pop() (v DecryptedMessageMediaAudio8, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[len(a)-1]
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// DecryptedMessageMediaVideo23Array is adapter for slice of DecryptedMessageMediaVideo23.
type DecryptedMessageMediaVideo23Array []DecryptedMessageMediaVideo23

// Sort sorts slice of DecryptedMessageMediaVideo23.
func (s DecryptedMessageMediaVideo23Array) Sort(less func(a, b DecryptedMessageMediaVideo23) bool) DecryptedMessageMediaVideo23Array {
	sort.Slice(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// SortStable sorts slice of DecryptedMessageMediaVideo23.
func (s DecryptedMessageMediaVideo23Array) SortStable(less func(a, b DecryptedMessageMediaVideo23) bool) DecryptedMessageMediaVideo23Array {
	sort.SliceStable(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// Retain filters in-place slice of DecryptedMessageMediaVideo23.
func (s DecryptedMessageMediaVideo23Array) Retain(keep func(x DecryptedMessageMediaVideo23) bool) DecryptedMessageMediaVideo23Array {
	n := 0
	for _, x := range s {
		if keep(x) {
			s[n] = x
			n++
		}
	}
	s = s[:n]

	return s
}

// First returns first element of slice (if exists).
func (s DecryptedMessageMediaVideo23Array) First() (v DecryptedMessageMediaVideo23, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[0], true
}

// Last returns last element of slice (if exists).
func (s DecryptedMessageMediaVideo23Array) Last() (v DecryptedMessageMediaVideo23, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[len(s)-1], true
}

// PopFirst returns first element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaVideo23Array) PopFirst() (v DecryptedMessageMediaVideo23, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[0]

	// Delete by index from SliceTricks.
	copy(a[0:], a[1:])
	var zero DecryptedMessageMediaVideo23
	a[len(a)-1] = zero
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// Pop returns last element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaVideo23Array) Pop() (v DecryptedMessageMediaVideo23, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[len(a)-1]
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// DecryptedMessageMediaAudioArray is adapter for slice of DecryptedMessageMediaAudio.
type DecryptedMessageMediaAudioArray []DecryptedMessageMediaAudio

// Sort sorts slice of DecryptedMessageMediaAudio.
func (s DecryptedMessageMediaAudioArray) Sort(less func(a, b DecryptedMessageMediaAudio) bool) DecryptedMessageMediaAudioArray {
	sort.Slice(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// SortStable sorts slice of DecryptedMessageMediaAudio.
func (s DecryptedMessageMediaAudioArray) SortStable(less func(a, b DecryptedMessageMediaAudio) bool) DecryptedMessageMediaAudioArray {
	sort.SliceStable(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// Retain filters in-place slice of DecryptedMessageMediaAudio.
func (s DecryptedMessageMediaAudioArray) Retain(keep func(x DecryptedMessageMediaAudio) bool) DecryptedMessageMediaAudioArray {
	n := 0
	for _, x := range s {
		if keep(x) {
			s[n] = x
			n++
		}
	}
	s = s[:n]

	return s
}

// First returns first element of slice (if exists).
func (s DecryptedMessageMediaAudioArray) First() (v DecryptedMessageMediaAudio, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[0], true
}

// Last returns last element of slice (if exists).
func (s DecryptedMessageMediaAudioArray) Last() (v DecryptedMessageMediaAudio, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[len(s)-1], true
}

// PopFirst returns first element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaAudioArray) PopFirst() (v DecryptedMessageMediaAudio, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[0]

	// Delete by index from SliceTricks.
	copy(a[0:], a[1:])
	var zero DecryptedMessageMediaAudio
	a[len(a)-1] = zero
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// Pop returns last element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaAudioArray) Pop() (v DecryptedMessageMediaAudio, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[len(a)-1]
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// DecryptedMessageMediaExternalDocumentArray is adapter for slice of DecryptedMessageMediaExternalDocument.
type DecryptedMessageMediaExternalDocumentArray []DecryptedMessageMediaExternalDocument

// Sort sorts slice of DecryptedMessageMediaExternalDocument.
func (s DecryptedMessageMediaExternalDocumentArray) Sort(less func(a, b DecryptedMessageMediaExternalDocument) bool) DecryptedMessageMediaExternalDocumentArray {
	sort.Slice(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// SortStable sorts slice of DecryptedMessageMediaExternalDocument.
func (s DecryptedMessageMediaExternalDocumentArray) SortStable(less func(a, b DecryptedMessageMediaExternalDocument) bool) DecryptedMessageMediaExternalDocumentArray {
	sort.SliceStable(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// Retain filters in-place slice of DecryptedMessageMediaExternalDocument.
func (s DecryptedMessageMediaExternalDocumentArray) Retain(keep func(x DecryptedMessageMediaExternalDocument) bool) DecryptedMessageMediaExternalDocumentArray {
	n := 0
	for _, x := range s {
		if keep(x) {
			s[n] = x
			n++
		}
	}
	s = s[:n]

	return s
}

// First returns first element of slice (if exists).
func (s DecryptedMessageMediaExternalDocumentArray) First() (v DecryptedMessageMediaExternalDocument, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[0], true
}

// Last returns last element of slice (if exists).
func (s DecryptedMessageMediaExternalDocumentArray) Last() (v DecryptedMessageMediaExternalDocument, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[len(s)-1], true
}

// PopFirst returns first element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaExternalDocumentArray) PopFirst() (v DecryptedMessageMediaExternalDocument, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[0]

	// Delete by index from SliceTricks.
	copy(a[0:], a[1:])
	var zero DecryptedMessageMediaExternalDocument
	a[len(a)-1] = zero
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// Pop returns last element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaExternalDocumentArray) Pop() (v DecryptedMessageMediaExternalDocument, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[len(a)-1]
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// SortByDate sorts slice of DecryptedMessageMediaExternalDocument by Date.
func (s DecryptedMessageMediaExternalDocumentArray) SortByDate() DecryptedMessageMediaExternalDocumentArray {
	return s.Sort(func(a, b DecryptedMessageMediaExternalDocument) bool {
		return a.GetDate() < b.GetDate()
	})
}

// SortStableByDate sorts slice of DecryptedMessageMediaExternalDocument by Date.
func (s DecryptedMessageMediaExternalDocumentArray) SortStableByDate() DecryptedMessageMediaExternalDocumentArray {
	return s.SortStable(func(a, b DecryptedMessageMediaExternalDocument) bool {
		return a.GetDate() < b.GetDate()
	})
}

// DecryptedMessageMediaPhotoArray is adapter for slice of DecryptedMessageMediaPhoto.
type DecryptedMessageMediaPhotoArray []DecryptedMessageMediaPhoto

// Sort sorts slice of DecryptedMessageMediaPhoto.
func (s DecryptedMessageMediaPhotoArray) Sort(less func(a, b DecryptedMessageMediaPhoto) bool) DecryptedMessageMediaPhotoArray {
	sort.Slice(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// SortStable sorts slice of DecryptedMessageMediaPhoto.
func (s DecryptedMessageMediaPhotoArray) SortStable(less func(a, b DecryptedMessageMediaPhoto) bool) DecryptedMessageMediaPhotoArray {
	sort.SliceStable(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// Retain filters in-place slice of DecryptedMessageMediaPhoto.
func (s DecryptedMessageMediaPhotoArray) Retain(keep func(x DecryptedMessageMediaPhoto) bool) DecryptedMessageMediaPhotoArray {
	n := 0
	for _, x := range s {
		if keep(x) {
			s[n] = x
			n++
		}
	}
	s = s[:n]

	return s
}

// First returns first element of slice (if exists).
func (s DecryptedMessageMediaPhotoArray) First() (v DecryptedMessageMediaPhoto, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[0], true
}

// Last returns last element of slice (if exists).
func (s DecryptedMessageMediaPhotoArray) Last() (v DecryptedMessageMediaPhoto, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[len(s)-1], true
}

// PopFirst returns first element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaPhotoArray) PopFirst() (v DecryptedMessageMediaPhoto, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[0]

	// Delete by index from SliceTricks.
	copy(a[0:], a[1:])
	var zero DecryptedMessageMediaPhoto
	a[len(a)-1] = zero
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// Pop returns last element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaPhotoArray) Pop() (v DecryptedMessageMediaPhoto, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[len(a)-1]
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// DecryptedMessageMediaVideoArray is adapter for slice of DecryptedMessageMediaVideo.
type DecryptedMessageMediaVideoArray []DecryptedMessageMediaVideo

// Sort sorts slice of DecryptedMessageMediaVideo.
func (s DecryptedMessageMediaVideoArray) Sort(less func(a, b DecryptedMessageMediaVideo) bool) DecryptedMessageMediaVideoArray {
	sort.Slice(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// SortStable sorts slice of DecryptedMessageMediaVideo.
func (s DecryptedMessageMediaVideoArray) SortStable(less func(a, b DecryptedMessageMediaVideo) bool) DecryptedMessageMediaVideoArray {
	sort.SliceStable(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// Retain filters in-place slice of DecryptedMessageMediaVideo.
func (s DecryptedMessageMediaVideoArray) Retain(keep func(x DecryptedMessageMediaVideo) bool) DecryptedMessageMediaVideoArray {
	n := 0
	for _, x := range s {
		if keep(x) {
			s[n] = x
			n++
		}
	}
	s = s[:n]

	return s
}

// First returns first element of slice (if exists).
func (s DecryptedMessageMediaVideoArray) First() (v DecryptedMessageMediaVideo, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[0], true
}

// Last returns last element of slice (if exists).
func (s DecryptedMessageMediaVideoArray) Last() (v DecryptedMessageMediaVideo, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[len(s)-1], true
}

// PopFirst returns first element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaVideoArray) PopFirst() (v DecryptedMessageMediaVideo, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[0]

	// Delete by index from SliceTricks.
	copy(a[0:], a[1:])
	var zero DecryptedMessageMediaVideo
	a[len(a)-1] = zero
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// Pop returns last element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaVideoArray) Pop() (v DecryptedMessageMediaVideo, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[len(a)-1]
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// DecryptedMessageMediaDocumentArray is adapter for slice of DecryptedMessageMediaDocument.
type DecryptedMessageMediaDocumentArray []DecryptedMessageMediaDocument

// Sort sorts slice of DecryptedMessageMediaDocument.
func (s DecryptedMessageMediaDocumentArray) Sort(less func(a, b DecryptedMessageMediaDocument) bool) DecryptedMessageMediaDocumentArray {
	sort.Slice(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// SortStable sorts slice of DecryptedMessageMediaDocument.
func (s DecryptedMessageMediaDocumentArray) SortStable(less func(a, b DecryptedMessageMediaDocument) bool) DecryptedMessageMediaDocumentArray {
	sort.SliceStable(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// Retain filters in-place slice of DecryptedMessageMediaDocument.
func (s DecryptedMessageMediaDocumentArray) Retain(keep func(x DecryptedMessageMediaDocument) bool) DecryptedMessageMediaDocumentArray {
	n := 0
	for _, x := range s {
		if keep(x) {
			s[n] = x
			n++
		}
	}
	s = s[:n]

	return s
}

// First returns first element of slice (if exists).
func (s DecryptedMessageMediaDocumentArray) First() (v DecryptedMessageMediaDocument, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[0], true
}

// Last returns last element of slice (if exists).
func (s DecryptedMessageMediaDocumentArray) Last() (v DecryptedMessageMediaDocument, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[len(s)-1], true
}

// PopFirst returns first element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaDocumentArray) PopFirst() (v DecryptedMessageMediaDocument, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[0]

	// Delete by index from SliceTricks.
	copy(a[0:], a[1:])
	var zero DecryptedMessageMediaDocument
	a[len(a)-1] = zero
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// Pop returns last element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaDocumentArray) Pop() (v DecryptedMessageMediaDocument, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[len(a)-1]
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// DecryptedMessageMediaVenueArray is adapter for slice of DecryptedMessageMediaVenue.
type DecryptedMessageMediaVenueArray []DecryptedMessageMediaVenue

// Sort sorts slice of DecryptedMessageMediaVenue.
func (s DecryptedMessageMediaVenueArray) Sort(less func(a, b DecryptedMessageMediaVenue) bool) DecryptedMessageMediaVenueArray {
	sort.Slice(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// SortStable sorts slice of DecryptedMessageMediaVenue.
func (s DecryptedMessageMediaVenueArray) SortStable(less func(a, b DecryptedMessageMediaVenue) bool) DecryptedMessageMediaVenueArray {
	sort.SliceStable(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// Retain filters in-place slice of DecryptedMessageMediaVenue.
func (s DecryptedMessageMediaVenueArray) Retain(keep func(x DecryptedMessageMediaVenue) bool) DecryptedMessageMediaVenueArray {
	n := 0
	for _, x := range s {
		if keep(x) {
			s[n] = x
			n++
		}
	}
	s = s[:n]

	return s
}

// First returns first element of slice (if exists).
func (s DecryptedMessageMediaVenueArray) First() (v DecryptedMessageMediaVenue, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[0], true
}

// Last returns last element of slice (if exists).
func (s DecryptedMessageMediaVenueArray) Last() (v DecryptedMessageMediaVenue, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[len(s)-1], true
}

// PopFirst returns first element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaVenueArray) PopFirst() (v DecryptedMessageMediaVenue, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[0]

	// Delete by index from SliceTricks.
	copy(a[0:], a[1:])
	var zero DecryptedMessageMediaVenue
	a[len(a)-1] = zero
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// Pop returns last element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaVenueArray) Pop() (v DecryptedMessageMediaVenue, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[len(a)-1]
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// DecryptedMessageMediaWebPageArray is adapter for slice of DecryptedMessageMediaWebPage.
type DecryptedMessageMediaWebPageArray []DecryptedMessageMediaWebPage

// Sort sorts slice of DecryptedMessageMediaWebPage.
func (s DecryptedMessageMediaWebPageArray) Sort(less func(a, b DecryptedMessageMediaWebPage) bool) DecryptedMessageMediaWebPageArray {
	sort.Slice(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// SortStable sorts slice of DecryptedMessageMediaWebPage.
func (s DecryptedMessageMediaWebPageArray) SortStable(less func(a, b DecryptedMessageMediaWebPage) bool) DecryptedMessageMediaWebPageArray {
	sort.SliceStable(s, func(i, j int) bool {
		return less(s[i], s[j])
	})
	return s
}

// Retain filters in-place slice of DecryptedMessageMediaWebPage.
func (s DecryptedMessageMediaWebPageArray) Retain(keep func(x DecryptedMessageMediaWebPage) bool) DecryptedMessageMediaWebPageArray {
	n := 0
	for _, x := range s {
		if keep(x) {
			s[n] = x
			n++
		}
	}
	s = s[:n]

	return s
}

// First returns first element of slice (if exists).
func (s DecryptedMessageMediaWebPageArray) First() (v DecryptedMessageMediaWebPage, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[0], true
}

// Last returns last element of slice (if exists).
func (s DecryptedMessageMediaWebPageArray) Last() (v DecryptedMessageMediaWebPage, ok bool) {
	if len(s) < 1 {
		return
	}
	return s[len(s)-1], true
}

// PopFirst returns first element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaWebPageArray) PopFirst() (v DecryptedMessageMediaWebPage, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[0]

	// Delete by index from SliceTricks.
	copy(a[0:], a[1:])
	var zero DecryptedMessageMediaWebPage
	a[len(a)-1] = zero
	a = a[:len(a)-1]
	*s = a

	return v, true
}

// Pop returns last element of slice (if exists) and deletes it.
func (s *DecryptedMessageMediaWebPageArray) Pop() (v DecryptedMessageMediaWebPage, ok bool) {
	if s == nil || len(*s) < 1 {
		return
	}

	a := *s
	v = a[len(a)-1]
	a = a[:len(a)-1]
	*s = a

	return v, true
}