// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v7.36.2
// source: internal/ynison/proto/ynison.proto

package proto

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// DeviceType represents the type of device
type DeviceType int32

const (
	DeviceType_DEVICE_TYPE_UNSPECIFIED   DeviceType = 0
	DeviceType_DEVICE_TYPE_WEB           DeviceType = 1
	DeviceType_DEVICE_TYPE_ANDROID       DeviceType = 2
	DeviceType_DEVICE_TYPE_IOS           DeviceType = 3
	DeviceType_DEVICE_TYPE_SMART_SPEAKER DeviceType = 4
	DeviceType_DEVICE_TYPE_WEB_TV        DeviceType = 5
	DeviceType_DEVICE_TYPE_ANDROID_TV    DeviceType = 6
	DeviceType_DEVICE_TYPE_APPLE_TV      DeviceType = 7
	DeviceType_DEVICE_TYPE_ANDROID_WEAR  DeviceType = 8
	DeviceType_DEVICE_TYPE_WEB_DESKTOP   DeviceType = 9
)

// Enum value maps for DeviceType.
var (
	DeviceType_name = map[int32]string{
		0: "DEVICE_TYPE_UNSPECIFIED",
		1: "DEVICE_TYPE_WEB",
		2: "DEVICE_TYPE_ANDROID",
		3: "DEVICE_TYPE_IOS",
		4: "DEVICE_TYPE_SMART_SPEAKER",
		5: "DEVICE_TYPE_WEB_TV",
		6: "DEVICE_TYPE_ANDROID_TV",
		7: "DEVICE_TYPE_APPLE_TV",
		8: "DEVICE_TYPE_ANDROID_WEAR",
		9: "DEVICE_TYPE_WEB_DESKTOP",
	}
	DeviceType_value = map[string]int32{
		"DEVICE_TYPE_UNSPECIFIED":   0,
		"DEVICE_TYPE_WEB":           1,
		"DEVICE_TYPE_ANDROID":       2,
		"DEVICE_TYPE_IOS":           3,
		"DEVICE_TYPE_SMART_SPEAKER": 4,
		"DEVICE_TYPE_WEB_TV":        5,
		"DEVICE_TYPE_ANDROID_TV":    6,
		"DEVICE_TYPE_APPLE_TV":      7,
		"DEVICE_TYPE_ANDROID_WEAR":  8,
		"DEVICE_TYPE_WEB_DESKTOP":   9,
	}
)

func (x DeviceType) Enum() *DeviceType {
	p := new(DeviceType)
	*p = x
	return p
}

