// Copyright (c) 2018 Anki, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License in the file LICENSE.txt or at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Settings definition

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        v6.31.1
// source: settings.proto

package Anki_Vector_external_interface

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

type ApiVersion int32

const (
	ApiVersion_INVALID ApiVersion = 0
	ApiVersion_LATEST  ApiVersion = 1
)

// Enum value maps for ApiVersion.
var (
	ApiVersion_name = map[int32]string{
		0: "INVALID",
		1: "LATEST",
	}
	ApiVersion_value = map[string]int32{
		"INVALID": 0,
		"LATEST":  1,
	}
)

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

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

func (ApiVersion) Descriptor() protoreflect.EnumDescriptor {
	return file_settings_proto_enumTypes[0].Descriptor()
}

func (ApiVersion) Type() protoreflect.EnumType {
	return &file_settings_proto_enumTypes[0]
}

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

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

type Volume int32

const (
	Volume_MUTE        Volume = 0
	Volume_LOW         Volume = 1
	Volume_MEDIUM_LOW  Volume = 2
	Volume_MEDIUM      Volume = 3
	Volume_MEDIUM_HIGH Volume = 4
	Volume_HIGH        Volume = 5
)

// Enum value maps for Volume.
var (
	Volume_name = map[int32]string{
		0: "MUTE",
		1: "LOW",
		2: "MEDIUM_LOW",
		3: "MEDIUM",
		4: "MEDIUM_HIGH",
		5: "HIGH",
	}
	Volume_value = map[string]int32{
		"MUTE":        0,
		"LOW":         1,
		"MEDIUM_LOW":  2,
		"MEDIUM":      3,
		"MEDIUM_HIGH": 4,
		"HIGH":        5,
	}
)

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

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

func (Volume) Descriptor() protoreflect.EnumDescriptor {
	return file_settings_proto_enumTypes[1].Descriptor()
}

func (Volume) Type() protoreflect.EnumType {
	return &file_settings_proto_enumTypes[1]
}

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

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

type JdocType int32

const (
	JdocType_ROBOT_SETTINGS       JdocType = 0
	JdocType_ROBOT_LIFETIME_STATS JdocType = 1
	JdocType_ACCOUNT_SETTINGS     JdocType = 2
	JdocType_USER_ENTITLEMENTS    JdocType = 3
)

// Enum value maps for JdocType.
var (
	JdocType_name = map[int32]string{
		0: "ROBOT_SETTINGS",
		1: "ROBOT_LIFETIME_STATS",
		2: "ACCOUNT_SETTINGS",
		3: "USER_ENTITLEMENTS",
	}
	JdocType_value = map[string]int32{
		"ROBOT_SETTINGS":       0,
		"ROBOT_LIFETIME_STATS": 1,
		"ACCOUNT_SETTINGS":     2,
		"USER_ENTITLEMENTS":    3,
	}
)

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

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

func (JdocType) Descriptor() protoreflect.EnumDescriptor {
	return file_settings_proto_enumTypes[2].Descriptor()
}

func (JdocType) Type() protoreflect.EnumType {
	return &file_settings_proto_enumTypes[2]
}

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

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

type JdocResolveMethod int32

const (
	JdocResolveMethod_PUSH_TO_CLOUD   JdocResolveMethod = 0
	JdocResolveMethod_PULL_FROM_CLOUD JdocResolveMethod = 1
)

// Enum value maps for JdocResolveMethod.
var (
	JdocResolveMethod_name = map[int32]string{
		0: "PUSH_TO_CLOUD",
		1: "PULL_FROM_CLOUD",
	}
	JdocResolveMethod_value = map[string]int32{
		"PUSH_TO_CLOUD":   0,
		"PULL_FROM_CLOUD": 1,
	}
)

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

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

func (JdocResolveMethod) Descriptor() protoreflect.EnumDescriptor {
	return file_settings_proto_enumTypes[3].Descriptor()
}

func (JdocResolveMethod) Type() protoreflect.EnumType {
	return &file_settings_proto_enumTypes[3]
}

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

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

// RobotSetting enum values are not in all caps for historical reasons.
// Changing that now would involve a format migration because we're now
// saving robot settings jdocs in the cloud.
type RobotSetting int32

const (
	RobotSetting_clock_24_hour      RobotSetting = 0
	RobotSetting_eye_color          RobotSetting = 1
	RobotSetting_custom_eye_color   RobotSetting = 2
	RobotSetting_default_location   RobotSetting = 3
	RobotSetting_dist_is_metric     RobotSetting = 4
	RobotSetting_locale             RobotSetting = 5
	RobotSetting_master_volume      RobotSetting = 6
	RobotSetting_temp_is_fahrenheit RobotSetting = 7
	RobotSetting_time_zone          RobotSetting = 8
	RobotSetting_button_wakeword    RobotSetting = 9
)

// Enum value maps for RobotSetting.
var (
	RobotSetting_name = map[int32]string{
		0: "clock_24_hour",
		1: "eye_color",
		2: "custom_eye_color",
		3: "default_location",
		4: "dist_is_metric",
		5: "locale",
		6: "master_volume",
		7: "temp_is_fahrenheit",
		8: "time_zone",
		9: "button_wakeword",
	}
	RobotSetting_value = map[string]int32{
		"clock_24_hour":      0,
		"eye_color":          1,
		"custom_eye_color":   2,
		"default_location":   3,
		"dist_is_metric":     4,
		"locale":             5,
		"master_volume":      6,
		"temp_is_fahrenheit": 7,
		"time_zone":          8,
		"button_wakeword":    9,
	}
)

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

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

func (RobotSetting) Descriptor() protoreflect.EnumDescriptor {
	return file_settings_proto_enumTypes[4].Descriptor()
}

func (RobotSetting) Type() protoreflect.EnumType {
	return &file_settings_proto_enumTypes[4]
}

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

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

type EyeColor int32

const (
	EyeColor_TIP_OVER_TEAL          EyeColor = 0
	EyeColor_OVERFIT_ORANGE         EyeColor = 1
	EyeColor_UNCANNY_YELLOW         EyeColor = 2
	EyeColor_NON_LINEAR_LIME        EyeColor = 3
	EyeColor_SINGULARITY_SAPPHIRE   EyeColor = 4
	EyeColor_FALSE_POSITIVE_PURPLE  EyeColor = 5
	EyeColor_CONFUSION_MATRIX_GREEN EyeColor = 6
	EyeColor_RAINBOW_EYES           EyeColor = 7
	EyeColor_ROBOT_RED              EyeColor = 8
)

// Enum value maps for EyeColor.
var (
	EyeColor_name = map[int32]string{
		0: "TIP_OVER_TEAL",
		1: "OVERFIT_ORANGE",
		2: "UNCANNY_YELLOW",
		3: "NON_LINEAR_LIME",
		4: "SINGULARITY_SAPPHIRE",
		5: "FALSE_POSITIVE_PURPLE",
		6: "CONFUSION_MATRIX_GREEN",
		7: "RAINBOW_EYES",
		8: "ROBOT_RED",
	}
	EyeColor_value = map[string]int32{
		"TIP_OVER_TEAL":          0,
		"OVERFIT_ORANGE":         1,
		"UNCANNY_YELLOW":         2,
		"NON_LINEAR_LIME":        3,
		"SINGULARITY_SAPPHIRE":   4,
		"FALSE_POSITIVE_PURPLE":  5,
		"CONFUSION_MATRIX_GREEN": 6,
		"RAINBOW_EYES":           7,
		"ROBOT_RED":              8,
	}
)

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

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

