flagt.go

// SPDX-License-Identifier: Apache-2.0
// Copyright 2023 The Prime Citizens

package cli

import (
	"regexp"
	"time"
)

// predefined flag types for scalar values from command line.
type (
	String       = FlagBase[string, VPString[string]]
	Bool         = FlagBase[bool, VPBool[bool]]
	Int          = FlagBase[int, VPInt[int]]
	Int8         = FlagBase[int8, VPInt[int8]]
	Int16        = FlagBase[int16, VPInt[int16]]
	Int32        = FlagBase[int32, VPInt[int32]]
	Int64        = FlagBase[int64, VPInt[int64]]
	Uint         = FlagBase[uint, VPUint[uint]]
	Uint8        = FlagBase[uint8, VPUint[uint8]]
	Uint16       = FlagBase[uint16, VPUint[uint16]]
	Uint32       = FlagBase[uint32, VPUint[uint32]]
	Uint64       = FlagBase[uint64, VPUint[uint64]]
	Uintptr      = FlagBase[uintptr, VPUint[uintptr]]
	Float32      = FlagBase[float32, VPFloat[float32]]
	Float64      = FlagBase[float64, VPFloat[float64]]
	Size         = FlagBase[int64, VPSize[int64]]
	Duration     = FlagBase[time.Duration, VPDuration[time.Duration]]
	Time         = FlagBase[time.Time, VPTime[time.Time]]
	UnixSec      = FlagBase[int64, VPUnixSec[int64]]
	UnixMilli    = FlagBase[int64, VPUnixMilli[int64]]
	UnixMicro    = FlagBase[int64, VPUnixMicro[int64]]
	UnixNano     = FlagBase[int64, VPUnixNano[int64]]
	Regexp       = FlagBase[*regexp.Regexp, VPPointer[regexp.Regexp, VPRegexp[regexp.Regexp]]]
	RegexpNocase = FlagBase[*regexp.Regexp, VPPointer[regexp.Regexp, VPRegexpNocase[regexp.Regexp]]]

	StringV       = FlagBaseV[string, VPString[string]]
	BoolV         = FlagBaseV[bool, VPBool[bool]]
	IntV          = FlagBaseV[int, VPInt[int]]
	Int8V         = FlagBaseV[int8, VPInt[int8]]
	Int16V        = FlagBaseV[int16, VPInt[int16]]
	Int32V        = FlagBaseV[int32, VPInt[int32]]
	Int64V        = FlagBaseV[int64, VPInt[int64]]
	UintV         = FlagBaseV[uint, VPUint[uint]]
	Uint8V        = FlagBaseV[uint8, VPUint[uint8]]
	Uint16V       = FlagBaseV[uint16, VPUint[uint16]]
	Uint32V       = FlagBaseV[uint32, VPUint[uint32]]
	Uint64V       = FlagBaseV[uint64, VPUint[uint64]]
	UintptrV      = FlagBaseV[uintptr, VPUint[uintptr]]
	Float32V      = FlagBaseV[float32, VPFloat[float32]]
	Float64V      = FlagBaseV[float64, VPFloat[float64]]
	SizeV         = FlagBaseV[int64, VPSize[int64]]
	DurationV     = FlagBaseV[time.Duration, VPDuration[time.Duration]]
	TimeV         = FlagBaseV[time.Time, VPTime[time.Time]]
	UnixSecV      = FlagBaseV[int64, VPUnixSec[int64]]
	UnixMilliV    = FlagBaseV[int64, VPUnixMilli[int64]]
	UnixMicroV    = FlagBaseV[int64, VPUnixMicro[int64]]
	UnixNanoV     = FlagBaseV[int64, VPUnixNano[int64]]
	RegexpV       = FlagBaseV[regexp.Regexp, VPRegexp[regexp.Regexp]]
	RegexpNocaseV = FlagBaseV[regexp.Regexp, VPRegexpNocase[regexp.Regexp]]
)