func (x DeviceType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (DeviceType) Descriptor() protoreflect.EnumDescriptor {
	return file_internal_ynison_proto_ynison_proto_enumTypes[0].Descriptor()
}

func (DeviceType) Type() protoreflect.EnumType {
	return &file_internal_ynison_proto_ynison_proto_enumTypes[0]
}

func (x DeviceType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use DeviceType.Descriptor instead.
func (DeviceType) EnumDescriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{0}
}

// PlayablePlayableType represents the type of playable entity
type PlayablePlayableType int32

const (
	PlayablePlayableType_PLAYABLE_TYPE_UNSPECIFIED PlayablePlayableType = 0
	PlayablePlayableType_PLAYABLE_TYPE_TRACK       PlayablePlayableType = 1
	PlayablePlayableType_PLAYABLE_TYPE_LOCAL_TRACK PlayablePlayableType = 2
	PlayablePlayableType_PLAYABLE_TYPE_INFINITE    PlayablePlayableType = 3
	PlayablePlayableType_PLAYABLE_TYPE_VIDEO_CLIP  PlayablePlayableType = 4
)

// Enum value maps for PlayablePlayableType.
var (
	PlayablePlayableType_name = map[int32]string{
		0: "PLAYABLE_TYPE_UNSPECIFIED",
		1: "PLAYABLE_TYPE_TRACK",
		2: "PLAYABLE_TYPE_LOCAL_TRACK",
		3: "PLAYABLE_TYPE_INFINITE",
		4: "PLAYABLE_TYPE_VIDEO_CLIP",
	}
	PlayablePlayableType_value = map[string]int32{
		"PLAYABLE_TYPE_UNSPECIFIED": 0,
		"PLAYABLE_TYPE_TRACK":       1,
		"PLAYABLE_TYPE_LOCAL_TRACK": 2,
		"PLAYABLE_TYPE_INFINITE":    3,
		"PLAYABLE_TYPE_VIDEO_CLIP":  4,
	}
)

func (x PlayablePlayableType) Enum() *PlayablePlayableType {
	p := new(PlayablePlayableType)
	*p = x
	return p
}

func (x PlayablePlayableType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (PlayablePlayableType) Descriptor() protoreflect.EnumDescriptor {
	return file_internal_ynison_proto_ynison_proto_enumTypes[1].Descriptor()
}

func (PlayablePlayableType) Type() protoreflect.EnumType {
	return &file_internal_ynison_proto_ynison_proto_enumTypes[1]
}

func (x PlayablePlayableType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use PlayablePlayableType.Descriptor instead.
func (PlayablePlayableType) EnumDescriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{1}
}

// VideoClipInfoRecommendationType represents how a video clip got into the queue
type VideoClipInfoRecommendationType int32

const (
	VideoClipInfoRecommendationType_VIDEO_CLIP_RECOMMENDATION_UNSPECIFIED      VideoClipInfoRecommendationType = 0
	VideoClipInfoRecommendationType_VIDEO_CLIP_RECOMMENDATION_RECOMMENDED      VideoClipInfoRecommendationType = 1
	VideoClipInfoRecommendationType_VIDEO_CLIP_RECOMMENDATION_ON_DEMAND        VideoClipInfoRecommendationType = 2
	VideoClipInfoRecommendationType_VIDEO_CLIP_RECOMMENDATION_SEARCH           VideoClipInfoRecommendationType = 3
	VideoClipInfoRecommendationType_VIDEO_CLIP_RECOMMENDATION_ARTIST           VideoClipInfoRecommendationType = 4
	VideoClipInfoRecommendationType_VIDEO_CLIP_RECOMMENDATION_OWN              VideoClipInfoRecommendationType = 5
	VideoClipInfoRecommendationType_VIDEO_CLIP_RECOMMENDATION_EDITORIAL_CHOICE VideoClipInfoRecommendationType = 6
)

// Enum value maps for VideoClipInfoRecommendationType.
var (
	VideoClipInfoRecommendationType_name = map[int32]string{
		0: "VIDEO_CLIP_RECOMMENDATION_UNSPECIFIED",
		1: "VIDEO_CLIP_RECOMMENDATION_RECOMMENDED",
		2: "VIDEO_CLIP_RECOMMENDATION_ON_DEMAND",
		3: "VIDEO_CLIP_RECOMMENDATION_SEARCH",
		4: "VIDEO_CLIP_RECOMMENDATION_ARTIST",
		5: "VIDEO_CLIP_RECOMMENDATION_OWN",
		6: "VIDEO_CLIP_RECOMMENDATION_EDITORIAL_CHOICE",
	}
	VideoClipInfoRecommendationType_value = map[string]int32{
		"VIDEO_CLIP_RECOMMENDATION_UNSPECIFIED":      0,
		"VIDEO_CLIP_RECOMMENDATION_RECOMMENDED":      1,
		"VIDEO_CLIP_RECOMMENDATION_ON_DEMAND":        2,
		"VIDEO_CLIP_RECOMMENDATION_SEARCH":           3,
		"VIDEO_CLIP_RECOMMENDATION_ARTIST":           4,
		"VIDEO_CLIP_RECOMMENDATION_OWN":              5,
		"VIDEO_CLIP_RECOMMENDATION_EDITORIAL_CHOICE": 6,
	}
)

func (x VideoClipInfoRecommendationType) Enum() *VideoClipInfoRecommendationType {
	p := new(VideoClipInfoRecommendationType)
	*p = x
	return p
}

func (x VideoClipInfoRecommendationType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (VideoClipInfoRecommendationType) Descriptor() protoreflect.EnumDescriptor {
	return file_internal_ynison_proto_ynison_proto_enumTypes[2].Descriptor()
}

func (VideoClipInfoRecommendationType) Type() protoreflect.EnumType {
	return &file_internal_ynison_proto_ynison_proto_enumTypes[2]
}

func (x VideoClipInfoRecommendationType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use VideoClipInfoRecommendationType.Descriptor instead.
func (VideoClipInfoRecommendationType) EnumDescriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{2}
}

// PlayerQueueEntityType represents the type of entity the queue originated from
type PlayerQueueEntityType int32

const (
	PlayerQueueEntityType_ENTITY_TYPE_UNSPECIFIED  PlayerQueueEntityType = 0
	PlayerQueueEntityType_ENTITY_TYPE_ARTIST       PlayerQueueEntityType = 1
	PlayerQueueEntityType_ENTITY_TYPE_PLAYLIST     PlayerQueueEntityType = 2
	PlayerQueueEntityType_ENTITY_TYPE_ALBUM        PlayerQueueEntityType = 3
	PlayerQueueEntityType_ENTITY_TYPE_RADIO        PlayerQueueEntityType = 4
	PlayerQueueEntityType_ENTITY_TYPE_VARIOUS      PlayerQueueEntityType = 5
	PlayerQueueEntityType_ENTITY_TYPE_GENERATIVE   PlayerQueueEntityType = 6
	PlayerQueueEntityType_ENTITY_TYPE_FM_RADIO     PlayerQueueEntityType = 7
	PlayerQueueEntityType_ENTITY_TYPE_VIDEO_WAVE   PlayerQueueEntityType = 8
	PlayerQueueEntityType_ENTITY_TYPE_LOCAL_TRACKS PlayerQueueEntityType = 9
)

// Enum value maps for PlayerQueueEntityType.
var (
	PlayerQueueEntityType_name = map[int32]string{
		0: "ENTITY_TYPE_UNSPECIFIED",
		1: "ENTITY_TYPE_ARTIST",
		2: "ENTITY_TYPE_PLAYLIST",
		3: "ENTITY_TYPE_ALBUM",
		4: "ENTITY_TYPE_RADIO",
		5: "ENTITY_TYPE_VARIOUS",
		6: "ENTITY_TYPE_GENERATIVE",
		7: "ENTITY_TYPE_FM_RADIO",
		8: "ENTITY_TYPE_VIDEO_WAVE",
		9: "ENTITY_TYPE_LOCAL_TRACKS",
	}
	PlayerQueueEntityType_value = map[string]int32{
		"ENTITY_TYPE_UNSPECIFIED":  0,
		"ENTITY_TYPE_ARTIST":       1,
		"ENTITY_TYPE_PLAYLIST":     2,
		"ENTITY_TYPE_ALBUM":        3,
		"ENTITY_TYPE_RADIO":        4,
		"ENTITY_TYPE_VARIOUS":      5,
		"ENTITY_TYPE_GENERATIVE":   6,
		"ENTITY_TYPE_FM_RADIO":     7,
		"ENTITY_TYPE_VIDEO_WAVE":   8,
		"ENTITY_TYPE_LOCAL_TRACKS": 9,
	}
)

func (x PlayerQueueEntityType) Enum() *PlayerQueueEntityType {
	p := new(PlayerQueueEntityType)
	*p = x
	return p
}

func (x PlayerQueueEntityType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (PlayerQueueEntityType) Descriptor() protoreflect.EnumDescriptor {
	return file_internal_ynison_proto_ynison_proto_enumTypes[3].Descriptor()
}

func (PlayerQueueEntityType) Type() protoreflect.EnumType {
	return &file_internal_ynison_proto_ynison_proto_enumTypes[3]
}

func (x PlayerQueueEntityType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use PlayerQueueEntityType.Descriptor instead.
func (PlayerQueueEntityType) EnumDescriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{3}
}

// PlayerQueueEntityContext represents the playback context
type PlayerQueueEntityContext int32

const (
	PlayerQueueEntityContext_ENTITY_CONTEXT_UNSPECIFIED                PlayerQueueEntityContext = 0
	PlayerQueueEntityContext_ENTITY_CONTEXT_BASED_ON_ENTITY_BY_DEFAULT PlayerQueueEntityContext = 1
	PlayerQueueEntityContext_ENTITY_CONTEXT_USER_TRACKS                PlayerQueueEntityContext = 2
	PlayerQueueEntityContext_ENTITY_CONTEXT_DOWNLOADED_TRACKS          PlayerQueueEntityContext = 3
	PlayerQueueEntityContext_ENTITY_CONTEXT_SEARCH                     PlayerQueueEntityContext = 4
	PlayerQueueEntityContext_ENTITY_CONTEXT_MUSIC_HISTORY              PlayerQueueEntityContext = 5
	PlayerQueueEntityContext_ENTITY_CONTEXT_MUSIC_HISTORY_SEARCH       PlayerQueueEntityContext = 6
	PlayerQueueEntityContext_ENTITY_CONTEXT_ARTIST_MY_COLLECTION       PlayerQueueEntityContext = 7
	PlayerQueueEntityContext_ENTITY_CONTEXT_ARTIST_FAMILIAR_FROM_WAVE  PlayerQueueEntityContext = 8
)

// Enum value maps for PlayerQueueEntityContext.
var (
	PlayerQueueEntityContext_name = map[int32]string{
		0: "ENTITY_CONTEXT_UNSPECIFIED",
		1: "ENTITY_CONTEXT_BASED_ON_ENTITY_BY_DEFAULT",
		2: "ENTITY_CONTEXT_USER_TRACKS",
		3: "ENTITY_CONTEXT_DOWNLOADED_TRACKS",
		4: "ENTITY_CONTEXT_SEARCH",
		5: "ENTITY_CONTEXT_MUSIC_HISTORY",
		6: "ENTITY_CONTEXT_MUSIC_HISTORY_SEARCH",
		7: "ENTITY_CONTEXT_ARTIST_MY_COLLECTION",
		8: "ENTITY_CONTEXT_ARTIST_FAMILIAR_FROM_WAVE",
	}
	PlayerQueueEntityContext_value = map[string]int32{
		"ENTITY_CONTEXT_UNSPECIFIED":                0,
		"ENTITY_CONTEXT_BASED_ON_ENTITY_BY_DEFAULT": 1,
		"ENTITY_CONTEXT_USER_TRACKS":                2,
		"ENTITY_CONTEXT_DOWNLOADED_TRACKS":          3,
		"ENTITY_CONTEXT_SEARCH":                     4,
		"ENTITY_CONTEXT_MUSIC_HISTORY":              5,
		"ENTITY_CONTEXT_MUSIC_HISTORY_SEARCH":       6,
		"ENTITY_CONTEXT_ARTIST_MY_COLLECTION":       7,
		"ENTITY_CONTEXT_ARTIST_FAMILIAR_FROM_WAVE":  8,
	}
)

func (x PlayerQueueEntityContext) Enum() *PlayerQueueEntityContext {
	p := new(PlayerQueueEntityContext)
	*p = x
	return p
}

func (x PlayerQueueEntityContext) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (PlayerQueueEntityContext) Descriptor() protoreflect.EnumDescriptor {
	return file_internal_ynison_proto_ynison_proto_enumTypes[4].Descriptor()
}

func (PlayerQueueEntityContext) Type() protoreflect.EnumType {
	return &file_internal_ynison_proto_ynison_proto_enumTypes[4]
}

func (x PlayerQueueEntityContext) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use PlayerQueueEntityContext.Descriptor instead.
func (PlayerQueueEntityContext) EnumDescriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{4}
}

// WaveSourceSourceType represents how a track got into the wave queue
type WaveSourceSourceType int32

const (
	WaveSourceSourceType_WAVE_SOURCE_ONLINE_BY_DEFAULT WaveSourceSourceType = 0
	WaveSourceSourceType_WAVE_SOURCE_OFFLINE           WaveSourceSourceType = 1
)

// Enum value maps for WaveSourceSourceType.
var (
	WaveSourceSourceType_name = map[int32]string{
		0: "WAVE_SOURCE_ONLINE_BY_DEFAULT",
		1: "WAVE_SOURCE_OFFLINE",
	}
	WaveSourceSourceType_value = map[string]int32{
		"WAVE_SOURCE_ONLINE_BY_DEFAULT": 0,
		"WAVE_SOURCE_OFFLINE":           1,
	}
)

func (x WaveSourceSourceType) Enum() *WaveSourceSourceType {
	p := new(WaveSourceSourceType)
	*p = x
	return p
}

func (x WaveSourceSourceType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (WaveSourceSourceType) Descriptor() protoreflect.EnumDescriptor {
	return file_internal_ynison_proto_ynison_proto_enumTypes[5].Descriptor()
}

func (WaveSourceSourceType) Type() protoreflect.EnumType {
	return &file_internal_ynison_proto_ynison_proto_enumTypes[5]
}

func (x WaveSourceSourceType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use WaveSourceSourceType.Descriptor instead.
func (WaveSourceSourceType) EnumDescriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{5}
}

// PlayerStateOptionsRepeatMode represents the repeat mode
type PlayerStateOptionsRepeatMode int32

const (
	PlayerStateOptionsRepeatMode_REPEAT_MODE_UNSPECIFIED PlayerStateOptionsRepeatMode = 0
	PlayerStateOptionsRepeatMode_REPEAT_MODE_NONE        PlayerStateOptionsRepeatMode = 1
	PlayerStateOptionsRepeatMode_REPEAT_MODE_ONE         PlayerStateOptionsRepeatMode = 2
	PlayerStateOptionsRepeatMode_REPEAT_MODE_ALL         PlayerStateOptionsRepeatMode = 3
)

// Enum value maps for PlayerStateOptionsRepeatMode.
var (
	PlayerStateOptionsRepeatMode_name = map[int32]string{
		0: "REPEAT_MODE_UNSPECIFIED",
		1: "REPEAT_MODE_NONE",
		2: "REPEAT_MODE_ONE",
		3: "REPEAT_MODE_ALL",
	}
	PlayerStateOptionsRepeatMode_value = map[string]int32{
		"REPEAT_MODE_UNSPECIFIED": 0,
		"REPEAT_MODE_NONE":        1,
		"REPEAT_MODE_ONE":         2,
		"REPEAT_MODE_ALL":         3,
	}
)

func (x PlayerStateOptionsRepeatMode) Enum() *PlayerStateOptionsRepeatMode {
	p := new(PlayerStateOptionsRepeatMode)
	*p = x
	return p
}

func (x PlayerStateOptionsRepeatMode) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (PlayerStateOptionsRepeatMode) Descriptor() protoreflect.EnumDescriptor {
	return file_internal_ynison_proto_ynison_proto_enumTypes[6].Descriptor()
}

func (PlayerStateOptionsRepeatMode) Type() protoreflect.EnumType {
	return &file_internal_ynison_proto_ynison_proto_enumTypes[6]
}

func (x PlayerStateOptionsRepeatMode) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use PlayerStateOptionsRepeatMode.Descriptor instead.
func (PlayerStateOptionsRepeatMode) EnumDescriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{6}
}

// PlayerQueueInjectPlayablePlayableType represents injectable playable type
type PlayerQueueInjectPlayablePlayableType int32

const (
	PlayerQueueInjectPlayablePlayableType_INJECT_PLAYABLE_TYPE_UNSPECIFIED PlayerQueueInjectPlayablePlayableType = 0
	PlayerQueueInjectPlayablePlayableType_INJECT_PLAYABLE_TYPE_ALICE_SHOT  PlayerQueueInjectPlayablePlayableType = 1
	PlayerQueueInjectPlayablePlayableType_INJECT_PLAYABLE_TYPE_AD          PlayerQueueInjectPlayablePlayableType = 2
	PlayerQueueInjectPlayablePlayableType_INJECT_PLAYABLE_TYPE_PREROLL     PlayerQueueInjectPlayablePlayableType = 3
)

// Enum value maps for PlayerQueueInjectPlayablePlayableType.
var (
	PlayerQueueInjectPlayablePlayableType_name = map[int32]string{
		0: "INJECT_PLAYABLE_TYPE_UNSPECIFIED",
		1: "INJECT_PLAYABLE_TYPE_ALICE_SHOT",
		2: "INJECT_PLAYABLE_TYPE_AD",
		3: "INJECT_PLAYABLE_TYPE_PREROLL",
	}
	PlayerQueueInjectPlayablePlayableType_value = map[string]int32{
		"INJECT_PLAYABLE_TYPE_UNSPECIFIED": 0,
		"INJECT_PLAYABLE_TYPE_ALICE_SHOT":  1,
		"INJECT_PLAYABLE_TYPE_AD":          2,
		"INJECT_PLAYABLE_TYPE_PREROLL":     3,
	}
)

func (x PlayerQueueInjectPlayablePlayableType) Enum() *PlayerQueueInjectPlayablePlayableType {
	p := new(PlayerQueueInjectPlayablePlayableType)
	*p = x
	return p
}

func (x PlayerQueueInjectPlayablePlayableType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (PlayerQueueInjectPlayablePlayableType) Descriptor() protoreflect.EnumDescriptor {
	return file_internal_ynison_proto_ynison_proto_enumTypes[7].Descriptor()
}

func (PlayerQueueInjectPlayablePlayableType) Type() protoreflect.EnumType {
	return &file_internal_ynison_proto_ynison_proto_enumTypes[7]
}

func (x PlayerQueueInjectPlayablePlayableType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use PlayerQueueInjectPlayablePlayableType.Descriptor instead.
func (PlayerQueueInjectPlayablePlayableType) EnumDescriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{7}
}

// PutYnisonStateRequestActivityInterceptionType represents activity interception type
type PutYnisonStateRequestActivityInterceptionType int32

const (
	PutYnisonStateRequestActivityInterceptionType_INTERCEPTION_DO_NOT_INTERCEPT_BY_DEFAULT PutYnisonStateRequestActivityInterceptionType = 0
	PutYnisonStateRequestActivityInterceptionType_INTERCEPTION_INTERCEPT_IF_NO_ONE_ACTIVE  PutYnisonStateRequestActivityInterceptionType = 1
	PutYnisonStateRequestActivityInterceptionType_INTERCEPTION_INTERCEPT_EAGER             PutYnisonStateRequestActivityInterceptionType = 2
)

// Enum value maps for PutYnisonStateRequestActivityInterceptionType.
var (
	PutYnisonStateRequestActivityInterceptionType_name = map[int32]string{
		0: "INTERCEPTION_DO_NOT_INTERCEPT_BY_DEFAULT",
		1: "INTERCEPTION_INTERCEPT_IF_NO_ONE_ACTIVE",
		2: "INTERCEPTION_INTERCEPT_EAGER",
	}
	PutYnisonStateRequestActivityInterceptionType_value = map[string]int32{
		"INTERCEPTION_DO_NOT_INTERCEPT_BY_DEFAULT": 0,
		"INTERCEPTION_INTERCEPT_IF_NO_ONE_ACTIVE":  1,
		"INTERCEPTION_INTERCEPT_EAGER":             2,
	}
)

func (x PutYnisonStateRequestActivityInterceptionType) Enum() *PutYnisonStateRequestActivityInterceptionType {
	p := new(PutYnisonStateRequestActivityInterceptionType)
	*p = x
	return p
}

func (x PutYnisonStateRequestActivityInterceptionType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (PutYnisonStateRequestActivityInterceptionType) Descriptor() protoreflect.EnumDescriptor {
	return file_internal_ynison_proto_ynison_proto_enumTypes[8].Descriptor()
}

func (PutYnisonStateRequestActivityInterceptionType) Type() protoreflect.EnumType {
	return &file_internal_ynison_proto_ynison_proto_enumTypes[8]
}

func (x PutYnisonStateRequestActivityInterceptionType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use PutYnisonStateRequestActivityInterceptionType.Descriptor instead.
func (PutYnisonStateRequestActivityInterceptionType) EnumDescriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{8}
}

// Playable represents a playable entity (track, video clip, etc.)
type Playable struct {
	state                    protoimpl.MessageState `protogen:"open.v1"`
	PlayableId               string                 `protobuf:"bytes,1,opt,name=playable_id,json=playableId,proto3" json:"playable_id,omitempty"`
	AlbumIdOptional          string                 `protobuf:"bytes,2,opt,name=album_id_optional,json=albumIdOptional,proto3" json:"album_id_optional,omitempty"`
	PlayableType             PlayablePlayableType   `protobuf:"varint,3,opt,name=playable_type,json=playableType,proto3,enum=ynison.PlayablePlayableType" json:"playable_type,omitempty"`
	From                     string                 `protobuf:"bytes,4,opt,name=from,proto3" json:"from,omitempty"`
	Title                    string                 `protobuf:"bytes,5,opt,name=title,proto3" json:"title,omitempty"`
	CoverUrlOptional         string                 `protobuf:"bytes,6,opt,name=cover_url_optional,json=coverUrlOptional,proto3" json:"cover_url_optional,omitempty"`
	VideoClipInfo            *VideoClipInfo         `protobuf:"bytes,7,opt,name=video_clip_info,json=videoClipInfo,proto3" json:"video_clip_info,omitempty"`
	TrackInfo                *TrackInfo             `protobuf:"bytes,8,opt,name=track_info,json=trackInfo,proto3" json:"track_info,omitempty"`
	NavigationIdOptional     string                 `protobuf:"bytes,9,opt,name=navigation_id_optional,json=navigationIdOptional,proto3" json:"navigation_id_optional,omitempty"`
	PlaybackActionIdOptional string                 `protobuf:"bytes,10,opt,name=playback_action_id_optional,json=playbackActionIdOptional,proto3" json:"playback_action_id_optional,omitempty"`
	unknownFields            protoimpl.UnknownFields
	sizeCache                protoimpl.SizeCache
}

func (x *Playable) Reset() {
	*x = Playable{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Playable) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Playable) ProtoMessage() {}

func (x *Playable) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Playable.ProtoReflect.Descriptor instead.
func (*Playable) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{0}
}

func (x *Playable) GetPlayableId() string {
	if x != nil {
		return x.PlayableId
	}
	return ""
}

func (x *Playable) GetAlbumIdOptional() string {
	if x != nil {
		return x.AlbumIdOptional
	}
	return ""
}

func (x *Playable) GetPlayableType() PlayablePlayableType {
	if x != nil {
		return x.PlayableType
	}
	return PlayablePlayableType_PLAYABLE_TYPE_UNSPECIFIED
}

func (x *Playable) GetFrom() string {
	if x != nil {
		return x.From
	}
	return ""
}

func (x *Playable) GetTitle() string {
	if x != nil {
		return x.Title
	}
	return ""
}

func (x *Playable) GetCoverUrlOptional() string {
	if x != nil {
		return x.CoverUrlOptional
	}
	return ""
}

func (x *Playable) GetVideoClipInfo() *VideoClipInfo {
	if x != nil {
		return x.VideoClipInfo
	}
	return nil
}

func (x *Playable) GetTrackInfo() *TrackInfo {
	if x != nil {
		return x.TrackInfo
	}
	return nil
}

func (x *Playable) GetNavigationIdOptional() string {
	if x != nil {
		return x.NavigationIdOptional
	}
	return ""
}

func (x *Playable) GetPlaybackActionIdOptional() string {
	if x != nil {
		return x.PlaybackActionIdOptional
	}
	return ""
}

// VideoClipInfo represents additional info about a video clip
type VideoClipInfo struct {
	state              protoimpl.MessageState          `protogen:"open.v1"`
	RecommendationType VideoClipInfoRecommendationType `protobuf:"varint,1,opt,name=recommendation_type,json=recommendationType,proto3,enum=ynison.VideoClipInfoRecommendationType" json:"recommendation_type,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

func (x *VideoClipInfo) Reset() {
	*x = VideoClipInfo{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *VideoClipInfo) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*VideoClipInfo) ProtoMessage() {}

func (x *VideoClipInfo) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use VideoClipInfo.ProtoReflect.Descriptor instead.
func (*VideoClipInfo) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{1}
}

func (x *VideoClipInfo) GetRecommendationType() VideoClipInfoRecommendationType {
	if x != nil {
		return x.RecommendationType
	}
	return VideoClipInfoRecommendationType_VIDEO_CLIP_RECOMMENDATION_UNSPECIFIED
}

// TrackInfo represents additional info about a track
type TrackInfo struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	TrackSourceKey  uint32                 `protobuf:"varint,1,opt,name=track_source_key,json=trackSourceKey,proto3" json:"track_source_key,omitempty"`
	BatchIdOptional string                 `protobuf:"bytes,2,opt,name=batch_id_optional,json=batchIdOptional,proto3" json:"batch_id_optional,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *TrackInfo) Reset() {
	*x = TrackInfo{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TrackInfo) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TrackInfo) ProtoMessage() {}

func (x *TrackInfo) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use TrackInfo.ProtoReflect.Descriptor instead.
func (*TrackInfo) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{2}
}

func (x *TrackInfo) GetTrackSourceKey() uint32 {
	if x != nil {
		return x.TrackSourceKey
	}
	return 0
}

func (x *TrackInfo) GetBatchIdOptional() string {
	if x != nil {
		return x.BatchIdOptional
	}
	return ""
}

// UpdateVersion represents a version of changes
type UpdateVersion struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	DeviceId      string                 `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	Version       int64                  `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"`
	TimestampMs   int64                  `protobuf:"varint,3,opt,name=timestamp_ms,json=timestampMs,proto3" json:"timestamp_ms,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *UpdateVersion) Reset() {
	*x = UpdateVersion{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *UpdateVersion) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*UpdateVersion) ProtoMessage() {}

func (x *UpdateVersion) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use UpdateVersion.ProtoReflect.Descriptor instead.
func (*UpdateVersion) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{3}
}

func (x *UpdateVersion) GetDeviceId() string {
	if x != nil {
		return x.DeviceId
	}
	return ""
}

func (x *UpdateVersion) GetVersion() int64 {
	if x != nil {
		return x.Version
	}
	return 0
}

func (x *UpdateVersion) GetTimestampMs() int64 {
	if x != nil {
		return x.TimestampMs
	}
	return 0
}

// PlayerQueue represents a playback queue
type PlayerQueue struct {
	state                    protoimpl.MessageState         `protogen:"open.v1"`
	EntityId                 string                         `protobuf:"bytes,1,opt,name=entity_id,json=entityId,proto3" json:"entity_id,omitempty"`
	EntityType               PlayerQueueEntityType          `protobuf:"varint,2,opt,name=entity_type,json=entityType,proto3,enum=ynison.PlayerQueueEntityType" json:"entity_type,omitempty"`
	Queue                    *PlayerQueueQueue              `protobuf:"bytes,12,opt,name=queue,proto3" json:"queue,omitempty"`
	CurrentPlayableIndex     int32                          `protobuf:"varint,3,opt,name=current_playable_index,json=currentPlayableIndex,proto3" json:"current_playable_index,omitempty"`
	PlayableList             []*Playable                    `protobuf:"bytes,4,rep,name=playable_list,json=playableList,proto3" json:"playable_list,omitempty"`
	Options                  *PlayerStateOptions            `protobuf:"bytes,5,opt,name=options,proto3" json:"options,omitempty"`
	Version                  *UpdateVersion                 `protobuf:"bytes,6,opt,name=version,proto3" json:"version,omitempty"`
	ShuffleOptional          *Shuffle                       `protobuf:"bytes,7,opt,name=shuffle_optional,json=shuffleOptional,proto3" json:"shuffle_optional,omitempty"`
	EntityContext            PlayerQueueEntityContext       `protobuf:"varint,8,opt,name=entity_context,json=entityContext,proto3,enum=ynison.PlayerQueueEntityContext" json:"entity_context,omitempty"`
	FromOptional             string                         `protobuf:"bytes,9,opt,name=from_optional,json=fromOptional,proto3" json:"from_optional,omitempty"`
	InitialEntityOptional    *PlayerQueueInitialEntity      `protobuf:"bytes,10,opt,name=initial_entity_optional,json=initialEntityOptional,proto3" json:"initial_entity_optional,omitempty"`
	AddingOptionsOptional    *PlayerQueuePlayerQueueOptions `protobuf:"bytes,11,opt,name=adding_options_optional,json=addingOptionsOptional,proto3" json:"adding_options_optional,omitempty"`
	NavigationIdOptional     string                         `protobuf:"bytes,13,opt,name=navigation_id_optional,json=navigationIdOptional,proto3" json:"navigation_id_optional,omitempty"`
	FilterOptional           string                         `protobuf:"bytes,14,opt,name=filter_optional,json=filterOptional,proto3" json:"filter_optional,omitempty"`
	PlaybackActionIdOptional string                         `protobuf:"bytes,15,opt,name=playback_action_id_optional,json=playbackActionIdOptional,proto3" json:"playback_action_id_optional,omitempty"`
	unknownFields            protoimpl.UnknownFields
	sizeCache                protoimpl.SizeCache
}

func (x *PlayerQueue) Reset() {
	*x = PlayerQueue{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PlayerQueue) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PlayerQueue) ProtoMessage() {}

func (x *PlayerQueue) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PlayerQueue.ProtoReflect.Descriptor instead.
func (*PlayerQueue) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{4}
}

func (x *PlayerQueue) GetEntityId() string {
	if x != nil {
		return x.EntityId
	}
	return ""
}

func (x *PlayerQueue) GetEntityType() PlayerQueueEntityType {
	if x != nil {
		return x.EntityType
	}
	return PlayerQueueEntityType_ENTITY_TYPE_UNSPECIFIED
}

func (x *PlayerQueue) GetQueue() *PlayerQueueQueue {
	if x != nil {
		return x.Queue
	}
	return nil
}

func (x *PlayerQueue) GetCurrentPlayableIndex() int32 {
	if x != nil {
		return x.CurrentPlayableIndex
	}
	return 0
}

func (x *PlayerQueue) GetPlayableList() []*Playable {
	if x != nil {
		return x.PlayableList
	}
	return nil
}

func (x *PlayerQueue) GetOptions() *PlayerStateOptions {
	if x != nil {
		return x.Options
	}
	return nil
}

func (x *PlayerQueue) GetVersion() *UpdateVersion {
	if x != nil {
		return x.Version
	}
	return nil
}

func (x *PlayerQueue) GetShuffleOptional() *Shuffle {
	if x != nil {
		return x.ShuffleOptional
	}
	return nil
}

func (x *PlayerQueue) GetEntityContext() PlayerQueueEntityContext {
	if x != nil {
		return x.EntityContext
	}
	return PlayerQueueEntityContext_ENTITY_CONTEXT_UNSPECIFIED
}

func (x *PlayerQueue) GetFromOptional() string {
	if x != nil {
		return x.FromOptional
	}
	return ""
}

func (x *PlayerQueue) GetInitialEntityOptional() *PlayerQueueInitialEntity {
	if x != nil {
		return x.InitialEntityOptional
	}
	return nil
}

func (x *PlayerQueue) GetAddingOptionsOptional() *PlayerQueuePlayerQueueOptions {
	if x != nil {
		return x.AddingOptionsOptional
	}
	return nil
}

func (x *PlayerQueue) GetNavigationIdOptional() string {
	if x != nil {
		return x.NavigationIdOptional
	}
	return ""
}

func (x *PlayerQueue) GetFilterOptional() string {
	if x != nil {
		return x.FilterOptional
	}
	return ""
}

func (x *PlayerQueue) GetPlaybackActionIdOptional() string {
	if x != nil {
		return x.PlaybackActionIdOptional
	}
	return ""
}

// PlayerQueueQueue represents hierarchical queue structure
type PlayerQueueQueue struct {
	state            protoimpl.MessageState            `protogen:"open.v1"`
	WaveQueue        *PlayerQueueQueueWaveQueue        `protobuf:"bytes,1,opt,name=wave_queue,json=waveQueue,proto3" json:"wave_queue,omitempty"`
	GenerativeQueue  *PlayerQueueQueueGenerativeQueue  `protobuf:"bytes,2,opt,name=generative_queue,json=generativeQueue,proto3" json:"generative_queue,omitempty"`
	FmRadioQueue     *PlayerQueueQueueFmRadioQueue     `protobuf:"bytes,3,opt,name=fm_radio_queue,json=fmRadioQueue,proto3" json:"fm_radio_queue,omitempty"`
	VideoWaveQueue   *PlayerQueueQueueVideoWaveQueue   `protobuf:"bytes,4,opt,name=video_wave_queue,json=videoWaveQueue,proto3" json:"video_wave_queue,omitempty"`
	LocalTracksQueue *PlayerQueueQueueLocalTracksQueue `protobuf:"bytes,5,opt,name=local_tracks_queue,json=localTracksQueue,proto3" json:"local_tracks_queue,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *PlayerQueueQueue) Reset() {
	*x = PlayerQueueQueue{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PlayerQueueQueue) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PlayerQueueQueue) ProtoMessage() {}

func (x *PlayerQueueQueue) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PlayerQueueQueue.ProtoReflect.Descriptor instead.
func (*PlayerQueueQueue) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{5}
}

func (x *PlayerQueueQueue) GetWaveQueue() *PlayerQueueQueueWaveQueue {
	if x != nil {
		return x.WaveQueue
	}
	return nil
}

func (x *PlayerQueueQueue) GetGenerativeQueue() *PlayerQueueQueueGenerativeQueue {
	if x != nil {
		return x.GenerativeQueue
	}
	return nil
}

func (x *PlayerQueueQueue) GetFmRadioQueue() *PlayerQueueQueueFmRadioQueue {
	if x != nil {
		return x.FmRadioQueue
	}
	return nil
}

func (x *PlayerQueueQueue) GetVideoWaveQueue() *PlayerQueueQueueVideoWaveQueue {
	if x != nil {
		return x.VideoWaveQueue
	}
	return nil
}

func (x *PlayerQueueQueue) GetLocalTracksQueue() *PlayerQueueQueueLocalTracksQueue {
	if x != nil {
		return x.LocalTracksQueue
	}
	return nil
}

// PlayerQueueQueueWaveQueue represents a wave queue
type PlayerQueueQueueWaveQueue struct {
	state                    protoimpl.MessageState                  `protogen:"open.v1"`
	RecommendedPlayableList  []*Playable                             `protobuf:"bytes,1,rep,name=recommended_playable_list,json=recommendedPlayableList,proto3" json:"recommended_playable_list,omitempty"`
	LivePlayableIndex        int32                                   `protobuf:"varint,2,opt,name=live_playable_index,json=livePlayableIndex,proto3" json:"live_playable_index,omitempty"`
	EntityOptions            *PlayerQueueQueueWaveQueueEntityOptions `protobuf:"bytes,3,opt,name=entity_options,json=entityOptions,proto3" json:"entity_options,omitempty"`
	NavigationIdOptional     string                                  `protobuf:"bytes,4,opt,name=navigation_id_optional,json=navigationIdOptional,proto3" json:"navigation_id_optional,omitempty"`
	PlaybackActionIdOptional string                                  `protobuf:"bytes,5,opt,name=playback_action_id_optional,json=playbackActionIdOptional,proto3" json:"playback_action_id_optional,omitempty"`
	unknownFields            protoimpl.UnknownFields
	sizeCache                protoimpl.SizeCache
}

func (x *PlayerQueueQueueWaveQueue) Reset() {
	*x = PlayerQueueQueueWaveQueue{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PlayerQueueQueueWaveQueue) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PlayerQueueQueueWaveQueue) ProtoMessage() {}

func (x *PlayerQueueQueueWaveQueue) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PlayerQueueQueueWaveQueue.ProtoReflect.Descriptor instead.
func (*PlayerQueueQueueWaveQueue) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{6}
}

