enuminf

type ActionTyper interface {
	BasicEnumer
	internalenuminf.ActionTyper
}

type AddCmdTyper interface {
	BasicEnumer
	internalenuminf.AddCmdTyper
}

type ApplyDefaultChmodCmdTyper interface {
	BasicEnumer
	internalenuminf.ApplyDefaultChmodCmdTyper
}

type ApplyDefaultConfigureCmdTyper interface {
	BasicEnumer
	internalenuminf.ApplyDefaultConfigureCmdTyper
}

type ApplyInstallFixCmdTyper interface {
	BasicEnumer
	internalenuminf.ApplyInstallFixCmdTyper
}

type BackupCmdTyper interface {
	BasicEnumer
	internalenuminf.BackupCmdTyper
}

type BaseCmdTyper interface {
	BasicEnumer
	internalenuminf.BaseCmdTyper
}

type BaseEnumer interface {
	SimpleEnumer
	NameValuer
	IsNameEqualer
	IsAnyNameOfChecker
	ToNumberStringer
	IsValidInvalidChecker
	BasicEnumValuer
	RangeNamesCsvGetter
	corejson.JsonMarshaller
	// contains filtered or unexported methods
}

type BasicByteContractsEnumer interface {
	BasicContractsEnumer
	IsValueByteEqualer
	IsAnyValueByteEqualer
	BasicByteEnumer
}

type BasicByteEnumContractsBinder interface {
	BasicByteContractsEnumer
	AsBasicByteEnumContractsBinder() BasicByteEnumContractsBinder
}

type BasicByteEnumContractsDelegateBinder interface {
	AsBasicByteEnumContractsDelegateBinder() BasicByteEnumContractsDelegateBinder
}

type BasicByteEnumer interface {
	UnmarshallEnumToValueByter
	MaxByte() byte
	MinByte() byte
	ValueByte() byte
	RangesByte() []byte
}

type BasicContractsEnumer interface {
	BasicEnumer
	TypeNameWithRangeNamesCsvGetter
}

type BasicEnumContractsBinder interface {
	BasicContractsEnumer
	AsBasicEnumContractsBinder() BasicEnumContractsBinder
}

type BasicEnumValuer interface {
	ValueByte() byte
	ValueInt() int
	ValueInt8() int8
	ValueInt16() int16
	ValueUInt16() uint16
	ValueInt32() int32
	// ValueString
	//
	//  alias for ToNumberStringer
	//  returns the value number as string format (no name)
	//
	// Example:
	//  - "1", "2" NOT "Name"
	ValueString() string // value in string format
}

type BasicEnumWithComparer interface {
	BasicEnumer
	IsBothEnumEqualer
}

type BasicEnumer interface {
	BaseEnumer
	EnumFormatter
	MinMaxAny() (min, max interface{})
	MinValueString() string
	MaxValueString() string
	MaxInt() int
	MinInt() int
	RangesDynamicMapGetter
	AllNameValues() []string
	OnlySupportedNamesErrorer
	IntegerEnumRangesGetter
	EnumType() EnumTyper
}

type BasicEnumerGetter interface {
	TypeBasicEnum() BasicEnumer
}

type BasicInt16ContractsEnumer interface {
	BasicContractsEnumer
	BasicInt16Enumer
	Int16ToEnumStringer
	IsValueInteger16Equaler
	IsAnyValueInteger16Equaler
}

type BasicInt16EnumContractsBinder interface {
	BasicInt16ContractsEnumer
	AsBasicIn16EnumContractsBinder() BasicInt16ContractsEnumer
}

type BasicInt16Enumer interface {
	UnmarshallEnumToValueInt16(jsonUnmarshallingValue []byte) (int16, error)
	MaxInt16() int16
	MinInt16() int16
	ValueInt16() int16
	RangesInt16() []int16
	ToEnumString(input int16) string
}

type BasicInt32ContractsEnumer interface {
	BasicContractsEnumer
	BasicInt32Enumer
	Int32ToEnumStringer
	IsValueInteger32Equaler
	IsAnyValueInteger32Equaler
}