// predefined flag types for slice values from command line.
type (
	StringSlice       = FlagBase[[]string, VPSlice[string, VPString[string]]]
	BoolSlice         = FlagBase[[]bool, VPSlice[bool, VPBool[bool]]]
	IntSlice          = FlagBase[[]int, VPSlice[int, VPInt[int]]]
	Int8Slice         = FlagBase[[]int8, VPSlice[int8, VPInt[int8]]]
	Int16Slice        = FlagBase[[]int16, VPSlice[int16, VPInt[int16]]]
	Int32Slice        = FlagBase[[]int32, VPSlice[int32, VPInt[int32]]]
	Int64Slice        = FlagBase[[]int64, VPSlice[int64, VPInt[int64]]]
	UintSlice         = FlagBase[[]uint, VPSlice[uint, VPUint[uint]]]
	Uint8Slice        = FlagBase[[]uint8, VPSlice[uint8, VPUint[uint8]]]
	Uint16Slice       = FlagBase[[]uint16, VPSlice[uint16, VPUint[uint16]]]
	Uint32Slice       = FlagBase[[]uint32, VPSlice[uint32, VPUint[uint32]]]
	Uint64Slice       = FlagBase[[]uint64, VPSlice[uint64, VPUint[uint64]]]
	UintptrSlice      = FlagBase[[]uintptr, VPSlice[uintptr, VPUint[uintptr]]]
	Float32Slice      = FlagBase[[]float32, VPSlice[float32, VPFloat[float32]]]
	Float64Slice      = FlagBase[[]float64, VPSlice[float64, VPFloat[float64]]]
	SizeSlice         = FlagBase[[]int64, VPSlice[int64, VPSize[int64]]]
	DurationSlice     = FlagBase[[]time.Duration, VPSlice[time.Duration, VPDuration[time.Duration]]]
	TimeSlice         = FlagBase[[]time.Time, VPSlice[time.Time, VPTime[time.Time]]]
	UnixSecSlice      = FlagBase[[]int64, VPSlice[int64, VPUnixSec[int64]]]
	UnixMilliSlice    = FlagBase[[]int64, VPSlice[int64, VPUnixMilli[int64]]]
	UnixMicroSlice    = FlagBase[[]int64, VPSlice[int64, VPUnixMicro[int64]]]
	UnixNanoSlice     = FlagBase[[]int64, VPSlice[int64, VPUnixNano[int64]]]
	RegexpSlice       = FlagBase[[]*regexp.Regexp, VPSlice[*regexp.Regexp, VPPointer[regexp.Regexp, VPRegexp[regexp.Regexp]]]]
	RegexpNocaseSlice = FlagBase[[]*regexp.Regexp, VPSlice[*regexp.Regexp, VPPointer[regexp.Regexp, VPRegexpNocase[regexp.Regexp]]]]

	StringSliceV       = FlagBaseV[[]string, VPSlice[string, VPString[string]]]
	BoolSliceV         = FlagBaseV[[]bool, VPSlice[bool, VPBool[bool]]]
	IntSliceV          = FlagBaseV[[]int, VPSlice[int, VPInt[int]]]
	Int8SliceV         = FlagBaseV[[]int8, VPSlice[int8, VPInt[int8]]]
	Int16SliceV        = FlagBaseV[[]int16, VPSlice[int16, VPInt[int16]]]
	Int32SliceV        = FlagBaseV[[]int32, VPSlice[int32, VPInt[int32]]]
	Int64SliceV        = FlagBaseV[[]int64, VPSlice[int64, VPInt[int64]]]
	UintSliceV         = FlagBaseV[[]uint, VPSlice[uint, VPUint[uint]]]
	Uint8SliceV        = FlagBaseV[[]uint8, VPSlice[uint8, VPUint[uint8]]]
	Uint16SliceV       = FlagBaseV[[]uint16, VPSlice[uint16, VPUint[uint16]]]
	Uint32SliceV       = FlagBaseV[[]uint32, VPSlice[uint32, VPUint[uint32]]]
	Uint64SliceV       = FlagBaseV[[]uint64, VPSlice[uint64, VPUint[uint64]]]
	UintptrSliceV      = FlagBaseV[[]uintptr, VPSlice[uintptr, VPUint[uintptr]]]
	Float32SliceV      = FlagBaseV[[]float32, VPSlice[float32, VPFloat[float32]]]
	Float64SliceV      = FlagBaseV[[]float64, VPSlice[float64, VPFloat[float64]]]
	SizeSliceV         = FlagBaseV[[]int64, VPSlice[int64, VPSize[int64]]]
	DurationSliceV     = FlagBaseV[[]time.Duration, VPSlice[time.Duration, VPDuration[time.Duration]]]
	TimeSliceV         = FlagBaseV[[]time.Time, VPSlice[time.Time, VPTime[time.Time]]]
	UnixSecSliceV      = FlagBaseV[[]int64, VPSlice[int64, VPUnixSec[int64]]]
	UnixMilliSliceV    = FlagBaseV[[]int64, VPSlice[int64, VPUnixMilli[int64]]]
	UnixMicroSliceV    = FlagBaseV[[]int64, VPSlice[int64, VPUnixMicro[int64]]]
	UnixNanoSliceV     = FlagBaseV[[]int64, VPSlice[int64, VPUnixNano[int64]]]
	RegexpSliceV       = FlagBaseV[[]*regexp.Regexp, VPSlice[*regexp.Regexp, VPPointer[regexp.Regexp, VPRegexp[regexp.Regexp]]]]
	RegexpNocaseSliceV = FlagBaseV[[]*regexp.Regexp, VPSlice[*regexp.Regexp, VPPointer[regexp.Regexp, VPRegexpNocase[regexp.Regexp]]]]
)

// predefined flag types for sumed scalar values from command line.
type (
	IntSum      = FlagBase[int, VPSum[int, VPInt[int]]]
	Int8Sum     = FlagBase[int8, VPSum[int8, VPInt[int8]]]
	Int16Sum    = FlagBase[int16, VPSum[int16, VPInt[int16]]]
	Int32Sum    = FlagBase[int32, VPSum[int32, VPInt[int32]]]
	Int64Sum    = FlagBase[int64, VPSum[int64, VPInt[int64]]]
	UintSum     = FlagBase[uint, VPSum[uint, VPUint[uint]]]
	Uint8Sum    = FlagBase[uint8, VPSum[uint8, VPUint[uint8]]]
	Uint16Sum   = FlagBase[uint16, VPSum[uint16, VPUint[uint16]]]
	Uint32Sum   = FlagBase[uint32, VPSum[uint32, VPUint[uint32]]]
	Uint64Sum   = FlagBase[uint64, VPSum[uint64, VPUint[uint64]]]
	UintptrSum  = FlagBase[uintptr, VPSum[uintptr, VPUint[uintptr]]]
	Float32Sum  = FlagBase[float32, VPSum[float32, VPFloat[float32]]]
	Float64Sum  = FlagBase[float64, VPSum[float64, VPFloat[float64]]]
	SizeSum     = FlagBase[int64, VPSum[int64, VPSize[int64]]]
	DurationSum = FlagBase[time.Duration, VPSum[time.Duration, VPDuration[time.Duration]]]

	IntSumV      = FlagBaseV[int, VPSum[int, VPInt[int]]]
	Int8SumV     = FlagBaseV[int8, VPSum[int8, VPInt[int8]]]
	Int16SumV    = FlagBaseV[int16, VPSum[int16, VPInt[int16]]]
	Int32SumV    = FlagBaseV[int32, VPSum[int32, VPInt[int32]]]
	Int64SumV    = FlagBaseV[int64, VPSum[int64, VPInt[int64]]]
	UintSumV     = FlagBaseV[uint, VPSum[uint, VPUint[uint]]]
	Uint8SumV    = FlagBaseV[uint8, VPSum[uint8, VPUint[uint8]]]
	Uint16SumV   = FlagBaseV[uint16, VPSum[uint16, VPUint[uint16]]]
	Uint32SumV   = FlagBaseV[uint32, VPSum[uint32, VPUint[uint32]]]
	Uint64SumV   = FlagBaseV[uint64, VPSum[uint64, VPUint[uint64]]]
	UintptrSumV  = FlagBaseV[uintptr, VPSum[uintptr, VPUint[uintptr]]]
	Float32SumV  = FlagBaseV[float32, VPSum[float32, VPFloat[float32]]]
	Float64SumV  = FlagBaseV[float64, VPSum[float64, VPFloat[float64]]]
	SizeSumV     = FlagBaseV[int64, VPSum[int64, VPSize[int64]]]
	DurationSumV = FlagBaseV[time.Duration, VPSum[time.Duration, VPDuration[time.Duration]]]
)