func (x *PlayerQueueQueueWaveQueue) GetRecommendedPlayableList() []*Playable {
	if x != nil {
		return x.RecommendedPlayableList
	}
	return nil
}

func (x *PlayerQueueQueueWaveQueue) GetLivePlayableIndex() int32 {
	if x != nil {
		return x.LivePlayableIndex
	}
	return 0
}

func (x *PlayerQueueQueueWaveQueue) GetEntityOptions() *PlayerQueueQueueWaveQueueEntityOptions {
	if x != nil {
		return x.EntityOptions
	}
	return nil
}

func (x *PlayerQueueQueueWaveQueue) GetNavigationIdOptional() string {
	if x != nil {
		return x.NavigationIdOptional
	}
	return ""
}

func (x *PlayerQueueQueueWaveQueue) GetPlaybackActionIdOptional() string {
	if x != nil {
		return x.PlaybackActionIdOptional
	}
	return ""
}

// PlayerQueueQueueWaveQueueEntityOptions represents wave queue entity options
type PlayerQueueQueueWaveQueueEntityOptions struct {
	state              protoimpl.MessageState                                      `protogen:"open.v1"`
	WaveEntityOptional *PlayerQueueQueueWaveQueueEntityOptionsWaveSession          `protobuf:"bytes,1,opt,name=wave_entity_optional,json=waveEntityOptional,proto3" json:"wave_entity_optional,omitempty"`
	TrackSources       []*PlayerQueueQueueWaveQueueEntityOptionsTrackSourceWithKey `protobuf:"bytes,2,rep,name=track_sources,json=trackSources,proto3" json:"track_sources,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

func (x *PlayerQueueQueueWaveQueueEntityOptions) Reset() {
	*x = PlayerQueueQueueWaveQueueEntityOptions{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PlayerQueueQueueWaveQueueEntityOptions) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PlayerQueueQueueWaveQueueEntityOptions) ProtoMessage() {}

func (x *PlayerQueueQueueWaveQueueEntityOptions) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PlayerQueueQueueWaveQueueEntityOptions.ProtoReflect.Descriptor instead.
func (*PlayerQueueQueueWaveQueueEntityOptions) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{7}
}

func (x *PlayerQueueQueueWaveQueueEntityOptions) GetWaveEntityOptional() *PlayerQueueQueueWaveQueueEntityOptionsWaveSession {
	if x != nil {
		return x.WaveEntityOptional
	}
	return nil
}

func (x *PlayerQueueQueueWaveQueueEntityOptions) GetTrackSources() []*PlayerQueueQueueWaveQueueEntityOptionsTrackSourceWithKey {
	if x != nil {
		return x.TrackSources
	}
	return nil
}

// PlayerQueueQueueWaveQueueEntityOptionsWaveSession represents a wave session
type PlayerQueueQueueWaveQueueEntityOptionsWaveSession struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	SessionId     string                 `protobuf:"bytes,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsWaveSession) Reset() {
	*x = PlayerQueueQueueWaveQueueEntityOptionsWaveSession{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsWaveSession) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PlayerQueueQueueWaveQueueEntityOptionsWaveSession) ProtoMessage() {}

func (x *PlayerQueueQueueWaveQueueEntityOptionsWaveSession) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PlayerQueueQueueWaveQueueEntityOptionsWaveSession.ProtoReflect.Descriptor instead.
func (*PlayerQueueQueueWaveQueueEntityOptionsWaveSession) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{8}
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsWaveSession) GetSessionId() string {
	if x != nil {
		return x.SessionId
	}
	return ""
}

// PlayerQueueQueueWaveQueueEntityOptionsTrackSourceWithKey represents a track source with key
type PlayerQueueQueueWaveQueueEntityOptionsTrackSourceWithKey struct {
	state           protoimpl.MessageState                                 `protogen:"open.v1"`
	Key             uint32                                                 `protobuf:"varint,1,opt,name=key,proto3" json:"key,omitempty"`
	WaveSource      *PlayerQueueQueueWaveQueueEntityOptionsWaveSource      `protobuf:"bytes,2,opt,name=wave_source,json=waveSource,proto3" json:"wave_source,omitempty"`
	PhonotekaSource *PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSource `protobuf:"bytes,3,opt,name=phonoteka_source,json=phonotekaSource,proto3" json:"phonoteka_source,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsTrackSourceWithKey) Reset() {
	*x = PlayerQueueQueueWaveQueueEntityOptionsTrackSourceWithKey{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsTrackSourceWithKey) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PlayerQueueQueueWaveQueueEntityOptionsTrackSourceWithKey) ProtoMessage() {}

func (x *PlayerQueueQueueWaveQueueEntityOptionsTrackSourceWithKey) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PlayerQueueQueueWaveQueueEntityOptionsTrackSourceWithKey.ProtoReflect.Descriptor instead.
func (*PlayerQueueQueueWaveQueueEntityOptionsTrackSourceWithKey) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{9}
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsTrackSourceWithKey) GetKey() uint32 {
	if x != nil {
		return x.Key
	}
	return 0
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsTrackSourceWithKey) GetWaveSource() *PlayerQueueQueueWaveQueueEntityOptionsWaveSource {
	if x != nil {
		return x.WaveSource
	}
	return nil
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsTrackSourceWithKey) GetPhonotekaSource() *PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSource {
	if x != nil {
		return x.PhonotekaSource
	}
	return nil
}

// PlayerQueueQueueWaveQueueEntityOptionsWaveSource represents a wave source
type PlayerQueueQueueWaveQueueEntityOptionsWaveSource struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	SourceType    WaveSourceSourceType   `protobuf:"varint,1,opt,name=source_type,json=sourceType,proto3,enum=ynison.WaveSourceSourceType" json:"source_type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsWaveSource) Reset() {
	*x = PlayerQueueQueueWaveQueueEntityOptionsWaveSource{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsWaveSource) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PlayerQueueQueueWaveQueueEntityOptionsWaveSource) ProtoMessage() {}

func (x *PlayerQueueQueueWaveQueueEntityOptionsWaveSource) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PlayerQueueQueueWaveQueueEntityOptionsWaveSource.ProtoReflect.Descriptor instead.
func (*PlayerQueueQueueWaveQueueEntityOptionsWaveSource) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{10}
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsWaveSource) GetSourceType() WaveSourceSourceType {
	if x != nil {
		return x.SourceType
	}
	return WaveSourceSourceType_WAVE_SOURCE_ONLINE_BY_DEFAULT
}

// PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSource represents a phonoteka source
type PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSource struct {
	state         protoimpl.MessageState                            `protogen:"open.v1"`
	EntityContext PlayerQueueEntityContext                          `protobuf:"varint,1,opt,name=entity_context,json=entityContext,proto3,enum=ynison.PlayerQueueEntityContext" json:"entity_context,omitempty"`
	ArtistId      *PlayerQueueQueueWaveQueueEntityOptionsArtistId   `protobuf:"bytes,2,opt,name=artist_id,json=artistId,proto3" json:"artist_id,omitempty"`
	PlaylistId    *PlayerQueueQueueWaveQueueEntityOptionsPlaylistId `protobuf:"bytes,3,opt,name=playlist_id,json=playlistId,proto3" json:"playlist_id,omitempty"`
	AlbumId       *PlayerQueueQueueWaveQueueEntityOptionsAlbumId    `protobuf:"bytes,4,opt,name=album_id,json=albumId,proto3" json:"album_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSource) Reset() {
	*x = PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSource{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSource) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSource) ProtoMessage() {}

func (x *PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSource) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSource.ProtoReflect.Descriptor instead.
func (*PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSource) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{11}
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSource) GetEntityContext() PlayerQueueEntityContext {
	if x != nil {
		return x.EntityContext
	}
	return PlayerQueueEntityContext_ENTITY_CONTEXT_UNSPECIFIED
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSource) GetArtistId() *PlayerQueueQueueWaveQueueEntityOptionsArtistId {
	if x != nil {
		return x.ArtistId
	}
	return nil
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSource) GetPlaylistId() *PlayerQueueQueueWaveQueueEntityOptionsPlaylistId {
	if x != nil {
		return x.PlaylistId
	}
	return nil
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSource) GetAlbumId() *PlayerQueueQueueWaveQueueEntityOptionsAlbumId {
	if x != nil {
		return x.AlbumId
	}
	return nil
}

// PlayerQueueQueueWaveQueueEntityOptionsArtistId represents artist ID
type PlayerQueueQueueWaveQueueEntityOptionsArtistId struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsArtistId) Reset() {
	*x = PlayerQueueQueueWaveQueueEntityOptionsArtistId{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsArtistId) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PlayerQueueQueueWaveQueueEntityOptionsArtistId) ProtoMessage() {}

func (x *PlayerQueueQueueWaveQueueEntityOptionsArtistId) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[12]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PlayerQueueQueueWaveQueueEntityOptionsArtistId.ProtoReflect.Descriptor instead.
func (*PlayerQueueQueueWaveQueueEntityOptionsArtistId) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{12}
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsArtistId) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

// PlayerQueueQueueWaveQueueEntityOptionsPlaylistId represents playlist ID
type PlayerQueueQueueWaveQueueEntityOptionsPlaylistId struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	Id             string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	FilterOptional string                 `protobuf:"bytes,2,opt,name=filter_optional,json=filterOptional,proto3" json:"filter_optional,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsPlaylistId) Reset() {
	*x = PlayerQueueQueueWaveQueueEntityOptionsPlaylistId{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsPlaylistId) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PlayerQueueQueueWaveQueueEntityOptionsPlaylistId) ProtoMessage() {}