type BasicInt32EnumContractsBinder interface {
	BasicInt32ContractsEnumer
	AsBasicInt32EnumContractsBinder() BasicInt32ContractsEnumer
}

type BasicInt32Enumer interface {
	UnmarshallEnumToValueInt32(jsonUnmarshallingValue []byte) (int32, error)
	MaxInt32() int32
	MinInt32() int32
	ValueInt32() int32
	RangesInt32() []int32
	ToEnumString(input int32) string
}

type BasicInt64Enumer interface {
	MaxInt64() int64
	MinInt64() int64
	ValueInt64() int64
	RangesInt64() []int64
}

type BasicInt8ContractsEnumer interface {
	BasicContractsEnumer
	BasicInt8Enumer
	Int8ToEnumStringer
	IsValueInteger8Equaler
	IsAnyValueInteger8Equaler
}

type BasicInt8EnumContractsBinder interface {
	BasicInt8ContractsEnumer
	AsBasicInt8EnumContractsBinder() BasicInt8EnumContractsBinder
}

type BasicInt8Enumer interface {
	UnmarshallEnumToValueInt8(jsonUnmarshallingValue []byte) (int8, error)
	MaxInt8() int8
	MinInt8() int8
	ValueInt8() int8
	RangesInt8() []int8
	ToEnumString(input int8) string
}

type BasicIntEnumer interface {
	MaxInt() int
	MinInt() int
	ValueInt() int
	RangesInt() []int
	ToEnumString(input int) string
}

type ByteEnumNamer interface {
	ValueByte() byte
	// contains filtered or unexported methods
}

type ByteEnumValuer interface {
	ValueByte() byte
}

type ByteToEnumStringer interface {
	ToByteEnumString(input byte) string
}

type ByteTypeEnumGetter interface {
	TypeEnum() BasicByteEnumContractsBinder
}

type ChangeDirCmdTyper interface {
	BasicEnumer
	internalenuminf.ChangeDirCmdTyper
}

type ChangePortCmdTyper interface {
	BasicEnumer
	internalenuminf.ChangePortCmdTyper
}

type CleanupCmdTyper interface {
	BasicEnumer
	internalenuminf.CleanupCmdTyper
}

type CompareBasicEnumer interface {
	IsEqual(enum BasicEnumer) bool
	IsLess(enum BasicEnumer) bool
	IsLessEqual(enum BasicEnumer) bool
	IsGreater(enum BasicEnumer) bool
	IsGreaterEqual(enum BasicEnumer) bool
	IsNotEqual(enum BasicEnumer) bool
}

type CompareByteEnumer interface {
	IsEqual(comparingValue byte) bool
	IsLess(comparingValue byte) bool
	IsLessEqual(comparingValue byte) bool
	IsGreater(comparingValue byte) bool
	IsGreaterEqual(comparingValue byte) bool
	IsNotEqual(comparingValue byte) bool
}

type CompareInt16Enumer interface {
	IsEqual(comparingValue int16) bool
	IsLess(comparingValue int16) bool
	IsLessEqual(comparingValue int16) bool
	IsGreater(comparingValue int16) bool
	IsGreaterEqual(comparingValue int16) bool
	IsNotEqual(comparingValue int16) bool
}

type CompareInt32Enumer interface {
	IsEqual(comparingValue int32) bool
	IsLess(comparingValue int32) bool
	IsLessEqual(comparingValue int32) bool
	IsGreater(comparingValue int32) bool
	IsGreaterEqual(comparingValue int32) bool
	IsNotEqual(comparingValue int32) bool
}

type CompareInt8Enumer interface {
	IsEqual(comparingValue int8) bool
	IsLess(comparingValue int8) bool
	IsLessEqual(comparingValue int8) bool
	IsGreater(comparingValue int8) bool
	IsGreaterEqual(comparingValue int8) bool
	IsNotEqual(comparingValue int8) bool
}

type CompareIntegerEnumer interface {
	IsEqual(comparingValue int) bool
	IsLess(comparingValue int) bool
	IsLessEqual(comparingValue int) bool
	IsGreater(comparingValue int) bool
	IsGreaterEqual(comparingValue int) bool
	IsNotEqual(comparingValue int) bool
}

