const _DayName = "DayMondayDayTuesdayDayWednesdayDayThursdayDayFridayDaySaturdayDaySunday"

var _DayIndex = [...]uint8{0, 9, 19, 31, 42, 51, 62, 71}

const _DayLowerName = "daymondaydaytuesdaydaywednesdaydaythursdaydayfridaydaysaturdaydaysunday"

func (i Day) string() (string, error) {
	if i < 0 || i >= Day(len(_DayIndex)-1) {
		return "", fmt.Errorf("value is out of enum range")
	}
	return _DayName[_DayIndex[i]:_DayIndex[i+1]], nil
}

func (i Day) String() string {
	val, _ := i.string()
	return val
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _DayNoOp() {
	var x [1]struct{}
	_ = x[Monday-(0)]
	_ = x[Tuesday-(1)]
	_ = x[Wednesday-(2)]
	_ = x[Thursday-(3)]
	_ = x[Friday-(4)]
	_ = x[Saturday-(5)]
	_ = x[Sunday-(6)]
}

var _DayValues = []Day{Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday}

var _DayNameToValueMap = map[string]Day{
	_DayName[0:9]:        Monday,
	_DayLowerName[0:9]:   Monday,
	_DayName[9:19]:       Tuesday,
	_DayLowerName[9:19]:  Tuesday,
	_DayName[19:31]:      Wednesday,
	_DayLowerName[19:31]: Wednesday,
	_DayName[31:42]:      Thursday,
	_DayLowerName[31:42]: Thursday,
	_DayName[42:51]:      Friday,
	_DayLowerName[42:51]: Friday,
	_DayName[51:62]:      Saturday,
	_DayLowerName[51:62]: Saturday,
	_DayName[62:71]:      Sunday,
	_DayLowerName[62:71]: Sunday,
}

var _DayNames = []string{
	_DayName[0:9],
	_DayName[9:19],
	_DayName[19:31],
	_DayName[31:42],
	_DayName[42:51],
	_DayName[51:62],
	_DayName[62:71],
}

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

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

// DayValues returns all values of the enum
func DayValues() []Day {
	return _DayValues
}

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

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