func (x *PlayerQueueQueueWaveQueueEntityOptionsPlaylistId) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[13]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PlayerQueueQueueWaveQueueEntityOptionsPlaylistId.ProtoReflect.Descriptor instead.
func (*PlayerQueueQueueWaveQueueEntityOptionsPlaylistId) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{13}
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsPlaylistId) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsPlaylistId) GetFilterOptional() string {
	if x != nil {
		return x.FilterOptional
	}
	return ""
}

// PlayerQueueQueueWaveQueueEntityOptionsAlbumId represents album ID
type PlayerQueueQueueWaveQueueEntityOptionsAlbumId struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsAlbumId) Reset() {
	*x = PlayerQueueQueueWaveQueueEntityOptionsAlbumId{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsAlbumId) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PlayerQueueQueueWaveQueueEntityOptionsAlbumId) ProtoMessage() {}

func (x *PlayerQueueQueueWaveQueueEntityOptionsAlbumId) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[14]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PlayerQueueQueueWaveQueueEntityOptionsAlbumId.ProtoReflect.Descriptor instead.
func (*PlayerQueueQueueWaveQueueEntityOptionsAlbumId) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{14}
}

func (x *PlayerQueueQueueWaveQueueEntityOptionsAlbumId) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

// PlayerQueueQueueGenerativeQueue represents a generative queue
type PlayerQueueQueueGenerativeQueue struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PlayerQueueQueueGenerativeQueue) Reset() {
	*x = PlayerQueueQueueGenerativeQueue{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PlayerQueueQueueGenerativeQueue) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PlayerQueueQueueGenerativeQueue) ProtoMessage() {}

func (x *PlayerQueueQueueGenerativeQueue) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[15]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PlayerQueueQueueGenerativeQueue.ProtoReflect.Descriptor instead.
func (*PlayerQueueQueueGenerativeQueue) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{15}
}

func (x *PlayerQueueQueueGenerativeQueue) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

// PlayerQueueQueueFmRadioQueue represents an FM radio queue
type PlayerQueueQueueFmRadioQueue struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PlayerQueueQueueFmRadioQueue) Reset() {
	*x = PlayerQueueQueueFmRadioQueue{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PlayerQueueQueueFmRadioQueue) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PlayerQueueQueueFmRadioQueue) ProtoMessage() {}

func (x *PlayerQueueQueueFmRadioQueue) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[16]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PlayerQueueQueueFmRadioQueue.ProtoReflect.Descriptor instead.
func (*PlayerQueueQueueFmRadioQueue) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{16}
}

func (x *PlayerQueueQueueFmRadioQueue) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

// PlayerQueueQueueVideoWaveQueue represents a video wave queue
type PlayerQueueQueueVideoWaveQueue struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PlayerQueueQueueVideoWaveQueue) Reset() {
	*x = PlayerQueueQueueVideoWaveQueue{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PlayerQueueQueueVideoWaveQueue) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PlayerQueueQueueVideoWaveQueue) ProtoMessage() {}

func (x *PlayerQueueQueueVideoWaveQueue) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[17]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PlayerQueueQueueVideoWaveQueue.ProtoReflect.Descriptor instead.
func (*PlayerQueueQueueVideoWaveQueue) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{17}
}

func (x *PlayerQueueQueueVideoWaveQueue) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

// PlayerQueueQueueLocalTracksQueue represents a local tracks queue
type PlayerQueueQueueLocalTracksQueue struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PlayerQueueQueueLocalTracksQueue) Reset() {
	*x = PlayerQueueQueueLocalTracksQueue{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PlayerQueueQueueLocalTracksQueue) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PlayerQueueQueueLocalTracksQueue) ProtoMessage() {}

func (x *PlayerQueueQueueLocalTracksQueue) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[18]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PlayerQueueQueueLocalTracksQueue.ProtoReflect.Descriptor instead.
func (*PlayerQueueQueueLocalTracksQueue) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{18}
}

// PlayerQueueInitialEntity represents initial queue entity (deprecated)
type PlayerQueueInitialEntity struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	EntityId      string                 `protobuf:"bytes,1,opt,name=entity_id,json=entityId,proto3" json:"entity_id,omitempty"`
	EntityType    PlayerQueueEntityType  `protobuf:"varint,2,opt,name=entity_type,json=entityType,proto3,enum=ynison.PlayerQueueEntityType" json:"entity_type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PlayerQueueInitialEntity) Reset() {
	*x = PlayerQueueInitialEntity{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PlayerQueueInitialEntity) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PlayerQueueInitialEntity) ProtoMessage() {}

func (x *PlayerQueueInitialEntity) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[19]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PlayerQueueInitialEntity.ProtoReflect.Descriptor instead.
func (*PlayerQueueInitialEntity) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{19}
}

func (x *PlayerQueueInitialEntity) GetEntityId() string {
	if x != nil {
		return x.EntityId
	}
	return ""
}

func (x *PlayerQueueInitialEntity) GetEntityType() PlayerQueueEntityType {
	if x != nil {
		return x.EntityType
	}
	return PlayerQueueEntityType_ENTITY_TYPE_UNSPECIFIED
}

// PlayerQueuePlayerQueueOptions represents queue options (deprecated)
type PlayerQueuePlayerQueueOptions struct {
	state         protoimpl.MessageState                     `protogen:"open.v1"`
	RadioOptions  *PlayerQueuePlayerQueueOptionsRadioOptions `protobuf:"bytes,1,opt,name=radio_options,json=radioOptions,proto3" json:"radio_options,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PlayerQueuePlayerQueueOptions) Reset() {
	*x = PlayerQueuePlayerQueueOptions{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[20]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PlayerQueuePlayerQueueOptions) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PlayerQueuePlayerQueueOptions) ProtoMessage() {}

func (x *PlayerQueuePlayerQueueOptions) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[20]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PlayerQueuePlayerQueueOptions.ProtoReflect.Descriptor instead.
func (*PlayerQueuePlayerQueueOptions) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{20}
}

func (x *PlayerQueuePlayerQueueOptions) GetRadioOptions() *PlayerQueuePlayerQueueOptionsRadioOptions {
	if x != nil {
		return x.RadioOptions
	}
	return nil
}

// PlayerQueuePlayerQueueOptionsRadioOptions represents radio options
type PlayerQueuePlayerQueueOptionsRadioOptions struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	SessionId     string                 `protobuf:"bytes,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PlayerQueuePlayerQueueOptionsRadioOptions) Reset() {
	*x = PlayerQueuePlayerQueueOptionsRadioOptions{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[21]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PlayerQueuePlayerQueueOptionsRadioOptions) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PlayerQueuePlayerQueueOptionsRadioOptions) ProtoMessage() {}

func (x *PlayerQueuePlayerQueueOptionsRadioOptions) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[21]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PlayerQueuePlayerQueueOptionsRadioOptions.ProtoReflect.Descriptor instead.
func (*PlayerQueuePlayerQueueOptionsRadioOptions) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{21}
}

func (x *PlayerQueuePlayerQueueOptionsRadioOptions) GetSessionId() string {
	if x != nil {
		return x.SessionId
	}
	return ""
}

// PlayerStateOptions represents player state options
type PlayerStateOptions struct {
	state         protoimpl.MessageState       `protogen:"open.v1"`
	RepeatMode    PlayerStateOptionsRepeatMode `protobuf:"varint,1,opt,name=repeat_mode,json=repeatMode,proto3,enum=ynison.PlayerStateOptionsRepeatMode" json:"repeat_mode,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PlayerStateOptions) Reset() {
	*x = PlayerStateOptions{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[22]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PlayerStateOptions) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PlayerStateOptions) ProtoMessage() {}

func (x *PlayerStateOptions) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[22]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PlayerStateOptions.ProtoReflect.Descriptor instead.
func (*PlayerStateOptions) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{22}
}

func (x *PlayerStateOptions) GetRepeatMode() PlayerStateOptionsRepeatMode {
	if x != nil {
		return x.RepeatMode
	}
	return PlayerStateOptionsRepeatMode_REPEAT_MODE_UNSPECIFIED
}

// Shuffle represents shuffle settings
type Shuffle struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	PlayableIndices []uint32               `protobuf:"varint,1,rep,packed,name=playable_indices,json=playableIndices,proto3" json:"playable_indices,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *Shuffle) Reset() {
	*x = Shuffle{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[23]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Shuffle) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Shuffle) ProtoMessage() {}

func (x *Shuffle) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[23]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Shuffle.ProtoReflect.Descriptor instead.
func (*Shuffle) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{23}
}

func (x *Shuffle) GetPlayableIndices() []uint32 {
	if x != nil {
		return x.PlayableIndices
	}
	return nil
}

// Device represents a device
type Device struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Info          *DeviceInfo            `protobuf:"bytes,1,opt,name=info,proto3" json:"info,omitempty"`
	Volume        float64                `protobuf:"fixed64,2,opt,name=volume,proto3" json:"volume,omitempty"`
	Capabilities  *DeviceCapabilities    `protobuf:"bytes,3,opt,name=capabilities,proto3" json:"capabilities,omitempty"`
	Session       *Session               `protobuf:"bytes,4,opt,name=session,proto3" json:"session,omitempty"`
	IsOffline     bool                   `protobuf:"varint,5,opt,name=is_offline,json=isOffline,proto3" json:"is_offline,omitempty"`
	VolumeInfo    *DeviceVolume          `protobuf:"bytes,6,opt,name=volume_info,json=volumeInfo,proto3" json:"volume_info,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Device) Reset() {
	*x = Device{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[24]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Device) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Device) ProtoMessage() {}

func (x *Device) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[24]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Device.ProtoReflect.Descriptor instead.
func (*Device) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{24}
}

func (x *Device) GetInfo() *DeviceInfo {
	if x != nil {
		return x.Info
	}
	return nil
}

func (x *Device) GetVolume() float64 {
	if x != nil {
		return x.Volume
	}
	return 0
}

func (x *Device) GetCapabilities() *DeviceCapabilities {
	if x != nil {
		return x.Capabilities
	}
	return nil
}

func (x *Device) GetSession() *Session {
	if x != nil {
		return x.Session
	}
	return nil
}

func (x *Device) GetIsOffline() bool {
	if x != nil {
		return x.IsOffline
	}
	return false
}

func (x *Device) GetVolumeInfo() *DeviceVolume {
	if x != nil {
		return x.VolumeInfo
	}
	return nil
}

// DeviceVolume represents device volume state
type DeviceVolume struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Volume        float64                `protobuf:"fixed64,1,opt,name=volume,proto3" json:"volume,omitempty"`
	Version       *UpdateVersion         `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DeviceVolume) Reset() {
	*x = DeviceVolume{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[25]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DeviceVolume) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DeviceVolume) ProtoMessage() {}

func (x *DeviceVolume) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[25]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DeviceVolume.ProtoReflect.Descriptor instead.
func (*DeviceVolume) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{25}
}

func (x *DeviceVolume) GetVolume() float64 {
	if x != nil {
		return x.Volume
	}
	return 0
}

func (x *DeviceVolume) GetVersion() *UpdateVersion {
	if x != nil {
		return x.Version
	}
	return nil
}

// DeviceInfo represents device information
type DeviceInfo struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	DeviceId      string                 `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	Title         string                 `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`
	Type          DeviceType             `protobuf:"varint,3,opt,name=type,proto3,enum=ynison.DeviceType" json:"type,omitempty"`
	AppName       string                 `protobuf:"bytes,4,opt,name=app_name,json=appName,proto3" json:"app_name,omitempty"`
	AppVersion    string                 `protobuf:"bytes,5,opt,name=app_version,json=appVersion,proto3" json:"app_version,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DeviceInfo) Reset() {
	*x = DeviceInfo{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[26]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DeviceInfo) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DeviceInfo) ProtoMessage() {}

func (x *DeviceInfo) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[26]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DeviceInfo.ProtoReflect.Descriptor instead.
func (*DeviceInfo) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{26}
}

func (x *DeviceInfo) GetDeviceId() string {
	if x != nil {
		return x.DeviceId
	}
	return ""
}

func (x *DeviceInfo) GetTitle() string {
	if x != nil {
		return x.Title
	}
	return ""
}

func (x *DeviceInfo) GetType() DeviceType {
	if x != nil {
		return x.Type
	}
	return DeviceType_DEVICE_TYPE_UNSPECIFIED
}

func (x *DeviceInfo) GetAppName() string {
	if x != nil {
		return x.AppName
	}
	return ""
}

func (x *DeviceInfo) GetAppVersion() string {
	if x != nil {
		return x.AppVersion
	}
	return ""
}

// DeviceCapabilities represents device capabilities
type DeviceCapabilities struct {
	state                 protoimpl.MessageState `protogen:"open.v1"`
	CanBePlayer           bool                   `protobuf:"varint,1,opt,name=can_be_player,json=canBePlayer,proto3" json:"can_be_player,omitempty"`
	CanBeRemoteController bool                   `protobuf:"varint,2,opt,name=can_be_remote_controller,json=canBeRemoteController,proto3" json:"can_be_remote_controller,omitempty"`
	VolumeGranularity     uint32                 `protobuf:"varint,3,opt,name=volume_granularity,json=volumeGranularity,proto3" json:"volume_granularity,omitempty"`
	unknownFields         protoimpl.UnknownFields
	sizeCache             protoimpl.SizeCache
}

func (x *DeviceCapabilities) Reset() {
	*x = DeviceCapabilities{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[27]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DeviceCapabilities) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DeviceCapabilities) ProtoMessage() {}

func (x *DeviceCapabilities) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[27]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DeviceCapabilities.ProtoReflect.Descriptor instead.
func (*DeviceCapabilities) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{27}
}

func (x *DeviceCapabilities) GetCanBePlayer() bool {
	if x != nil {
		return x.CanBePlayer
	}
	return false
}

func (x *DeviceCapabilities) GetCanBeRemoteController() bool {
	if x != nil {
		return x.CanBeRemoteController
	}
	return false
}

func (x *DeviceCapabilities) GetVolumeGranularity() uint32 {
	if x != nil {
		return x.VolumeGranularity
	}
	return 0
}

// Session represents a device session
type Session struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            int64                  `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Session) Reset() {
	*x = Session{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[28]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Session) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Session) ProtoMessage() {}

func (x *Session) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[28]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Session.ProtoReflect.Descriptor instead.
func (*Session) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{28}
}

func (x *Session) GetId() int64 {
	if x != nil {
		return x.Id
	}
	return 0
}