type CompareMethodsTyper interface {
	BasicEnumer
	internalenuminf.CompareMethodsTyper
}

type CompletionStateTyper interface {
	BasicEnumer
	internalenuminf.CompletionStateTyper
}

type CompressCmdTyper interface {
	BasicEnumer
	internalenuminf.CompressCmdTyper
}

type CreateCmdTyper interface {
	BasicEnumer
	internalenuminf.CreateCmdTyper
}

type CrudTyper interface {
	BasicEnumer
	internalenuminf.CrudTyper
}

type DecompressCmdTyper interface {
	BasicEnumer
	internalenuminf.DecompressCmdTyper
}

type DownloadCmdTyper interface {
	BasicEnumer
	internalenuminf.DownloadCmdTyper
}

type DownloadDecompressCmdTyper interface {
	BasicEnumer
	internalenuminf.DownloadDecompressCmdTyper
}

type EnumFormatter interface {
	// Format
	//
	//  Outputs name and
	//  value by given format.
	//
	// sample-format :
	//  - "Enum of {type-name} - {name} - {value}"
	//
	// sample-format-output :
	//  - "Enum of EnumFullName - Invalid - 0"
	//
	// Key-Meaning :
	//  - {type-name} : represents type-name string
	//  - {name}      : represents name string
	//  - {value}     : represents value string
	Format(format string) (compiled string)
}

type EnumTypeChecker interface {
	IsBoolean() bool
	IsByte() bool
	IsUnsignedInteger16() bool
	IsUnsignedInteger32() bool
	IsUnsignedInteger64() bool
	IsInteger8() bool
	IsInteger16() bool
	IsInteger32() bool
	IsInteger64() bool
	IsInteger() bool
	IsString() bool
	// IsNumber
	//
	// Any number returns true
	IsNumber() bool
	IsAnyInteger() bool
	IsAnyUnsignedNumber() bool
	IsValidInvalidChecker
}

type EnumTyper interface {
	EnumTypeChecker

	NameValuer
	IsNameEqualer
	IsAnyNameOfChecker
	ValueByte() byte
	Value() byte
	ToNumberStringer
	// contains filtered or unexported methods
}

type EnvironmentFlagTyper interface {
	BasicEnumer
	internalenuminf.EnvironmentFlagTyper
}

type EnvironmentOptioner interface {
	EnvTyper() EnvironmentTyper
	FlagTyper() EnvironmentFlagTyper
}

type EnvironmentTyper interface {
	BasicEnumer
	internalenuminf.EnvironmentTyper
}

type ErrorStringGetter interface {
	internalinterface.ErrorStringGetter
}

type EventTyper interface {
	BasicEnumer
	internalenuminf.EventTyper
}

type EventTyperGetter interface {
	EventTyper() EventTyper
}

type ExportCmdTyper interface {
	BasicEnumer
	internalenuminf.ExportCmdTyper
}

type HelpCmdTyper interface {
	BasicEnumer
	internalenuminf.HelpCmdTyper
}

type HistoriesCmdTyper interface {
	BasicEnumer
	internalenuminf.HistoriesCmdTyper
}

type HttpMethodTyper interface {
	BasicEnumer
	internalenuminf.HttpMethodTyper
}

type ImportCmdTyper interface {
	BasicEnumer
	internalenuminf.ImportCmdTyper
}

type ImportExportBackupCmdTyper interface {
	BasicEnumer
	internalenuminf.ImportExportBackupCmdTyper
}

type InstallCmdTyper interface {
	BasicEnumer
	internalenuminf.InstallCmdTyper
}

type Int16EnumNamer interface {
	ValueInt16() int16
	// contains filtered or unexported methods
}

type Int16ToEnumStringer interface {
	ToInt16EnumString(input int16) string
}

type Int32EnumNamer interface {
	ValueInt32() int32
	// contains filtered or unexported methods
}

type Int32ToEnumStringer interface {
	ToInt32EnumString(input int32) string
}

type Int8EnumNamer interface {
	ValueInt8() int8
	// contains filtered or unexported methods
}