func (EyeColor) Descriptor() protoreflect.EnumDescriptor {
	return file_settings_proto_enumTypes[5].Descriptor()
}

func (EyeColor) Type() protoreflect.EnumType {
	return &file_settings_proto_enumTypes[5]
}

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

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

type ButtonWakeWord int32

const (
	ButtonWakeWord_BUTTON_WAKEWORD_HEY_VECTOR ButtonWakeWord = 0
	ButtonWakeWord_BUTTON_WAKEWORD_ALEXA      ButtonWakeWord = 1
)

// Enum value maps for ButtonWakeWord.
var (
	ButtonWakeWord_name = map[int32]string{
		0: "BUTTON_WAKEWORD_HEY_VECTOR",
		1: "BUTTON_WAKEWORD_ALEXA",
	}
	ButtonWakeWord_value = map[string]int32{
		"BUTTON_WAKEWORD_HEY_VECTOR": 0,
		"BUTTON_WAKEWORD_ALEXA":      1,
	}
)

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

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

func (ButtonWakeWord) Descriptor() protoreflect.EnumDescriptor {
	return file_settings_proto_enumTypes[6].Descriptor()
}

func (ButtonWakeWord) Type() protoreflect.EnumType {
	return &file_settings_proto_enumTypes[6]
}

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

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

type AccountSetting int32

const (
	AccountSetting_DATA_COLLECTION AccountSetting = 0
	AccountSetting_APP_LOCALE      AccountSetting = 1
)

// Enum value maps for AccountSetting.
var (
	AccountSetting_name = map[int32]string{
		0: "DATA_COLLECTION",
		1: "APP_LOCALE",
	}
	AccountSetting_value = map[string]int32{
		"DATA_COLLECTION": 0,
		"APP_LOCALE":      1,
	}
)

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

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

func (AccountSetting) Descriptor() protoreflect.EnumDescriptor {
	return file_settings_proto_enumTypes[7].Descriptor()
}

func (AccountSetting) Type() protoreflect.EnumType {
	return &file_settings_proto_enumTypes[7]
}

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

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

type UserEntitlement int32

const (
	UserEntitlement_KICKSTARTER_EYES UserEntitlement = 0
)

// Enum value maps for UserEntitlement.
var (
	UserEntitlement_name = map[int32]string{
		0: "KICKSTARTER_EYES",
	}
	UserEntitlement_value = map[string]int32{
		"KICKSTARTER_EYES": 0,
	}
)

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

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

func (UserEntitlement) Descriptor() protoreflect.EnumDescriptor {
	return file_settings_proto_enumTypes[8].Descriptor()
}

func (UserEntitlement) Type() protoreflect.EnumType {
	return &file_settings_proto_enumTypes[8]
}

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

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

type ResultCode int32

const (
	ResultCode_SETTINGS_ACCEPTED        ResultCode = 0
	ResultCode_ERROR_UPDATE_IN_PROGRESS ResultCode = 1
)

// Enum value maps for ResultCode.
var (
	ResultCode_name = map[int32]string{
		0: "SETTINGS_ACCEPTED",
		1: "ERROR_UPDATE_IN_PROGRESS",
	}
	ResultCode_value = map[string]int32{
		"SETTINGS_ACCEPTED":        0,
		"ERROR_UPDATE_IN_PROGRESS": 1,
	}
)

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

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

func (ResultCode) Descriptor() protoreflect.EnumDescriptor {
	return file_settings_proto_enumTypes[9].Descriptor()
}

func (ResultCode) Type() protoreflect.EnumType {
	return &file_settings_proto_enumTypes[9]
}

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

// Deprecated: Use ResultCode.Descriptor instead.
func (ResultCode) EnumDescriptor() ([]byte, []int) {
	return file_settings_proto_rawDescGZIP(), []int{9}
}

type CustomEyeColor struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Hue           float32                `protobuf:"fixed32,1,opt,name=hue,proto3" json:"hue,omitempty"`
	Saturation    float32                `protobuf:"fixed32,2,opt,name=saturation,proto3" json:"saturation,omitempty"`
	Enabled       bool                   `protobuf:"varint,3,opt,name=enabled,proto3" json:"enabled,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CustomEyeColor) ProtoMessage() {}

func (x *CustomEyeColor) ProtoReflect() protoreflect.Message {
	mi := &file_settings_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 CustomEyeColor.ProtoReflect.Descriptor instead.
func (*CustomEyeColor) Descriptor() ([]byte, []int) {
	return file_settings_proto_rawDescGZIP(), []int{0}
}

func (x *CustomEyeColor) GetHue() float32 {
	if x != nil {
		return x.Hue
	}
	return 0
}

func (x *CustomEyeColor) GetSaturation() float32 {
	if x != nil {
		return x.Saturation
	}
	return 0
}

func (x *CustomEyeColor) GetEnabled() bool {
	if x != nil {
		return x.Enabled
	}
	return false
}

type RobotSettingsConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to OneofClock_24Hour:
	//
	//	*RobotSettingsConfig_Clock_24Hour
	OneofClock_24Hour isRobotSettingsConfig_OneofClock_24Hour `protobuf_oneof:"oneof_clock_24_hour"`
	// Types that are valid to be assigned to OneofEyeColor:
	//
	//	*RobotSettingsConfig_EyeColor
	OneofEyeColor isRobotSettingsConfig_OneofEyeColor `protobuf_oneof:"oneof_eye_color"`
	// Types that are valid to be assigned to OneofCustomEyeColor:
	//
	//	*RobotSettingsConfig_CustomEyeColor
	OneofCustomEyeColor isRobotSettingsConfig_OneofCustomEyeColor `protobuf_oneof:"oneof_custom_eye_color"`
	// Types that are valid to be assigned to OneofDefaultLocation:
	//
	//	*RobotSettingsConfig_DefaultLocation
	OneofDefaultLocation isRobotSettingsConfig_OneofDefaultLocation `protobuf_oneof:"oneof_default_location"`
	// Types that are valid to be assigned to OneofDistIsMetric:
	//
	//	*RobotSettingsConfig_DistIsMetric
	OneofDistIsMetric isRobotSettingsConfig_OneofDistIsMetric `protobuf_oneof:"oneof_dist_is_metric"`
	// Types that are valid to be assigned to OneofLocale:
	//
	//	*RobotSettingsConfig_Locale
	OneofLocale isRobotSettingsConfig_OneofLocale `protobuf_oneof:"oneof_locale"`
	// Types that are valid to be assigned to OneofMasterVolume:
	//
	//	*RobotSettingsConfig_MasterVolume
	OneofMasterVolume isRobotSettingsConfig_OneofMasterVolume `protobuf_oneof:"oneof_master_volume"`
	// Types that are valid to be assigned to OneofTempIsFahrenheit:
	//
	//	*RobotSettingsConfig_TempIsFahrenheit
	OneofTempIsFahrenheit isRobotSettingsConfig_OneofTempIsFahrenheit `protobuf_oneof:"oneof_temp_is_fahrenheit"`
	// Types that are valid to be assigned to OneofTimeZone:
	//
	//	*RobotSettingsConfig_TimeZone
	OneofTimeZone isRobotSettingsConfig_OneofTimeZone `protobuf_oneof:"oneof_time_zone"`
	// Types that are valid to be assigned to OneofButtonWakeword:
	//
	//	*RobotSettingsConfig_ButtonWakeword
	OneofButtonWakeword isRobotSettingsConfig_OneofButtonWakeword `protobuf_oneof:"oneof_button_wakeword"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

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

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