// PlayingStatus represents playback status
type PlayingStatus struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ProgressMs    int64                  `protobuf:"varint,1,opt,name=progress_ms,json=progressMs,proto3" json:"progress_ms,omitempty"`
	DurationMs    int64                  `protobuf:"varint,2,opt,name=duration_ms,json=durationMs,proto3" json:"duration_ms,omitempty"`
	Paused        bool                   `protobuf:"varint,3,opt,name=paused,proto3" json:"paused,omitempty"`
	PlaybackSpeed float64                `protobuf:"fixed64,4,opt,name=playback_speed,json=playbackSpeed,proto3" json:"playback_speed,omitempty"`
	Version       *UpdateVersion         `protobuf:"bytes,5,opt,name=version,proto3" json:"version,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PlayingStatus) Reset() {
	*x = PlayingStatus{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[29]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PlayingStatus) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PlayingStatus) ProtoMessage() {}

func (x *PlayingStatus) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[29]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PlayingStatus.ProtoReflect.Descriptor instead.
func (*PlayingStatus) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{29}
}

func (x *PlayingStatus) GetProgressMs() int64 {
	if x != nil {
		return x.ProgressMs
	}
	return 0
}

func (x *PlayingStatus) GetDurationMs() int64 {
	if x != nil {
		return x.DurationMs
	}
	return 0
}

func (x *PlayingStatus) GetPaused() bool {
	if x != nil {
		return x.Paused
	}
	return false
}

func (x *PlayingStatus) GetPlaybackSpeed() float64 {
	if x != nil {
		return x.PlaybackSpeed
	}
	return 0
}

func (x *PlayingStatus) GetVersion() *UpdateVersion {
	if x != nil {
		return x.Version
	}
	return nil
}

// PlayerQueueInject represents injected queue entity state
type PlayerQueueInject struct {
	state         protoimpl.MessageState     `protogen:"open.v1"`
	PlayingStatus *PlayingStatus             `protobuf:"bytes,1,opt,name=playing_status,json=playingStatus,proto3" json:"playing_status,omitempty"`
	Playable      *PlayerQueueInjectPlayable `protobuf:"bytes,2,opt,name=playable,proto3" json:"playable,omitempty"`
	Version       *UpdateVersion             `protobuf:"bytes,3,opt,name=version,proto3" json:"version,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PlayerQueueInject) Reset() {
	*x = PlayerQueueInject{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[30]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PlayerQueueInject) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PlayerQueueInject) ProtoMessage() {}

func (x *PlayerQueueInject) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[30]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PlayerQueueInject.ProtoReflect.Descriptor instead.
func (*PlayerQueueInject) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{30}
}

func (x *PlayerQueueInject) GetPlayingStatus() *PlayingStatus {
	if x != nil {
		return x.PlayingStatus
	}
	return nil
}

func (x *PlayerQueueInject) GetPlayable() *PlayerQueueInjectPlayable {
	if x != nil {
		return x.Playable
	}
	return nil
}

func (x *PlayerQueueInject) GetVersion() *UpdateVersion {
	if x != nil {
		return x.Version
	}
	return nil
}

// PlayerQueueInjectPlayable represents an injectable playable
type PlayerQueueInjectPlayable struct {
	state         protoimpl.MessageState                `protogen:"open.v1"`
	PlayableId    string                                `protobuf:"bytes,1,opt,name=playable_id,json=playableId,proto3" json:"playable_id,omitempty"`
	PlayableType  PlayerQueueInjectPlayablePlayableType `protobuf:"varint,2,opt,name=playable_type,json=playableType,proto3,enum=ynison.PlayerQueueInjectPlayablePlayableType" json:"playable_type,omitempty"`
	Title         string                                `protobuf:"bytes,3,opt,name=title,proto3" json:"title,omitempty"`
	CoverUrl      string                                `protobuf:"bytes,4,opt,name=cover_url,json=coverUrl,proto3" json:"cover_url,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PlayerQueueInjectPlayable) Reset() {
	*x = PlayerQueueInjectPlayable{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[31]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PlayerQueueInjectPlayable) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PlayerQueueInjectPlayable) ProtoMessage() {}

func (x *PlayerQueueInjectPlayable) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[31]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PlayerQueueInjectPlayable.ProtoReflect.Descriptor instead.
func (*PlayerQueueInjectPlayable) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{31}
}

func (x *PlayerQueueInjectPlayable) GetPlayableId() string {
	if x != nil {
		return x.PlayableId
	}
	return ""
}

func (x *PlayerQueueInjectPlayable) GetPlayableType() PlayerQueueInjectPlayablePlayableType {
	if x != nil {
		return x.PlayableType
	}
	return PlayerQueueInjectPlayablePlayableType_INJECT_PLAYABLE_TYPE_UNSPECIFIED
}

func (x *PlayerQueueInjectPlayable) GetTitle() string {
	if x != nil {
		return x.Title
	}
	return ""
}

func (x *PlayerQueueInjectPlayable) GetCoverUrl() string {
	if x != nil {
		return x.CoverUrl
	}
	return ""
}

// PlayerState represents player state
type PlayerState struct {
	state                     protoimpl.MessageState `protogen:"open.v1"`
	Status                    *PlayingStatus         `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	PlayerQueue               *PlayerQueue           `protobuf:"bytes,2,opt,name=player_queue,json=playerQueue,proto3" json:"player_queue,omitempty"`
	PlayerQueueInjectOptional *PlayerQueueInject     `protobuf:"bytes,3,opt,name=player_queue_inject_optional,json=playerQueueInjectOptional,proto3" json:"player_queue_inject_optional,omitempty"`
	unknownFields             protoimpl.UnknownFields
	sizeCache                 protoimpl.SizeCache
}

func (x *PlayerState) Reset() {
	*x = PlayerState{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[32]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PlayerState) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PlayerState) ProtoMessage() {}

func (x *PlayerState) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[32]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PlayerState.ProtoReflect.Descriptor instead.
func (*PlayerState) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{32}
}

func (x *PlayerState) GetStatus() *PlayingStatus {
	if x != nil {
		return x.Status
	}
	return nil
}

func (x *PlayerState) GetPlayerQueue() *PlayerQueue {
	if x != nil {
		return x.PlayerQueue
	}
	return nil
}

func (x *PlayerState) GetPlayerQueueInjectOptional() *PlayerQueueInject {
	if x != nil {
		return x.PlayerQueueInjectOptional
	}
	return nil
}

// PutYnisonStateRequest represents a state update request
type PutYnisonStateRequest struct {
	state                    protoimpl.MessageState                        `protogen:"open.v1"`
	UpdateFullState          *UpdateFullState                              `protobuf:"bytes,1,opt,name=update_full_state,json=updateFullState,proto3" json:"update_full_state,omitempty"`
	UpdateActiveDevice       *UpdateActiveDevice                           `protobuf:"bytes,2,opt,name=update_active_device,json=updateActiveDevice,proto3" json:"update_active_device,omitempty"`
	UpdatePlayingStatus      *UpdatePlayingStatus                          `protobuf:"bytes,3,opt,name=update_playing_status,json=updatePlayingStatus,proto3" json:"update_playing_status,omitempty"`
	UpdatePlayerState        *UpdatePlayerState                            `protobuf:"bytes,4,opt,name=update_player_state,json=updatePlayerState,proto3" json:"update_player_state,omitempty"`
	UpdateVolume             *UpdateVolume                                 `protobuf:"bytes,5,opt,name=update_volume,json=updateVolume,proto3" json:"update_volume,omitempty"`
	UpdatePlayerQueueInject  *UpdatePlayerQueueInject                      `protobuf:"bytes,6,opt,name=update_player_queue_inject,json=updatePlayerQueueInject,proto3" json:"update_player_queue_inject,omitempty"`
	UpdateSessionParams      *UpdateSessionParams                          `protobuf:"bytes,9,opt,name=update_session_params,json=updateSessionParams,proto3" json:"update_session_params,omitempty"`
	UpdateVolumeInfo         *UpdateVolumeInfo                             `protobuf:"bytes,11,opt,name=update_volume_info,json=updateVolumeInfo,proto3" json:"update_volume_info,omitempty"`
	SyncStateFromEov         *SyncStateFromEOV                             `protobuf:"bytes,12,opt,name=sync_state_from_eov,json=syncStateFromEov,proto3" json:"sync_state_from_eov,omitempty"`
	PlayerActionTimestampMs  int64                                         `protobuf:"varint,7,opt,name=player_action_timestamp_ms,json=playerActionTimestampMs,proto3" json:"player_action_timestamp_ms,omitempty"`
	Rid                      string                                        `protobuf:"bytes,8,opt,name=rid,proto3" json:"rid,omitempty"`
	ActivityInterceptionType PutYnisonStateRequestActivityInterceptionType `protobuf:"varint,10,opt,name=activity_interception_type,json=activityInterceptionType,proto3,enum=ynison.PutYnisonStateRequestActivityInterceptionType" json:"activity_interception_type,omitempty"`
	unknownFields            protoimpl.UnknownFields
	sizeCache                protoimpl.SizeCache
}

func (x *PutYnisonStateRequest) Reset() {
	*x = PutYnisonStateRequest{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[33]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PutYnisonStateRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PutYnisonStateRequest) ProtoMessage() {}

func (x *PutYnisonStateRequest) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[33]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PutYnisonStateRequest.ProtoReflect.Descriptor instead.
func (*PutYnisonStateRequest) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{33}
}

func (x *PutYnisonStateRequest) GetUpdateFullState() *UpdateFullState {
	if x != nil {
		return x.UpdateFullState
	}
	return nil
}

func (x *PutYnisonStateRequest) GetUpdateActiveDevice() *UpdateActiveDevice {
	if x != nil {
		return x.UpdateActiveDevice
	}
	return nil
}

func (x *PutYnisonStateRequest) GetUpdatePlayingStatus() *UpdatePlayingStatus {
	if x != nil {
		return x.UpdatePlayingStatus
	}
	return nil
}

func (x *PutYnisonStateRequest) GetUpdatePlayerState() *UpdatePlayerState {
	if x != nil {
		return x.UpdatePlayerState
	}
	return nil
}

func (x *PutYnisonStateRequest) GetUpdateVolume() *UpdateVolume {
	if x != nil {
		return x.UpdateVolume
	}
	return nil
}

func (x *PutYnisonStateRequest) GetUpdatePlayerQueueInject() *UpdatePlayerQueueInject {
	if x != nil {
		return x.UpdatePlayerQueueInject
	}
	return nil
}

func (x *PutYnisonStateRequest) GetUpdateSessionParams() *UpdateSessionParams {
	if x != nil {
		return x.UpdateSessionParams
	}
	return nil
}

func (x *PutYnisonStateRequest) GetUpdateVolumeInfo() *UpdateVolumeInfo {
	if x != nil {
		return x.UpdateVolumeInfo
	}
	return nil
}

func (x *PutYnisonStateRequest) GetSyncStateFromEov() *SyncStateFromEOV {
	if x != nil {
		return x.SyncStateFromEov
	}
	return nil
}

func (x *PutYnisonStateRequest) GetPlayerActionTimestampMs() int64 {
	if x != nil {
		return x.PlayerActionTimestampMs
	}
	return 0
}

func (x *PutYnisonStateRequest) GetRid() string {
	if x != nil {
		return x.Rid
	}
	return ""
}

func (x *PutYnisonStateRequest) GetActivityInterceptionType() PutYnisonStateRequestActivityInterceptionType {
	if x != nil {
		return x.ActivityInterceptionType
	}
	return PutYnisonStateRequestActivityInterceptionType_INTERCEPTION_DO_NOT_INTERCEPT_BY_DEFAULT
}

// PutYnisonStateResponse represents a state update response
type PutYnisonStateResponse struct {
	state                  protoimpl.MessageState `protogen:"open.v1"`
	PlayerState            *PlayerState           `protobuf:"bytes,1,opt,name=player_state,json=playerState,proto3" json:"player_state,omitempty"`
	Devices                []*Device              `protobuf:"bytes,2,rep,name=devices,proto3" json:"devices,omitempty"`
	ActiveDeviceIdOptional string                 `protobuf:"bytes,3,opt,name=active_device_id_optional,json=activeDeviceIdOptional,proto3" json:"active_device_id_optional,omitempty"`
	TimestampMs            int64                  `protobuf:"varint,4,opt,name=timestamp_ms,json=timestampMs,proto3" json:"timestamp_ms,omitempty"`
	Rid                    string                 `protobuf:"bytes,5,opt,name=rid,proto3" json:"rid,omitempty"`
	unknownFields          protoimpl.UnknownFields
	sizeCache              protoimpl.SizeCache
}

func (x *PutYnisonStateResponse) Reset() {
	*x = PutYnisonStateResponse{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[34]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PutYnisonStateResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PutYnisonStateResponse) ProtoMessage() {}

func (x *PutYnisonStateResponse) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[34]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PutYnisonStateResponse.ProtoReflect.Descriptor instead.
func (*PutYnisonStateResponse) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{34}
}

func (x *PutYnisonStateResponse) GetPlayerState() *PlayerState {
	if x != nil {
		return x.PlayerState
	}
	return nil
}

func (x *PutYnisonStateResponse) GetDevices() []*Device {
	if x != nil {
		return x.Devices
	}
	return nil
}

func (x *PutYnisonStateResponse) GetActiveDeviceIdOptional() string {
	if x != nil {
		return x.ActiveDeviceIdOptional
	}
	return ""
}

func (x *PutYnisonStateResponse) GetTimestampMs() int64 {
	if x != nil {
		return x.TimestampMs
	}
	return 0
}

func (x *PutYnisonStateResponse) GetRid() string {
	if x != nil {
		return x.Rid
	}
	return ""
}

// UpdatePlayerQueueInject represents player queue inject update
type UpdatePlayerQueueInject struct {
	state             protoimpl.MessageState `protogen:"open.v1"`
	PlayerQueueInject *PlayerQueueInject     `protobuf:"bytes,1,opt,name=player_queue_inject,json=playerQueueInject,proto3" json:"player_queue_inject,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

func (x *UpdatePlayerQueueInject) Reset() {
	*x = UpdatePlayerQueueInject{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[35]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *UpdatePlayerQueueInject) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*UpdatePlayerQueueInject) ProtoMessage() {}

func (x *UpdatePlayerQueueInject) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[35]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use UpdatePlayerQueueInject.ProtoReflect.Descriptor instead.
func (*UpdatePlayerQueueInject) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{35}
}

func (x *UpdatePlayerQueueInject) GetPlayerQueueInject() *PlayerQueueInject {
	if x != nil {
		return x.PlayerQueueInject
	}
	return nil
}

// UpdateActiveDevice represents active device update
type UpdateActiveDevice struct {
	state            protoimpl.MessageState `protogen:"open.v1"`
	DeviceIdOptional string                 `protobuf:"bytes,1,opt,name=device_id_optional,json=deviceIdOptional,proto3" json:"device_id_optional,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *UpdateActiveDevice) Reset() {
	*x = UpdateActiveDevice{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[36]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *UpdateActiveDevice) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*UpdateActiveDevice) ProtoMessage() {}

func (x *UpdateActiveDevice) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[36]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use UpdateActiveDevice.ProtoReflect.Descriptor instead.
func (*UpdateActiveDevice) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{36}
}

func (x *UpdateActiveDevice) GetDeviceIdOptional() string {
	if x != nil {
		return x.DeviceIdOptional
	}
	return ""
}

// UpdatePlayingStatus represents playing status update
type UpdatePlayingStatus struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	PlayingStatus *PlayingStatus         `protobuf:"bytes,1,opt,name=playing_status,json=playingStatus,proto3" json:"playing_status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *UpdatePlayingStatus) Reset() {
	*x = UpdatePlayingStatus{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[37]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *UpdatePlayingStatus) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*UpdatePlayingStatus) ProtoMessage() {}

func (x *UpdatePlayingStatus) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[37]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use UpdatePlayingStatus.ProtoReflect.Descriptor instead.
func (*UpdatePlayingStatus) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{37}
}

func (x *UpdatePlayingStatus) GetPlayingStatus() *PlayingStatus {
	if x != nil {
		return x.PlayingStatus
	}
	return nil
}

// UpdateVolume represents volume update (deprecated)
type UpdateVolume struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Volume        float64                `protobuf:"fixed64,1,opt,name=volume,proto3" json:"volume,omitempty"`
	DeviceId      string                 `protobuf:"bytes,2,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *UpdateVolume) Reset() {
	*x = UpdateVolume{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[38]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *UpdateVolume) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*UpdateVolume) ProtoMessage() {}

func (x *UpdateVolume) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[38]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use UpdateVolume.ProtoReflect.Descriptor instead.
func (*UpdateVolume) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{38}
}

func (x *UpdateVolume) GetVolume() float64 {
	if x != nil {
		return x.Volume
	}
	return 0
}

func (x *UpdateVolume) GetDeviceId() string {
	if x != nil {
		return x.DeviceId
	}
	return ""
}

// UpdateVolumeInfo represents volume info update
type UpdateVolumeInfo struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	DeviceId      string                 `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	VolumeInfo    *DeviceVolume          `protobuf:"bytes,2,opt,name=volume_info,json=volumeInfo,proto3" json:"volume_info,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *UpdateVolumeInfo) Reset() {
	*x = UpdateVolumeInfo{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[39]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *UpdateVolumeInfo) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*UpdateVolumeInfo) ProtoMessage() {}

