-// NewTaintsVar wraps []api.Taint in a struct that implements flag.Value to allow taints to be
-// bound to command line flags.
-func NewTaintsVar(ptr *[]api.Taint) taintsVar {
-       return taintsVar{
-               ptr: ptr,
-       }
-}
-
-type taintsVar struct {
-       ptr *[]api.Taint
+// RegisterWithTaintsVar is used for validating a command line option that represents a register with taints. It implements the pflag.Value interface
+type RegisterWithTaintsVar struct {
+       Value *[]v1.Taint
 }
 
-func (t taintsVar) Set(s string) error {
+// Set sets the flag value
+func (t RegisterWithTaintsVar) Set(s string) error {
        if len(s) == 0 {
-               *t.ptr = nil
+               *t.Value = nil
                return nil
        }
        sts := strings.Split(s, ",")
-       var taints []api.Taint
-       for _, st := range sts {
-               taint, err := parseTaint(st)
-               if err != nil {
-                       return err
-               }
-               taints = append(taints, api.Taint{Key: taint.Key, Value: taint.Value, Effect: api.TaintEffect(taint.Effect)})
+       corev1Taints, _, err := utiltaints.ParseTaints(sts)
+       if err != nil {
+               return err
+       }
+       var taints []v1.Taint
+       for _, ct := range corev1Taints {
+               taints = append(taints, v1.Taint{Key: ct.Key, Value: ct.Value, Effect: v1.TaintEffect(ct.Effect)})
        }
-       *t.ptr = taints
+       *t.Value = taints
        return nil
 }
 
-func (t taintsVar) String() string {
-       if len(*t.ptr) == 0 {
+// String returns the flag value
+func (t RegisterWithTaintsVar) String() string {
+       if len(*t.Value) == 0 {
                return ""
        }
        var taints []string
-       for _, taint := range *t.ptr {
+       for _, taint := range *t.Value {
                taints = append(taints, fmt.Sprintf("%s=%s:%s", taint.Key, taint.Value, taint.Effect))
        }
        return strings.Join(taints, ",")
 }
 
-func (t taintsVar) Type() string {
-       return "[]api.Taint"
+// Type gets the flag type
+func (t RegisterWithTaintsVar) Type() string {
+       return "[]v1.Taint"
 }

diff --git a/tmp/bar2 b/tmp/bar1
index 756ac87..4fed623 100644
--- a/tmp/bar2
+++ b/tmp/bar1
@@ -2,32 +2,32 @@ func TestTaintsVar(t *testing.T) {
        cases := []struct {
                f   string
                err bool
-               t   []api.Taint
+               t   []v1.Taint
        }{
                {
                        f: "",
-                       t: []api.Taint(nil),
+                       t: []v1.Taint(nil),
                },
                {
                        f: "--t=foo=bar:NoSchedule",
-                       t: []api.Taint{{Key: "foo", Value: "bar", Effect: "NoSchedule"}},
+                       t: []v1.Taint{{Key: "foo", Value: "bar", Effect: "NoSchedule"}},
                },
                {
                        f: "--t=baz:NoSchedule",
-                       t: []api.Taint{{Key: "baz", Value: "", Effect: "NoSchedule"}},
+                       t: []v1.Taint{{Key: "baz", Value: "", Effect: "NoSchedule"}},
                },
                {
                        f: "--t=foo=bar:NoSchedule,baz:NoSchedule,bing=bang:PreferNoSchedule,qux=:NoSchedule",
-                       t: []api.Taint{
-                               {Key: "foo", Value: "bar", Effect: api.TaintEffectNoSchedule},
+                       t: []v1.Taint{
+                               {Key: "foo", Value: "bar", Effect: v1.TaintEffectNoSchedule},
                                {Key: "baz", Value: "", Effect: "NoSchedule"},
-                               {Key: "bing", Value: "bang", Effect: api.TaintEffectPreferNoSchedule},
+                               {Key: "bing", Value: "bang", Effect: v1.TaintEffectPreferNoSchedule},
                                {Key: "qux", Value: "", Effect: "NoSchedule"},
                        },
                },
                {
                        f: "--t=dedicated-for=user1:NoExecute,baz:NoSchedule,foo-bar=:NoSchedule",
-                       t: []api.Taint{
+                       t: []v1.Taint{
                                {Key: "dedicated-for", Value: "user1", Effect: "NoExecute"},
                                {Key: "baz", Value: "", Effect: "NoSchedule"},
                                {Key: "foo-bar", Value: "", Effect: "NoSchedule"},
@@ -38,8 +38,8 @@ func TestTaintsVar(t *testing.T) {
        for i, c := range cases {
                args := append([]string{"test"}, strings.Fields(c.f)...)
                cli := pflag.NewFlagSet("test", pflag.ContinueOnError)
-               var taints []api.Taint
-               cli.Var(NewTaintsVar(&taints), "t", "bar")
+               var taints []v1.Taint
+               cli.Var(RegisterWithTaintsVar{Value: &taints}, "t", "bar")
 
                err := cli.Parse(args)
                if err == nil && c.err {