// predefined flag types for "<string>=<scalar>" from command line.
type (
	MapStringString       = FlagBase[map[string]string, VPMap[string, string, VPString[string], VPString[string]]]
	MapStringBool         = FlagBase[map[string]bool, VPMap[string, bool, VPString[string], VPBool[bool]]]
	MapStringInt          = FlagBase[map[string]int, VPMap[string, int, VPString[string], VPInt[int]]]
	MapStringInt8         = FlagBase[map[string]int8, VPMap[string, int8, VPString[string], VPInt[int8]]]
	MapStringInt16        = FlagBase[map[string]int16, VPMap[string, int16, VPString[string], VPInt[int16]]]
	MapStringInt32        = FlagBase[map[string]int32, VPMap[string, int32, VPString[string], VPInt[int32]]]
	MapStringInt64        = FlagBase[map[string]int64, VPMap[string, int64, VPString[string], VPInt[int64]]]
	MapStringUint         = FlagBase[map[string]uint, VPMap[string, uint, VPString[string], VPUint[uint]]]
	MapStringUint8        = FlagBase[map[string]uint8, VPMap[string, uint8, VPString[string], VPUint[uint8]]]
	MapStringUint16       = FlagBase[map[string]uint16, VPMap[string, uint16, VPString[string], VPUint[uint16]]]
	MapStringUint32       = FlagBase[map[string]uint32, VPMap[string, uint32, VPString[string], VPUint[uint32]]]
	MapStringUint64       = FlagBase[map[string]uint64, VPMap[string, uint64, VPString[string], VPUint[uint64]]]
	MapStringUintptr      = FlagBase[map[string]uintptr, VPMap[string, uintptr, VPString[string], VPUint[uintptr]]]
	MapStringFloat32      = FlagBase[map[string]float32, VPMap[string, float32, VPString[string], VPFloat[float32]]]
	MapStringFloat64      = FlagBase[map[string]float64, VPMap[string, float64, VPString[string], VPFloat[float64]]]
	MapStringSize         = FlagBase[map[string]int64, VPMap[string, int64, VPString[string], VPSize[int64]]]
	MapStringDuration     = FlagBase[map[string]time.Duration, VPMap[string, time.Duration, VPString[string], VPDuration[time.Duration]]]
	MapStringTime         = FlagBase[map[string]time.Time, VPMap[string, time.Time, VPString[string], VPTime[time.Time]]]
	MapStringUnixSec      = FlagBase[map[string]int64, VPMap[string, int64, VPString[string], VPUnixSec[int64]]]
	MapStringUnixMilli    = FlagBase[map[string]int64, VPMap[string, int64, VPString[string], VPUnixMilli[int64]]]
	MapStringUnixMicro    = FlagBase[map[string]int64, VPMap[string, int64, VPString[string], VPUnixMicro[int64]]]
	MapStringUnixNano     = FlagBase[map[string]int64, VPMap[string, int64, VPString[string], VPUnixNano[int64]]]
	MapStringRegexp       = FlagBase[map[string]*regexp.Regexp, VPMap[string, *regexp.Regexp, VPString[string], VPPointer[regexp.Regexp, VPRegexp[regexp.Regexp]]]]
	MapStringRegexpNocase = FlagBase[map[string]*regexp.Regexp, VPMap[string, *regexp.Regexp, VPString[string], VPPointer[regexp.Regexp, VPRegexpNocase[regexp.Regexp]]]]

	MapStringStringSlice       = FlagBase[map[string][]string, VPMap[string, []string, VPString[string], VPSlice[string, VPString[string]]]]
	MapStringBoolSlice         = FlagBase[map[string][]bool, VPMap[string, []bool, VPString[string], VPSlice[bool, VPBool[bool]]]]
	MapStringIntSlice          = FlagBase[map[string][]int, VPMap[string, []int, VPString[string], VPSlice[int, VPInt[int]]]]
	MapStringInt8Slice         = FlagBase[map[string][]int8, VPMap[string, []int8, VPString[string], VPSlice[int8, VPInt[int8]]]]
	MapStringInt16Slice        = FlagBase[map[string][]int16, VPMap[string, []int16, VPString[string], VPSlice[int16, VPInt[int16]]]]
	MapStringInt32Slice        = FlagBase[map[string][]int32, VPMap[string, []int32, VPString[string], VPSlice[int32, VPInt[int32]]]]
	MapStringInt64Slice        = FlagBase[map[string][]int64, VPMap[string, []int64, VPString[string], VPSlice[int64, VPInt[int64]]]]
	MapStringUintSlice         = FlagBase[map[string][]uint, VPMap[string, []uint, VPString[string], VPSlice[uint, VPUint[uint]]]]
	MapStringUint8Slice        = FlagBase[map[string][]uint8, VPMap[string, []uint8, VPString[string], VPSlice[uint8, VPUint[uint8]]]]
	MapStringUint16Slice       = FlagBase[map[string][]uint16, VPMap[string, []uint16, VPString[string], VPSlice[uint16, VPUint[uint16]]]]
	MapStringUint32Slice       = FlagBase[map[string][]uint32, VPMap[string, []uint32, VPString[string], VPSlice[uint32, VPUint[uint32]]]]
	MapStringUint64Slice       = FlagBase[map[string][]uint64, VPMap[string, []uint64, VPString[string], VPSlice[uint64, VPUint[uint64]]]]
	MapStringUintptrSlice      = FlagBase[map[string][]uintptr, VPMap[string, []uintptr, VPString[string], VPSlice[uintptr, VPUint[uintptr]]]]
	MapStringFloat32Slice      = FlagBase[map[string][]float32, VPMap[string, []float32, VPString[string], VPSlice[float32, VPFloat[float32]]]]
	MapStringFloat64Slice      = FlagBase[map[string][]float64, VPMap[string, []float64, VPString[string], VPSlice[float64, VPFloat[float64]]]]
	MapStringSizeSlice         = FlagBase[map[string][]int64, VPMap[string, []int64, VPString[string], VPSlice[int64, VPSize[int64]]]]
	MapStringDurationSlice     = FlagBase[map[string][]time.Duration, VPMap[string, []time.Duration, VPString[string], VPSlice[time.Duration, VPDuration[time.Duration]]]]
	MapStringTimeSlice         = FlagBase[map[string][]time.Time, VPMap[string, []time.Time, VPString[string], VPSlice[time.Time, VPTime[time.Time]]]]
	MapStringUnixSecSlice      = FlagBase[map[string][]int64, VPMap[string, []int64, VPString[string], VPSlice[int64, VPUnixSec[int64]]]]
	MapStringUnixMilliSlice    = FlagBase[map[string][]int64, VPMap[string, []int64, VPString[string], VPSlice[int64, VPUnixMilli[int64]]]]
	MapStringUnixMicroSlice    = FlagBase[map[string][]int64, VPMap[string, []int64, VPString[string], VPSlice[int64, VPUnixMicro[int64]]]]
	MapStringUnixNanoSlice     = FlagBase[map[string][]int64, VPMap[string, []int64, VPString[string], VPSlice[int64, VPUnixNano[int64]]]]
	MapStringRegexpSlice       = FlagBase[map[string][]*regexp.Regexp, VPMap[string, []*regexp.Regexp, VPString[string], VPSlice[*regexp.Regexp, VPPointer[regexp.Regexp, VPRegexp[regexp.Regexp]]]]]
	MapStringRegexpNocaseSlice = FlagBase[map[string][]*regexp.Regexp, VPMap[string, []*regexp.Regexp, VPString[string], VPSlice[*regexp.Regexp, VPPointer[regexp.Regexp, VPRegexpNocase[regexp.Regexp]]]]]

	MapStringIntSum      = FlagBase[map[string]int, VPMap[string, int, VPString[string], VPSum[int, VPInt[int]]]]
	MapStringInt8Sum     = FlagBase[map[string]int8, VPMap[string, int8, VPString[string], VPSum[int8, VPInt[int8]]]]
	MapStringInt16Sum    = FlagBase[map[string]int16, VPMap[string, int16, VPString[string], VPSum[int16, VPInt[int16]]]]
	MapStringInt32Sum    = FlagBase[map[string]int32, VPMap[string, int32, VPString[string], VPSum[int32, VPInt[int32]]]]
	MapStringInt64Sum    = FlagBase[map[string]int64, VPMap[string, int64, VPString[string], VPSum[int64, VPInt[int64]]]]
	MapStringUintSum     = FlagBase[map[string]uint, VPMap[string, uint, VPString[string], VPSum[uint, VPUint[uint]]]]
	MapStringUint8Sum    = FlagBase[map[string]uint8, VPMap[string, uint8, VPString[string], VPSum[uint8, VPUint[uint8]]]]
	MapStringUint16Sum   = FlagBase[map[string]uint16, VPMap[string, uint16, VPString[string], VPSum[uint16, VPUint[uint16]]]]
	MapStringUint32Sum   = FlagBase[map[string]uint32, VPMap[string, uint32, VPString[string], VPSum[uint32, VPUint[uint32]]]]
	MapStringUint64Sum   = FlagBase[map[string]uint64, VPMap[string, uint64, VPString[string], VPSum[uint64, VPUint[uint64]]]]
	MapStringUintptrSum  = FlagBase[map[string]uintptr, VPMap[string, uintptr, VPString[string], VPSum[uintptr, VPUint[uintptr]]]]
	MapStringFloat32Sum  = FlagBase[map[string]float32, VPMap[string, float32, VPString[string], VPSum[float32, VPFloat[float32]]]]
	MapStringFloat64Sum  = FlagBase[map[string]float64, VPMap[string, float64, VPString[string], VPSum[float64, VPFloat[float64]]]]
	MapStringSizeSum     = FlagBase[map[string]int64, VPMap[string, int64, VPString[string], VPSum[int64, VPSize[int64]]]]
	MapStringDurationSum = FlagBase[map[string]time.Duration, VPMap[string, time.Duration, VPString[string], VPSum[time.Duration, VPDuration[time.Duration]]]]

	//

	MapStringStringV       = FlagBaseV[map[string]string, VPMap[string, string, VPString[string], VPString[string]]]
	MapStringBoolV         = FlagBaseV[map[string]bool, VPMap[string, bool, VPString[string], VPBool[bool]]]
	MapStringIntV          = FlagBaseV[map[string]int, VPMap[string, int, VPString[string], VPInt[int]]]
	MapStringInt8V         = FlagBaseV[map[string]int8, VPMap[string, int8, VPString[string], VPInt[int8]]]
	MapStringInt16V        = FlagBaseV[map[string]int16, VPMap[string, int16, VPString[string], VPInt[int16]]]
	MapStringInt32V        = FlagBaseV[map[string]int32, VPMap[string, int32, VPString[string], VPInt[int32]]]
	MapStringInt64V        = FlagBaseV[map[string]int64, VPMap[string, int64, VPString[string], VPInt[int64]]]
	MapStringUintV         = FlagBaseV[map[string]uint, VPMap[string, uint, VPString[string], VPUint[uint]]]
	MapStringUint8V        = FlagBaseV[map[string]uint8, VPMap[string, uint8, VPString[string], VPUint[uint8]]]
	MapStringUint16V       = FlagBaseV[map[string]uint16, VPMap[string, uint16, VPString[string], VPUint[uint16]]]
	MapStringUint32V       = FlagBaseV[map[string]uint32, VPMap[string, uint32, VPString[string], VPUint[uint32]]]
	MapStringUint64V       = FlagBaseV[map[string]uint64, VPMap[string, uint64, VPString[string], VPUint[uint64]]]
	MapStringUintptrV      = FlagBaseV[map[string]uintptr, VPMap[string, uintptr, VPString[string], VPUint[uintptr]]]
	MapStringFloat32V      = FlagBaseV[map[string]float32, VPMap[string, float32, VPString[string], VPFloat[float32]]]
	MapStringFloat64V      = FlagBaseV[map[string]float64, VPMap[string, float64, VPString[string], VPFloat[float64]]]
	MapStringSizeV         = FlagBaseV[map[string]int64, VPMap[string, int64, VPString[string], VPSize[int64]]]
	MapStringDurationV     = FlagBaseV[map[string]time.Duration, VPMap[string, time.Duration, VPString[string], VPDuration[time.Duration]]]
	MapStringTimeV         = FlagBaseV[map[string]time.Time, VPMap[string, time.Time, VPString[string], VPTime[time.Time]]]
	MapStringUnixSecV      = FlagBaseV[map[string]int64, VPMap[string, int64, VPString[string], VPUnixSec[int64]]]
	MapStringUnixMilliV    = FlagBaseV[map[string]int64, VPMap[string, int64, VPString[string], VPUnixMilli[int64]]]
	MapStringUnixMicroV    = FlagBaseV[map[string]int64, VPMap[string, int64, VPString[string], VPUnixMicro[int64]]]
	MapStringUnixNanoV     = FlagBaseV[map[string]int64, VPMap[string, int64, VPString[string], VPUnixNano[int64]]]
	MapStringRegexpV       = FlagBaseV[map[string]*regexp.Regexp, VPMap[string, *regexp.Regexp, VPString[string], VPPointer[regexp.Regexp, VPRegexp[regexp.Regexp]]]]
	MapStringRegexpNocaseV = FlagBaseV[map[string]*regexp.Regexp, VPMap[string, *regexp.Regexp, VPString[string], VPPointer[regexp.Regexp, VPRegexpNocase[regexp.Regexp]]]]

	MapStringStringSliceV       = FlagBaseV[map[string][]string, VPMap[string, []string, VPString[string], VPSlice[string, VPString[string]]]]
	MapStringBoolSliceV         = FlagBaseV[map[string][]bool, VPMap[string, []bool, VPString[string], VPSlice[bool, VPBool[bool]]]]
	MapStringIntSliceV          = FlagBaseV[map[string][]int, VPMap[string, []int, VPString[string], VPSlice[int, VPInt[int]]]]
	MapStringInt8SliceV         = FlagBaseV[map[string][]int8, VPMap[string, []int8, VPString[string], VPSlice[int8, VPInt[int8]]]]
	MapStringInt16SliceV        = FlagBaseV[map[string][]int16, VPMap[string, []int16, VPString[string], VPSlice[int16, VPInt[int16]]]]
	MapStringInt32SliceV        = FlagBaseV[map[string][]int32, VPMap[string, []int32, VPString[string], VPSlice[int32, VPInt[int32]]]]
	MapStringInt64SliceV        = FlagBaseV[map[string][]int64, VPMap[string, []int64, VPString[string], VPSlice[int64, VPInt[int64]]]]
	MapStringUintSliceV         = FlagBaseV[map[string][]uint, VPMap[string, []uint, VPString[string], VPSlice[uint, VPUint[uint]]]]
	MapStringUint8SliceV        = FlagBaseV[map[string][]uint8, VPMap[string, []uint8, VPString[string], VPSlice[uint8, VPUint[uint8]]]]
	MapStringUint16SliceV       = FlagBaseV[map[string][]uint16, VPMap[string, []uint16, VPString[string], VPSlice[uint16, VPUint[uint16]]]]
	MapStringUint32SliceV       = FlagBaseV[map[string][]uint32, VPMap[string, []uint32, VPString[string], VPSlice[uint32, VPUint[uint32]]]]
	MapStringUint64SliceV       = FlagBaseV[map[string][]uint64, VPMap[string, []uint64, VPString[string], VPSlice[uint64, VPUint[uint64]]]]
	MapStringUintptrSliceV      = FlagBaseV[map[string][]uintptr, VPMap[string, []uintptr, VPString[string], VPSlice[uintptr, VPUint[uintptr]]]]
	MapStringFloat32SliceV      = FlagBaseV[map[string][]float32, VPMap[string, []float32, VPString[string], VPSlice[float32, VPFloat[float32]]]]
	MapStringFloat64SliceV      = FlagBaseV[map[string][]float64, VPMap[string, []float64, VPString[string], VPSlice[float64, VPFloat[float64]]]]
	MapStringSizeSliceV         = FlagBaseV[map[string][]int64, VPMap[string, []int64, VPString[string], VPSlice[int64, VPSize[int64]]]]
	MapStringDurationSliceV     = FlagBaseV[map[string][]time.Duration, VPMap[string, []time.Duration, VPString[string], VPSlice[time.Duration, VPDuration[time.Duration]]]]
	MapStringTimeSliceV         = FlagBaseV[map[string][]time.Time, VPMap[string, []time.Time, VPString[string], VPSlice[time.Time, VPTime[time.Time]]]]
	MapStringUnixSecSliceV      = FlagBaseV[map[string][]int64, VPMap[string, []int64, VPString[string], VPSlice[int64, VPUnixSec[int64]]]]
	MapStringUnixMilliSliceV    = FlagBaseV[map[string][]int64, VPMap[string, []int64, VPString[string], VPSlice[int64, VPUnixMilli[int64]]]]
	MapStringUnixMicroSliceV    = FlagBaseV[map[string][]int64, VPMap[string, []int64, VPString[string], VPSlice[int64, VPUnixMicro[int64]]]]
	MapStringUnixNanoSliceV     = FlagBaseV[map[string][]int64, VPMap[string, []int64, VPString[string], VPSlice[int64, VPUnixNano[int64]]]]
	MapStringRegexpSliceV       = FlagBaseV[map[string][]*regexp.Regexp, VPMap[string, []*regexp.Regexp, VPString[string], VPSlice[*regexp.Regexp, VPPointer[regexp.Regexp, VPRegexp[regexp.Regexp]]]]]
	MapStringRegexpNocaseSliceV = FlagBaseV[map[string][]*regexp.Regexp, VPMap[string, []*regexp.Regexp, VPString[string], VPSlice[*regexp.Regexp, VPPointer[regexp.Regexp, VPRegexpNocase[regexp.Regexp]]]]]

	MapStringIntSumV      = FlagBaseV[map[string]int, VPMap[string, int, VPString[string], VPSum[int, VPInt[int]]]]
	MapStringInt8SumV     = FlagBaseV[map[string]int8, VPMap[string, int8, VPString[string], VPSum[int8, VPInt[int8]]]]
	MapStringInt16SumV    = FlagBaseV[map[string]int16, VPMap[string, int16, VPString[string], VPSum[int16, VPInt[int16]]]]
	MapStringInt32SumV    = FlagBaseV[map[string]int32, VPMap[string, int32, VPString[string], VPSum[int32, VPInt[int32]]]]
	MapStringInt64SumV    = FlagBaseV[map[string]int64, VPMap[string, int64, VPString[string], VPSum[int64, VPInt[int64]]]]
	MapStringUintSumV     = FlagBaseV[map[string]uint, VPMap[string, uint, VPString[string], VPSum[uint, VPUint[uint]]]]
	MapStringUint8SumV    = FlagBaseV[map[string]uint8, VPMap[string, uint8, VPString[string], VPSum[uint8, VPUint[uint8]]]]
	MapStringUint16SumV   = FlagBaseV[map[string]uint16, VPMap[string, uint16, VPString[string], VPSum[uint16, VPUint[uint16]]]]
	MapStringUint32SumV   = FlagBaseV[map[string]uint32, VPMap[string, uint32, VPString[string], VPSum[uint32, VPUint[uint32]]]]
	MapStringUint64SumV   = FlagBaseV[map[string]uint64, VPMap[string, uint64, VPString[string], VPSum[uint64, VPUint[uint64]]]]
	MapStringUintptrSumV  = FlagBaseV[map[string]uintptr, VPMap[string, uintptr, VPString[string], VPSum[uintptr, VPUint[uintptr]]]]
	MapStringFloat32SumV  = FlagBaseV[map[string]float32, VPMap[string, float32, VPString[string], VPSum[float32, VPFloat[float32]]]]
	MapStringFloat64SumV  = FlagBaseV[map[string]float64, VPMap[string, float64, VPString[string], VPSum[float64, VPFloat[float64]]]]
	MapStringSizeSumV     = FlagBaseV[map[string]int64, VPMap[string, int64, VPString[string], VPSum[int64, VPSize[int64]]]]
	MapStringDurationSumV = FlagBaseV[map[string]time.Duration, VPMap[string, time.Duration, VPString[string], VPSum[time.Duration, VPDuration[time.Duration]]]]
)