func (x *UpdateVolumeInfo) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[39]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use UpdateVolumeInfo.ProtoReflect.Descriptor instead.
func (*UpdateVolumeInfo) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{39}
}

func (x *UpdateVolumeInfo) GetDeviceId() string {
	if x != nil {
		return x.DeviceId
	}
	return ""
}

func (x *UpdateVolumeInfo) GetVolumeInfo() *DeviceVolume {
	if x != nil {
		return x.VolumeInfo
	}
	return nil
}

// UpdatePlayerState represents player state update
type UpdatePlayerState struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	PlayerState   *PlayerState           `protobuf:"bytes,1,opt,name=player_state,json=playerState,proto3" json:"player_state,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *UpdatePlayerState) Reset() {
	*x = UpdatePlayerState{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[40]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *UpdatePlayerState) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*UpdatePlayerState) ProtoMessage() {}

func (x *UpdatePlayerState) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[40]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use UpdatePlayerState.ProtoReflect.Descriptor instead.
func (*UpdatePlayerState) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{40}
}

func (x *UpdatePlayerState) GetPlayerState() *PlayerState {
	if x != nil {
		return x.PlayerState
	}
	return nil
}

// UpdateFullState represents full state update
type UpdateFullState struct {
	state                    protoimpl.MessageState `protogen:"open.v1"`
	PlayerState              *PlayerState           `protobuf:"bytes,1,opt,name=player_state,json=playerState,proto3" json:"player_state,omitempty"`
	IsCurrentlyActive        bool                   `protobuf:"varint,2,opt,name=is_currently_active,json=isCurrentlyActive,proto3" json:"is_currently_active,omitempty"`
	Device                   *UpdateDevice          `protobuf:"bytes,3,opt,name=device,proto3" json:"device,omitempty"`
	SyncStateFromEovOptional *SyncStateFromEOV      `protobuf:"bytes,4,opt,name=sync_state_from_eov_optional,json=syncStateFromEovOptional,proto3" json:"sync_state_from_eov_optional,omitempty"`
	unknownFields            protoimpl.UnknownFields
	sizeCache                protoimpl.SizeCache
}

func (x *UpdateFullState) Reset() {
	*x = UpdateFullState{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[41]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *UpdateFullState) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*UpdateFullState) ProtoMessage() {}

func (x *UpdateFullState) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[41]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use UpdateFullState.ProtoReflect.Descriptor instead.
func (*UpdateFullState) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{41}
}

func (x *UpdateFullState) GetPlayerState() *PlayerState {
	if x != nil {
		return x.PlayerState
	}
	return nil
}

func (x *UpdateFullState) GetIsCurrentlyActive() bool {
	if x != nil {
		return x.IsCurrentlyActive
	}
	return false
}

func (x *UpdateFullState) GetDevice() *UpdateDevice {
	if x != nil {
		return x.Device
	}
	return nil
}

func (x *UpdateFullState) GetSyncStateFromEovOptional() *SyncStateFromEOV {
	if x != nil {
		return x.SyncStateFromEovOptional
	}
	return nil
}

// UpdateSessionParams represents session params update
type UpdateSessionParams struct {
	state               protoimpl.MessageState `protogen:"open.v1"`
	MuteEventsIfPassive bool                   `protobuf:"varint,1,opt,name=mute_events_if_passive,json=muteEventsIfPassive,proto3" json:"mute_events_if_passive,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

func (x *UpdateSessionParams) Reset() {
	*x = UpdateSessionParams{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[42]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *UpdateSessionParams) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*UpdateSessionParams) ProtoMessage() {}

func (x *UpdateSessionParams) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[42]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use UpdateSessionParams.ProtoReflect.Descriptor instead.
func (*UpdateSessionParams) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{42}
}

func (x *UpdateSessionParams) GetMuteEventsIfPassive() bool {
	if x != nil {
		return x.MuteEventsIfPassive
	}
	return false
}

// UpdateDevice represents device update
type UpdateDevice struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Info          *DeviceInfo            `protobuf:"bytes,1,opt,name=info,proto3" json:"info,omitempty"`
	Volume        float64                `protobuf:"fixed64,2,opt,name=volume,proto3" json:"volume,omitempty"`
	Capabilities  *DeviceCapabilities    `protobuf:"bytes,3,opt,name=capabilities,proto3" json:"capabilities,omitempty"`
	VolumeInfo    *DeviceVolume          `protobuf:"bytes,4,opt,name=volume_info,json=volumeInfo,proto3" json:"volume_info,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *UpdateDevice) Reset() {
	*x = UpdateDevice{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[43]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *UpdateDevice) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*UpdateDevice) ProtoMessage() {}

func (x *UpdateDevice) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[43]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use UpdateDevice.ProtoReflect.Descriptor instead.
func (*UpdateDevice) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{43}
}

func (x *UpdateDevice) GetInfo() *DeviceInfo {
	if x != nil {
		return x.Info
	}
	return nil
}

func (x *UpdateDevice) GetVolume() float64 {
	if x != nil {
		return x.Volume
	}
	return 0
}

func (x *UpdateDevice) GetCapabilities() *DeviceCapabilities {
	if x != nil {
		return x.Capabilities
	}
	return nil
}

func (x *UpdateDevice) GetVolumeInfo() *DeviceVolume {
	if x != nil {
		return x.VolumeInfo
	}
	return nil
}

// SyncStateFromEOV represents sync state from EOV request
type SyncStateFromEOV struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ActualQueueId string                 `protobuf:"bytes,1,opt,name=actual_queue_id,json=actualQueueId,proto3" json:"actual_queue_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SyncStateFromEOV) Reset() {
	*x = SyncStateFromEOV{}
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[44]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SyncStateFromEOV) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SyncStateFromEOV) ProtoMessage() {}

