// Code generated by "enumer -type OutputKind,OutFormat,DiskFormat,SDBootEnrollKeys,BootloaderKind -linecomment -text"; DO NOT EDIT.

package profile

import (
	"fmt"
	"strings"
)

const _OutputKindName = "unknownisoimageinstallerkernelinitramfsukicmdline"

var _OutputKindIndex = [...]uint8{0, 7, 10, 15, 24, 30, 39, 42, 49}

const _OutputKindLowerName = "unknownisoimageinstallerkernelinitramfsukicmdline"

func (i OutputKind) String() string {
	if i < 0 || i >= OutputKind(len(_OutputKindIndex)-1) {
		return fmt.Sprintf("OutputKind(%d)", i)
	}
	return _OutputKindName[_OutputKindIndex[i]:_OutputKindIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _OutputKindNoOp() {
	var x [1]struct{}
	_ = x[OutKindUnknown-(0)]
	_ = x[OutKindISO-(1)]
	_ = x[OutKindImage-(2)]
	_ = x[OutKindInstaller-(3)]
	_ = x[OutKindKernel-(4)]
	_ = x[OutKindInitramfs-(5)]
	_ = x[OutKindUKI-(6)]
	_ = x[OutKindCmdline-(7)]
}

var _OutputKindValues = []OutputKind{OutKindUnknown, OutKindISO, OutKindImage, OutKindInstaller, OutKindKernel, OutKindInitramfs, OutKindUKI, OutKindCmdline}

var _OutputKindNameToValueMap = map[string]OutputKind{
	_OutputKindName[0:7]:        OutKindUnknown,
	_OutputKindLowerName[0:7]:   OutKindUnknown,
	_OutputKindName[7:10]:       OutKindISO,
	_OutputKindLowerName[7:10]:  OutKindISO,
	_OutputKindName[10:15]:      OutKindImage,
	_OutputKindLowerName[10:15]: OutKindImage,
	_OutputKindName[15:24]:      OutKindInstaller,
	_OutputKindLowerName[15:24]: OutKindInstaller,
	_OutputKindName[24:30]:      OutKindKernel,
	_OutputKindLowerName[24:30]: OutKindKernel,
	_OutputKindName[30:39]:      OutKindInitramfs,
	_OutputKindLowerName[30:39]: OutKindInitramfs,
	_OutputKindName[39:42]:      OutKindUKI,
	_OutputKindLowerName[39:42]: OutKindUKI,
	_OutputKindName[42:49]:      OutKindCmdline,
	_OutputKindLowerName[42:49]: OutKindCmdline,
}

var _OutputKindNames = []string{
	_OutputKindName[0:7],
	_OutputKindName[7:10],
	_OutputKindName[10:15],
	_OutputKindName[15:24],
	_OutputKindName[24:30],
	_OutputKindName[30:39],
	_OutputKindName[39:42],
	_OutputKindName[42:49],
}

// OutputKindString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func OutputKindString(s string) (OutputKind, error) {
	if val, ok := _OutputKindNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _OutputKindNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to OutputKind values", s)
}

// OutputKindValues returns all values of the enum
func OutputKindValues() []OutputKind {
	return _OutputKindValues
}

// OutputKindStrings returns a slice of all String values of the enum
func OutputKindStrings() []string {
	strs := make([]string, len(_OutputKindNames))
	copy(strs, _OutputKindNames)
	return strs
}

// IsAOutputKind returns "true" if the value is listed in the enum definition. "false" otherwise
func (i OutputKind) IsAOutputKind() bool {
	for _, v := range _OutputKindValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for OutputKind
func (i OutputKind) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for OutputKind
func (i *OutputKind) UnmarshalText(text []byte) error {
	var err error
	*i, err = OutputKindString(string(text))
	return err
}

const _OutFormatName = "unknownraw.tar.gz.xz.gz.zst"

var _OutFormatIndex = [...]uint8{0, 7, 10, 17, 20, 23, 27}

const _OutFormatLowerName = "unknownraw.tar.gz.xz.gz.zst"

func (i OutFormat) String() string {
	if i < 0 || i >= OutFormat(len(_OutFormatIndex)-1) {
		return fmt.Sprintf("OutFormat(%d)", i)
	}
	return _OutFormatName[_OutFormatIndex[i]:_OutFormatIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _OutFormatNoOp() {
	var x [1]struct{}
	_ = x[OutFormatUnknown-(0)]
	_ = x[OutFormatRaw-(1)]
	_ = x[OutFormatTar-(2)]
	_ = x[OutFormatXZ-(3)]
	_ = x[OutFormatGZ-(4)]
	_ = x[OutFormatZSTD-(5)]
}

var _OutFormatValues = []OutFormat{OutFormatUnknown, OutFormatRaw, OutFormatTar, OutFormatXZ, OutFormatGZ, OutFormatZSTD}

var _OutFormatNameToValueMap = map[string]OutFormat{
	_OutFormatName[0:7]:        OutFormatUnknown,
	_OutFormatLowerName[0:7]:   OutFormatUnknown,
	_OutFormatName[7:10]:       OutFormatRaw,
	_OutFormatLowerName[7:10]:  OutFormatRaw,
	_OutFormatName[10:17]:      OutFormatTar,
	_OutFormatLowerName[10:17]: OutFormatTar,
	_OutFormatName[17:20]:      OutFormatXZ,
	_OutFormatLowerName[17:20]: OutFormatXZ,
	_OutFormatName[20:23]:      OutFormatGZ,
	_OutFormatLowerName[20:23]: OutFormatGZ,
	_OutFormatName[23:27]:      OutFormatZSTD,
	_OutFormatLowerName[23:27]: OutFormatZSTD,
}

var _OutFormatNames = []string{
	_OutFormatName[0:7],
	_OutFormatName[7:10],
	_OutFormatName[10:17],
	_OutFormatName[17:20],
	_OutFormatName[20:23],
	_OutFormatName[23:27],
}

// OutFormatString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func OutFormatString(s string) (OutFormat, error) {
	if val, ok := _OutFormatNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _OutFormatNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to OutFormat values", s)
}

// OutFormatValues returns all values of the enum
func OutFormatValues() []OutFormat {
	return _OutFormatValues
}

// OutFormatStrings returns a slice of all String values of the enum
func OutFormatStrings() []string {
	strs := make([]string, len(_OutFormatNames))
	copy(strs, _OutFormatNames)
	return strs
}

// IsAOutFormat returns "true" if the value is listed in the enum definition. "false" otherwise
func (i OutFormat) IsAOutFormat() bool {
	for _, v := range _OutFormatValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for OutFormat
func (i OutFormat) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for OutFormat
func (i *OutFormat) UnmarshalText(text []byte) error {
	var err error
	*i, err = OutFormatString(string(text))
	return err
}

const _DiskFormatName = "unknownrawqcow2vhdova"

var _DiskFormatIndex = [...]uint8{0, 7, 10, 15, 18, 21}

const _DiskFormatLowerName = "unknownrawqcow2vhdova"

func (i DiskFormat) String() string {
	if i < 0 || i >= DiskFormat(len(_DiskFormatIndex)-1) {
		return fmt.Sprintf("DiskFormat(%d)", i)
	}
	return _DiskFormatName[_DiskFormatIndex[i]:_DiskFormatIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _DiskFormatNoOp() {
	var x [1]struct{}
	_ = x[DiskFormatUnknown-(0)]
	_ = x[DiskFormatRaw-(1)]
	_ = x[DiskFormatQCOW2-(2)]
	_ = x[DiskFormatVPC-(3)]
	_ = x[DiskFormatOVA-(4)]
}

var _DiskFormatValues = []DiskFormat{DiskFormatUnknown, DiskFormatRaw, DiskFormatQCOW2, DiskFormatVPC, DiskFormatOVA}

var _DiskFormatNameToValueMap = map[string]DiskFormat{
	_DiskFormatName[0:7]:        DiskFormatUnknown,
	_DiskFormatLowerName[0:7]:   DiskFormatUnknown,
	_DiskFormatName[7:10]:       DiskFormatRaw,
	_DiskFormatLowerName[7:10]:  DiskFormatRaw,
	_DiskFormatName[10:15]:      DiskFormatQCOW2,
	_DiskFormatLowerName[10:15]: DiskFormatQCOW2,
	_DiskFormatName[15:18]:      DiskFormatVPC,
	_DiskFormatLowerName[15:18]: DiskFormatVPC,
	_DiskFormatName[18:21]:      DiskFormatOVA,
	_DiskFormatLowerName[18:21]: DiskFormatOVA,
}

var _DiskFormatNames = []string{
	_DiskFormatName[0:7],
	_DiskFormatName[7:10],
	_DiskFormatName[10:15],
	_DiskFormatName[15:18],
	_DiskFormatName[18:21],
}

// DiskFormatString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func DiskFormatString(s string) (DiskFormat, error) {
	if val, ok := _DiskFormatNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _DiskFormatNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to DiskFormat values", s)
}

// DiskFormatValues returns all values of the enum
func DiskFormatValues() []DiskFormat {
	return _DiskFormatValues
}

// DiskFormatStrings returns a slice of all String values of the enum
func DiskFormatStrings() []string {
	strs := make([]string, len(_DiskFormatNames))
	copy(strs, _DiskFormatNames)
	return strs
}

// IsADiskFormat returns "true" if the value is listed in the enum definition. "false" otherwise
func (i DiskFormat) IsADiskFormat() bool {
	for _, v := range _DiskFormatValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for DiskFormat
func (i DiskFormat) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for DiskFormat
func (i *DiskFormat) UnmarshalText(text []byte) error {
	var err error
	*i, err = DiskFormatString(string(text))
	return err
}

const _SDBootEnrollKeysName = "if-safemanualforceoff"

var _SDBootEnrollKeysIndex = [...]uint8{0, 7, 13, 18, 21}

const _SDBootEnrollKeysLowerName = "if-safemanualforceoff"

func (i SDBootEnrollKeys) String() string {
	if i < 0 || i >= SDBootEnrollKeys(len(_SDBootEnrollKeysIndex)-1) {
		return fmt.Sprintf("SDBootEnrollKeys(%d)", i)
	}
	return _SDBootEnrollKeysName[_SDBootEnrollKeysIndex[i]:_SDBootEnrollKeysIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _SDBootEnrollKeysNoOp() {
	var x [1]struct{}
	_ = x[SDBootEnrollKeysIfSafe-(0)]
	_ = x[SDBootEnrollKeysManual-(1)]
	_ = x[SDBootEnrollKeysForce-(2)]
	_ = x[SDBootEnrollKeysOff-(3)]
}

var _SDBootEnrollKeysValues = []SDBootEnrollKeys{SDBootEnrollKeysIfSafe, SDBootEnrollKeysManual, SDBootEnrollKeysForce, SDBootEnrollKeysOff}

var _SDBootEnrollKeysNameToValueMap = map[string]SDBootEnrollKeys{
	_SDBootEnrollKeysName[0:7]:        SDBootEnrollKeysIfSafe,
	_SDBootEnrollKeysLowerName[0:7]:   SDBootEnrollKeysIfSafe,
	_SDBootEnrollKeysName[7:13]:       SDBootEnrollKeysManual,
	_SDBootEnrollKeysLowerName[7:13]:  SDBootEnrollKeysManual,
	_SDBootEnrollKeysName[13:18]:      SDBootEnrollKeysForce,
	_SDBootEnrollKeysLowerName[13:18]: SDBootEnrollKeysForce,
	_SDBootEnrollKeysName[18:21]:      SDBootEnrollKeysOff,
	_SDBootEnrollKeysLowerName[18:21]: SDBootEnrollKeysOff,
}

var _SDBootEnrollKeysNames = []string{
	_SDBootEnrollKeysName[0:7],
	_SDBootEnrollKeysName[7:13],
	_SDBootEnrollKeysName[13:18],
	_SDBootEnrollKeysName[18:21],
}

// SDBootEnrollKeysString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func SDBootEnrollKeysString(s string) (SDBootEnrollKeys, error) {
	if val, ok := _SDBootEnrollKeysNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _SDBootEnrollKeysNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to SDBootEnrollKeys values", s)
}

// SDBootEnrollKeysValues returns all values of the enum
func SDBootEnrollKeysValues() []SDBootEnrollKeys {
	return _SDBootEnrollKeysValues
}

// SDBootEnrollKeysStrings returns a slice of all String values of the enum
func SDBootEnrollKeysStrings() []string {
	strs := make([]string, len(_SDBootEnrollKeysNames))
	copy(strs, _SDBootEnrollKeysNames)
	return strs
}

// IsASDBootEnrollKeys returns "true" if the value is listed in the enum definition. "false" otherwise
func (i SDBootEnrollKeys) IsASDBootEnrollKeys() bool {
	for _, v := range _SDBootEnrollKeysValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for SDBootEnrollKeys
func (i SDBootEnrollKeys) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for SDBootEnrollKeys
func (i *SDBootEnrollKeys) UnmarshalText(text []byte) error {
	var err error
	*i, err = SDBootEnrollKeysString(string(text))
	return err
}

const _BootloaderKindName = "nonedual-bootsd-bootgrub"

var _BootloaderKindIndex = [...]uint8{0, 4, 13, 20, 24}

const _BootloaderKindLowerName = "nonedual-bootsd-bootgrub"

func (i BootloaderKind) String() string {
	if i < 0 || i >= BootloaderKind(len(_BootloaderKindIndex)-1) {
		return fmt.Sprintf("BootloaderKind(%d)", i)
	}
	return _BootloaderKindName[_BootloaderKindIndex[i]:_BootloaderKindIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _BootloaderKindNoOp() {
	var x [1]struct{}
	_ = x[BootLoaderKindNone-(0)]
	_ = x[BootLoaderKindDualBoot-(1)]
	_ = x[BootLoaderKindSDBoot-(2)]
	_ = x[BootLoaderKindGrub-(3)]
}

var _BootloaderKindValues = []BootloaderKind{BootLoaderKindNone, BootLoaderKindDualBoot, BootLoaderKindSDBoot, BootLoaderKindGrub}

var _BootloaderKindNameToValueMap = map[string]BootloaderKind{
	_BootloaderKindName[0:4]:        BootLoaderKindNone,
	_BootloaderKindLowerName[0:4]:   BootLoaderKindNone,
	_BootloaderKindName[4:13]:       BootLoaderKindDualBoot,
	_BootloaderKindLowerName[4:13]:  BootLoaderKindDualBoot,
	_BootloaderKindName[13:20]:      BootLoaderKindSDBoot,
	_BootloaderKindLowerName[13:20]: BootLoaderKindSDBoot,
	_BootloaderKindName[20:24]:      BootLoaderKindGrub,
	_BootloaderKindLowerName[20:24]: BootLoaderKindGrub,
}

var _BootloaderKindNames = []string{
	_BootloaderKindName[0:4],
	_BootloaderKindName[4:13],
	_BootloaderKindName[13:20],
	_BootloaderKindName[20:24],
}

// BootloaderKindString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func BootloaderKindString(s string) (BootloaderKind, error) {
	if val, ok := _BootloaderKindNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _BootloaderKindNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to BootloaderKind values", s)
}

// BootloaderKindValues returns all values of the enum
func BootloaderKindValues() []BootloaderKind {
	return _BootloaderKindValues
}

// BootloaderKindStrings returns a slice of all String values of the enum
func BootloaderKindStrings() []string {
	strs := make([]string, len(_BootloaderKindNames))
	copy(strs, _BootloaderKindNames)
	return strs
}

// IsABootloaderKind returns "true" if the value is listed in the enum definition. "false" otherwise
func (i BootloaderKind) IsABootloaderKind() bool {
	for _, v := range _BootloaderKindValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for BootloaderKind
func (i BootloaderKind) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for BootloaderKind
func (i *BootloaderKind) UnmarshalText(text []byte) error {
	var err error
	*i, err = BootloaderKindString(string(text))
	return err
}