type Int8ToEnumStringer interface {
	ToInt8EnumString(input int8) string
}

type IntToEnumStringer interface {
	ToIntEnumString(input int) string
}

type IntegerEnumRangesGetter interface {
	IntegerEnumRanges() []int
}

type IsAnyEnumsEqualer interface {
	IsAnyEnumsEqual(enums ...BasicEnumer) bool
}

type IsAnyNameOfChecker interface {
	// IsAnyNamesOf
	//
	//  Returns true if any of the name matches.
	IsAnyNamesOf(names ...string) bool
}

type IsAnyValueByteEqualer interface {
	IsAnyValuesEqual(anyByteValues ...byte) bool
}

type IsAnyValueInteger16Equaler interface {
	IsAnyValuesEqual(anyValues ...int16) bool
}

type IsAnyValueInteger32Equaler interface {
	IsAnyValuesEqual(anyValues ...int32) bool
}

type IsAnyValueInteger8Equaler interface {
	IsAnyValuesEqual(anyValues ...int8) bool
}

type IsAnyValueIntegerEqualer interface {
	IsAnyValuesEqual(anyValues ...int) bool
}

type IsBothEnumEqualer interface {
	IsEnumEqualer
	IsAnyEnumsEqualer
}

type IsEndChecker interface {
	IsEnd() bool
}

type IsEnumEqualer interface {
	IsEnumEqual(enum BasicEnumer) bool
}

type IsInvalidChecker interface {
	IsInvalid() bool
}

type IsNameEqualer interface {
	IsNameEqual(name string) bool
}

type IsStartChecker interface {
	IsStart() bool
}

type IsStartEndChecker interface {
	IsStartChecker
	IsEndChecker
}

type IsValidChecker interface {
	// IsValid similar or alias for IsSuccessChecker
	IsValid() bool
}

type IsValidInvalidChecker interface {
	IsValidChecker
	IsInvalidChecker
}

type IsValueByteEqualer interface {
	IsByteValueEqual(value byte) bool
}

type IsValueInteger16Equaler interface {
	IsInteger16ValueEqual(value int16) bool
}

type IsValueInteger32Equaler interface {
	IsInteger32ValueEqual(value int32) bool
}

type IsValueInteger8Equaler interface {
	IsInteger8ValueEqual(value int8) bool
}

type IsValueIntegerEqualer interface {
	IsIntegerValueEqual(value int) bool
}

type LinuxTyper interface {
	BasicEnumer
	internalenuminf.LinuxTyper
}

type ListCmdTyper interface {
	BasicEnumer
	internalenuminf.ListCmdTyper
}

type LogCmdTyper interface {
	BasicEnumer
	internalenuminf.LogCmdTyper
}

type LogLevelTyper interface {
	BasicEnumer
	internalenuminf.LogLevelTyper
}

type LoggerTyper interface {
	BasicEnumer
	internalinterface.LoggerTyper
}

type LoggerTyperGetter interface {
	LoggerTyper() LoggerTyper
}

type NameValuer interface {
	// NameValue
	//
	//   should be a combined string output using name[value]
	//
	// Sample :
	//  - "`EnumName[EnumValInteger]" -> `EnumName[2]`
	NameValue() string
}

type Namer interface {
	Name() string
}

type OnOffLater interface {
	BasicEnumer
	internalenuminf.OnOffLater
}

type OnlySupportedNamesErrorer interface {
	internalenuminf.OnlySupportedNamesErrorer
}

type OverwriteOrRideOrEnforcer interface {
	BasicEnumer
	internalenuminf.OverwriteOrRideOrEnforcer
}

type PatternsSplitter interface {
	// PatternSplit
	//
	//  based on pattern string it will split
	//  and try to convert each string split to enum
	PatternSplit(splitter, format string) []BasicEnumer
}

type PrivilegeTyper interface {
	BasicEnumer
	internalenuminf.PrivilegeTyper
}

type RangeNamesCsvGetter interface {
	RangeNamesCsv() string
}