func (x *SyncStateFromEOV) ProtoReflect() protoreflect.Message {
	mi := &file_internal_ynison_proto_ynison_proto_msgTypes[44]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SyncStateFromEOV.ProtoReflect.Descriptor instead.
func (*SyncStateFromEOV) Descriptor() ([]byte, []int) {
	return file_internal_ynison_proto_ynison_proto_rawDescGZIP(), []int{44}
}

func (x *SyncStateFromEOV) GetActualQueueId() string {
	if x != nil {
		return x.ActualQueueId
	}
	return ""
}

var File_internal_ynison_proto_ynison_proto protoreflect.FileDescriptor

const file_internal_ynison_proto_ynison_proto_rawDesc = "" +
	"\n" +
	"\"internal/ynison/proto/ynison.proto\x12\x06ynison\"\xd8\x03\n" +
	"\bPlayable\x12\x1f\n" +
	"\vplayable_id\x18\x01 \x01(\tR\n" +
	"playableId\x12*\n" +
	"\x11album_id_optional\x18\x02 \x01(\tR\x0falbumIdOptional\x12A\n" +
	"\rplayable_type\x18\x03 \x01(\x0e2\x1c.ynison.PlayablePlayableTypeR\fplayableType\x12\x12\n" +
	"\x04from\x18\x04 \x01(\tR\x04from\x12\x14\n" +
	"\x05title\x18\x05 \x01(\tR\x05title\x12,\n" +
	"\x12cover_url_optional\x18\x06 \x01(\tR\x10coverUrlOptional\x12=\n" +
	"\x0fvideo_clip_info\x18\a \x01(\v2\x15.ynison.VideoClipInfoR\rvideoClipInfo\x120\n" +
	"\n" +
	"track_info\x18\b \x01(\v2\x11.ynison.TrackInfoR\ttrackInfo\x124\n" +
	"\x16navigation_id_optional\x18\t \x01(\tR\x14navigationIdOptional\x12=\n" +
	"\x1bplayback_action_id_optional\x18\n" +
	" \x01(\tR\x18playbackActionIdOptional\"i\n" +
	"\rVideoClipInfo\x12X\n" +
	"\x13recommendation_type\x18\x01 \x01(\x0e2'.ynison.VideoClipInfoRecommendationTypeR\x12recommendationType\"a\n" +
	"\tTrackInfo\x12(\n" +
	"\x10track_source_key\x18\x01 \x01(\rR\x0etrackSourceKey\x12*\n" +
	"\x11batch_id_optional\x18\x02 \x01(\tR\x0fbatchIdOptional\"i\n" +
	"\rUpdateVersion\x12\x1b\n" +
	"\tdevice_id\x18\x01 \x01(\tR\bdeviceId\x12\x18\n" +
	"\aversion\x18\x02 \x01(\x03R\aversion\x12!\n" +
	"\ftimestamp_ms\x18\x03 \x01(\x03R\vtimestampMs\"\xef\x06\n" +
	"\vPlayerQueue\x12\x1b\n" +
	"\tentity_id\x18\x01 \x01(\tR\bentityId\x12>\n" +
	"\ventity_type\x18\x02 \x01(\x0e2\x1d.ynison.PlayerQueueEntityTypeR\n" +
	"entityType\x12.\n" +
	"\x05queue\x18\f \x01(\v2\x18.ynison.PlayerQueueQueueR\x05queue\x124\n" +
	"\x16current_playable_index\x18\x03 \x01(\x05R\x14currentPlayableIndex\x125\n" +
	"\rplayable_list\x18\x04 \x03(\v2\x10.ynison.PlayableR\fplayableList\x124\n" +
	"\aoptions\x18\x05 \x01(\v2\x1a.ynison.PlayerStateOptionsR\aoptions\x12/\n" +
	"\aversion\x18\x06 \x01(\v2\x15.ynison.UpdateVersionR\aversion\x12:\n" +
	"\x10shuffle_optional\x18\a \x01(\v2\x0f.ynison.ShuffleR\x0fshuffleOptional\x12G\n" +
	"\x0eentity_context\x18\b \x01(\x0e2 .ynison.PlayerQueueEntityContextR\rentityContext\x12#\n" +
	"\rfrom_optional\x18\t \x01(\tR\ffromOptional\x12X\n" +
	"\x17initial_entity_optional\x18\n" +
	" \x01(\v2 .ynison.PlayerQueueInitialEntityR\x15initialEntityOptional\x12]\n" +
	"\x17adding_options_optional\x18\v \x01(\v2%.ynison.PlayerQueuePlayerQueueOptionsR\x15addingOptionsOptional\x124\n" +
	"\x16navigation_id_optional\x18\r \x01(\tR\x14navigationIdOptional\x12'\n" +
	"\x0ffilter_optional\x18\x0e \x01(\tR\x0efilterOptional\x12=\n" +
	"\x1bplayback_action_id_optional\x18\x0f \x01(\tR\x18playbackActionIdOptional\"\x9e\x03\n" +
	"\x10PlayerQueueQueue\x12@\n" +
	"\n" +
	"wave_queue\x18\x01 \x01(\v2!.ynison.PlayerQueueQueueWaveQueueR\twaveQueue\x12R\n" +
	"\x10generative_queue\x18\x02 \x01(\v2'.ynison.PlayerQueueQueueGenerativeQueueR\x0fgenerativeQueue\x12J\n" +
	"\x0efm_radio_queue\x18\x03 \x01(\v2$.ynison.PlayerQueueQueueFmRadioQueueR\ffmRadioQueue\x12P\n" +
	"\x10video_wave_queue\x18\x04 \x01(\v2&.ynison.PlayerQueueQueueVideoWaveQueueR\x0evideoWaveQueue\x12V\n" +
	"\x12local_tracks_queue\x18\x05 \x01(\v2(.ynison.PlayerQueueQueueLocalTracksQueueR\x10localTracksQueue\"\xe5\x02\n" +
	"\x19PlayerQueueQueueWaveQueue\x12L\n" +
	"\x19recommended_playable_list\x18\x01 \x03(\v2\x10.ynison.PlayableR\x17recommendedPlayableList\x12.\n" +
	"\x13live_playable_index\x18\x02 \x01(\x05R\x11livePlayableIndex\x12U\n" +
	"\x0eentity_options\x18\x03 \x01(\v2..ynison.PlayerQueueQueueWaveQueueEntityOptionsR\rentityOptions\x124\n" +
	"\x16navigation_id_optional\x18\x04 \x01(\tR\x14navigationIdOptional\x12=\n" +
	"\x1bplayback_action_id_optional\x18\x05 \x01(\tR\x18playbackActionIdOptional\"\xfc\x01\n" +
	"&PlayerQueueQueueWaveQueueEntityOptions\x12k\n" +
	"\x14wave_entity_optional\x18\x01 \x01(\v29.ynison.PlayerQueueQueueWaveQueueEntityOptionsWaveSessionR\x12waveEntityOptional\x12e\n" +
	"\rtrack_sources\x18\x02 \x03(\v2@.ynison.PlayerQueueQueueWaveQueueEntityOptionsTrackSourceWithKeyR\ftrackSources\"R\n" +
	"1PlayerQueueQueueWaveQueueEntityOptionsWaveSession\x12\x1d\n" +
	"\n" +
	"session_id\x18\x01 \x01(\tR\tsessionId\"\x91\x02\n" +
	"8PlayerQueueQueueWaveQueueEntityOptionsTrackSourceWithKey\x12\x10\n" +
	"\x03key\x18\x01 \x01(\rR\x03key\x12Y\n" +
	"\vwave_source\x18\x02 \x01(\v28.ynison.PlayerQueueQueueWaveQueueEntityOptionsWaveSourceR\n" +
	"waveSource\x12h\n" +
	"\x10phonoteka_source\x18\x03 \x01(\v2=.ynison.PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSourceR\x0fphonotekaSource\"q\n" +
	"0PlayerQueueQueueWaveQueueEntityOptionsWaveSource\x12=\n" +
	"\vsource_type\x18\x01 \x01(\x0e2\x1c.ynison.WaveSourceSourceTypeR\n" +
	"sourceType\"\x82\x03\n" +
	"5PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSource\x12G\n" +
	"\x0eentity_context\x18\x01 \x01(\x0e2 .ynison.PlayerQueueEntityContextR\rentityContext\x12S\n" +
	"\tartist_id\x18\x02 \x01(\v26.ynison.PlayerQueueQueueWaveQueueEntityOptionsArtistIdR\bartistId\x12Y\n" +
	"\vplaylist_id\x18\x03 \x01(\v28.ynison.PlayerQueueQueueWaveQueueEntityOptionsPlaylistIdR\n" +
	"playlistId\x12P\n" +
	"\balbum_id\x18\x04 \x01(\v25.ynison.PlayerQueueQueueWaveQueueEntityOptionsAlbumIdR\aalbumId\"@\n" +
	".PlayerQueueQueueWaveQueueEntityOptionsArtistId\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\"k\n" +
	"0PlayerQueueQueueWaveQueueEntityOptionsPlaylistId\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x12'\n" +
	"\x0ffilter_optional\x18\x02 \x01(\tR\x0efilterOptional\"?\n" +
	"-PlayerQueueQueueWaveQueueEntityOptionsAlbumId\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\"1\n" +
	"\x1fPlayerQueueQueueGenerativeQueue\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\".\n" +
	"\x1cPlayerQueueQueueFmRadioQueue\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\"0\n" +
	"\x1ePlayerQueueQueueVideoWaveQueue\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\"\"\n" +
	" PlayerQueueQueueLocalTracksQueue\"w\n" +
	"\x18PlayerQueueInitialEntity\x12\x1b\n" +
	"\tentity_id\x18\x01 \x01(\tR\bentityId\x12>\n" +
	"\ventity_type\x18\x02 \x01(\x0e2\x1d.ynison.PlayerQueueEntityTypeR\n" +
	"entityType\"w\n" +
	"\x1dPlayerQueuePlayerQueueOptions\x12V\n" +
	"\rradio_options\x18\x01 \x01(\v21.ynison.PlayerQueuePlayerQueueOptionsRadioOptionsR\fradioOptions\"J\n" +
	")PlayerQueuePlayerQueueOptionsRadioOptions\x12\x1d\n" +
	"\n" +
	"session_id\x18\x01 \x01(\tR\tsessionId\"[\n" +
	"\x12PlayerStateOptions\x12E\n" +
	"\vrepeat_mode\x18\x01 \x01(\x0e2$.ynison.PlayerStateOptionsRepeatModeR\n" +
	"repeatMode\"4\n" +
	"\aShuffle\x12)\n" +
	"\x10playable_indices\x18\x01 \x03(\rR\x0fplayableIndices\"\x89\x02\n" +
	"\x06Device\x12&\n" +
	"\x04info\x18\x01 \x01(\v2\x12.ynison.DeviceInfoR\x04info\x12\x16\n" +
	"\x06volume\x18\x02 \x01(\x01R\x06volume\x12>\n" +
	"\fcapabilities\x18\x03 \x01(\v2\x1a.ynison.DeviceCapabilitiesR\fcapabilities\x12)\n" +
	"\asession\x18\x04 \x01(\v2\x0f.ynison.SessionR\asession\x12\x1d\n" +
	"\n" +
	"is_offline\x18\x05 \x01(\bR\tisOffline\x125\n" +
	"\vvolume_info\x18\x06 \x01(\v2\x14.ynison.DeviceVolumeR\n" +
	"volumeInfo\"W\n" +
	"\fDeviceVolume\x12\x16\n" +
	"\x06volume\x18\x01 \x01(\x01R\x06volume\x12/\n" +
	"\aversion\x18\x02 \x01(\v2\x15.ynison.UpdateVersionR\aversion\"\xa3\x01\n" +
	"\n" +
	"DeviceInfo\x12\x1b\n" +
	"\tdevice_id\x18\x01 \x01(\tR\bdeviceId\x12\x14\n" +
	"\x05title\x18\x02 \x01(\tR\x05title\x12&\n" +
	"\x04type\x18\x03 \x01(\x0e2\x12.ynison.DeviceTypeR\x04type\x12\x19\n" +
	"\bapp_name\x18\x04 \x01(\tR\aappName\x12\x1f\n" +
	"\vapp_version\x18\x05 \x01(\tR\n" +
	"appVersion\"\xa0\x01\n" +
	"\x12DeviceCapabilities\x12\"\n" +
	"\rcan_be_player\x18\x01 \x01(\bR\vcanBePlayer\x127\n" +
	"\x18can_be_remote_controller\x18\x02 \x01(\bR\x15canBeRemoteController\x12-\n" +
	"\x12volume_granularity\x18\x03 \x01(\rR\x11volumeGranularity\"\x19\n" +
	"\aSession\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\x03R\x02id\"\xc1\x01\n" +
	"\rPlayingStatus\x12\x1f\n" +
	"\vprogress_ms\x18\x01 \x01(\x03R\n" +
	"progressMs\x12\x1f\n" +
	"\vduration_ms\x18\x02 \x01(\x03R\n" +
	"durationMs\x12\x16\n" +
	"\x06paused\x18\x03 \x01(\bR\x06paused\x12%\n" +
	"\x0eplayback_speed\x18\x04 \x01(\x01R\rplaybackSpeed\x12/\n" +
	"\aversion\x18\x05 \x01(\v2\x15.ynison.UpdateVersionR\aversion\"\xc1\x01\n" +
	"\x11PlayerQueueInject\x12<\n" +
	"\x0eplaying_status\x18\x01 \x01(\v2\x15.ynison.PlayingStatusR\rplayingStatus\x12=\n" +
	"\bplayable\x18\x02 \x01(\v2!.ynison.PlayerQueueInjectPlayableR\bplayable\x12/\n" +
	"\aversion\x18\x03 \x01(\v2\x15.ynison.UpdateVersionR\aversion\"\xc3\x01\n" +
	"\x19PlayerQueueInjectPlayable\x12\x1f\n" +
	"\vplayable_id\x18\x01 \x01(\tR\n" +
	"playableId\x12R\n" +
	"\rplayable_type\x18\x02 \x01(\x0e2-.ynison.PlayerQueueInjectPlayablePlayableTypeR\fplayableType\x12\x14\n" +
	"\x05title\x18\x03 \x01(\tR\x05title\x12\x1b\n" +
	"\tcover_url\x18\x04 \x01(\tR\bcoverUrl\"\xd0\x01\n" +
	"\vPlayerState\x12-\n" +
	"\x06status\x18\x01 \x01(\v2\x15.ynison.PlayingStatusR\x06status\x126\n" +
	"\fplayer_queue\x18\x02 \x01(\v2\x13.ynison.PlayerQueueR\vplayerQueue\x12Z\n" +
	"\x1cplayer_queue_inject_optional\x18\x03 \x01(\v2\x19.ynison.PlayerQueueInjectR\x19playerQueueInjectOptional\"\x85\a\n" +
	"\x15PutYnisonStateRequest\x12C\n" +
	"\x11update_full_state\x18\x01 \x01(\v2\x17.ynison.UpdateFullStateR\x0fupdateFullState\x12L\n" +
	"\x14update_active_device\x18\x02 \x01(\v2\x1a.ynison.UpdateActiveDeviceR\x12updateActiveDevice\x12O\n" +
	"\x15update_playing_status\x18\x03 \x01(\v2\x1b.ynison.UpdatePlayingStatusR\x13updatePlayingStatus\x12I\n" +
	"\x13update_player_state\x18\x04 \x01(\v2\x19.ynison.UpdatePlayerStateR\x11updatePlayerState\x129\n" +
	"\rupdate_volume\x18\x05 \x01(\v2\x14.ynison.UpdateVolumeR\fupdateVolume\x12\\\n" +
	"\x1aupdate_player_queue_inject\x18\x06 \x01(\v2\x1f.ynison.UpdatePlayerQueueInjectR\x17updatePlayerQueueInject\x12O\n" +
	"\x15update_session_params\x18\t \x01(\v2\x1b.ynison.UpdateSessionParamsR\x13updateSessionParams\x12F\n" +
	"\x12update_volume_info\x18\v \x01(\v2\x18.ynison.UpdateVolumeInfoR\x10updateVolumeInfo\x12G\n" +
	"\x13sync_state_from_eov\x18\f \x01(\v2\x18.ynison.SyncStateFromEOVR\x10syncStateFromEov\x12;\n" +
	"\x1aplayer_action_timestamp_ms\x18\a \x01(\x03R\x17playerActionTimestampMs\x12\x10\n" +
	"\x03rid\x18\b \x01(\tR\x03rid\x12s\n" +
	"\x1aactivity_interception_type\x18\n" +
	" \x01(\x0e25.ynison.PutYnisonStateRequestActivityInterceptionTypeR\x18activityInterceptionType\"\xea\x01\n" +
	"\x16PutYnisonStateResponse\x126\n" +
	"\fplayer_state\x18\x01 \x01(\v2\x13.ynison.PlayerStateR\vplayerState\x12(\n" +
	"\adevices\x18\x02 \x03(\v2\x0e.ynison.DeviceR\adevices\x129\n" +
	"\x19active_device_id_optional\x18\x03 \x01(\tR\x16activeDeviceIdOptional\x12!\n" +
	"\ftimestamp_ms\x18\x04 \x01(\x03R\vtimestampMs\x12\x10\n" +
	"\x03rid\x18\x05 \x01(\tR\x03rid\"d\n" +
	"\x17UpdatePlayerQueueInject\x12I\n" +
	"\x13player_queue_inject\x18\x01 \x01(\v2\x19.ynison.PlayerQueueInjectR\x11playerQueueInject\"B\n" +
	"\x12UpdateActiveDevice\x12,\n" +
	"\x12device_id_optional\x18\x01 \x01(\tR\x10deviceIdOptional\"S\n" +
	"\x13UpdatePlayingStatus\x12<\n" +
	"\x0eplaying_status\x18\x01 \x01(\v2\x15.ynison.PlayingStatusR\rplayingStatus\"C\n" +
	"\fUpdateVolume\x12\x16\n" +
	"\x06volume\x18\x01 \x01(\x01R\x06volume\x12\x1b\n" +
	"\tdevice_id\x18\x02 \x01(\tR\bdeviceId\"f\n" +
	"\x10UpdateVolumeInfo\x12\x1b\n" +
	"\tdevice_id\x18\x01 \x01(\tR\bdeviceId\x125\n" +
	"\vvolume_info\x18\x02 \x01(\v2\x14.ynison.DeviceVolumeR\n" +
	"volumeInfo\"K\n" +
	"\x11UpdatePlayerState\x126\n" +
	"\fplayer_state\x18\x01 \x01(\v2\x13.ynison.PlayerStateR\vplayerState\"\x81\x02\n" +
	"\x0fUpdateFullState\x126\n" +
	"\fplayer_state\x18\x01 \x01(\v2\x13.ynison.PlayerStateR\vplayerState\x12.\n" +
	"\x13is_currently_active\x18\x02 \x01(\bR\x11isCurrentlyActive\x12,\n" +
	"\x06device\x18\x03 \x01(\v2\x14.ynison.UpdateDeviceR\x06device\x12X\n" +
	"\x1csync_state_from_eov_optional\x18\x04 \x01(\v2\x18.ynison.SyncStateFromEOVR\x18syncStateFromEovOptional\"J\n" +
	"\x13UpdateSessionParams\x123\n" +
	"\x16mute_events_if_passive\x18\x01 \x01(\bR\x13muteEventsIfPassive\"\xc5\x01\n" +
	"\fUpdateDevice\x12&\n" +
	"\x04info\x18\x01 \x01(\v2\x12.ynison.DeviceInfoR\x04info\x12\x16\n" +
	"\x06volume\x18\x02 \x01(\x01R\x06volume\x12>\n" +
	"\fcapabilities\x18\x03 \x01(\v2\x1a.ynison.DeviceCapabilitiesR\fcapabilities\x125\n" +
	"\vvolume_info\x18\x04 \x01(\v2\x14.ynison.DeviceVolumeR\n" +
	"volumeInfo\":\n" +
	"\x10SyncStateFromEOV\x12&\n" +
	"\x0factual_queue_id\x18\x01 \x01(\tR\ractualQueueId*\x94\x02\n" +
	"\n" +
	"DeviceType\x12\x1b\n" +
	"\x17DEVICE_TYPE_UNSPECIFIED\x10\x00\x12\x13\n" +
	"\x0fDEVICE_TYPE_WEB\x10\x01\x12\x17\n" +
	"\x13DEVICE_TYPE_ANDROID\x10\x02\x12\x13\n" +
	"\x0fDEVICE_TYPE_IOS\x10\x03\x12\x1d\n" +
	"\x19DEVICE_TYPE_SMART_SPEAKER\x10\x04\x12\x16\n" +
	"\x12DEVICE_TYPE_WEB_TV\x10\x05\x12\x1a\n" +
	"\x16DEVICE_TYPE_ANDROID_TV\x10\x06\x12\x18\n" +
	"\x14DEVICE_TYPE_APPLE_TV\x10\a\x12\x1c\n" +
	"\x18DEVICE_TYPE_ANDROID_WEAR\x10\b\x12\x1b\n" +
	"\x17DEVICE_TYPE_WEB_DESKTOP\x10\t*\xa7\x01\n" +
	"\x14PlayablePlayableType\x12\x1d\n" +
	"\x19PLAYABLE_TYPE_UNSPECIFIED\x10\x00\x12\x17\n" +
	"\x13PLAYABLE_TYPE_TRACK\x10\x01\x12\x1d\n" +
	"\x19PLAYABLE_TYPE_LOCAL_TRACK\x10\x02\x12\x1a\n" +
	"\x16PLAYABLE_TYPE_INFINITE\x10\x03\x12\x1c\n" +
	"\x18PLAYABLE_TYPE_VIDEO_CLIP\x10\x04*\xbf\x02\n" +
	"\x1fVideoClipInfoRecommendationType\x12)\n" +
	"%VIDEO_CLIP_RECOMMENDATION_UNSPECIFIED\x10\x00\x12)\n" +
	"%VIDEO_CLIP_RECOMMENDATION_RECOMMENDED\x10\x01\x12'\n" +
	"#VIDEO_CLIP_RECOMMENDATION_ON_DEMAND\x10\x02\x12$\n" +
	" VIDEO_CLIP_RECOMMENDATION_SEARCH\x10\x03\x12$\n" +
	" VIDEO_CLIP_RECOMMENDATION_ARTIST\x10\x04\x12!\n" +
	"\x1dVIDEO_CLIP_RECOMMENDATION_OWN\x10\x05\x12.\n" +
	"*VIDEO_CLIP_RECOMMENDATION_EDITORIAL_CHOICE\x10\x06*\x9d\x02\n" +
	"\x15PlayerQueueEntityType\x12\x1b\n" +
	"\x17ENTITY_TYPE_UNSPECIFIED\x10\x00\x12\x16\n" +
	"\x12ENTITY_TYPE_ARTIST\x10\x01\x12\x18\n" +
	"\x14ENTITY_TYPE_PLAYLIST\x10\x02\x12\x15\n" +
	"\x11ENTITY_TYPE_ALBUM\x10\x03\x12\x15\n" +
	"\x11ENTITY_TYPE_RADIO\x10\x04\x12\x17\n" +
	"\x13ENTITY_TYPE_VARIOUS\x10\x05\x12\x1a\n" +
	"\x16ENTITY_TYPE_GENERATIVE\x10\x06\x12\x18\n" +
	"\x14ENTITY_TYPE_FM_RADIO\x10\a\x12\x1a\n" +
	"\x16ENTITY_TYPE_VIDEO_WAVE\x10\b\x12\x1c\n" +
	"\x18ENTITY_TYPE_LOCAL_TRACKS\x10\t*\xec\x02\n" +
	"\x18PlayerQueueEntityContext\x12\x1e\n" +
	"\x1aENTITY_CONTEXT_UNSPECIFIED\x10\x00\x12-\n" +
	")ENTITY_CONTEXT_BASED_ON_ENTITY_BY_DEFAULT\x10\x01\x12\x1e\n" +
	"\x1aENTITY_CONTEXT_USER_TRACKS\x10\x02\x12$\n" +
	" ENTITY_CONTEXT_DOWNLOADED_TRACKS\x10\x03\x12\x19\n" +
	"\x15ENTITY_CONTEXT_SEARCH\x10\x04\x12 \n" +
	"\x1cENTITY_CONTEXT_MUSIC_HISTORY\x10\x05\x12'\n" +
	"#ENTITY_CONTEXT_MUSIC_HISTORY_SEARCH\x10\x06\x12'\n" +
	"#ENTITY_CONTEXT_ARTIST_MY_COLLECTION\x10\a\x12,\n" +
	"(ENTITY_CONTEXT_ARTIST_FAMILIAR_FROM_WAVE\x10\b*R\n" +
	"\x14WaveSourceSourceType\x12!\n" +
	"\x1dWAVE_SOURCE_ONLINE_BY_DEFAULT\x10\x00\x12\x17\n" +
	"\x13WAVE_SOURCE_OFFLINE\x10\x01*{\n" +
	"\x1cPlayerStateOptionsRepeatMode\x12\x1b\n" +
	"\x17REPEAT_MODE_UNSPECIFIED\x10\x00\x12\x14\n" +
	"\x10REPEAT_MODE_NONE\x10\x01\x12\x13\n" +
	"\x0fREPEAT_MODE_ONE\x10\x02\x12\x13\n" +
	"\x0fREPEAT_MODE_ALL\x10\x03*\xb1\x01\n" +
	"%PlayerQueueInjectPlayablePlayableType\x12$\n" +
	" INJECT_PLAYABLE_TYPE_UNSPECIFIED\x10\x00\x12#\n" +
	"\x1fINJECT_PLAYABLE_TYPE_ALICE_SHOT\x10\x01\x12\x1b\n" +
	"\x17INJECT_PLAYABLE_TYPE_AD\x10\x02\x12 \n" +
	"\x1cINJECT_PLAYABLE_TYPE_PREROLL\x10\x03*\xac\x01\n" +
	"-PutYnisonStateRequestActivityInterceptionType\x12,\n" +
	"(INTERCEPTION_DO_NOT_INTERCEPT_BY_DEFAULT\x10\x00\x12+\n" +
	"'INTERCEPTION_INTERCEPT_IF_NO_ONE_ACTIVE\x10\x01\x12 \n" +
	"\x1cINTERCEPTION_INTERCEPT_EAGER\x10\x02B@Z>gitea.mrixs.me/Mrixs/yandex-music-api-go/internal/ynison/protob\x06proto3"

var (
	file_internal_ynison_proto_ynison_proto_rawDescOnce sync.Once
	file_internal_ynison_proto_ynison_proto_rawDescData []byte
)

func file_internal_ynison_proto_ynison_proto_rawDescGZIP() []byte {
	file_internal_ynison_proto_ynison_proto_rawDescOnce.Do(func() {
		file_internal_ynison_proto_ynison_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_internal_ynison_proto_ynison_proto_rawDesc), len(file_internal_ynison_proto_ynison_proto_rawDesc)))
	})
	return file_internal_ynison_proto_ynison_proto_rawDescData
}