func (*RobotSettingsConfig) ProtoMessage() {}

func (x *RobotSettingsConfig) ProtoReflect() protoreflect.Message {
	mi := &file_settings_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 RobotSettingsConfig.ProtoReflect.Descriptor instead.
func (*RobotSettingsConfig) Descriptor() ([]byte, []int) {
	return file_settings_proto_rawDescGZIP(), []int{1}
}

func (x *RobotSettingsConfig) GetOneofClock_24Hour() isRobotSettingsConfig_OneofClock_24Hour {
	if x != nil {
		return x.OneofClock_24Hour
	}
	return nil
}

func (x *RobotSettingsConfig) GetClock_24Hour() bool {
	if x != nil {
		if x, ok := x.OneofClock_24Hour.(*RobotSettingsConfig_Clock_24Hour); ok {
			return x.Clock_24Hour
		}
	}
	return false
}

func (x *RobotSettingsConfig) GetOneofEyeColor() isRobotSettingsConfig_OneofEyeColor {
	if x != nil {
		return x.OneofEyeColor
	}
	return nil
}

func (x *RobotSettingsConfig) GetEyeColor() EyeColor {
	if x != nil {
		if x, ok := x.OneofEyeColor.(*RobotSettingsConfig_EyeColor); ok {
			return x.EyeColor
		}
	}
	return EyeColor_TIP_OVER_TEAL
}

func (x *RobotSettingsConfig) GetOneofCustomEyeColor() isRobotSettingsConfig_OneofCustomEyeColor {
	if x != nil {
		return x.OneofCustomEyeColor
	}
	return nil
}

func (x *RobotSettingsConfig) GetCustomEyeColor() *CustomEyeColor {
	if x != nil {
		if x, ok := x.OneofCustomEyeColor.(*RobotSettingsConfig_CustomEyeColor); ok {
			return x.CustomEyeColor
		}
	}
	return nil
}

func (x *RobotSettingsConfig) GetOneofDefaultLocation() isRobotSettingsConfig_OneofDefaultLocation {
	if x != nil {
		return x.OneofDefaultLocation
	}
	return nil
}

func (x *RobotSettingsConfig) GetDefaultLocation() string {
	if x != nil {
		if x, ok := x.OneofDefaultLocation.(*RobotSettingsConfig_DefaultLocation); ok {
			return x.DefaultLocation
		}
	}
	return ""
}

func (x *RobotSettingsConfig) GetOneofDistIsMetric() isRobotSettingsConfig_OneofDistIsMetric {
	if x != nil {
		return x.OneofDistIsMetric
	}
	return nil
}

func (x *RobotSettingsConfig) GetDistIsMetric() bool {
	if x != nil {
		if x, ok := x.OneofDistIsMetric.(*RobotSettingsConfig_DistIsMetric); ok {
			return x.DistIsMetric
		}
	}
	return false
}

func (x *RobotSettingsConfig) GetOneofLocale() isRobotSettingsConfig_OneofLocale {
	if x != nil {
		return x.OneofLocale
	}
	return nil
}

func (x *RobotSettingsConfig) GetLocale() string {
	if x != nil {
		if x, ok := x.OneofLocale.(*RobotSettingsConfig_Locale); ok {
			return x.Locale
		}
	}
	return ""
}

func (x *RobotSettingsConfig) GetOneofMasterVolume() isRobotSettingsConfig_OneofMasterVolume {
	if x != nil {
		return x.OneofMasterVolume
	}
	return nil
}

func (x *RobotSettingsConfig) GetMasterVolume() Volume {
	if x != nil {
		if x, ok := x.OneofMasterVolume.(*RobotSettingsConfig_MasterVolume); ok {
			return x.MasterVolume
		}
	}
	return Volume_MUTE
}

func (x *RobotSettingsConfig) GetOneofTempIsFahrenheit() isRobotSettingsConfig_OneofTempIsFahrenheit {
	if x != nil {
		return x.OneofTempIsFahrenheit
	}
	return nil
}

func (x *RobotSettingsConfig) GetTempIsFahrenheit() bool {
	if x != nil {
		if x, ok := x.OneofTempIsFahrenheit.(*RobotSettingsConfig_TempIsFahrenheit); ok {
			return x.TempIsFahrenheit
		}
	}
	return false
}

func (x *RobotSettingsConfig) GetOneofTimeZone() isRobotSettingsConfig_OneofTimeZone {
	if x != nil {
		return x.OneofTimeZone
	}
	return nil
}

func (x *RobotSettingsConfig) GetTimeZone() string {
	if x != nil {
		if x, ok := x.OneofTimeZone.(*RobotSettingsConfig_TimeZone); ok {
			return x.TimeZone
		}
	}
	return ""
}

func (x *RobotSettingsConfig) GetOneofButtonWakeword() isRobotSettingsConfig_OneofButtonWakeword {
	if x != nil {
		return x.OneofButtonWakeword
	}
	return nil
}

func (x *RobotSettingsConfig) GetButtonWakeword() ButtonWakeWord {
	if x != nil {
		if x, ok := x.OneofButtonWakeword.(*RobotSettingsConfig_ButtonWakeword); ok {
			return x.ButtonWakeword
		}
	}
	return ButtonWakeWord_BUTTON_WAKEWORD_HEY_VECTOR
}

type isRobotSettingsConfig_OneofClock_24Hour interface {
	isRobotSettingsConfig_OneofClock_24Hour()
}

type RobotSettingsConfig_Clock_24Hour struct {
	Clock_24Hour bool `protobuf:"varint,1,opt,name=clock_24_hour,json=clock24Hour,proto3,oneof"`
}

func (*RobotSettingsConfig_Clock_24Hour) isRobotSettingsConfig_OneofClock_24Hour() {}

type isRobotSettingsConfig_OneofEyeColor interface {
	isRobotSettingsConfig_OneofEyeColor()
}

type RobotSettingsConfig_EyeColor struct {
	EyeColor EyeColor `protobuf:"varint,2,opt,name=eye_color,json=eyeColor,proto3,enum=Anki.Vector.external_interface.EyeColor,oneof"`
}

func (*RobotSettingsConfig_EyeColor) isRobotSettingsConfig_OneofEyeColor() {}

type isRobotSettingsConfig_OneofCustomEyeColor interface {
	isRobotSettingsConfig_OneofCustomEyeColor()
}

type RobotSettingsConfig_CustomEyeColor struct {
	CustomEyeColor *CustomEyeColor `protobuf:"bytes,3,opt,name=custom_eye_color,json=customEyeColor,proto3,oneof"`
}

func (*RobotSettingsConfig_CustomEyeColor) isRobotSettingsConfig_OneofCustomEyeColor() {}

type isRobotSettingsConfig_OneofDefaultLocation interface {
	isRobotSettingsConfig_OneofDefaultLocation()
}

type RobotSettingsConfig_DefaultLocation struct {
	DefaultLocation string `protobuf:"bytes,4,opt,name=default_location,json=defaultLocation,proto3,oneof"`
}

func (*RobotSettingsConfig_DefaultLocation) isRobotSettingsConfig_OneofDefaultLocation() {}

type isRobotSettingsConfig_OneofDistIsMetric interface {
	isRobotSettingsConfig_OneofDistIsMetric()
}

type RobotSettingsConfig_DistIsMetric struct {
	DistIsMetric bool `protobuf:"varint,5,opt,name=dist_is_metric,json=distIsMetric,proto3,oneof"`
}

func (*RobotSettingsConfig_DistIsMetric) isRobotSettingsConfig_OneofDistIsMetric() {}

type isRobotSettingsConfig_OneofLocale interface {
	isRobotSettingsConfig_OneofLocale()
}

type RobotSettingsConfig_Locale struct {
	Locale string `protobuf:"bytes,6,opt,name=locale,proto3,oneof"`
}

func (*RobotSettingsConfig_Locale) isRobotSettingsConfig_OneofLocale() {}

type isRobotSettingsConfig_OneofMasterVolume interface {
	isRobotSettingsConfig_OneofMasterVolume()
}

type RobotSettingsConfig_MasterVolume struct {
	MasterVolume Volume `protobuf:"varint,7,opt,name=master_volume,json=masterVolume,proto3,enum=Anki.Vector.external_interface.Volume,oneof"`
}

func (*RobotSettingsConfig_MasterVolume) isRobotSettingsConfig_OneofMasterVolume() {}

type isRobotSettingsConfig_OneofTempIsFahrenheit interface {
	isRobotSettingsConfig_OneofTempIsFahrenheit()
}

type RobotSettingsConfig_TempIsFahrenheit struct {
	TempIsFahrenheit bool `protobuf:"varint,8,opt,name=temp_is_fahrenheit,json=tempIsFahrenheit,proto3,oneof"`
}

func (*RobotSettingsConfig_TempIsFahrenheit) isRobotSettingsConfig_OneofTempIsFahrenheit() {}

type isRobotSettingsConfig_OneofTimeZone interface {
	isRobotSettingsConfig_OneofTimeZone()
}

type RobotSettingsConfig_TimeZone struct {
	TimeZone string `protobuf:"bytes,9,opt,name=time_zone,json=timeZone,proto3,oneof"`
}

func (*RobotSettingsConfig_TimeZone) isRobotSettingsConfig_OneofTimeZone() {}

type isRobotSettingsConfig_OneofButtonWakeword interface {
	isRobotSettingsConfig_OneofButtonWakeword()
}

type RobotSettingsConfig_ButtonWakeword struct {
	ButtonWakeword ButtonWakeWord `protobuf:"varint,10,opt,name=button_wakeword,json=buttonWakeword,proto3,enum=Anki.Vector.external_interface.ButtonWakeWord,oneof"`
}

func (*RobotSettingsConfig_ButtonWakeword) isRobotSettingsConfig_OneofButtonWakeword() {}

type AccountSettingsConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to OneofDataCollection:
	//
	//	*AccountSettingsConfig_DataCollection
	OneofDataCollection isAccountSettingsConfig_OneofDataCollection `protobuf_oneof:"oneof_data_collection"`
	// Types that are valid to be assigned to OneofAppLocale:
	//
	//	*AccountSettingsConfig_AppLocale
	OneofAppLocale isAccountSettingsConfig_OneofAppLocale `protobuf_oneof:"oneof_app_locale"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*AccountSettingsConfig) ProtoMessage() {}

func (x *AccountSettingsConfig) ProtoReflect() protoreflect.Message {
	mi := &file_settings_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 AccountSettingsConfig.ProtoReflect.Descriptor instead.
func (*AccountSettingsConfig) Descriptor() ([]byte, []int) {
	return file_settings_proto_rawDescGZIP(), []int{2}
}

func (x *AccountSettingsConfig) GetOneofDataCollection() isAccountSettingsConfig_OneofDataCollection {
	if x != nil {
		return x.OneofDataCollection
	}
	return nil
}

func (x *AccountSettingsConfig) GetDataCollection() bool {
	if x != nil {
		if x, ok := x.OneofDataCollection.(*AccountSettingsConfig_DataCollection); ok {
			return x.DataCollection
		}
	}
	return false
}

func (x *AccountSettingsConfig) GetOneofAppLocale() isAccountSettingsConfig_OneofAppLocale {
	if x != nil {
		return x.OneofAppLocale
	}
	return nil
}

func (x *AccountSettingsConfig) GetAppLocale() string {
	if x != nil {
		if x, ok := x.OneofAppLocale.(*AccountSettingsConfig_AppLocale); ok {
			return x.AppLocale
		}
	}
	return ""
}

type isAccountSettingsConfig_OneofDataCollection interface {
	isAccountSettingsConfig_OneofDataCollection()
}

type AccountSettingsConfig_DataCollection struct {
	DataCollection bool `protobuf:"varint,1,opt,name=data_collection,json=dataCollection,proto3,oneof"`
}

func (*AccountSettingsConfig_DataCollection) isAccountSettingsConfig_OneofDataCollection() {}

type isAccountSettingsConfig_OneofAppLocale interface {
	isAccountSettingsConfig_OneofAppLocale()
}

type AccountSettingsConfig_AppLocale struct {
	AppLocale string `protobuf:"bytes,2,opt,name=app_locale,json=appLocale,proto3,oneof"`
}

func (*AccountSettingsConfig_AppLocale) isAccountSettingsConfig_OneofAppLocale() {}

type UserEntitlementsConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to OneofKickstarterEyes:
	//
	//	*UserEntitlementsConfig_KickstarterEyes
	OneofKickstarterEyes isUserEntitlementsConfig_OneofKickstarterEyes `protobuf_oneof:"oneof_kickstarter_eyes"`
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

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

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

func (*UserEntitlementsConfig) ProtoMessage() {}

func (x *UserEntitlementsConfig) ProtoReflect() protoreflect.Message {
	mi := &file_settings_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 UserEntitlementsConfig.ProtoReflect.Descriptor instead.
func (*UserEntitlementsConfig) Descriptor() ([]byte, []int) {
	return file_settings_proto_rawDescGZIP(), []int{3}
}

func (x *UserEntitlementsConfig) GetOneofKickstarterEyes() isUserEntitlementsConfig_OneofKickstarterEyes {
	if x != nil {
		return x.OneofKickstarterEyes
	}
	return nil
}

func (x *UserEntitlementsConfig) GetKickstarterEyes() bool {
	if x != nil {
		if x, ok := x.OneofKickstarterEyes.(*UserEntitlementsConfig_KickstarterEyes); ok {
			return x.KickstarterEyes
		}
	}
	return false
}

type isUserEntitlementsConfig_OneofKickstarterEyes interface {
	isUserEntitlementsConfig_OneofKickstarterEyes()
}

type UserEntitlementsConfig_KickstarterEyes struct {
	KickstarterEyes bool `protobuf:"varint,1,opt,name=kickstarter_eyes,json=kickstarterEyes,proto3,oneof"`
}

func (*UserEntitlementsConfig_KickstarterEyes) isUserEntitlementsConfig_OneofKickstarterEyes() {}

type Jdoc struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	DocVersion     uint64                 `protobuf:"varint,1,opt,name=doc_version,json=docVersion,proto3" json:"doc_version,omitempty"`
	FmtVersion     uint64                 `protobuf:"varint,2,opt,name=fmt_version,json=fmtVersion,proto3" json:"fmt_version,omitempty"`
	ClientMetadata string                 `protobuf:"bytes,3,opt,name=client_metadata,json=clientMetadata,proto3" json:"client_metadata,omitempty"`
	JsonDoc        string                 `protobuf:"bytes,4,opt,name=json_doc,json=jsonDoc,proto3" json:"json_doc,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*Jdoc) ProtoMessage() {}

func (x *Jdoc) ProtoReflect() protoreflect.Message {
	mi := &file_settings_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 Jdoc.ProtoReflect.Descriptor instead.
func (*Jdoc) Descriptor() ([]byte, []int) {
	return file_settings_proto_rawDescGZIP(), []int{4}
}

func (x *Jdoc) GetDocVersion() uint64 {
	if x != nil {
		return x.DocVersion
	}
	return 0
}

func (x *Jdoc) GetFmtVersion() uint64 {
	if x != nil {
		return x.FmtVersion
	}
	return 0
}

func (x *Jdoc) GetClientMetadata() string {
	if x != nil {
		return x.ClientMetadata
	}
	return ""
}

func (x *Jdoc) GetJsonDoc() string {
	if x != nil {
		return x.JsonDoc
	}
	return ""
}

type NamedJdoc struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	JdocType      JdocType               `protobuf:"varint,1,opt,name=jdoc_type,json=jdocType,proto3,enum=Anki.Vector.external_interface.JdocType" json:"jdoc_type,omitempty"`
	Doc           *Jdoc                  `protobuf:"bytes,2,opt,name=doc,proto3" json:"doc,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*NamedJdoc) ProtoMessage() {}

func (x *NamedJdoc) ProtoReflect() protoreflect.Message {
	mi := &file_settings_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 NamedJdoc.ProtoReflect.Descriptor instead.
func (*NamedJdoc) Descriptor() ([]byte, []int) {
	return file_settings_proto_rawDescGZIP(), []int{5}
}

func (x *NamedJdoc) GetJdocType() JdocType {
	if x != nil {
		return x.JdocType
	}
	return JdocType_ROBOT_SETTINGS
}

func (x *NamedJdoc) GetDoc() *Jdoc {
	if x != nil {
		return x.Doc
	}
	return nil
}

type PullJdocsRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	JdocTypes     []JdocType             `protobuf:"varint,1,rep,packed,name=jdoc_types,json=jdocTypes,proto3,enum=Anki.Vector.external_interface.JdocType" json:"jdoc_types,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PullJdocsRequest) ProtoMessage() {}

func (x *PullJdocsRequest) ProtoReflect() protoreflect.Message {
	mi := &file_settings_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 PullJdocsRequest.ProtoReflect.Descriptor instead.
func (*PullJdocsRequest) Descriptor() ([]byte, []int) {
	return file_settings_proto_rawDescGZIP(), []int{6}
}

func (x *PullJdocsRequest) GetJdocTypes() []JdocType {
	if x != nil {
		return x.JdocTypes
	}
	return nil
}

type PullJdocsResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Status        *ResponseStatus        `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	NamedJdocs    []*NamedJdoc           `protobuf:"bytes,2,rep,name=named_jdocs,json=namedJdocs,proto3" json:"named_jdocs,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PullJdocsResponse) ProtoMessage() {}

func (x *PullJdocsResponse) ProtoReflect() protoreflect.Message {
	mi := &file_settings_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 PullJdocsResponse.ProtoReflect.Descriptor instead.
func (*PullJdocsResponse) Descriptor() ([]byte, []int) {
	return file_settings_proto_rawDescGZIP(), []int{7}
}

func (x *PullJdocsResponse) GetStatus() *ResponseStatus {
	if x != nil {
		return x.Status
	}
	return nil
}

func (x *PullJdocsResponse) GetNamedJdocs() []*NamedJdoc {
	if x != nil {
		return x.NamedJdocs
	}
	return nil
}

type UpdateSettingsRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Settings      *RobotSettingsConfig   `protobuf:"bytes,1,opt,name=settings,proto3" json:"settings,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UpdateSettingsRequest) ProtoMessage() {}

func (x *UpdateSettingsRequest) ProtoReflect() protoreflect.Message {
	mi := &file_settings_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 UpdateSettingsRequest.ProtoReflect.Descriptor instead.
func (*UpdateSettingsRequest) Descriptor() ([]byte, []int) {
	return file_settings_proto_rawDescGZIP(), []int{8}
}

func (x *UpdateSettingsRequest) GetSettings() *RobotSettingsConfig {
	if x != nil {
		return x.Settings
	}
	return nil
}

type UpdateSettingsResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Status        *ResponseStatus        `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	Code          ResultCode             `protobuf:"varint,2,opt,name=code,proto3,enum=Anki.Vector.external_interface.ResultCode" json:"code,omitempty"`
	Doc           *Jdoc                  `protobuf:"bytes,3,opt,name=doc,proto3" json:"doc,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UpdateSettingsResponse) ProtoMessage() {}

func (x *UpdateSettingsResponse) ProtoReflect() protoreflect.Message {
	mi := &file_settings_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 UpdateSettingsResponse.ProtoReflect.Descriptor instead.
func (*UpdateSettingsResponse) Descriptor() ([]byte, []int) {
	return file_settings_proto_rawDescGZIP(), []int{9}
}

func (x *UpdateSettingsResponse) GetStatus() *ResponseStatus {
	if x != nil {
		return x.Status
	}
	return nil
}

func (x *UpdateSettingsResponse) GetCode() ResultCode {
	if x != nil {
		return x.Code
	}
	return ResultCode_SETTINGS_ACCEPTED
}

func (x *UpdateSettingsResponse) GetDoc() *Jdoc {
	if x != nil {
		return x.Doc
	}
	return nil
}

type UpdateAccountSettingsRequest struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	AccountSettings *AccountSettingsConfig `protobuf:"bytes,1,opt,name=account_settings,json=accountSettings,proto3" json:"account_settings,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*UpdateAccountSettingsRequest) ProtoMessage() {}

func (x *UpdateAccountSettingsRequest) ProtoReflect() protoreflect.Message {
	mi := &file_settings_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 UpdateAccountSettingsRequest.ProtoReflect.Descriptor instead.
func (*UpdateAccountSettingsRequest) Descriptor() ([]byte, []int) {
	return file_settings_proto_rawDescGZIP(), []int{10}
}

func (x *UpdateAccountSettingsRequest) GetAccountSettings() *AccountSettingsConfig {
	if x != nil {
		return x.AccountSettings
	}
	return nil
}

type UpdateAccountSettingsResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Status        *ResponseStatus        `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	Code          ResultCode             `protobuf:"varint,2,opt,name=code,proto3,enum=Anki.Vector.external_interface.ResultCode" json:"code,omitempty"`
	Doc           *Jdoc                  `protobuf:"bytes,3,opt,name=doc,proto3" json:"doc,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UpdateAccountSettingsResponse) ProtoMessage() {}

func (x *UpdateAccountSettingsResponse) ProtoReflect() protoreflect.Message {
	mi := &file_settings_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 UpdateAccountSettingsResponse.ProtoReflect.Descriptor instead.
func (*UpdateAccountSettingsResponse) Descriptor() ([]byte, []int) {
	return file_settings_proto_rawDescGZIP(), []int{11}
}

func (x *UpdateAccountSettingsResponse) GetStatus() *ResponseStatus {
	if x != nil {
		return x.Status
	}
	return nil
}

func (x *UpdateAccountSettingsResponse) GetCode() ResultCode {
	if x != nil {
		return x.Code
	}
	return ResultCode_SETTINGS_ACCEPTED
}

func (x *UpdateAccountSettingsResponse) GetDoc() *Jdoc {
	if x != nil {
		return x.Doc
	}
	return nil
}

type UpdateUserEntitlementsRequest struct {
	state            protoimpl.MessageState  `protogen:"open.v1"`
	UserEntitlements *UserEntitlementsConfig `protobuf:"bytes,1,opt,name=user_entitlements,json=userEntitlements,proto3" json:"user_entitlements,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*UpdateUserEntitlementsRequest) ProtoMessage() {}

func (x *UpdateUserEntitlementsRequest) ProtoReflect() protoreflect.Message {
	mi := &file_settings_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 UpdateUserEntitlementsRequest.ProtoReflect.Descriptor instead.
func (*UpdateUserEntitlementsRequest) Descriptor() ([]byte, []int) {
	return file_settings_proto_rawDescGZIP(), []int{12}
}

func (x *UpdateUserEntitlementsRequest) GetUserEntitlements() *UserEntitlementsConfig {
	if x != nil {
		return x.UserEntitlements
	}
	return nil
}

type UpdateUserEntitlementsResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Status        *ResponseStatus        `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	Code          ResultCode             `protobuf:"varint,2,opt,name=code,proto3,enum=Anki.Vector.external_interface.ResultCode" json:"code,omitempty"`
	Doc           *Jdoc                  `protobuf:"bytes,3,opt,name=doc,proto3" json:"doc,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UpdateUserEntitlementsResponse) ProtoMessage() {}

func (x *UpdateUserEntitlementsResponse) ProtoReflect() protoreflect.Message {
	mi := &file_settings_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 UpdateUserEntitlementsResponse.ProtoReflect.Descriptor instead.
func (*UpdateUserEntitlementsResponse) Descriptor() ([]byte, []int) {
	return file_settings_proto_rawDescGZIP(), []int{13}
}

func (x *UpdateUserEntitlementsResponse) GetStatus() *ResponseStatus {
	if x != nil {
		return x.Status
	}
	return nil
}

func (x *UpdateUserEntitlementsResponse) GetCode() ResultCode {
	if x != nil {
		return x.Code
	}
	return ResultCode_SETTINGS_ACCEPTED
}

func (x *UpdateUserEntitlementsResponse) GetDoc() *Jdoc {
	if x != nil {
		return x.Doc
	}
	return nil
}

type JdocsChanged struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	JdocTypes     []JdocType             `protobuf:"varint,1,rep,packed,name=jdoc_types,json=jdocTypes,proto3,enum=Anki.Vector.external_interface.JdocType" json:"jdoc_types,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*JdocsChanged) ProtoMessage() {}

func (x *JdocsChanged) ProtoReflect() protoreflect.Message {
	mi := &file_settings_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 JdocsChanged.ProtoReflect.Descriptor instead.
func (*JdocsChanged) Descriptor() ([]byte, []int) {
	return file_settings_proto_rawDescGZIP(), []int{14}
}

func (x *JdocsChanged) GetJdocTypes() []JdocType {
	if x != nil {
		return x.JdocTypes
	}
	return nil
}

var File_settings_proto protoreflect.FileDescriptor

const file_settings_proto_rawDesc = "" +
	"\n" +
	"\x0esettings.proto\x12\x1eAnki.Vector.external_interface\x1a\x15response_status.proto\"\\\n" +
	"\x0eCustomEyeColor\x12\x10\n" +
	"\x03hue\x18\x01 \x01(\x02R\x03hue\x12\x1e\n" +
	"\n" +
	"saturation\x18\x02 \x01(\x02R\n" +
	"saturation\x12\x18\n" +
	"\aenabled\x18\x03 \x01(\bR\aenabled\"\xad\x06\n" +
	"\x13RobotSettingsConfig\x12$\n" +
	"\rclock_24_hour\x18\x01 \x01(\bH\x00R\vclock24Hour\x12G\n" +
	"\teye_color\x18\x02 \x01(\x0e2(.Anki.Vector.external_interface.EyeColorH\x01R\beyeColor\x12Z\n" +
	"\x10custom_eye_color\x18\x03 \x01(\v2..Anki.Vector.external_interface.CustomEyeColorH\x02R\x0ecustomEyeColor\x12+\n" +
	"\x10default_location\x18\x04 \x01(\tH\x03R\x0fdefaultLocation\x12&\n" +
	"\x0edist_is_metric\x18\x05 \x01(\bH\x04R\fdistIsMetric\x12\x18\n" +
	"\x06locale\x18\x06 \x01(\tH\x05R\x06locale\x12M\n" +
	"\rmaster_volume\x18\a \x01(\x0e2&.Anki.Vector.external_interface.VolumeH\x06R\fmasterVolume\x12.\n" +
	"\x12temp_is_fahrenheit\x18\b \x01(\bH\aR\x10tempIsFahrenheit\x12\x1d\n" +
	"\ttime_zone\x18\t \x01(\tH\bR\btimeZone\x12Y\n" +
	"\x0fbutton_wakeword\x18\n" +
	" \x01(\x0e2..Anki.Vector.external_interface.ButtonWakeWordH\tR\x0ebuttonWakewordB\x15\n" +
	"\x13oneof_clock_24_hourB\x11\n" +
	"\x0foneof_eye_colorB\x18\n" +
	"\x16oneof_custom_eye_colorB\x18\n" +
	"\x16oneof_default_locationB\x16\n" +
	"\x14oneof_dist_is_metricB\x0e\n" +
	"\foneof_localeB\x15\n" +
	"\x13oneof_master_volumeB\x1a\n" +
	"\x18oneof_temp_is_fahrenheitB\x11\n" +
	"\x0foneof_time_zoneB\x17\n" +
	"\x15oneof_button_wakeword\"\x90\x01\n" +
	"\x15AccountSettingsConfig\x12)\n" +
	"\x0fdata_collection\x18\x01 \x01(\bH\x00R\x0edataCollection\x12\x1f\n" +
	"\n" +
	"app_locale\x18\x02 \x01(\tH\x01R\tappLocaleB\x17\n" +
	"\x15oneof_data_collectionB\x12\n" +
	"\x10oneof_app_locale\"_\n" +
	"\x16UserEntitlementsConfig\x12+\n" +
	"\x10kickstarter_eyes\x18\x01 \x01(\bH\x00R\x0fkickstarterEyesB\x18\n" +
	"\x16oneof_kickstarter_eyes\"\x8c\x01\n" +
	"\x04Jdoc\x12\x1f\n" +
	"\vdoc_version\x18\x01 \x01(\x04R\n" +
	"docVersion\x12\x1f\n" +
	"\vfmt_version\x18\x02 \x01(\x04R\n" +
	"fmtVersion\x12'\n" +
	"\x0fclient_metadata\x18\x03 \x01(\tR\x0eclientMetadata\x12\x19\n" +
	"\bjson_doc\x18\x04 \x01(\tR\ajsonDoc\"\x8a\x01\n" +
	"\tNamedJdoc\x12E\n" +
	"\tjdoc_type\x18\x01 \x01(\x0e2(.Anki.Vector.external_interface.JdocTypeR\bjdocType\x126\n" +
	"\x03doc\x18\x02 \x01(\v2$.Anki.Vector.external_interface.JdocR\x03doc\"[\n" +
	"\x10PullJdocsRequest\x12G\n" +
	"\n" +
	"jdoc_types\x18\x01 \x03(\x0e2(.Anki.Vector.external_interface.JdocTypeR\tjdocTypes\"\xa7\x01\n" +
	"\x11PullJdocsResponse\x12F\n" +
	"\x06status\x18\x01 \x01(\v2..Anki.Vector.external_interface.ResponseStatusR\x06status\x12J\n" +
	"\vnamed_jdocs\x18\x02 \x03(\v2).Anki.Vector.external_interface.NamedJdocR\n" +
	"namedJdocs\"h\n" +
	"\x15UpdateSettingsRequest\x12O\n" +
	"\bsettings\x18\x01 \x01(\v23.Anki.Vector.external_interface.RobotSettingsConfigR\bsettings\"\xd8\x01\n" +
	"\x16UpdateSettingsResponse\x12F\n" +
	"\x06status\x18\x01 \x01(\v2..Anki.Vector.external_interface.ResponseStatusR\x06status\x12>\n" +
	"\x04code\x18\x02 \x01(\x0e2*.Anki.Vector.external_interface.ResultCodeR\x04code\x126\n" +
	"\x03doc\x18\x03 \x01(\v2$.Anki.Vector.external_interface.JdocR\x03doc\"\x80\x01\n" +
	"\x1cUpdateAccountSettingsRequest\x12`\n" +
	"\x10account_settings\x18\x01 \x01(\v25.Anki.Vector.external_interface.AccountSettingsConfigR\x0faccountSettings\"\xdf\x01\n" +
	"\x1dUpdateAccountSettingsResponse\x12F\n" +
	"\x06status\x18\x01 \x01(\v2..Anki.Vector.external_interface.ResponseStatusR\x06status\x12>\n" +
	"\x04code\x18\x02 \x01(\x0e2*.Anki.Vector.external_interface.ResultCodeR\x04code\x126\n" +
	"\x03doc\x18\x03 \x01(\v2$.Anki.Vector.external_interface.JdocR\x03doc\"\x84\x01\n" +
	"\x1dUpdateUserEntitlementsRequest\x12c\n" +
	"\x11user_entitlements\x18\x01 \x01(\v26.Anki.Vector.external_interface.UserEntitlementsConfigR\x10userEntitlements\"\xe0\x01\n" +
	"\x1eUpdateUserEntitlementsResponse\x12F\n" +
	"\x06status\x18\x01 \x01(\v2..Anki.Vector.external_interface.ResponseStatusR\x06status\x12>\n" +
	"\x04code\x18\x02 \x01(\x0e2*.Anki.Vector.external_interface.ResultCodeR\x04code\x126\n" +
	"\x03doc\x18\x03 \x01(\v2$.Anki.Vector.external_interface.JdocR\x03doc\"W\n" +
	"\fJdocsChanged\x12G\n" +
	"\n" +
	"jdoc_types\x18\x01 \x03(\x0e2(.Anki.Vector.external_interface.JdocTypeR\tjdocTypes*%\n" +
	"\n" +
	"ApiVersion\x12\v\n" +
	"\aINVALID\x10\x00\x12\n" +
	"\n" +
	"\x06LATEST\x10\x01*R\n" +
	"\x06Volume\x12\b\n" +
	"\x04MUTE\x10\x00\x12\a\n" +
	"\x03LOW\x10\x01\x12\x0e\n" +
	"\n" +
	"MEDIUM_LOW\x10\x02\x12\n" +
	"\n" +
	"\x06MEDIUM\x10\x03\x12\x0f\n" +
	"\vMEDIUM_HIGH\x10\x04\x12\b\n" +
	"\x04HIGH\x10\x05*e\n" +
	"\bJdocType\x12\x12\n" +
	"\x0eROBOT_SETTINGS\x10\x00\x12\x18\n" +
	"\x14ROBOT_LIFETIME_STATS\x10\x01\x12\x14\n" +
	"\x10ACCOUNT_SETTINGS\x10\x02\x12\x15\n" +
	"\x11USER_ENTITLEMENTS\x10\x03*;\n" +
	"\x11JdocResolveMethod\x12\x11\n" +
	"\rPUSH_TO_CLOUD\x10\x00\x12\x13\n" +
	"\x0fPULL_FROM_CLOUD\x10\x01*\xcb\x01\n" +
	"\fRobotSetting\x12\x11\n" +
	"\rclock_24_hour\x10\x00\x12\r\n" +
	"\teye_color\x10\x01\x12\x14\n" +
	"\x10custom_eye_color\x10\x02\x12\x14\n" +
	"\x10default_location\x10\x03\x12\x12\n" +
	"\x0edist_is_metric\x10\x04\x12\n" +
	"\n" +
	"\x06locale\x10\x05\x12\x11\n" +
	"\rmaster_volume\x10\x06\x12\x16\n" +
	"\x12temp_is_fahrenheit\x10\a\x12\r\n" +
	"\ttime_zone\x10\b\x12\x13\n" +
	"\x0fbutton_wakeword\x10\t*\xcc\x01\n" +
	"\bEyeColor\x12\x11\n" +
	"\rTIP_OVER_TEAL\x10\x00\x12\x12\n" +
	"\x0eOVERFIT_ORANGE\x10\x01\x12\x12\n" +
	"\x0eUNCANNY_YELLOW\x10\x02\x12\x13\n" +
	"\x0fNON_LINEAR_LIME\x10\x03\x12\x18\n" +
	"\x14SINGULARITY_SAPPHIRE\x10\x04\x12\x19\n" +
	"\x15FALSE_POSITIVE_PURPLE\x10\x05\x12\x1a\n" +
	"\x16CONFUSION_MATRIX_GREEN\x10\x06\x12\x10\n" +
	"\fRAINBOW_EYES\x10\a\x12\r\n" +
	"\tROBOT_RED\x10\b*K\n" +
	"\x0eButtonWakeWord\x12\x1e\n" +
	"\x1aBUTTON_WAKEWORD_HEY_VECTOR\x10\x00\x12\x19\n" +
	"\x15BUTTON_WAKEWORD_ALEXA\x10\x01*5\n" +
	"\x0eAccountSetting\x12\x13\n" +
	"\x0fDATA_COLLECTION\x10\x00\x12\x0e\n" +
	"\n" +
	"APP_LOCALE\x10\x01*'\n" +
	"\x0fUserEntitlement\x12\x14\n" +
	"\x10KICKSTARTER_EYES\x10\x00*A\n" +
	"\n" +
	"ResultCode\x12\x15\n" +
	"\x11SETTINGS_ACCEPTED\x10\x00\x12\x1c\n" +
	"\x18ERROR_UPDATE_IN_PROGRESS\x10\x01B Z\x1eAnki.Vector.external_interfaceb\x06proto3"

var (
	file_settings_proto_rawDescOnce sync.Once
	file_settings_proto_rawDescData []byte
)

func file_settings_proto_rawDescGZIP() []byte {
	file_settings_proto_rawDescOnce.Do(func() {
		file_settings_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_settings_proto_rawDesc), len(file_settings_proto_rawDesc)))
	})
	return file_settings_proto_rawDescData
}

var file_settings_proto_enumTypes = make([]protoimpl.EnumInfo, 10)
var file_settings_proto_msgTypes = make([]protoimpl.MessageInfo, 15)
var file_settings_proto_goTypes = []any{
	(ApiVersion)(0),                        // 0: Anki.Vector.external_interface.ApiVersion
	(Volume)(0),                            // 1: Anki.Vector.external_interface.Volume
	(JdocType)(0),                          // 2: Anki.Vector.external_interface.JdocType
	(JdocResolveMethod)(0),                 // 3: Anki.Vector.external_interface.JdocResolveMethod
	(RobotSetting)(0),                      // 4: Anki.Vector.external_interface.RobotSetting
	(EyeColor)(0),                          // 5: Anki.Vector.external_interface.EyeColor
	(ButtonWakeWord)(0),                    // 6: Anki.Vector.external_interface.ButtonWakeWord
	(AccountSetting)(0),                    // 7: Anki.Vector.external_interface.AccountSetting
	(UserEntitlement)(0),                   // 8: Anki.Vector.external_interface.UserEntitlement
	(ResultCode)(0),                        // 9: Anki.Vector.external_interface.ResultCode
	(*CustomEyeColor)(nil),                 // 10: Anki.Vector.external_interface.CustomEyeColor
	(*RobotSettingsConfig)(nil),            // 11: Anki.Vector.external_interface.RobotSettingsConfig
	(*AccountSettingsConfig)(nil),          // 12: Anki.Vector.external_interface.AccountSettingsConfig
	(*UserEntitlementsConfig)(nil),         // 13: Anki.Vector.external_interface.UserEntitlementsConfig
	(*Jdoc)(nil),                           // 14: Anki.Vector.external_interface.Jdoc
	(*NamedJdoc)(nil),                      // 15: Anki.Vector.external_interface.NamedJdoc
	(*PullJdocsRequest)(nil),               // 16: Anki.Vector.external_interface.PullJdocsRequest
	(*PullJdocsResponse)(nil),              // 17: Anki.Vector.external_interface.PullJdocsResponse
	(*UpdateSettingsRequest)(nil),          // 18: Anki.Vector.external_interface.UpdateSettingsRequest
	(*UpdateSettingsResponse)(nil),         // 19: Anki.Vector.external_interface.UpdateSettingsResponse
	(*UpdateAccountSettingsRequest)(nil),   // 20: Anki.Vector.external_interface.UpdateAccountSettingsRequest
	(*UpdateAccountSettingsResponse)(nil),  // 21: Anki.Vector.external_interface.UpdateAccountSettingsResponse
	(*UpdateUserEntitlementsRequest)(nil),  // 22: Anki.Vector.external_interface.UpdateUserEntitlementsRequest
	(*UpdateUserEntitlementsResponse)(nil), // 23: Anki.Vector.external_interface.UpdateUserEntitlementsResponse
	(*JdocsChanged)(nil),                   // 24: Anki.Vector.external_interface.JdocsChanged
	(*ResponseStatus)(nil),                 // 25: Anki.Vector.external_interface.ResponseStatus
}
var file_settings_proto_depIdxs = []int32{
	5,  // 0: Anki.Vector.external_interface.RobotSettingsConfig.eye_color:type_name -> Anki.Vector.external_interface.EyeColor
	10, // 1: Anki.Vector.external_interface.RobotSettingsConfig.custom_eye_color:type_name -> Anki.Vector.external_interface.CustomEyeColor
	1,  // 2: Anki.Vector.external_interface.RobotSettingsConfig.master_volume:type_name -> Anki.Vector.external_interface.Volume
	6,  // 3: Anki.Vector.external_interface.RobotSettingsConfig.button_wakeword:type_name -> Anki.Vector.external_interface.ButtonWakeWord
	2,  // 4: Anki.Vector.external_interface.NamedJdoc.jdoc_type:type_name -> Anki.Vector.external_interface.JdocType
	14, // 5: Anki.Vector.external_interface.NamedJdoc.doc:type_name -> Anki.Vector.external_interface.Jdoc
	2,  // 6: Anki.Vector.external_interface.PullJdocsRequest.jdoc_types:type_name -> Anki.Vector.external_interface.JdocType
	25, // 7: Anki.Vector.external_interface.PullJdocsResponse.status:type_name -> Anki.Vector.external_interface.ResponseStatus
	15, // 8: Anki.Vector.external_interface.PullJdocsResponse.named_jdocs:type_name -> Anki.Vector.external_interface.NamedJdoc
	11, // 9: Anki.Vector.external_interface.UpdateSettingsRequest.settings:type_name -> Anki.Vector.external_interface.RobotSettingsConfig
	25, // 10: Anki.Vector.external_interface.UpdateSettingsResponse.status:type_name -> Anki.Vector.external_interface.ResponseStatus
	9,  // 11: Anki.Vector.external_interface.UpdateSettingsResponse.code:type_name -> Anki.Vector.external_interface.ResultCode
	14, // 12: Anki.Vector.external_interface.UpdateSettingsResponse.doc:type_name -> Anki.Vector.external_interface.Jdoc
	12, // 13: Anki.Vector.external_interface.UpdateAccountSettingsRequest.account_settings:type_name -> Anki.Vector.external_interface.AccountSettingsConfig
	25, // 14: Anki.Vector.external_interface.UpdateAccountSettingsResponse.status:type_name -> Anki.Vector.external_interface.ResponseStatus
	9,  // 15: Anki.Vector.external_interface.UpdateAccountSettingsResponse.code:type_name -> Anki.Vector.external_interface.ResultCode
	14, // 16: Anki.Vector.external_interface.UpdateAccountSettingsResponse.doc:type_name -> Anki.Vector.external_interface.Jdoc
	13, // 17: Anki.Vector.external_interface.UpdateUserEntitlementsRequest.user_entitlements:type_name -> Anki.Vector.external_interface.UserEntitlementsConfig
	25, // 18: Anki.Vector.external_interface.UpdateUserEntitlementsResponse.status:type_name -> Anki.Vector.external_interface.ResponseStatus
	9,  // 19: Anki.Vector.external_interface.UpdateUserEntitlementsResponse.code:type_name -> Anki.Vector.external_interface.ResultCode
	14, // 20: Anki.Vector.external_interface.UpdateUserEntitlementsResponse.doc:type_name -> Anki.Vector.external_interface.Jdoc
	2,  // 21: Anki.Vector.external_interface.JdocsChanged.jdoc_types:type_name -> Anki.Vector.external_interface.JdocType
	22, // [22:22] is the sub-list for method output_type
	22, // [22:22] is the sub-list for method input_type
	22, // [22:22] is the sub-list for extension type_name
	22, // [22:22] is the sub-list for extension extendee
	0,  // [0:22] is the sub-list for field type_name
}

func init() { file_settings_proto_init() }
func file_settings_proto_init() {
	if File_settings_proto != nil {
		return
	}
	file_response_status_proto_init()
	file_settings_proto_msgTypes[1].OneofWrappers = []any{
		(*RobotSettingsConfig_Clock_24Hour)(nil),
		(*RobotSettingsConfig_EyeColor)(nil),
		(*RobotSettingsConfig_CustomEyeColor)(nil),
		(*RobotSettingsConfig_DefaultLocation)(nil),
		(*RobotSettingsConfig_DistIsMetric)(nil),
		(*RobotSettingsConfig_Locale)(nil),
		(*RobotSettingsConfig_MasterVolume)(nil),
		(*RobotSettingsConfig_TempIsFahrenheit)(nil),
		(*RobotSettingsConfig_TimeZone)(nil),
		(*RobotSettingsConfig_ButtonWakeword)(nil),
	}
	file_settings_proto_msgTypes[2].OneofWrappers = []any{
		(*AccountSettingsConfig_DataCollection)(nil),
		(*AccountSettingsConfig_AppLocale)(nil),
	}
	file_settings_proto_msgTypes[3].OneofWrappers = []any{
		(*UserEntitlementsConfig_KickstarterEyes)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_settings_proto_rawDesc), len(file_settings_proto_rawDesc)),
			NumEnums:      10,
			NumMessages:   15,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_settings_proto_goTypes,
		DependencyIndexes: file_settings_proto_depIdxs,
		EnumInfos:         file_settings_proto_enumTypes,
		MessageInfos:      file_settings_proto_msgTypes,
	}.Build()
	File_settings_proto = out.File
	file_settings_proto_goTypes = nil
	file_settings_proto_depIdxs = nil
}