type RangeValidateChecker interface {
	// RangesInvalidMessage get invalid message
	RangesInvalidMessage() string
	// RangesInvalidErr get invalid message error
	RangesInvalidErr() error
	// IsValidRange Is with in the range as expected.
	IsValidRange() bool
	// IsInvalidRange Is out of the ranges expected.
	IsInvalidRange() bool
}

type RangesDynamicMapGetter interface {
	RangesDynamicMap() map[string]interface{}
}

type RangesIntegerStringMapGetter interface {
	RangesIntegerStringMap() map[int]string
}

type ReinstallCmdTyper interface {
	BasicEnumer
	internalenuminf.ReinstallCmdTyper
}

type RemoveCmdTyper interface {
	BasicEnumer
	internalenuminf.RemoveCmdTyper
}

type RevertCmdTyper interface {
	BasicEnumer
	internalenuminf.RevertCmdTyper
}

type SimpleEnumer interface {
	internalinterface.SimpleEnumer
}

type SplitNameValueByteGetter interface {
	Value() byte
	// contains filtered or unexported methods
}

type SplitNameValueInteger16Getter interface {
	Value() int16
	// contains filtered or unexported methods
}

type SplitNameValueInteger32Getter interface {
	Value() int32
	// contains filtered or unexported methods
}

type SplitNameValueInteger8Getter interface {
	Value() int8
	// contains filtered or unexported methods
}

type SplitNameValueIntegerGetter interface {
	Value() int
	// contains filtered or unexported methods
}

type StandardEnumer interface {
	BasicEnumer
	StringRangesGetter
	RangeValidateChecker
	corejson.JsonContractsBinder
}

type StandardEnumerContractsBinder interface {
	StandardEnumer
	AsStandardEnumerContractsBinder() StandardEnumerContractsBinder
}

type StatusCmdTyper interface {
	BasicEnumer
	internalenuminf.StatusCmdTyper
}

type StringCompareTyper interface {
	BasicEnumer
	internalenuminf.StringCompareTyper
}

type StringRangeNamesCsvGetter interface {
	RangeNamesCsv() string
}

type StringRangesGetter interface {
	StringRangesPtr() *[]string
	StringRanges() []string
}

type SwitchOrChangePortCmdTyper interface {
	ChangePortCmdTyper
	SwitchPortCmdTyper
}

type SwitchPortCmdTyper interface {
	BasicEnumer
	internalenuminf.SwitchPortCmdTyper
}

type SyncCmdTyper interface {
	BasicEnumer
	internalenuminf.SyncCmdTyper
}

type ToNameLower interface {
	internalenuminf.ToNameLower
}

type ToNumberStringer interface {
	// ToNumberString
	//
	//  It returns string number value.
	//
	// Examples:
	//  - ToNumberString() -> "1"  if the value is 1
	//  - ToNumberString() -> "10" if the value is 10
	ToNumberString() string
}

type TypeNameGetter interface {
	TypeName() string
}

type TypeNameWithRangeNamesCsvGetter interface {
	StringRangeNamesCsvGetter
	TypeNameGetter
}

type UninstallCmdTyper interface {
	BasicEnumer
	internalenuminf.CleanupCmdTyper
}

type UnmarshallEnumToValueByter interface {
	UnmarshallEnumToValue(jsonUnmarshallingValue []byte) (byte, error)
}

type UnmarshallToValueByter interface {
	UnmarshallToValue(isMappedToFirstIfEmpty bool, jsonUnmarshallingValue []byte) (byte, error)
}

type UnmarshallToValueInt16er interface {
	UnmarshallToValue(isMappedToFirstIfEmpty bool, jsonUnmarshallingValue []byte) (int16, error)
}

type UnmarshallToValueInt8er interface {
	UnmarshallToValue(isMappedToFirstIfEmpty bool, jsonUnmarshallingValue []byte) (int8, error)
}

type UnmarshallToValueInter interface {
	UnmarshallToValue(isMappedToFirstIfEmpty bool, jsonUnmarshallingValue []byte) (int, error)
}

type WhichPortCmdTyper interface {
	BasicEnumer
	internalenuminf.WhichPortCmdTyper
}