var file_internal_ynison_proto_ynison_proto_enumTypes = make([]protoimpl.EnumInfo, 9)
var file_internal_ynison_proto_ynison_proto_msgTypes = make([]protoimpl.MessageInfo, 45)
var file_internal_ynison_proto_ynison_proto_goTypes = []any{
	(DeviceType)(0),                                                  // 0: ynison.DeviceType
	(PlayablePlayableType)(0),                                        // 1: ynison.PlayablePlayableType
	(VideoClipInfoRecommendationType)(0),                             // 2: ynison.VideoClipInfoRecommendationType
	(PlayerQueueEntityType)(0),                                       // 3: ynison.PlayerQueueEntityType
	(PlayerQueueEntityContext)(0),                                    // 4: ynison.PlayerQueueEntityContext
	(WaveSourceSourceType)(0),                                        // 5: ynison.WaveSourceSourceType
	(PlayerStateOptionsRepeatMode)(0),                                // 6: ynison.PlayerStateOptionsRepeatMode
	(PlayerQueueInjectPlayablePlayableType)(0),                       // 7: ynison.PlayerQueueInjectPlayablePlayableType
	(PutYnisonStateRequestActivityInterceptionType)(0),               // 8: ynison.PutYnisonStateRequestActivityInterceptionType
	(*Playable)(nil),                                                 // 9: ynison.Playable
	(*VideoClipInfo)(nil),                                            // 10: ynison.VideoClipInfo
	(*TrackInfo)(nil),                                                // 11: ynison.TrackInfo
	(*UpdateVersion)(nil),                                            // 12: ynison.UpdateVersion
	(*PlayerQueue)(nil),                                              // 13: ynison.PlayerQueue
	(*PlayerQueueQueue)(nil),                                         // 14: ynison.PlayerQueueQueue
	(*PlayerQueueQueueWaveQueue)(nil),                                // 15: ynison.PlayerQueueQueueWaveQueue
	(*PlayerQueueQueueWaveQueueEntityOptions)(nil),                   // 16: ynison.PlayerQueueQueueWaveQueueEntityOptions
	(*PlayerQueueQueueWaveQueueEntityOptionsWaveSession)(nil),        // 17: ynison.PlayerQueueQueueWaveQueueEntityOptionsWaveSession
	(*PlayerQueueQueueWaveQueueEntityOptionsTrackSourceWithKey)(nil), // 18: ynison.PlayerQueueQueueWaveQueueEntityOptionsTrackSourceWithKey
	(*PlayerQueueQueueWaveQueueEntityOptionsWaveSource)(nil),         // 19: ynison.PlayerQueueQueueWaveQueueEntityOptionsWaveSource
	(*PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSource)(nil),    // 20: ynison.PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSource
	(*PlayerQueueQueueWaveQueueEntityOptionsArtistId)(nil),           // 21: ynison.PlayerQueueQueueWaveQueueEntityOptionsArtistId
	(*PlayerQueueQueueWaveQueueEntityOptionsPlaylistId)(nil),         // 22: ynison.PlayerQueueQueueWaveQueueEntityOptionsPlaylistId
	(*PlayerQueueQueueWaveQueueEntityOptionsAlbumId)(nil),            // 23: ynison.PlayerQueueQueueWaveQueueEntityOptionsAlbumId
	(*PlayerQueueQueueGenerativeQueue)(nil),                          // 24: ynison.PlayerQueueQueueGenerativeQueue
	(*PlayerQueueQueueFmRadioQueue)(nil),                             // 25: ynison.PlayerQueueQueueFmRadioQueue
	(*PlayerQueueQueueVideoWaveQueue)(nil),                           // 26: ynison.PlayerQueueQueueVideoWaveQueue
	(*PlayerQueueQueueLocalTracksQueue)(nil),                         // 27: ynison.PlayerQueueQueueLocalTracksQueue
	(*PlayerQueueInitialEntity)(nil),                                 // 28: ynison.PlayerQueueInitialEntity
	(*PlayerQueuePlayerQueueOptions)(nil),                            // 29: ynison.PlayerQueuePlayerQueueOptions
	(*PlayerQueuePlayerQueueOptionsRadioOptions)(nil),                // 30: ynison.PlayerQueuePlayerQueueOptionsRadioOptions
	(*PlayerStateOptions)(nil),                                       // 31: ynison.PlayerStateOptions
	(*Shuffle)(nil),                                                  // 32: ynison.Shuffle
	(*Device)(nil),                                                   // 33: ynison.Device
	(*DeviceVolume)(nil),                                             // 34: ynison.DeviceVolume
	(*DeviceInfo)(nil),                                               // 35: ynison.DeviceInfo
	(*DeviceCapabilities)(nil),                                       // 36: ynison.DeviceCapabilities
	(*Session)(nil),                                                  // 37: ynison.Session
	(*PlayingStatus)(nil),                                            // 38: ynison.PlayingStatus
	(*PlayerQueueInject)(nil),                                        // 39: ynison.PlayerQueueInject
	(*PlayerQueueInjectPlayable)(nil),                                // 40: ynison.PlayerQueueInjectPlayable
	(*PlayerState)(nil),                                              // 41: ynison.PlayerState
	(*PutYnisonStateRequest)(nil),                                    // 42: ynison.PutYnisonStateRequest
	(*PutYnisonStateResponse)(nil),                                   // 43: ynison.PutYnisonStateResponse
	(*UpdatePlayerQueueInject)(nil),                                  // 44: ynison.UpdatePlayerQueueInject
	(*UpdateActiveDevice)(nil),                                       // 45: ynison.UpdateActiveDevice
	(*UpdatePlayingStatus)(nil),                                      // 46: ynison.UpdatePlayingStatus
	(*UpdateVolume)(nil),                                             // 47: ynison.UpdateVolume
	(*UpdateVolumeInfo)(nil),                                         // 48: ynison.UpdateVolumeInfo
	(*UpdatePlayerState)(nil),                                        // 49: ynison.UpdatePlayerState
	(*UpdateFullState)(nil),                                          // 50: ynison.UpdateFullState
	(*UpdateSessionParams)(nil),                                      // 51: ynison.UpdateSessionParams
	(*UpdateDevice)(nil),                                             // 52: ynison.UpdateDevice
	(*SyncStateFromEOV)(nil),                                         // 53: ynison.SyncStateFromEOV
}
var file_internal_ynison_proto_ynison_proto_depIdxs = []int32{
	1,  // 0: ynison.Playable.playable_type:type_name -> ynison.PlayablePlayableType
	10, // 1: ynison.Playable.video_clip_info:type_name -> ynison.VideoClipInfo
	11, // 2: ynison.Playable.track_info:type_name -> ynison.TrackInfo
	2,  // 3: ynison.VideoClipInfo.recommendation_type:type_name -> ynison.VideoClipInfoRecommendationType
	3,  // 4: ynison.PlayerQueue.entity_type:type_name -> ynison.PlayerQueueEntityType
	14, // 5: ynison.PlayerQueue.queue:type_name -> ynison.PlayerQueueQueue
	9,  // 6: ynison.PlayerQueue.playable_list:type_name -> ynison.Playable
	31, // 7: ynison.PlayerQueue.options:type_name -> ynison.PlayerStateOptions
	12, // 8: ynison.PlayerQueue.version:type_name -> ynison.UpdateVersion
	32, // 9: ynison.PlayerQueue.shuffle_optional:type_name -> ynison.Shuffle
	4,  // 10: ynison.PlayerQueue.entity_context:type_name -> ynison.PlayerQueueEntityContext
	28, // 11: ynison.PlayerQueue.initial_entity_optional:type_name -> ynison.PlayerQueueInitialEntity
	29, // 12: ynison.PlayerQueue.adding_options_optional:type_name -> ynison.PlayerQueuePlayerQueueOptions
	15, // 13: ynison.PlayerQueueQueue.wave_queue:type_name -> ynison.PlayerQueueQueueWaveQueue
	24, // 14: ynison.PlayerQueueQueue.generative_queue:type_name -> ynison.PlayerQueueQueueGenerativeQueue
	25, // 15: ynison.PlayerQueueQueue.fm_radio_queue:type_name -> ynison.PlayerQueueQueueFmRadioQueue
	26, // 16: ynison.PlayerQueueQueue.video_wave_queue:type_name -> ynison.PlayerQueueQueueVideoWaveQueue
	27, // 17: ynison.PlayerQueueQueue.local_tracks_queue:type_name -> ynison.PlayerQueueQueueLocalTracksQueue
	9,  // 18: ynison.PlayerQueueQueueWaveQueue.recommended_playable_list:type_name -> ynison.Playable
	16, // 19: ynison.PlayerQueueQueueWaveQueue.entity_options:type_name -> ynison.PlayerQueueQueueWaveQueueEntityOptions
	17, // 20: ynison.PlayerQueueQueueWaveQueueEntityOptions.wave_entity_optional:type_name -> ynison.PlayerQueueQueueWaveQueueEntityOptionsWaveSession
	18, // 21: ynison.PlayerQueueQueueWaveQueueEntityOptions.track_sources:type_name -> ynison.PlayerQueueQueueWaveQueueEntityOptionsTrackSourceWithKey
	19, // 22: ynison.PlayerQueueQueueWaveQueueEntityOptionsTrackSourceWithKey.wave_source:type_name -> ynison.PlayerQueueQueueWaveQueueEntityOptionsWaveSource
	20, // 23: ynison.PlayerQueueQueueWaveQueueEntityOptionsTrackSourceWithKey.phonoteka_source:type_name -> ynison.PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSource
	5,  // 24: ynison.PlayerQueueQueueWaveQueueEntityOptionsWaveSource.source_type:type_name -> ynison.WaveSourceSourceType
	4,  // 25: ynison.PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSource.entity_context:type_name -> ynison.PlayerQueueEntityContext
	21, // 26: ynison.PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSource.artist_id:type_name -> ynison.PlayerQueueQueueWaveQueueEntityOptionsArtistId
	22, // 27: ynison.PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSource.playlist_id:type_name -> ynison.PlayerQueueQueueWaveQueueEntityOptionsPlaylistId
	23, // 28: ynison.PlayerQueueQueueWaveQueueEntityOptionsPhonotekaSource.album_id:type_name -> ynison.PlayerQueueQueueWaveQueueEntityOptionsAlbumId
	3,  // 29: ynison.PlayerQueueInitialEntity.entity_type:type_name -> ynison.PlayerQueueEntityType
	30, // 30: ynison.PlayerQueuePlayerQueueOptions.radio_options:type_name -> ynison.PlayerQueuePlayerQueueOptionsRadioOptions
	6,  // 31: ynison.PlayerStateOptions.repeat_mode:type_name -> ynison.PlayerStateOptionsRepeatMode
	35, // 32: ynison.Device.info:type_name -> ynison.DeviceInfo
	36, // 33: ynison.Device.capabilities:type_name -> ynison.DeviceCapabilities
	37, // 34: ynison.Device.session:type_name -> ynison.Session
	34, // 35: ynison.Device.volume_info:type_name -> ynison.DeviceVolume
	12, // 36: ynison.DeviceVolume.version:type_name -> ynison.UpdateVersion
	0,  // 37: ynison.DeviceInfo.type:type_name -> ynison.DeviceType
	12, // 38: ynison.PlayingStatus.version:type_name -> ynison.UpdateVersion
	38, // 39: ynison.PlayerQueueInject.playing_status:type_name -> ynison.PlayingStatus
	40, // 40: ynison.PlayerQueueInject.playable:type_name -> ynison.PlayerQueueInjectPlayable
	12, // 41: ynison.PlayerQueueInject.version:type_name -> ynison.UpdateVersion
	7,  // 42: ynison.PlayerQueueInjectPlayable.playable_type:type_name -> ynison.PlayerQueueInjectPlayablePlayableType
	38, // 43: ynison.PlayerState.status:type_name -> ynison.PlayingStatus
	13, // 44: ynison.PlayerState.player_queue:type_name -> ynison.PlayerQueue
	39, // 45: ynison.PlayerState.player_queue_inject_optional:type_name -> ynison.PlayerQueueInject
	50, // 46: ynison.PutYnisonStateRequest.update_full_state:type_name -> ynison.UpdateFullState
	45, // 47: ynison.PutYnisonStateRequest.update_active_device:type_name -> ynison.UpdateActiveDevice
	46, // 48: ynison.PutYnisonStateRequest.update_playing_status:type_name -> ynison.UpdatePlayingStatus
	49, // 49: ynison.PutYnisonStateRequest.update_player_state:type_name -> ynison.UpdatePlayerState
	47, // 50: ynison.PutYnisonStateRequest.update_volume:type_name -> ynison.UpdateVolume
	44, // 51: ynison.PutYnisonStateRequest.update_player_queue_inject:type_name -> ynison.UpdatePlayerQueueInject
	51, // 52: ynison.PutYnisonStateRequest.update_session_params:type_name -> ynison.UpdateSessionParams
	48, // 53: ynison.PutYnisonStateRequest.update_volume_info:type_name -> ynison.UpdateVolumeInfo
	53, // 54: ynison.PutYnisonStateRequest.sync_state_from_eov:type_name -> ynison.SyncStateFromEOV
	8,  // 55: ynison.PutYnisonStateRequest.activity_interception_type:type_name -> ynison.PutYnisonStateRequestActivityInterceptionType
	41, // 56: ynison.PutYnisonStateResponse.player_state:type_name -> ynison.PlayerState
	33, // 57: ynison.PutYnisonStateResponse.devices:type_name -> ynison.Device
	39, // 58: ynison.UpdatePlayerQueueInject.player_queue_inject:type_name -> ynison.PlayerQueueInject
	38, // 59: ynison.UpdatePlayingStatus.playing_status:type_name -> ynison.PlayingStatus
	34, // 60: ynison.UpdateVolumeInfo.volume_info:type_name -> ynison.DeviceVolume
	41, // 61: ynison.UpdatePlayerState.player_state:type_name -> ynison.PlayerState
	41, // 62: ynison.UpdateFullState.player_state:type_name -> ynison.PlayerState
	52, // 63: ynison.UpdateFullState.device:type_name -> ynison.UpdateDevice
	53, // 64: ynison.UpdateFullState.sync_state_from_eov_optional:type_name -> ynison.SyncStateFromEOV
	35, // 65: ynison.UpdateDevice.info:type_name -> ynison.DeviceInfo
	36, // 66: ynison.UpdateDevice.capabilities:type_name -> ynison.DeviceCapabilities
	34, // 67: ynison.UpdateDevice.volume_info:type_name -> ynison.DeviceVolume
	68, // [68:68] is the sub-list for method output_type
	68, // [68:68] is the sub-list for method input_type
	68, // [68:68] is the sub-list for extension type_name
	68, // [68:68] is the sub-list for extension extendee
	0,  // [0:68] is the sub-list for field type_name
}

func init() { file_internal_ynison_proto_ynison_proto_init() }
func file_internal_ynison_proto_ynison_proto_init() {
	if File_internal_ynison_proto_ynison_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_internal_ynison_proto_ynison_proto_rawDesc), len(file_internal_ynison_proto_ynison_proto_rawDesc)),
			NumEnums:      9,
			NumMessages:   45,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_internal_ynison_proto_ynison_proto_goTypes,
		DependencyIndexes: file_internal_ynison_proto_ynison_proto_depIdxs,
		EnumInfos:         file_internal_ynison_proto_ynison_proto_enumTypes,
		MessageInfos:      file_internal_ynison_proto_ynison_proto_msgTypes,
	}.Build()
	File_internal_ynison_proto_ynison_proto = out.File
	file_internal_ynison_proto_ynison_proto_goTypes = nil
	file_internal_ynison_proto_ynison_proto_depIdxs = nil
}