// predefined flag types for "<int>=<scalar>" from command line.
type (
	MapIntString       = FlagBase[map[int]string, VPMap[int, string, VPInt[int], VPString[string]]]
	MapIntBool         = FlagBase[map[int]bool, VPMap[int, bool, VPInt[int], VPBool[bool]]]
	MapIntInt          = FlagBase[map[int]int, VPMap[int, int, VPInt[int], VPInt[int]]]
	MapIntInt8         = FlagBase[map[int]int8, VPMap[int, int8, VPInt[int], VPInt[int8]]]
	MapIntInt16        = FlagBase[map[int]int16, VPMap[int, int16, VPInt[int], VPInt[int16]]]
	MapIntInt32        = FlagBase[map[int]int32, VPMap[int, int32, VPInt[int], VPInt[int32]]]
	MapIntInt64        = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPInt[int64]]]
	MapIntUint         = FlagBase[map[int]uint, VPMap[int, uint, VPInt[int], VPUint[uint]]]
	MapIntUint8        = FlagBase[map[int]uint8, VPMap[int, uint8, VPInt[int], VPUint[uint8]]]
	MapIntUint16       = FlagBase[map[int]uint16, VPMap[int, uint16, VPInt[int], VPUint[uint16]]]
	MapIntUint32       = FlagBase[map[int]uint32, VPMap[int, uint32, VPInt[int], VPUint[uint32]]]
	MapIntUint64       = FlagBase[map[int]uint64, VPMap[int, uint64, VPInt[int], VPUint[uint64]]]
	MapIntUintptr      = FlagBase[map[int]uintptr, VPMap[int, uintptr, VPInt[int], VPUint[uintptr]]]
	MapIntFloat32      = FlagBase[map[int]float32, VPMap[int, float32, VPInt[int], VPFloat[float32]]]
	MapIntFloat64      = FlagBase[map[int]float64, VPMap[int, float64, VPInt[int], VPFloat[float64]]]
	MapIntSize         = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPSize[int64]]]
	MapIntDuration     = FlagBase[map[int]time.Duration, VPMap[int, time.Duration, VPInt[int], VPDuration[time.Duration]]]
	MapIntTime         = FlagBase[map[int]time.Time, VPMap[int, time.Time, VPInt[int], VPTime[time.Time]]]
	MapIntUnixSec      = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPUnixSec[int64]]]
	MapIntUnixMilli    = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPUnixMilli[int64]]]
	MapIntUnixMicro    = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPUnixMicro[int64]]]
	MapIntUnixNano     = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPUnixNano[int64]]]
	MapIntRegexp       = FlagBase[map[int]*regexp.Regexp, VPMap[int, *regexp.Regexp, VPInt[int], VPPointer[regexp.Regexp, VPRegexp[regexp.Regexp]]]]
	MapIntRegexpNocase = FlagBase[map[int]*regexp.Regexp, VPMap[int, *regexp.Regexp, VPInt[int], VPPointer[regexp.Regexp, VPRegexpNocase[regexp.Regexp]]]]

	MapIntStringSlice       = FlagBase[map[int][]string, VPMap[int, []string, VPInt[int], VPSlice[string, VPString[string]]]]
	MapIntBoolSlice         = FlagBase[map[int][]bool, VPMap[int, []bool, VPInt[int], VPSlice[bool, VPBool[bool]]]]
	MapIntIntSlice          = FlagBase[map[int][]int, VPMap[int, []int, VPInt[int], VPSlice[int, VPInt[int]]]]
	MapIntInt8Slice         = FlagBase[map[int][]int8, VPMap[int, []int8, VPInt[int], VPSlice[int8, VPInt[int8]]]]
	MapIntInt16Slice        = FlagBase[map[int][]int16, VPMap[int, []int16, VPInt[int], VPSlice[int16, VPInt[int16]]]]
	MapIntInt32Slice        = FlagBase[map[int][]int32, VPMap[int, []int32, VPInt[int], VPSlice[int32, VPInt[int32]]]]
	MapIntInt64Slice        = FlagBase[map[int][]int64, VPMap[int, []int64, VPInt[int], VPSlice[int64, VPInt[int64]]]]
	MapIntUintSlice         = FlagBase[map[int][]uint, VPMap[int, []uint, VPInt[int], VPSlice[uint, VPUint[uint]]]]
	MapIntUint8Slice        = FlagBase[map[int][]uint8, VPMap[int, []uint8, VPInt[int], VPSlice[uint8, VPUint[uint8]]]]
	MapIntUint16Slice       = FlagBase[map[int][]uint16, VPMap[int, []uint16, VPInt[int], VPSlice[uint16, VPUint[uint16]]]]
	MapIntUint32Slice       = FlagBase[map[int][]uint32, VPMap[int, []uint32, VPInt[int], VPSlice[uint32, VPUint[uint32]]]]
	MapIntUint64Slice       = FlagBase[map[int][]uint64, VPMap[int, []uint64, VPInt[int], VPSlice[uint64, VPUint[uint64]]]]
	MapIntUintptrSlice      = FlagBase[map[int][]uintptr, VPMap[int, []uintptr, VPInt[int], VPSlice[uintptr, VPUint[uintptr]]]]
	MapIntFloat32Slice      = FlagBase[map[int][]float32, VPMap[int, []float32, VPInt[int], VPSlice[float32, VPFloat[float32]]]]
	MapIntFloat64Slice      = FlagBase[map[int][]float64, VPMap[int, []float64, VPInt[int], VPSlice[float64, VPFloat[float64]]]]
	MapIntSizeSlice         = FlagBase[map[int][]int64, VPMap[int, []int64, VPInt[int], VPSlice[int64, VPSize[int64]]]]
	MapIntDurationSlice     = FlagBase[map[int][]time.Duration, VPMap[int, []time.Duration, VPInt[int], VPSlice[time.Duration, VPDuration[time.Duration]]]]
	MapIntTimeSlice         = FlagBase[map[int][]time.Time, VPMap[int, []time.Time, VPInt[int], VPSlice[time.Time, VPTime[time.Time]]]]
	MapIntUnixSecSlice      = FlagBase[map[int][]int64, VPMap[int, []int64, VPInt[int], VPSlice[int64, VPUnixSec[int64]]]]
	MapIntUnixMilliSlice    = FlagBase[map[int][]int64, VPMap[int, []int64, VPInt[int], VPSlice[int64, VPUnixMilli[int64]]]]
	MapIntUnixMicroSlice    = FlagBase[map[int][]int64, VPMap[int, []int64, VPInt[int], VPSlice[int64, VPUnixMicro[int64]]]]
	MapIntUnixNanoSlice     = FlagBase[map[int][]int64, VPMap[int, []int64, VPInt[int], VPSlice[int64, VPUnixNano[int64]]]]
	MapIntRegexpSlice       = FlagBase[map[int][]*regexp.Regexp, VPMap[int, []*regexp.Regexp, VPInt[int], VPSlice[*regexp.Regexp, VPPointer[regexp.Regexp, VPRegexp[regexp.Regexp]]]]]
	MapIntRegexpNocaseSlice = FlagBase[map[int][]*regexp.Regexp, VPMap[int, []*regexp.Regexp, VPInt[int], VPSlice[*regexp.Regexp, VPPointer[regexp.Regexp, VPRegexpNocase[regexp.Regexp]]]]]

	MapIntIntSum      = FlagBase[map[int]int, VPMap[int, int, VPInt[int], VPSum[int, VPInt[int]]]]
	MapIntInt8Sum     = FlagBase[map[int]int8, VPMap[int, int8, VPInt[int], VPSum[int8, VPInt[int8]]]]
	MapIntInt16Sum    = FlagBase[map[int]int16, VPMap[int, int16, VPInt[int], VPSum[int16, VPInt[int16]]]]
	MapIntInt32Sum    = FlagBase[map[int]int32, VPMap[int, int32, VPInt[int], VPSum[int32, VPInt[int32]]]]
	MapIntInt64Sum    = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPSum[int64, VPInt[int64]]]]
	MapIntUintSum     = FlagBase[map[int]uint, VPMap[int, uint, VPInt[int], VPSum[uint, VPUint[uint]]]]
	MapIntUint8Sum    = FlagBase[map[int]uint8, VPMap[int, uint8, VPInt[int], VPSum[uint8, VPUint[uint8]]]]
	MapIntUint16Sum   = FlagBase[map[int]uint16, VPMap[int, uint16, VPInt[int], VPSum[uint16, VPUint[uint16]]]]
	MapIntUint32Sum   = FlagBase[map[int]uint32, VPMap[int, uint32, VPInt[int], VPSum[uint32, VPUint[uint32]]]]
	MapIntUint64Sum   = FlagBase[map[int]uint64, VPMap[int, uint64, VPInt[int], VPSum[uint64, VPUint[uint64]]]]
	MapIntUintptrSum  = FlagBase[map[int]uintptr, VPMap[int, uintptr, VPInt[int], VPSum[uintptr, VPUint[uintptr]]]]
	MapIntFloat32Sum  = FlagBase[map[int]float32, VPMap[int, float32, VPInt[int], VPSum[float32, VPFloat[float32]]]]
	MapIntFloat64Sum  = FlagBase[map[int]float64, VPMap[int, float64, VPInt[int], VPSum[float64, VPFloat[float64]]]]
	MapIntSizeSum     = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPSum[int64, VPSize[int64]]]]
	MapIntDurationSum = FlagBase[map[int]time.Duration, VPMap[int, time.Duration, VPInt[int], VPSum[time.Duration, VPDuration[time.Duration]]]]

	//

	MapIntStringV       = FlagBase[map[int]string, VPMap[int, string, VPInt[int], VPString[string]]]
	MapIntBoolV         = FlagBase[map[int]bool, VPMap[int, bool, VPInt[int], VPBool[bool]]]
	MapIntIntV          = FlagBase[map[int]int, VPMap[int, int, VPInt[int], VPInt[int]]]
	MapIntInt8V         = FlagBase[map[int]int8, VPMap[int, int8, VPInt[int], VPInt[int8]]]
	MapIntInt16V        = FlagBase[map[int]int16, VPMap[int, int16, VPInt[int], VPInt[int16]]]
	MapIntInt32V        = FlagBase[map[int]int32, VPMap[int, int32, VPInt[int], VPInt[int32]]]
	MapIntInt64V        = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPInt[int64]]]
	MapIntUintV         = FlagBase[map[int]uint, VPMap[int, uint, VPInt[int], VPUint[uint]]]
	MapIntUint8V        = FlagBase[map[int]uint8, VPMap[int, uint8, VPInt[int], VPUint[uint8]]]
	MapIntUint16V       = FlagBase[map[int]uint16, VPMap[int, uint16, VPInt[int], VPUint[uint16]]]
	MapIntUint32V       = FlagBase[map[int]uint32, VPMap[int, uint32, VPInt[int], VPUint[uint32]]]
	MapIntUint64V       = FlagBase[map[int]uint64, VPMap[int, uint64, VPInt[int], VPUint[uint64]]]
	MapIntUintptrV      = FlagBase[map[int]uintptr, VPMap[int, uintptr, VPInt[int], VPUint[uintptr]]]
	MapIntFloat32V      = FlagBase[map[int]float32, VPMap[int, float32, VPInt[int], VPFloat[float32]]]
	MapIntFloat64V      = FlagBase[map[int]float64, VPMap[int, float64, VPInt[int], VPFloat[float64]]]
	MapIntSizeV         = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPSize[int64]]]
	MapIntDurationV     = FlagBase[map[int]time.Duration, VPMap[int, time.Duration, VPInt[int], VPDuration[time.Duration]]]
	MapIntTimeV         = FlagBase[map[int]time.Time, VPMap[int, time.Time, VPInt[int], VPTime[time.Time]]]
	MapIntUnixSecV      = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPUnixSec[int64]]]
	MapIntUnixMilliV    = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPUnixMilli[int64]]]
	MapIntUnixMicroV    = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPUnixMicro[int64]]]
	MapIntUnixNanoV     = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPUnixNano[int64]]]
	MapIntRegexpV       = FlagBase[map[int]*regexp.Regexp, VPMap[int, *regexp.Regexp, VPInt[int], VPPointer[regexp.Regexp, VPRegexp[regexp.Regexp]]]]
	MapIntRegexpNocaseV = FlagBase[map[int]*regexp.Regexp, VPMap[int, *regexp.Regexp, VPInt[int], VPPointer[regexp.Regexp, VPRegexpNocase[regexp.Regexp]]]]

	MapIntStringSliceV       = FlagBase[map[int][]string, VPMap[int, []string, VPInt[int], VPSlice[string, VPString[string]]]]
	MapIntBoolSliceV         = FlagBase[map[int][]bool, VPMap[int, []bool, VPInt[int], VPSlice[bool, VPBool[bool]]]]
	MapIntIntSliceV          = FlagBase[map[int][]int, VPMap[int, []int, VPInt[int], VPSlice[int, VPInt[int]]]]
	MapIntInt8SliceV         = FlagBase[map[int][]int8, VPMap[int, []int8, VPInt[int], VPSlice[int8, VPInt[int8]]]]
	MapIntInt16SliceV        = FlagBase[map[int][]int16, VPMap[int, []int16, VPInt[int], VPSlice[int16, VPInt[int16]]]]
	MapIntInt32SliceV        = FlagBase[map[int][]int32, VPMap[int, []int32, VPInt[int], VPSlice[int32, VPInt[int32]]]]
	MapIntInt64SliceV        = FlagBase[map[int][]int64, VPMap[int, []int64, VPInt[int], VPSlice[int64, VPInt[int64]]]]
	MapIntUintSliceV         = FlagBase[map[int][]uint, VPMap[int, []uint, VPInt[int], VPSlice[uint, VPUint[uint]]]]
	MapIntUint8SliceV        = FlagBase[map[int][]uint8, VPMap[int, []uint8, VPInt[int], VPSlice[uint8, VPUint[uint8]]]]
	MapIntUint16SliceV       = FlagBase[map[int][]uint16, VPMap[int, []uint16, VPInt[int], VPSlice[uint16, VPUint[uint16]]]]
	MapIntUint32SliceV       = FlagBase[map[int][]uint32, VPMap[int, []uint32, VPInt[int], VPSlice[uint32, VPUint[uint32]]]]
	MapIntUint64SliceV       = FlagBase[map[int][]uint64, VPMap[int, []uint64, VPInt[int], VPSlice[uint64, VPUint[uint64]]]]
	MapIntUintptrSliceV      = FlagBase[map[int][]uintptr, VPMap[int, []uintptr, VPInt[int], VPSlice[uintptr, VPUint[uintptr]]]]
	MapIntFloat32SliceV      = FlagBase[map[int][]float32, VPMap[int, []float32, VPInt[int], VPSlice[float32, VPFloat[float32]]]]
	MapIntFloat64SliceV      = FlagBase[map[int][]float64, VPMap[int, []float64, VPInt[int], VPSlice[float64, VPFloat[float64]]]]
	MapIntSizeSliceV         = FlagBase[map[int][]int64, VPMap[int, []int64, VPInt[int], VPSlice[int64, VPSize[int64]]]]
	MapIntDurationSliceV     = FlagBase[map[int][]time.Duration, VPMap[int, []time.Duration, VPInt[int], VPSlice[time.Duration, VPDuration[time.Duration]]]]
	MapIntTimeSliceV         = FlagBase[map[int][]time.Time, VPMap[int, []time.Time, VPInt[int], VPSlice[time.Time, VPTime[time.Time]]]]
	MapIntUnixSecSliceV      = FlagBase[map[int][]int64, VPMap[int, []int64, VPInt[int], VPSlice[int64, VPUnixSec[int64]]]]
	MapIntUnixMilliSliceV    = FlagBase[map[int][]int64, VPMap[int, []int64, VPInt[int], VPSlice[int64, VPUnixMilli[int64]]]]
	MapIntUnixMicroSliceV    = FlagBase[map[int][]int64, VPMap[int, []int64, VPInt[int], VPSlice[int64, VPUnixMicro[int64]]]]
	MapIntUnixNanoSliceV     = FlagBase[map[int][]int64, VPMap[int, []int64, VPInt[int], VPSlice[int64, VPUnixNano[int64]]]]
	MapIntRegexpSliceV       = FlagBase[map[int][]*regexp.Regexp, VPMap[int, []*regexp.Regexp, VPInt[int], VPSlice[*regexp.Regexp, VPPointer[regexp.Regexp, VPRegexp[regexp.Regexp]]]]]
	MapIntRegexpNocaseSliceV = FlagBase[map[int][]*regexp.Regexp, VPMap[int, []*regexp.Regexp, VPInt[int], VPSlice[*regexp.Regexp, VPPointer[regexp.Regexp, VPRegexpNocase[regexp.Regexp]]]]]

	MapIntIntSumV      = FlagBase[map[int]int, VPMap[int, int, VPInt[int], VPSum[int, VPInt[int]]]]
	MapIntInt8SumV     = FlagBase[map[int]int8, VPMap[int, int8, VPInt[int], VPSum[int8, VPInt[int8]]]]
	MapIntInt16SumV    = FlagBase[map[int]int16, VPMap[int, int16, VPInt[int], VPSum[int16, VPInt[int16]]]]
	MapIntInt32SumV    = FlagBase[map[int]int32, VPMap[int, int32, VPInt[int], VPSum[int32, VPInt[int32]]]]
	MapIntInt64SumV    = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPSum[int64, VPInt[int64]]]]
	MapIntUintSumV     = FlagBase[map[int]uint, VPMap[int, uint, VPInt[int], VPSum[uint, VPUint[uint]]]]
	MapIntUint8SumV    = FlagBase[map[int]uint8, VPMap[int, uint8, VPInt[int], VPSum[uint8, VPUint[uint8]]]]
	MapIntUint16SumV   = FlagBase[map[int]uint16, VPMap[int, uint16, VPInt[int], VPSum[uint16, VPUint[uint16]]]]
	MapIntUint32SumV   = FlagBase[map[int]uint32, VPMap[int, uint32, VPInt[int], VPSum[uint32, VPUint[uint32]]]]
	MapIntUint64SumV   = FlagBase[map[int]uint64, VPMap[int, uint64, VPInt[int], VPSum[uint64, VPUint[uint64]]]]
	MapIntUintptrSumV  = FlagBase[map[int]uintptr, VPMap[int, uintptr, VPInt[int], VPSum[uintptr, VPUint[uintptr]]]]
	MapIntFloat32SumV  = FlagBase[map[int]float32, VPMap[int, float32, VPInt[int], VPSum[float32, VPFloat[float32]]]]
	MapIntFloat64SumV  = FlagBase[map[int]float64, VPMap[int, float64, VPInt[int], VPSum[float64, VPFloat[float64]]]]
	MapIntSizeSumV     = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPSum[int64, VPSize[int64]]]]
	MapIntDurationSumV = FlagBase[map[int]time.Duration, VPMap[int, time.Duration, VPInt[int], VPSum[time.Duration, VPDuration[time.Duration]]]]
)