Merge pull request #8767 from baude/bindings3pods

podman v3 pod bindings

19 files changed, 1468 insertions, 107 deletions

diff --git a/pkg/bindings/pods/pods.go b/pkg/bindings/pods/pods.go
index c3f98eaab..4fcaf81f1 100644
--- a/pkg/bindings/pods/pods.go
+++ b/pkg/bindings/pods/pods.go
@@ -2,10 +2,8 @@ package pods
 
 import (
 	"context"
-	"errors"
 	"net/http"
 	"net/url"
-	"strconv"
 	"strings"
 
 	"github.com/containers/podman/v2/pkg/api/handlers"
@@ -15,10 +13,14 @@ import (
 	jsoniter "github.com/json-iterator/go"
 )
 
-func CreatePodFromSpec(ctx context.Context, s *specgen.PodSpecGenerator) (*entities.PodCreateReport, error) {
+func CreatePodFromSpec(ctx context.Context, s *specgen.PodSpecGenerator, options *CreateOptions) (*entities.PodCreateReport, error) {
 	var (
 		pcr entities.PodCreateReport
 	)
+	if options == nil {
+		options = new(CreateOptions)
+	}
+	_ = options
 	conn, err := bindings.GetClient(ctx)
 	if err != nil {
 		return nil, err
@@ -49,10 +51,14 @@ func Exists(ctx context.Context, nameOrID string) (bool, error) {
 }
 
 // Inspect returns low-level information about the given pod.
-func Inspect(ctx context.Context, nameOrID string) (*entities.PodInspectReport, error) {
+func Inspect(ctx context.Context, nameOrID string, options *InspectOptions) (*entities.PodInspectReport, error) {
 	var (
 		report entities.PodInspectReport
 	)
+	if options == nil {
+		options = new(InspectOptions)
+	}
+	_ = options
 	conn, err := bindings.GetClient(ctx)
 	if err != nil {
 		return nil, err
@@ -66,17 +72,20 @@ func Inspect(ctx context.Context, nameOrID string) (*entities.PodInspectReport,
 
 // Kill sends a SIGTERM to all the containers in a pod.  The optional signal parameter
 // can be used to override  SIGTERM.
-func Kill(ctx context.Context, nameOrID string, signal *string) (*entities.PodKillReport, error) {
+func Kill(ctx context.Context, nameOrID string, options *KillOptions) (*entities.PodKillReport, error) {
 	var (
 		report entities.PodKillReport
 	)
+	if options == nil {
+		options = new(KillOptions)
+	}
 	conn, err := bindings.GetClient(ctx)
 	if err != nil {
 		return nil, err
 	}
-	params := url.Values{}
-	if signal != nil {
-		params.Set("signal", *signal)
+	params, err := options.ToParams()
+	if err != nil {
+		return nil, err
 	}
 	response, err := conn.DoRequest(nil, http.MethodPost, "/pods/%s/kill", params, nil, nameOrID)
 	if err != nil {
@@ -86,8 +95,12 @@ func Kill(ctx context.Context, nameOrID string, signal *string) (*entities.PodKi
 }
 
 // Pause pauses all running containers in a given pod.
-func Pause(ctx context.Context, nameOrID string) (*entities.PodPauseReport, error) {
+func Pause(ctx context.Context, nameOrID string, options *PauseOptions) (*entities.PodPauseReport, error) {
 	var report entities.PodPauseReport
+	if options == nil {
+		options = new(PauseOptions)
+	}
+	_ = options
 	conn, err := bindings.GetClient(ctx)
 	if err != nil {
 		return nil, err
@@ -101,8 +114,12 @@ func Pause(ctx context.Context, nameOrID string) (*entities.PodPauseReport, erro
 
 // Prune by default removes all non-running pods in local storage.
 // And with force set true removes all pods.
-func Prune(ctx context.Context) ([]*entities.PodPruneReport, error) {
+func Prune(ctx context.Context, options *PruneOptions) ([]*entities.PodPruneReport, error) {
 	var reports []*entities.PodPruneReport
+	if options == nil {
+		options = new(PruneOptions)
+	}
+	_ = options
 	conn, err := bindings.GetClient(ctx)
 	if err != nil {
 		return nil, err
@@ -116,21 +133,20 @@ func Prune(ctx context.Context) ([]*entities.PodPruneReport, error) {
 
 // List returns all pods in local storage.  The optional filters parameter can
 // be used to refine which pods should be listed.
-func List(ctx context.Context, filters map[string][]string) ([]*entities.ListPodsReport, error) {
+func List(ctx context.Context, options *ListOptions) ([]*entities.ListPodsReport, error) {
 	var (
 		podsReports []*entities.ListPodsReport
 	)
+	if options == nil {
+		options = new(ListOptions)
+	}
 	conn, err := bindings.GetClient(ctx)
 	if err != nil {
 		return nil, err
 	}
-	params := url.Values{}
-	if filters != nil {
-		stringFilter, err := bindings.FiltersToString(filters)
-		if err != nil {
-			return nil, err
-		}
-		params.Set("filters", stringFilter)
+	params, err := options.ToParams()
+	if err != nil {
+		return nil, err
 	}
 	response, err := conn.DoRequest(nil, http.MethodGet, "/pods/json", params, nil)
 	if err != nil {
@@ -140,8 +156,12 @@ func List(ctx context.Context, filters map[string][]string) ([]*entities.ListPod
 }
 
 // Restart restarts all containers in a pod.
-func Restart(ctx context.Context, nameOrID string) (*entities.PodRestartReport, error) {
+func Restart(ctx context.Context, nameOrID string, options *RestartOptions) (*entities.PodRestartReport, error) {
 	var report entities.PodRestartReport
+	if options == nil {
+		options = new(RestartOptions)
+	}
+	_ = options
 	conn, err := bindings.GetClient(ctx)
 	if err != nil {
 		return nil, err
@@ -155,15 +175,18 @@ func Restart(ctx context.Context, nameOrID string) (*entities.PodRestartReport,
 
 // Remove deletes a Pod from from local storage. The optional force parameter denotes
 // that the Pod can be removed even if in a running state.
-func Remove(ctx context.Context, nameOrID string, force *bool) (*entities.PodRmReport, error) {
+func Remove(ctx context.Context, nameOrID string, options *RemoveOptions) (*entities.PodRmReport, error) {
 	var report entities.PodRmReport
+	if options == nil {
+		options = new(RemoveOptions)
+	}
 	conn, err := bindings.GetClient(ctx)
 	if err != nil {
 		return nil, err
 	}
-	params := url.Values{}
-	if force != nil {
-		params.Set("force", strconv.FormatBool(*force))
+	params, err := options.ToParams()
+	if err != nil {
+		return nil, err
 	}
 	response, err := conn.DoRequest(nil, http.MethodDelete, "/pods/%s", params, nil, nameOrID)
 	if err != nil {
@@ -173,8 +196,12 @@ func Remove(ctx context.Context, nameOrID string, force *bool) (*entities.PodRmR
 }
 
 // Start starts all containers in a pod.
-func Start(ctx context.Context, nameOrID string) (*entities.PodStartReport, error) {
+func Start(ctx context.Context, nameOrID string, options *StartOptions) (*entities.PodStartReport, error) {
 	var report entities.PodStartReport
+	if options == nil {
+		options = new(StartOptions)
+	}
+	_ = options
 	conn, err := bindings.GetClient(ctx)
 	if err != nil {
 		return nil, err
@@ -192,15 +219,18 @@ func Start(ctx context.Context, nameOrID string) (*entities.PodStartReport, erro
 
 // Stop stops all containers in a Pod. The optional timeout parameter can be
 // used to override the timeout before the container is killed.
-func Stop(ctx context.Context, nameOrID string, timeout *int) (*entities.PodStopReport, error) {
+func Stop(ctx context.Context, nameOrID string, options *StopOptions) (*entities.PodStopReport, error) {
 	var report entities.PodStopReport
+	if options == nil {
+		options = new(StopOptions)
+	}
 	conn, err := bindings.GetClient(ctx)
 	if err != nil {
 		return nil, err
 	}
-	params := url.Values{}
-	if timeout != nil {
-		params.Set("t", strconv.Itoa(*timeout))
+	params, err := options.ToParams()
+	if err != nil {
+		return nil, err
 	}
 	response, err := conn.DoRequest(nil, http.MethodPost, "/pods/%s/stop", params, nil, nameOrID)
 	if err != nil {
@@ -215,15 +245,16 @@ func Stop(ctx context.Context, nameOrID string, timeout *int) (*entities.PodStop
 
 // Top gathers statistics about the running processes in a pod. The nameOrID can be a pod name
 // or a partial/full ID.  The descriptors allow for specifying which data to collect from each process.
-func Top(ctx context.Context, nameOrID string, descriptors []string) ([]string, error) {
+func Top(ctx context.Context, nameOrID string, options *TopOptions) ([]string, error) {
+	if options == nil {
+		options = new(TopOptions)
+	}
 	conn, err := bindings.GetClient(ctx)
 	if err != nil {
 		return nil, err
 	}
 	params := url.Values{}
-
-	if len(descriptors) > 0 {
-		// flatten the slice into one string
+	if descriptors := options.GetDescriptors(); len(descriptors) > 0 {
 		params.Set("ps_args", strings.Join(descriptors, ","))
 	}
 	response, err := conn.DoRequest(nil, http.MethodGet, "/pods/%s/top", params, nil, nameOrID)
@@ -248,7 +279,11 @@ func Top(ctx context.Context, nameOrID string, descriptors []string) ([]string,
 }
 
 // Unpause unpauses all paused containers in a Pod.
-func Unpause(ctx context.Context, nameOrID string) (*entities.PodUnpauseReport, error) {
+func Unpause(ctx context.Context, nameOrID string, options *UnpauseOptions) (*entities.PodUnpauseReport, error) {
+	if options == nil {
+		options = new(UnpauseOptions)
+	}
+	_ = options
 	var report entities.PodUnpauseReport
 	conn, err := bindings.GetClient(ctx)
 	if err != nil {
@@ -262,19 +297,21 @@ func Unpause(ctx context.Context, nameOrID string) (*entities.PodUnpauseReport,
 }
 
 // Stats display resource-usage statistics of one or more pods.
-func Stats(ctx context.Context, namesOrIDs []string, options entities.PodStatsOptions) ([]*entities.PodStatsReport, error) {
-	if options.Latest {
-		return nil, errors.New("latest is not supported")
+func Stats(ctx context.Context, namesOrIDs []string, options *StatsOptions) ([]*entities.PodStatsReport, error) {
+	if options == nil {
+		options = new(StatsOptions)
 	}
 	conn, err := bindings.GetClient(ctx)
 	if err != nil {
 		return nil, err
 	}
-	params := url.Values{}
+	params, err := options.ToParams()
+	if err != nil {
+		return nil, err
+	}
 	for _, i := range namesOrIDs {
 		params.Add("namesOrIDs", i)
 	}
-	params.Set("all", strconv.FormatBool(options.All))
 
 	var reports []*entities.PodStatsReport
 	response, err := conn.DoRequest(nil, http.MethodGet, "/pods/stats", params, nil)
diff --git a/pkg/bindings/pods/types.go b/pkg/bindings/pods/types.go
new file mode 100644
index 000000000..370c1aaa9
--- /dev/null
+++ b/pkg/bindings/pods/types.go
@@ -0,0 +1,72 @@
+package pods
+
+//go:generate go run ../generator/generator.go CreateOptions
+// CreateOptions are optional options for creating pods
+type CreateOptions struct {
+}
+
+//go:generate go run ../generator/generator.go InspectOptions
+// InspectOptions are optional options for inspecting pods
+type InspectOptions struct {
+}
+
+//go:generate go run ../generator/generator.go KillOptions
+// KillOptions are optional options for killing pods
+type KillOptions struct {
+	Signal *string
+}
+
+//go:generate go run ../generator/generator.go PauseOptions
+// PauseOptions are optional options for pausing pods
+type PauseOptions struct {
+}
+
+//go:generate go run ../generator/generator.go PruneOptions
+// PruneOptions are optional options for pruning pods
+type PruneOptions struct {
+}
+
+//go:generate go run ../generator/generator.go ListOptions
+// ListOptions are optional options for listing pods
+type ListOptions struct {
+	Filters map[string][]string
+}
+
+//go:generate go run ../generator/generator.go RestartOptions
+// RestartOptions are optional options for restarting pods
+type RestartOptions struct {
+}
+
+//go:generate go run ../generator/generator.go StartOptions
+// StartOptions are optional options for starting pods
+type StartOptions struct {
+}
+
+//go:generate go run ../generator/generator.go StopOptions
+// StopOptions are optional options for stopping pods
+type StopOptions struct {
+	Timeout *int
+}
+
+//go:generate go run ../generator/generator.go TopOptions
+// TopOptions are optional options for getting top on pods
+type TopOptions struct {
+	Descriptors []string
+}
+
+//go:generate go run ../generator/generator.go UnpauseOptions
+// UnpauseOptions are optional options for unpausinging pods
+type UnpauseOptions struct {
+}
+
+//go:generate go run ../generator/generator.go StatsOptions
+// StatsOptions are optional options for getting stats of pods
+type StatsOptions struct {
+	All *bool
+}
+
+//go:generate go run ../generator/generator.go RemoveOptions
+// RemoveOptions are optional options for removing pods
+type RemoveOptions struct {
+	Force *bool
+}
diff --git a/pkg/bindings/pods/types_create_options.go b/pkg/bindings/pods/types_create_options.go
new file mode 100644
index 000000000..a4d195f45
--- /dev/null
+++ b/pkg/bindings/pods/types_create_options.go
@@ -0,0 +1,88 @@
+package pods
+
+import (
+	"net/url"
+	"reflect"
+	"strconv"
+
+	jsoniter "github.com/json-iterator/go"
+	"github.com/pkg/errors"
+)
+
+/*
+This file is generated automatically by go generate.  Do not edit.
+
+Created 2020-12-17 07:45:32.352415253 -0600 CST m=+0.000183834
+*/
+
+// Changed
+func (o *CreateOptions) Changed(fieldName string) bool {
+	r := reflect.ValueOf(o)
+	value := reflect.Indirect(r).FieldByName(fieldName)
+	return !value.IsNil()
+}
+
+// ToParams
+func (o *CreateOptions) ToParams() (url.Values, error) {
+	params := url.Values{}
+	if o == nil {
+		return params, nil
+	}
+	json := jsoniter.ConfigCompatibleWithStandardLibrary
+	s := reflect.ValueOf(o)
+	if reflect.Ptr == s.Kind() {
+		s = s.Elem()
+	}
+	sType := s.Type()
+	for i := 0; i < s.NumField(); i++ {
+		fieldName := sType.Field(i).Name
+		if !o.Changed(fieldName) {
+			continue
+		}
+		f := s.Field(i)
+		if reflect.Ptr == f.Kind() {
+			f = f.Elem()
+		}
+		switch f.Kind() {
+		case reflect.Bool:
+			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+		case reflect.String:
+			params.Set(fieldName, f.String())
+		case reflect.Int, reflect.Int64:
+			// f.Int() is always an int64
+			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+		case reflect.Uint, reflect.Uint64:
+			// f.Uint() is always an uint64
+			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
+		case reflect.Slice:
+			typ := reflect.TypeOf(f.Interface()).Elem()
+			slice := reflect.MakeSlice(reflect.SliceOf(typ), f.Len(), f.Cap())
+			switch typ.Kind() {
+			case reflect.String:
+				s, ok := slice.Interface().([]string)
+				if !ok {
+					return nil, errors.New("failed to convert to string slice")
+				}
+				for _, val := range s {
+					params.Add(fieldName, val)
+				}
+			default:
+				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
+			}
+		case reflect.Map:
+			lowerCaseKeys := make(map[string][]string)
+			iter := f.MapRange()
+			for iter.Next() {
+				lowerCaseKeys[iter.Key().Interface().(string)] = iter.Value().Interface().([]string)
+
+			}
+			s, err := json.MarshalToString(lowerCaseKeys)
+			if err != nil {
+				return nil, err
+			}
+
+			params.Set(fieldName, s)
+		}
+	}
+	return params, nil
+}
diff --git a/pkg/bindings/pods/types_inspect_options.go b/pkg/bindings/pods/types_inspect_options.go
new file mode 100644
index 000000000..938c81e5b
--- /dev/null
+++ b/pkg/bindings/pods/types_inspect_options.go
@@ -0,0 +1,88 @@
+package pods
+
+import (
+	"net/url"
+	"reflect"
+	"strconv"
+
+	jsoniter "github.com/json-iterator/go"
+	"github.com/pkg/errors"
+)
+
+/*
+This file is generated automatically by go generate.  Do not edit.
+
+Created 2020-12-17 07:45:32.765915823 -0600 CST m=+0.000180826
+*/
+
+// Changed
+func (o *InspectOptions) Changed(fieldName string) bool {
+	r := reflect.ValueOf(o)
+	value := reflect.Indirect(r).FieldByName(fieldName)
+	return !value.IsNil()
+}
+
+// ToParams
+func (o *InspectOptions) ToParams() (url.Values, error) {
+	params := url.Values{}
+	if o == nil {
+		return params, nil
+	}
+	json := jsoniter.ConfigCompatibleWithStandardLibrary
+	s := reflect.ValueOf(o)
+	if reflect.Ptr == s.Kind() {
+		s = s.Elem()
+	}
+	sType := s.Type()
+	for i := 0; i < s.NumField(); i++ {
+		fieldName := sType.Field(i).Name
+		if !o.Changed(fieldName) {
+			continue
+		}
+		f := s.Field(i)
+		if reflect.Ptr == f.Kind() {
+			f = f.Elem()
+		}
+		switch f.Kind() {
+		case reflect.Bool:
+			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+		case reflect.String:
+			params.Set(fieldName, f.String())
+		case reflect.Int, reflect.Int64:
+			// f.Int() is always an int64
+			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+		case reflect.Uint, reflect.Uint64:
+			// f.Uint() is always an uint64
+			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
+		case reflect.Slice:
+			typ := reflect.TypeOf(f.Interface()).Elem()
+			slice := reflect.MakeSlice(reflect.SliceOf(typ), f.Len(), f.Cap())
+			switch typ.Kind() {
+			case reflect.String:
+				s, ok := slice.Interface().([]string)
+				if !ok {
+					return nil, errors.New("failed to convert to string slice")
+				}
+				for _, val := range s {
+					params.Add(fieldName, val)
+				}
+			default:
+				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
+			}
+		case reflect.Map:
+			lowerCaseKeys := make(map[string][]string)
+			iter := f.MapRange()
+			for iter.Next() {
+				lowerCaseKeys[iter.Key().Interface().(string)] = iter.Value().Interface().([]string)
+
+			}
+			s, err := json.MarshalToString(lowerCaseKeys)
+			if err != nil {
+				return nil, err
+			}
+
+			params.Set(fieldName, s)
+		}
+	}
+	return params, nil
+}
diff --git a/pkg/bindings/pods/types_kill_options.go b/pkg/bindings/pods/types_kill_options.go
new file mode 100644
index 000000000..93b36f12f
--- /dev/null
+++ b/pkg/bindings/pods/types_kill_options.go
@@ -0,0 +1,104 @@
+package pods
+
+import (
+	"net/url"
+	"reflect"
+	"strconv"
+
+	jsoniter "github.com/json-iterator/go"
+	"github.com/pkg/errors"
+)
+
+/*
+This file is generated automatically by go generate.  Do not edit.
+
+Created 2020-12-17 07:45:32.905440724 -0600 CST m=+0.000171399
+*/
+
+// Changed
+func (o *KillOptions) Changed(fieldName string) bool {
+	r := reflect.ValueOf(o)
+	value := reflect.Indirect(r).FieldByName(fieldName)
+	return !value.IsNil()
+}
+
+// ToParams
+func (o *KillOptions) ToParams() (url.Values, error) {
+	params := url.Values{}
+	if o == nil {
+		return params, nil
+	}
+	json := jsoniter.ConfigCompatibleWithStandardLibrary
+	s := reflect.ValueOf(o)
+	if reflect.Ptr == s.Kind() {
+		s = s.Elem()
+	}
+	sType := s.Type()
+	for i := 0; i < s.NumField(); i++ {
+		fieldName := sType.Field(i).Name
+		if !o.Changed(fieldName) {
+			continue
+		}
+		f := s.Field(i)
+		if reflect.Ptr == f.Kind() {
+			f = f.Elem()
+		}
+		switch f.Kind() {
+		case reflect.Bool:
+			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+		case reflect.String:
+			params.Set(fieldName, f.String())
+		case reflect.Int, reflect.Int64:
+			// f.Int() is always an int64
+			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+		case reflect.Uint, reflect.Uint64:
+			// f.Uint() is always an uint64
+			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
+		case reflect.Slice:
+			typ := reflect.TypeOf(f.Interface()).Elem()
+			slice := reflect.MakeSlice(reflect.SliceOf(typ), f.Len(), f.Cap())
+			switch typ.Kind() {
+			case reflect.String:
+				s, ok := slice.Interface().([]string)
+				if !ok {
+					return nil, errors.New("failed to convert to string slice")
+				}
+				for _, val := range s {
+					params.Add(fieldName, val)
+				}
+			default:
+				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
+			}
+		case reflect.Map:
+			lowerCaseKeys := make(map[string][]string)
+			iter := f.MapRange()
+			for iter.Next() {
+				lowerCaseKeys[iter.Key().Interface().(string)] = iter.Value().Interface().([]string)
+
+			}
+			s, err := json.MarshalToString(lowerCaseKeys)
+			if err != nil {
+				return nil, err
+			}
+
+			params.Set(fieldName, s)
+		}
+	}
+	return params, nil
+}
+
+// WithSignal
+func (o *KillOptions) WithSignal(value string) *KillOptions {
+	v := &value
+	o.Signal = v
+	return o
+}
+
+// GetSignal
+func (o *KillOptions) GetSignal() string {
+	var signal string
+	if o.Signal == nil {
+		return signal
+	}
+	return *o.Signal
+}
diff --git a/pkg/bindings/pods/types_list_options.go b/pkg/bindings/pods/types_list_options.go
new file mode 100644
index 000000000..a6dc62ea3
--- /dev/null
+++ b/pkg/bindings/pods/types_list_options.go
@@ -0,0 +1,104 @@
+package pods
+
+import (
+	"net/url"
+	"reflect"
+	"strconv"
+
+	jsoniter "github.com/json-iterator/go"
+	"github.com/pkg/errors"
+)
+
+/*
+This file is generated automatically by go generate.  Do not edit.
+
+Created 2020-12-17 07:45:33.326756506 -0600 CST m=+0.000223292
+*/
+
+// Changed
+func (o *ListOptions) Changed(fieldName string) bool {
+	r := reflect.ValueOf(o)
+	value := reflect.Indirect(r).FieldByName(fieldName)
+	return !value.IsNil()
+}
+
+// ToParams
+func (o *ListOptions) ToParams() (url.Values, error) {
+	params := url.Values{}
+	if o == nil {
+		return params, nil
+	}
+	json := jsoniter.ConfigCompatibleWithStandardLibrary
+	s := reflect.ValueOf(o)
+	if reflect.Ptr == s.Kind() {
+		s = s.Elem()
+	}
+	sType := s.Type()
+	for i := 0; i < s.NumField(); i++ {
+		fieldName := sType.Field(i).Name
+		if !o.Changed(fieldName) {
+			continue
+		}
+		f := s.Field(i)
+		if reflect.Ptr == f.Kind() {
+			f = f.Elem()
+		}
+		switch f.Kind() {
+		case reflect.Bool:
+			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+		case reflect.String:
+			params.Set(fieldName, f.String())
+		case reflect.Int, reflect.Int64:
+			// f.Int() is always an int64
+			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+		case reflect.Uint, reflect.Uint64:
+			// f.Uint() is always an uint64
+			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
+		case reflect.Slice:
+			typ := reflect.TypeOf(f.Interface()).Elem()
+			slice := reflect.MakeSlice(reflect.SliceOf(typ), f.Len(), f.Cap())
+			switch typ.Kind() {
+			case reflect.String:
+				s, ok := slice.Interface().([]string)
+				if !ok {
+					return nil, errors.New("failed to convert to string slice")
+				}
+				for _, val := range s {
+					params.Add(fieldName, val)
+				}
+			default:
+				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
+			}
+		case reflect.Map:
+			lowerCaseKeys := make(map[string][]string)
+			iter := f.MapRange()
+			for iter.Next() {
+				lowerCaseKeys[iter.Key().Interface().(string)] = iter.Value().Interface().([]string)
+
+			}
+			s, err := json.MarshalToString(lowerCaseKeys)
+			if err != nil {
+				return nil, err
+			}
+
+			params.Set(fieldName, s)
+		}
+	}
+	return params, nil
+}
+
+// WithFilters
+func (o *ListOptions) WithFilters(value map[string][]string) *ListOptions {
+	v := value
+	o.Filters = v
+	return o
+}
+
+// GetFilters
+func (o *ListOptions) GetFilters() map[string][]string {
+	var filters map[string][]string
+	if o.Filters == nil {
+		return filters
+	}
+	return o.Filters
+}
diff --git a/pkg/bindings/pods/types_pause_options.go b/pkg/bindings/pods/types_pause_options.go
new file mode 100644
index 000000000..1ba32f1a1
--- /dev/null
+++ b/pkg/bindings/pods/types_pause_options.go
@@ -0,0 +1,88 @@
+package pods
+
+import (
+	"net/url"
+	"reflect"
+	"strconv"
+
+	jsoniter "github.com/json-iterator/go"
+	"github.com/pkg/errors"
+)
+
+/*
+This file is generated automatically by go generate.  Do not edit.
+
+Created 2020-12-17 07:45:33.042658764 -0600 CST m=+0.000177336
+*/
+
+// Changed
+func (o *PauseOptions) Changed(fieldName string) bool {
+	r := reflect.ValueOf(o)
+	value := reflect.Indirect(r).FieldByName(fieldName)
+	return !value.IsNil()
+}
+
+// ToParams
+func (o *PauseOptions) ToParams() (url.Values, error) {
+	params := url.Values{}
+	if o == nil {
+		return params, nil
+	}
+	json := jsoniter.ConfigCompatibleWithStandardLibrary
+	s := reflect.ValueOf(o)
+	if reflect.Ptr == s.Kind() {
+		s = s.Elem()
+	}
+	sType := s.Type()
+	for i := 0; i < s.NumField(); i++ {
+		fieldName := sType.Field(i).Name
+		if !o.Changed(fieldName) {
+			continue
+		}
+		f := s.Field(i)
+		if reflect.Ptr == f.Kind() {
+			f = f.Elem()
+		}
+		switch f.Kind() {
+		case reflect.Bool:
+			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+		case reflect.String:
+			params.Set(fieldName, f.String())
+		case reflect.Int, reflect.Int64:
+			// f.Int() is always an int64
+			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+		case reflect.Uint, reflect.Uint64:
+			// f.Uint() is always an uint64
+			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
+		case reflect.Slice:
+			typ := reflect.TypeOf(f.Interface()).Elem()
+			slice := reflect.MakeSlice(reflect.SliceOf(typ), f.Len(), f.Cap())
+			switch typ.Kind() {
+			case reflect.String:
+				s, ok := slice.Interface().([]string)
+				if !ok {
+					return nil, errors.New("failed to convert to string slice")
+				}
+				for _, val := range s {
+					params.Add(fieldName, val)
+				}
+			default:
+				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
+			}
+		case reflect.Map:
+			lowerCaseKeys := make(map[string][]string)
+			iter := f.MapRange()
+			for iter.Next() {
+				lowerCaseKeys[iter.Key().Interface().(string)] = iter.Value().Interface().([]string)
+
+			}
+			s, err := json.MarshalToString(lowerCaseKeys)
+			if err != nil {
+				return nil, err
+			}
+
+			params.Set(fieldName, s)
+		}
+	}
+	return params, nil
+}
diff --git a/pkg/bindings/pods/types_prune_options.go b/pkg/bindings/pods/types_prune_options.go
new file mode 100644
index 000000000..abc579383
--- /dev/null
+++ b/pkg/bindings/pods/types_prune_options.go
@@ -0,0 +1,88 @@
+package pods
+
+import (
+	"net/url"
+	"reflect"
+	"strconv"
+
+	jsoniter "github.com/json-iterator/go"
+	"github.com/pkg/errors"
+)
+
+/*
+This file is generated automatically by go generate.  Do not edit.
+
+Created 2020-12-17 07:45:33.183777637 -0600 CST m=+0.000163998
+*/
+
+// Changed
+func (o *PruneOptions) Changed(fieldName string) bool {
+	r := reflect.ValueOf(o)
+	value := reflect.Indirect(r).FieldByName(fieldName)
+	return !value.IsNil()
+}
+
+// ToParams
+func (o *PruneOptions) ToParams() (url.Values, error) {
+	params := url.Values{}
+	if o == nil {
+		return params, nil
+	}
+	json := jsoniter.ConfigCompatibleWithStandardLibrary
+	s := reflect.ValueOf(o)
+	if reflect.Ptr == s.Kind() {
+		s = s.Elem()
+	}
+	sType := s.Type()
+	for i := 0; i < s.NumField(); i++ {
+		fieldName := sType.Field(i).Name
+		if !o.Changed(fieldName) {
+			continue
+		}
+		f := s.Field(i)
+		if reflect.Ptr == f.Kind() {
+			f = f.Elem()
+		}
+		switch f.Kind() {
+		case reflect.Bool:
+			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+		case reflect.String:
+			params.Set(fieldName, f.String())
+		case reflect.Int, reflect.Int64:
+			// f.Int() is always an int64
+			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+		case reflect.Uint, reflect.Uint64:
+			// f.Uint() is always an uint64
+			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
+		case reflect.Slice:
+			typ := reflect.TypeOf(f.Interface()).Elem()
+			slice := reflect.MakeSlice(reflect.SliceOf(typ), f.Len(), f.Cap())
+			switch typ.Kind() {
+			case reflect.String:
+				s, ok := slice.Interface().([]string)
+				if !ok {
+					return nil, errors.New("failed to convert to string slice")
+				}
+				for _, val := range s {
+					params.Add(fieldName, val)
+				}
+			default:
+				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
+			}
+		case reflect.Map:
+			lowerCaseKeys := make(map[string][]string)
+			iter := f.MapRange()
+			for iter.Next() {
+				lowerCaseKeys[iter.Key().Interface().(string)] = iter.Value().Interface().([]string)
+
+			}
+			s, err := json.MarshalToString(lowerCaseKeys)
+			if err != nil {
+				return nil, err
+			}
+
+			params.Set(fieldName, s)
+		}
+	}
+	return params, nil
+}
diff --git a/pkg/bindings/pods/types_remove_options.go b/pkg/bindings/pods/types_remove_options.go
new file mode 100644
index 000000000..f3f04a1ba
--- /dev/null
+++ b/pkg/bindings/pods/types_remove_options.go
@@ -0,0 +1,104 @@
+package pods
+
+import (
+	"net/url"
+	"reflect"
+	"strconv"
+
+	jsoniter "github.com/json-iterator/go"
+	"github.com/pkg/errors"
+)
+
+/*
+This file is generated automatically by go generate.  Do not edit.
+
+Created 2020-12-17 07:45:34.321961766 -0600 CST m=+0.000169681
+*/
+
+// Changed
+func (o *RemoveOptions) Changed(fieldName string) bool {
+	r := reflect.ValueOf(o)
+	value := reflect.Indirect(r).FieldByName(fieldName)
+	return !value.IsNil()
+}
+
+// ToParams
+func (o *RemoveOptions) ToParams() (url.Values, error) {
+	params := url.Values{}
+	if o == nil {
+		return params, nil
+	}
+	json := jsoniter.ConfigCompatibleWithStandardLibrary
+	s := reflect.ValueOf(o)
+	if reflect.Ptr == s.Kind() {
+		s = s.Elem()
+	}
+	sType := s.Type()
+	for i := 0; i < s.NumField(); i++ {
+		fieldName := sType.Field(i).Name
+		if !o.Changed(fieldName) {
+			continue
+		}
+		f := s.Field(i)
+		if reflect.Ptr == f.Kind() {
+			f = f.Elem()
+		}
+		switch f.Kind() {
+		case reflect.Bool:
+			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+		case reflect.String:
+			params.Set(fieldName, f.String())
+		case reflect.Int, reflect.Int64:
+			// f.Int() is always an int64
+			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+		case reflect.Uint, reflect.Uint64:
+			// f.Uint() is always an uint64
+			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
+		case reflect.Slice:
+			typ := reflect.TypeOf(f.Interface()).Elem()
+			slice := reflect.MakeSlice(reflect.SliceOf(typ), f.Len(), f.Cap())
+			switch typ.Kind() {
+			case reflect.String:
+				s, ok := slice.Interface().([]string)
+				if !ok {
+					return nil, errors.New("failed to convert to string slice")
+				}
+				for _, val := range s {
+					params.Add(fieldName, val)
+				}
+			default:
+				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
+			}
+		case reflect.Map:
+			lowerCaseKeys := make(map[string][]string)
+			iter := f.MapRange()
+			for iter.Next() {
+				lowerCaseKeys[iter.Key().Interface().(string)] = iter.Value().Interface().([]string)
+
+			}
+			s, err := json.MarshalToString(lowerCaseKeys)
+			if err != nil {
+				return nil, err
+			}
+
+			params.Set(fieldName, s)
+		}
+	}
+	return params, nil
+}
+
+// WithForce
+func (o *RemoveOptions) WithForce(value bool) *RemoveOptions {
+	v := &value
+	o.Force = v
+	return o
+}
+
+// GetForce
+func (o *RemoveOptions) GetForce() bool {
+	var force bool
+	if o.Force == nil {
+		return force
+	}
+	return *o.Force
+}
diff --git a/pkg/bindings/pods/types_restart_options.go b/pkg/bindings/pods/types_restart_options.go
new file mode 100644
index 000000000..f4992bf12
--- /dev/null
+++ b/pkg/bindings/pods/types_restart_options.go
@@ -0,0 +1,88 @@
+package pods
+
+import (
+	"net/url"
+	"reflect"
+	"strconv"
+
+	jsoniter "github.com/json-iterator/go"
+	"github.com/pkg/errors"
+)
+
+/*
+This file is generated automatically by go generate.  Do not edit.
+
+Created 2020-12-17 07:45:33.468350594 -0600 CST m=+0.000198305
+*/
+
+// Changed
+func (o *RestartOptions) Changed(fieldName string) bool {
+	r := reflect.ValueOf(o)
+	value := reflect.Indirect(r).FieldByName(fieldName)
+	return !value.IsNil()
+}
+
+// ToParams
+func (o *RestartOptions) ToParams() (url.Values, error) {
+	params := url.Values{}
+	if o == nil {
+		return params, nil
+	}
+	json := jsoniter.ConfigCompatibleWithStandardLibrary
+	s := reflect.ValueOf(o)
+	if reflect.Ptr == s.Kind() {
+		s = s.Elem()
+	}
+	sType := s.Type()
+	for i := 0; i < s.NumField(); i++ {
+		fieldName := sType.Field(i).Name
+		if !o.Changed(fieldName) {
+			continue
+		}
+		f := s.Field(i)
+		if reflect.Ptr == f.Kind() {
+			f = f.Elem()
+		}
+		switch f.Kind() {
+		case reflect.Bool:
+			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+		case reflect.String:
+			params.Set(fieldName, f.String())
+		case reflect.Int, reflect.Int64:
+			// f.Int() is always an int64
+			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+		case reflect.Uint, reflect.Uint64:
+			// f.Uint() is always an uint64
+			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
+		case reflect.Slice:
+			typ := reflect.TypeOf(f.Interface()).Elem()
+			slice := reflect.MakeSlice(reflect.SliceOf(typ), f.Len(), f.Cap())
+			switch typ.Kind() {
+			case reflect.String:
+				s, ok := slice.Interface().([]string)
+				if !ok {
+					return nil, errors.New("failed to convert to string slice")
+				}
+				for _, val := range s {
+					params.Add(fieldName, val)
+				}
+			default:
+				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
+			}
+		case reflect.Map:
+			lowerCaseKeys := make(map[string][]string)
+			iter := f.MapRange()
+			for iter.Next() {
+				lowerCaseKeys[iter.Key().Interface().(string)] = iter.Value().Interface().([]string)
+
+			}
+			s, err := json.MarshalToString(lowerCaseKeys)
+			if err != nil {
+				return nil, err
+			}
+
+			params.Set(fieldName, s)
+		}
+	}
+	return params, nil
+}
diff --git a/pkg/bindings/pods/types_start_options.go b/pkg/bindings/pods/types_start_options.go
new file mode 100644
index 000000000..21e382db8
--- /dev/null
+++ b/pkg/bindings/pods/types_start_options.go
@@ -0,0 +1,88 @@
+package pods
+
+import (
+	"net/url"
+	"reflect"
+	"strconv"
+
+	jsoniter "github.com/json-iterator/go"
+	"github.com/pkg/errors"
+)
+
+/*
+This file is generated automatically by go generate.  Do not edit.
+
+Created 2020-12-17 07:45:33.610327478 -0600 CST m=+0.000190011
+*/
+
+// Changed
+func (o *StartOptions) Changed(fieldName string) bool {
+	r := reflect.ValueOf(o)
+	value := reflect.Indirect(r).FieldByName(fieldName)
+	return !value.IsNil()
+}
+
+// ToParams
+func (o *StartOptions) ToParams() (url.Values, error) {
+	params := url.Values{}
+	if o == nil {
+		return params, nil
+	}
+	json := jsoniter.ConfigCompatibleWithStandardLibrary
+	s := reflect.ValueOf(o)
+	if reflect.Ptr == s.Kind() {
+		s = s.Elem()
+	}
+	sType := s.Type()
+	for i := 0; i < s.NumField(); i++ {
+		fieldName := sType.Field(i).Name
+		if !o.Changed(fieldName) {
+			continue
+		}
+		f := s.Field(i)
+		if reflect.Ptr == f.Kind() {
+			f = f.Elem()
+		}
+		switch f.Kind() {
+		case reflect.Bool:
+			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+		case reflect.String:
+			params.Set(fieldName, f.String())
+		case reflect.Int, reflect.Int64:
+			// f.Int() is always an int64
+			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+		case reflect.Uint, reflect.Uint64:
+			// f.Uint() is always an uint64
+			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
+		case reflect.Slice:
+			typ := reflect.TypeOf(f.Interface()).Elem()
+			slice := reflect.MakeSlice(reflect.SliceOf(typ), f.Len(), f.Cap())
+			switch typ.Kind() {
+			case reflect.String:
+				s, ok := slice.Interface().([]string)
+				if !ok {
+					return nil, errors.New("failed to convert to string slice")
+				}
+				for _, val := range s {
+					params.Add(fieldName, val)
+				}
+			default:
+				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
+			}
+		case reflect.Map:
+			lowerCaseKeys := make(map[string][]string)
+			iter := f.MapRange()
+			for iter.Next() {
+				lowerCaseKeys[iter.Key().Interface().(string)] = iter.Value().Interface().([]string)
+
+			}
+			s, err := json.MarshalToString(lowerCaseKeys)
+			if err != nil {
+				return nil, err
+			}
+
+			params.Set(fieldName, s)
+		}
+	}
+	return params, nil
+}
diff --git a/pkg/bindings/pods/types_stats_options.go b/pkg/bindings/pods/types_stats_options.go
new file mode 100644
index 000000000..eb10d16ce
--- /dev/null
+++ b/pkg/bindings/pods/types_stats_options.go
@@ -0,0 +1,104 @@
+package pods
+
+import (
+	"net/url"
+	"reflect"
+	"strconv"
+
+	jsoniter "github.com/json-iterator/go"
+	"github.com/pkg/errors"
+)
+
+/*
+This file is generated automatically by go generate.  Do not edit.
+
+Created 2020-12-17 07:45:34.181335419 -0600 CST m=+0.000176684
+*/
+
+// Changed
+func (o *StatsOptions) Changed(fieldName string) bool {
+	r := reflect.ValueOf(o)
+	value := reflect.Indirect(r).FieldByName(fieldName)
+	return !value.IsNil()
+}
+
+// ToParams
+func (o *StatsOptions) ToParams() (url.Values, error) {
+	params := url.Values{}
+	if o == nil {
+		return params, nil
+	}
+	json := jsoniter.ConfigCompatibleWithStandardLibrary
+	s := reflect.ValueOf(o)
+	if reflect.Ptr == s.Kind() {
+		s = s.Elem()
+	}
+	sType := s.Type()
+	for i := 0; i < s.NumField(); i++ {
+		fieldName := sType.Field(i).Name
+		if !o.Changed(fieldName) {
+			continue
+		}
+		f := s.Field(i)
+		if reflect.Ptr == f.Kind() {
+			f = f.Elem()
+		}
+		switch f.Kind() {
+		case reflect.Bool:
+			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+		case reflect.String:
+			params.Set(fieldName, f.String())
+		case reflect.Int, reflect.Int64:
+			// f.Int() is always an int64
+			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+		case reflect.Uint, reflect.Uint64:
+			// f.Uint() is always an uint64
+			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
+		case reflect.Slice:
+			typ := reflect.TypeOf(f.Interface()).Elem()
+			slice := reflect.MakeSlice(reflect.SliceOf(typ), f.Len(), f.Cap())
+			switch typ.Kind() {
+			case reflect.String:
+				s, ok := slice.Interface().([]string)
+				if !ok {
+					return nil, errors.New("failed to convert to string slice")
+				}
+				for _, val := range s {
+					params.Add(fieldName, val)
+				}
+			default:
+				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
+			}
+		case reflect.Map:
+			lowerCaseKeys := make(map[string][]string)
+			iter := f.MapRange()
+			for iter.Next() {
+				lowerCaseKeys[iter.Key().Interface().(string)] = iter.Value().Interface().([]string)
+
+			}
+			s, err := json.MarshalToString(lowerCaseKeys)
+			if err != nil {
+				return nil, err
+			}
+
+			params.Set(fieldName, s)
+		}
+	}
+	return params, nil
+}
+
+// WithAll
+func (o *StatsOptions) WithAll(value bool) *StatsOptions {
+	v := &value
+	o.All = v
+	return o
+}
+
+// GetAll
+func (o *StatsOptions) GetAll() bool {
+	var all bool
+	if o.All == nil {
+		return all
+	}
+	return *o.All
+}
diff --git a/pkg/bindings/pods/types_stop_options.go b/pkg/bindings/pods/types_stop_options.go
new file mode 100644
index 000000000..088c095e0
--- /dev/null
+++ b/pkg/bindings/pods/types_stop_options.go
@@ -0,0 +1,104 @@
+package pods
+
+import (
+	"net/url"
+	"reflect"
+	"strconv"
+
+	jsoniter "github.com/json-iterator/go"
+	"github.com/pkg/errors"
+)
+
+/*
+This file is generated automatically by go generate.  Do not edit.
+
+Created 2020-12-17 07:45:33.753353816 -0600 CST m=+0.000168107
+*/
+
+// Changed
+func (o *StopOptions) Changed(fieldName string) bool {
+	r := reflect.ValueOf(o)
+	value := reflect.Indirect(r).FieldByName(fieldName)
+	return !value.IsNil()
+}
+
+// ToParams
+func (o *StopOptions) ToParams() (url.Values, error) {
+	params := url.Values{}
+	if o == nil {
+		return params, nil
+	}
+	json := jsoniter.ConfigCompatibleWithStandardLibrary
+	s := reflect.ValueOf(o)
+	if reflect.Ptr == s.Kind() {
+		s = s.Elem()
+	}
+	sType := s.Type()
+	for i := 0; i < s.NumField(); i++ {
+		fieldName := sType.Field(i).Name
+		if !o.Changed(fieldName) {
+			continue
+		}
+		f := s.Field(i)
+		if reflect.Ptr == f.Kind() {
+			f = f.Elem()
+		}
+		switch f.Kind() {
+		case reflect.Bool:
+			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+		case reflect.String:
+			params.Set(fieldName, f.String())
+		case reflect.Int, reflect.Int64:
+			// f.Int() is always an int64
+			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+		case reflect.Uint, reflect.Uint64:
+			// f.Uint() is always an uint64
+			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
+		case reflect.Slice:
+			typ := reflect.TypeOf(f.Interface()).Elem()
+			slice := reflect.MakeSlice(reflect.SliceOf(typ), f.Len(), f.Cap())
+			switch typ.Kind() {
+			case reflect.String:
+				s, ok := slice.Interface().([]string)
+				if !ok {
+					return nil, errors.New("failed to convert to string slice")
+				}
+				for _, val := range s {
+					params.Add(fieldName, val)
+				}
+			default:
+				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
+			}
+		case reflect.Map:
+			lowerCaseKeys := make(map[string][]string)
+			iter := f.MapRange()
+			for iter.Next() {
+				lowerCaseKeys[iter.Key().Interface().(string)] = iter.Value().Interface().([]string)
+
+			}
+			s, err := json.MarshalToString(lowerCaseKeys)
+			if err != nil {
+				return nil, err
+			}
+
+			params.Set(fieldName, s)
+		}
+	}
+	return params, nil
+}
+
+// WithTimeout
+func (o *StopOptions) WithTimeout(value int) *StopOptions {
+	v := &value
+	o.Timeout = v
+	return o
+}
+
+// GetTimeout
+func (o *StopOptions) GetTimeout() int {
+	var timeout int
+	if o.Timeout == nil {
+		return timeout
+	}
+	return *o.Timeout
+}
diff --git a/pkg/bindings/pods/types_top_options.go b/pkg/bindings/pods/types_top_options.go
new file mode 100644
index 000000000..385f8655d
--- /dev/null
+++ b/pkg/bindings/pods/types_top_options.go
@@ -0,0 +1,104 @@
+package pods
+
+import (
+	"net/url"
+	"reflect"
+	"strconv"
+
+	jsoniter "github.com/json-iterator/go"
+	"github.com/pkg/errors"
+)
+
+/*
+This file is generated automatically by go generate.  Do not edit.
+
+Created 2020-12-17 07:45:33.897063 -0600 CST m=+0.000164071
+*/
+
+// Changed
+func (o *TopOptions) Changed(fieldName string) bool {
+	r := reflect.ValueOf(o)
+	value := reflect.Indirect(r).FieldByName(fieldName)
+	return !value.IsNil()
+}
+
+// ToParams
+func (o *TopOptions) ToParams() (url.Values, error) {
+	params := url.Values{}
+	if o == nil {
+		return params, nil
+	}
+	json := jsoniter.ConfigCompatibleWithStandardLibrary
+	s := reflect.ValueOf(o)
+	if reflect.Ptr == s.Kind() {
+		s = s.Elem()
+	}
+	sType := s.Type()
+	for i := 0; i < s.NumField(); i++ {
+		fieldName := sType.Field(i).Name
+		if !o.Changed(fieldName) {
+			continue
+		}
+		f := s.Field(i)
+		if reflect.Ptr == f.Kind() {
+			f = f.Elem()
+		}
+		switch f.Kind() {
+		case reflect.Bool:
+			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+		case reflect.String:
+			params.Set(fieldName, f.String())
+		case reflect.Int, reflect.Int64:
+			// f.Int() is always an int64
+			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+		case reflect.Uint, reflect.Uint64:
+			// f.Uint() is always an uint64
+			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
+		case reflect.Slice:
+			typ := reflect.TypeOf(f.Interface()).Elem()
+			slice := reflect.MakeSlice(reflect.SliceOf(typ), f.Len(), f.Cap())
+			switch typ.Kind() {
+			case reflect.String:
+				s, ok := slice.Interface().([]string)
+				if !ok {
+					return nil, errors.New("failed to convert to string slice")
+				}
+				for _, val := range s {
+					params.Add(fieldName, val)
+				}
+			default:
+				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
+			}
+		case reflect.Map:
+			lowerCaseKeys := make(map[string][]string)
+			iter := f.MapRange()
+			for iter.Next() {
+				lowerCaseKeys[iter.Key().Interface().(string)] = iter.Value().Interface().([]string)
+
+			}
+			s, err := json.MarshalToString(lowerCaseKeys)
+			if err != nil {
+				return nil, err
+			}
+
+			params.Set(fieldName, s)
+		}
+	}
+	return params, nil
+}
+
+// WithDescriptors
+func (o *TopOptions) WithDescriptors(value []string) *TopOptions {
+	v := value
+	o.Descriptors = v
+	return o
+}
+
+// GetDescriptors
+func (o *TopOptions) GetDescriptors() []string {
+	var descriptors []string
+	if o.Descriptors == nil {
+		return descriptors
+	}
+	return o.Descriptors
+}
diff --git a/pkg/bindings/pods/types_unpause_options.go b/pkg/bindings/pods/types_unpause_options.go
new file mode 100644
index 000000000..5ac588d9f
--- /dev/null
+++ b/pkg/bindings/pods/types_unpause_options.go
@@ -0,0 +1,88 @@
+package pods
+
+import (
+	"net/url"
+	"reflect"
+	"strconv"
+
+	jsoniter "github.com/json-iterator/go"
+	"github.com/pkg/errors"
+)
+
+/*
+This file is generated automatically by go generate.  Do not edit.
+
+Created 2020-12-17 07:45:34.038858053 -0600 CST m=+0.000173181
+*/
+
+// Changed
+func (o *UnpauseOptions) Changed(fieldName string) bool {
+	r := reflect.ValueOf(o)
+	value := reflect.Indirect(r).FieldByName(fieldName)
+	return !value.IsNil()
+}
+
+// ToParams
+func (o *UnpauseOptions) ToParams() (url.Values, error) {
+	params := url.Values{}
+	if o == nil {
+		return params, nil
+	}
+	json := jsoniter.ConfigCompatibleWithStandardLibrary
+	s := reflect.ValueOf(o)
+	if reflect.Ptr == s.Kind() {
+		s = s.Elem()
+	}
+	sType := s.Type()
+	for i := 0; i < s.NumField(); i++ {
+		fieldName := sType.Field(i).Name
+		if !o.Changed(fieldName) {
+			continue
+		}
+		f := s.Field(i)
+		if reflect.Ptr == f.Kind() {
+			f = f.Elem()
+		}
+		switch f.Kind() {
+		case reflect.Bool:
+			params.Set(fieldName, strconv.FormatBool(f.Bool()))
+		case reflect.String:
+			params.Set(fieldName, f.String())
+		case reflect.Int, reflect.Int64:
+			// f.Int() is always an int64
+			params.Set(fieldName, strconv.FormatInt(f.Int(), 10))
+		case reflect.Uint, reflect.Uint64:
+			// f.Uint() is always an uint64
+			params.Set(fieldName, strconv.FormatUint(f.Uint(), 10))
+		case reflect.Slice:
+			typ := reflect.TypeOf(f.Interface()).Elem()
+			slice := reflect.MakeSlice(reflect.SliceOf(typ), f.Len(), f.Cap())
+			switch typ.Kind() {
+			case reflect.String:
+				s, ok := slice.Interface().([]string)
+				if !ok {
+					return nil, errors.New("failed to convert to string slice")
+				}
+				for _, val := range s {
+					params.Add(fieldName, val)
+				}
+			default:
+				return nil, errors.Errorf("unknown slice type %s", f.Kind().String())
+			}
+		case reflect.Map:
+			lowerCaseKeys := make(map[string][]string)
+			iter := f.MapRange()
+			for iter.Next() {
+				lowerCaseKeys[iter.Key().Interface().(string)] = iter.Value().Interface().([]string)
+
+			}
+			s, err := json.MarshalToString(lowerCaseKeys)
+			if err != nil {
+				return nil, err
+			}
+
+			params.Set(fieldName, s)
+		}
+	}
+	return params, nil
+}
diff --git a/pkg/bindings/test/pods_test.go b/pkg/bindings/test/pods_test.go
index 8498de020..17b142fc2 100644
--- a/pkg/bindings/test/pods_test.go
+++ b/pkg/bindings/test/pods_test.go
@@ -40,13 +40,13 @@ var _ = Describe("Podman pods", func() {
 
 	It("inspect pod", func() {
 		//Inspect an invalid pod name
-		_, err := pods.Inspect(bt.conn, "dummyname")
+		_, err := pods.Inspect(bt.conn, "dummyname", nil)
 		Expect(err).ToNot(BeNil())
 		code, _ := bindings.CheckResponseCode(err)
 		Expect(code).To(BeNumerically("==", http.StatusNotFound))
 
 		//Inspect an valid pod name
-		response, err := pods.Inspect(bt.conn, newpod)
+		response, err := pods.Inspect(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
 		Expect(response.Name).To(Equal(newpod))
 	})
@@ -59,7 +59,7 @@ var _ = Describe("Podman pods", func() {
 		Expect(len(podSummary)).To(Equal(1))
 
 		// Start the pod
-		_, err = pods.Start(bt.conn, newpod)
+		_, err = pods.Start(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
 
 		// Adding an alpine container to the existing pod
@@ -90,7 +90,7 @@ var _ = Describe("Podman pods", func() {
 		bt.Podcreate(&newpod2)
 
 		// Start the pod
-		_, err = pods.Start(bt.conn, newpod)
+		_, err = pods.Start(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
 
 		_, err = bt.RunTopContainer(nil, bindings.PTrue, &newpod)
@@ -99,7 +99,8 @@ var _ = Describe("Podman pods", func() {
 		// Expected err with invalid filter params
 		filters := make(map[string][]string)
 		filters["dummy"] = []string{"dummy"}
-		filteredPods, err := pods.List(bt.conn, filters)
+		options := new(pods.ListOptions).WithFilters(filters)
+		filteredPods, err := pods.List(bt.conn, options)
 		Expect(err).ToNot(BeNil())
 		code, _ := bindings.CheckResponseCode(err)
 		Expect(code).To(BeNumerically("==", http.StatusInternalServerError))
@@ -107,14 +108,16 @@ var _ = Describe("Podman pods", func() {
 		// Expected empty response with invalid filters
 		filters = make(map[string][]string)
 		filters["name"] = []string{"dummy"}
-		filteredPods, err = pods.List(bt.conn, filters)
+		options = new(pods.ListOptions).WithFilters(filters)
+		filteredPods, err = pods.List(bt.conn, options)
 		Expect(err).To(BeNil())
 		Expect(len(filteredPods)).To(BeNumerically("==", 0))
 
 		// Validate list pod with name filter
 		filters = make(map[string][]string)
 		filters["name"] = []string{newpod2}
-		filteredPods, err = pods.List(bt.conn, filters)
+		options = new(pods.ListOptions).WithFilters(filters)
+		filteredPods, err = pods.List(bt.conn, options)
 		Expect(err).To(BeNil())
 		Expect(len(filteredPods)).To(BeNumerically("==", 1))
 		var names []string
@@ -125,11 +128,12 @@ var _ = Describe("Podman pods", func() {
 
 		// Validate list pod with id filter
 		filters = make(map[string][]string)
-		response, err := pods.Inspect(bt.conn, newpod)
+		response, err := pods.Inspect(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
 		id := response.ID
 		filters["id"] = []string{id}
-		filteredPods, err = pods.List(bt.conn, filters)
+		options = new(pods.ListOptions).WithFilters(filters)
+		filteredPods, err = pods.List(bt.conn, options)
 		Expect(err).To(BeNil())
 		Expect(len(filteredPods)).To(BeNumerically("==", 1))
 		names = names[:0]
@@ -140,7 +144,8 @@ var _ = Describe("Podman pods", func() {
 
 		// Using multiple filters
 		filters["name"] = []string{newpod}
-		filteredPods, err = pods.List(bt.conn, filters)
+		options = new(pods.ListOptions).WithFilters(filters)
+		filteredPods, err = pods.List(bt.conn, options)
 		Expect(err).To(BeNil())
 		Expect(len(filteredPods)).To(BeNumerically("==", 1))
 		names = names[:0]
@@ -168,7 +173,7 @@ var _ = Describe("Podman pods", func() {
 		// TODO fix this
 		Skip("Pod behavior is jacked right now.")
 		// Pause invalid container
-		_, err := pods.Pause(bt.conn, "dummyName")
+		_, err := pods.Pause(bt.conn, "dummyName", nil)
 		Expect(err).ToNot(BeNil())
 		code, _ := bindings.CheckResponseCode(err)
 		Expect(code).To(BeNumerically("==", http.StatusNotFound))
@@ -180,9 +185,9 @@ var _ = Describe("Podman pods", func() {
 		// Binding needs to be modified to inspect the pod state.
 		// Since we don't have a pod state we inspect the states of the containers within the pod.
 		// Pause a valid container
-		_, err = pods.Pause(bt.conn, newpod)
+		_, err = pods.Pause(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
-		response, err := pods.Inspect(bt.conn, newpod)
+		response, err := pods.Inspect(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
 		Expect(response.State).To(Equal(define.PodStatePaused))
 		for _, i := range response.Containers {
@@ -191,9 +196,9 @@ var _ = Describe("Podman pods", func() {
 		}
 
 		// Unpause a valid container
-		_, err = pods.Unpause(bt.conn, newpod)
+		_, err = pods.Unpause(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
-		response, err = pods.Inspect(bt.conn, newpod)
+		response, err = pods.Inspect(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
 		Expect(response.State).To(Equal(define.PodStateRunning))
 		for _, i := range response.Containers {
@@ -204,7 +209,7 @@ var _ = Describe("Podman pods", func() {
 
 	It("start stop restart pod", func() {
 		// Start an invalid pod
-		_, err = pods.Start(bt.conn, "dummyName")
+		_, err = pods.Start(bt.conn, "dummyName", nil)
 		Expect(err).ToNot(BeNil())
 		code, _ := bindings.CheckResponseCode(err)
 		Expect(code).To(BeNumerically("==", http.StatusNotFound))
@@ -216,16 +221,16 @@ var _ = Describe("Podman pods", func() {
 		Expect(code).To(BeNumerically("==", http.StatusNotFound))
 
 		// Restart an invalid pod
-		_, err = pods.Restart(bt.conn, "dummyName")
+		_, err = pods.Restart(bt.conn, "dummyName", nil)
 		Expect(err).ToNot(BeNil())
 		code, _ = bindings.CheckResponseCode(err)
 		Expect(code).To(BeNumerically("==", http.StatusNotFound))
 
 		// Start a valid pod and inspect status of each container
-		_, err = pods.Start(bt.conn, newpod)
+		_, err = pods.Start(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
 
-		response, err := pods.Inspect(bt.conn, newpod)
+		response, err := pods.Inspect(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
 		Expect(response.State).To(Equal(define.PodStateRunning))
 		for _, i := range response.Containers {
@@ -234,13 +239,13 @@ var _ = Describe("Podman pods", func() {
 		}
 
 		// Start an already running  pod
-		_, err = pods.Start(bt.conn, newpod)
+		_, err = pods.Start(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
 
 		// Stop the running pods
 		_, err = pods.Stop(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
-		response, _ = pods.Inspect(bt.conn, newpod)
+		response, _ = pods.Inspect(bt.conn, newpod, nil)
 		Expect(response.State).To(Equal(define.PodStateExited))
 		for _, i := range response.Containers {
 			Expect(define.StringToContainerStatus(i.State)).
@@ -251,9 +256,9 @@ var _ = Describe("Podman pods", func() {
 		_, err = pods.Stop(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
 
-		_, err = pods.Restart(bt.conn, newpod)
+		_, err = pods.Restart(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
-		response, _ = pods.Inspect(bt.conn, newpod)
+		response, _ = pods.Inspect(bt.conn, newpod, nil)
 		Expect(response.State).To(Equal(define.PodStateRunning))
 		for _, i := range response.Containers {
 			Expect(define.StringToContainerStatus(i.State)).
@@ -267,7 +272,7 @@ var _ = Describe("Podman pods", func() {
 		var newpod2 string = "newpod2"
 		bt.Podcreate(&newpod2)
 		// No pods pruned since no pod in exited state
-		pruneResponse, err := pods.Prune(bt.conn)
+		pruneResponse, err := pods.Prune(bt.conn, nil)
 		Expect(err).To(BeNil())
 		podSummary, err := pods.List(bt.conn, nil)
 		Expect(err).To(BeNil())
@@ -276,14 +281,14 @@ var _ = Describe("Podman pods", func() {
 		// Prune only one pod which is in exited state.
 		// Start then stop a pod.
 		// pod moves to exited state one pod should be pruned now.
-		_, err = pods.Start(bt.conn, newpod)
+		_, err = pods.Start(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
 		_, err = pods.Stop(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
-		response, err := pods.Inspect(bt.conn, newpod)
+		response, err := pods.Inspect(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
 		Expect(response.State).To(Equal(define.PodStateExited))
-		pruneResponse, err = pods.Prune(bt.conn)
+		pruneResponse, err = pods.Prune(bt.conn, nil)
 		Expect(err).To(BeNil())
 		// Validate status and record pod id of pod to be pruned
 		Expect(response.State).To(Equal(define.PodStateExited))
@@ -298,13 +303,13 @@ var _ = Describe("Podman pods", func() {
 
 		// Test prune multiple pods.
 		bt.Podcreate(&newpod)
-		_, err = pods.Start(bt.conn, newpod)
+		_, err = pods.Start(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
-		_, err = pods.Start(bt.conn, newpod2)
+		_, err = pods.Start(bt.conn, newpod2, nil)
 		Expect(err).To(BeNil())
 		_, err = pods.Stop(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
-		response, err = pods.Inspect(bt.conn, newpod)
+		response, err = pods.Inspect(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
 		Expect(response.State).To(Equal(define.PodStateExited))
 		for _, i := range response.Containers {
@@ -313,14 +318,14 @@ var _ = Describe("Podman pods", func() {
 		}
 		_, err = pods.Stop(bt.conn, newpod2, nil)
 		Expect(err).To(BeNil())
-		response, err = pods.Inspect(bt.conn, newpod2)
+		response, err = pods.Inspect(bt.conn, newpod2, nil)
 		Expect(err).To(BeNil())
 		Expect(response.State).To(Equal(define.PodStateExited))
 		for _, i := range response.Containers {
 			Expect(define.StringToContainerStatus(i.State)).
 				To(Equal(define.ContainerStateExited))
 		}
-		_, err = pods.Prune(bt.conn)
+		_, err = pods.Prune(bt.conn, nil)
 		Expect(err).To(BeNil())
 		podSummary, err = pods.List(bt.conn, nil)
 		Expect(err).To(BeNil())
@@ -330,7 +335,7 @@ var _ = Describe("Podman pods", func() {
 	It("simple create pod", func() {
 		ps := specgen.PodSpecGenerator{}
 		ps.Name = "foobar"
-		_, err := pods.CreatePodFromSpec(bt.conn, &ps)
+		_, err := pods.CreatePodFromSpec(bt.conn, &ps, nil)
 		Expect(err).To(BeNil())
 
 		exists, err := pods.Exists(bt.conn, "foobar")
@@ -343,7 +348,7 @@ var _ = Describe("Podman pods", func() {
 		var name string = "podA"
 
 		bt.Podcreate(&name)
-		_, err := pods.Start(bt.conn, name)
+		_, err := pods.Start(bt.conn, name, nil)
 		Expect(err).To(BeNil())
 
 		// By name
@@ -351,7 +356,8 @@ var _ = Describe("Podman pods", func() {
 		Expect(err).To(BeNil())
 
 		// With descriptors
-		output, err := pods.Top(bt.conn, name, []string{"user,pid,hpid"})
+		options := new(pods.TopOptions).WithDescriptors([]string{"user,pid,hpid"})
+		output, err := pods.Top(bt.conn, name, options)
 		Expect(err).To(BeNil())
 		header := strings.Split(output[0], "\t")
 		for _, d := range []string{"USER", "PID", "HPID"} {
@@ -363,7 +369,8 @@ var _ = Describe("Podman pods", func() {
 		Expect(err).ToNot(BeNil())
 
 		// With bogus descriptors
-		_, err = pods.Top(bt.conn, name, []string{"Me,Neither"})
+		options = new(pods.TopOptions).WithDescriptors([]string{"Me,Neither"})
+		_, err = pods.Top(bt.conn, name, options)
 		Expect(err).ToNot(BeNil())
 	})
 })
diff --git a/pkg/bindings/test/system_test.go b/pkg/bindings/test/system_test.go
index 8a8c94d09..5cb0f9125 100644
--- a/pkg/bindings/test/system_test.go
+++ b/pkg/bindings/test/system_test.go
@@ -65,7 +65,7 @@ var _ = Describe("Podman system", func() {
 
 	It("podman system prune - pod,container stopped", func() {
 		// Start and stop a pod to enter in exited state.
-		_, err := pods.Start(bt.conn, newpod)
+		_, err := pods.Start(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
 		_, err = pods.Stop(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
@@ -90,7 +90,7 @@ var _ = Describe("Podman system", func() {
 
 	It("podman system prune running alpine container", func() {
 		// Start and stop a pod to enter in exited state.
-		_, err := pods.Start(bt.conn, newpod)
+		_, err := pods.Start(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
 		_, err = pods.Stop(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
@@ -126,7 +126,7 @@ var _ = Describe("Podman system", func() {
 
 	It("podman system prune running alpine container volume prune", func() {
 		// Start a pod and leave it running
-		_, err := pods.Start(bt.conn, newpod)
+		_, err := pods.Start(bt.conn, newpod, nil)
 		Expect(err).To(BeNil())
 
 		// Start and stop a container to enter in exited state.
diff --git a/pkg/domain/infra/tunnel/helpers.go b/pkg/domain/infra/tunnel/helpers.go
index 63f9546be..cd116995f 100644
--- a/pkg/domain/infra/tunnel/helpers.go
+++ b/pkg/domain/infra/tunnel/helpers.go
@@ -90,7 +90,7 @@ func getPodsByContext(contextWithConnection context.Context, all bool, namesOrID
 		// First determine if the pod exists by doing an inspect.
 		// Inspect takes supports names and IDs and let's us determine
 		// a containers full ID.
-		inspectData, err := pods.Inspect(contextWithConnection, nameOrID)
+		inspectData, err := pods.Inspect(contextWithConnection, nameOrID, nil)
 		if err != nil {
 			if errorhandling.Contains(err, define.ErrNoSuchPod) {
 				return nil, errors.Wrapf(define.ErrNoSuchPod, "unable to find pod %q", nameOrID)
diff --git a/pkg/domain/infra/tunnel/pods.go b/pkg/domain/infra/tunnel/pods.go
index ee4978787..1ceff9ca7 100644
--- a/pkg/domain/infra/tunnel/pods.go
+++ b/pkg/domain/infra/tunnel/pods.go
@@ -16,19 +16,20 @@ func (ic *ContainerEngine) PodExists(ctx context.Context, nameOrID string) (*ent
 	return &entities.BoolReport{Value: exists}, err
 }
 
-func (ic *ContainerEngine) PodKill(ctx context.Context, namesOrIds []string, options entities.PodKillOptions) ([]*entities.PodKillReport, error) {
-	_, err := util.ParseSignal(options.Signal)
+func (ic *ContainerEngine) PodKill(ctx context.Context, namesOrIds []string, opts entities.PodKillOptions) ([]*entities.PodKillReport, error) {
+	_, err := util.ParseSignal(opts.Signal)
 	if err != nil {
 		return nil, err
 	}
 
-	foundPods, err := getPodsByContext(ic.ClientCxt, options.All, namesOrIds)
+	foundPods, err := getPodsByContext(ic.ClientCxt, opts.All, namesOrIds)
 	if err != nil {
 		return nil, err
 	}
 	reports := make([]*entities.PodKillReport, 0, len(foundPods))
+	options := new(pods.KillOptions).WithSignal(opts.Signal)
 	for _, p := range foundPods {
-		response, err := pods.Kill(ic.ClientCxt, p.Id, &options.Signal)
+		response, err := pods.Kill(ic.ClientCxt, p.Id, options)
 		if err != nil {
 			report := entities.PodKillReport{
 				Errs: []error{err},
@@ -49,7 +50,7 @@ func (ic *ContainerEngine) PodPause(ctx context.Context, namesOrIds []string, op
 	}
 	reports := make([]*entities.PodPauseReport, 0, len(foundPods))
 	for _, p := range foundPods {
-		response, err := pods.Pause(ic.ClientCxt, p.Id)
+		response, err := pods.Pause(ic.ClientCxt, p.Id, nil)
 		if err != nil {
 			report := entities.PodPauseReport{
 				Errs: []error{err},
@@ -70,7 +71,7 @@ func (ic *ContainerEngine) PodUnpause(ctx context.Context, namesOrIds []string,
 	}
 	reports := make([]*entities.PodUnpauseReport, 0, len(foundPods))
 	for _, p := range foundPods {
-		response, err := pods.Unpause(ic.ClientCxt, p.Id)
+		response, err := pods.Unpause(ic.ClientCxt, p.Id, nil)
 		if err != nil {
 			report := entities.PodUnpauseReport{
 				Errs: []error{err},
@@ -84,18 +85,19 @@ func (ic *ContainerEngine) PodUnpause(ctx context.Context, namesOrIds []string,
 	return reports, nil
 }
 
-func (ic *ContainerEngine) PodStop(ctx context.Context, namesOrIds []string, options entities.PodStopOptions) ([]*entities.PodStopReport, error) {
+func (ic *ContainerEngine) PodStop(ctx context.Context, namesOrIds []string, opts entities.PodStopOptions) ([]*entities.PodStopReport, error) {
 	timeout := -1
-	foundPods, err := getPodsByContext(ic.ClientCxt, options.All, namesOrIds)
-	if err != nil && !(options.Ignore && errors.Cause(err) == define.ErrNoSuchPod) {
+	foundPods, err := getPodsByContext(ic.ClientCxt, opts.All, namesOrIds)
+	if err != nil && !(opts.Ignore && errors.Cause(err) == define.ErrNoSuchPod) {
 		return nil, err
 	}
-	if options.Timeout != -1 {
-		timeout = options.Timeout
+	if opts.Timeout != -1 {
+		timeout = opts.Timeout
 	}
 	reports := make([]*entities.PodStopReport, 0, len(foundPods))
+	options := new(pods.StopOptions).WithTimeout(timeout)
 	for _, p := range foundPods {
-		response, err := pods.Stop(ic.ClientCxt, p.Id, &timeout)
+		response, err := pods.Stop(ic.ClientCxt, p.Id, options)
 		if err != nil {
 			report := entities.PodStopReport{
 				Errs: []error{err},
@@ -116,7 +118,7 @@ func (ic *ContainerEngine) PodRestart(ctx context.Context, namesOrIds []string,
 	}
 	reports := make([]*entities.PodRestartReport, 0, len(foundPods))
 	for _, p := range foundPods {
-		response, err := pods.Restart(ic.ClientCxt, p.Id)
+		response, err := pods.Restart(ic.ClientCxt, p.Id, nil)
 		if err != nil {
 			report := entities.PodRestartReport{
 				Errs: []error{err},
@@ -137,7 +139,7 @@ func (ic *ContainerEngine) PodStart(ctx context.Context, namesOrIds []string, op
 	}
 	reports := make([]*entities.PodStartReport, 0, len(foundPods))
 	for _, p := range foundPods {
-		response, err := pods.Start(ic.ClientCxt, p.Id)
+		response, err := pods.Start(ic.ClientCxt, p.Id, nil)
 		if err != nil {
 			report := entities.PodStartReport{
 				Errs: []error{err},
@@ -151,14 +153,15 @@ func (ic *ContainerEngine) PodStart(ctx context.Context, namesOrIds []string, op
 	return reports, nil
 }
 
-func (ic *ContainerEngine) PodRm(ctx context.Context, namesOrIds []string, options entities.PodRmOptions) ([]*entities.PodRmReport, error) {
-	foundPods, err := getPodsByContext(ic.ClientCxt, options.All, namesOrIds)
-	if err != nil && !(options.Ignore && errors.Cause(err) == define.ErrNoSuchPod) {
+func (ic *ContainerEngine) PodRm(ctx context.Context, namesOrIds []string, opts entities.PodRmOptions) ([]*entities.PodRmReport, error) {
+	foundPods, err := getPodsByContext(ic.ClientCxt, opts.All, namesOrIds)
+	if err != nil && !(opts.Ignore && errors.Cause(err) == define.ErrNoSuchPod) {
 		return nil, err
 	}
 	reports := make([]*entities.PodRmReport, 0, len(foundPods))
+	options := new(pods.RemoveOptions).WithForce(opts.Force)
 	for _, p := range foundPods {
-		response, err := pods.Remove(ic.ClientCxt, p.Id, &options.Force)
+		response, err := pods.Remove(ic.ClientCxt, p.Id, options)
 		if err != nil {
 			report := entities.PodRmReport{
 				Err: err,
@@ -173,32 +176,33 @@ func (ic *ContainerEngine) PodRm(ctx context.Context, namesOrIds []string, optio
 }
 
 func (ic *ContainerEngine) PodPrune(ctx context.Context, opts entities.PodPruneOptions) ([]*entities.PodPruneReport, error) {
-	return pods.Prune(ic.ClientCxt)
+	return pods.Prune(ic.ClientCxt, nil)
 }
 
 func (ic *ContainerEngine) PodCreate(ctx context.Context, opts entities.PodCreateOptions) (*entities.PodCreateReport, error) {
 	podSpec := specgen.NewPodSpecGenerator()
 	opts.ToPodSpecGen(podSpec)
-	return pods.CreatePodFromSpec(ic.ClientCxt, podSpec)
+	return pods.CreatePodFromSpec(ic.ClientCxt, podSpec, nil)
 }
 
-func (ic *ContainerEngine) PodTop(ctx context.Context, options entities.PodTopOptions) (*entities.StringSliceReport, error) {
+func (ic *ContainerEngine) PodTop(ctx context.Context, opts entities.PodTopOptions) (*entities.StringSliceReport, error) {
 	switch {
-	case options.Latest:
+	case opts.Latest:
 		return nil, errors.New("latest is not supported")
-	case options.NameOrID == "":
+	case opts.NameOrID == "":
 		return nil, errors.New("NameOrID must be specified")
 	}
-
-	topOutput, err := pods.Top(ic.ClientCxt, options.NameOrID, options.Descriptors)
+	options := new(pods.TopOptions).WithDescriptors(opts.Descriptors)
+	topOutput, err := pods.Top(ic.ClientCxt, opts.NameOrID, options)
 	if err != nil {
 		return nil, err
 	}
 	return &entities.StringSliceReport{Value: topOutput}, nil
 }
 
-func (ic *ContainerEngine) PodPs(ctx context.Context, options entities.PodPSOptions) ([]*entities.ListPodsReport, error) {
-	return pods.List(ic.ClientCxt, options.Filters)
+func (ic *ContainerEngine) PodPs(ctx context.Context, opts entities.PodPSOptions) ([]*entities.ListPodsReport, error) {
+	options := new(pods.ListOptions).WithFilters(opts.Filters)
+	return pods.List(ic.ClientCxt, options)
 }
 
 func (ic *ContainerEngine) PodInspect(ctx context.Context, options entities.PodInspectOptions) (*entities.PodInspectReport, error) {
@@ -208,9 +212,10 @@ func (ic *ContainerEngine) PodInspect(ctx context.Context, options entities.PodI
 	case options.NameOrID == "":
 		return nil, errors.New("NameOrID must be specified")
 	}
-	return pods.Inspect(ic.ClientCxt, options.NameOrID)
+	return pods.Inspect(ic.ClientCxt, options.NameOrID, nil)
 }
 
-func (ic *ContainerEngine) PodStats(ctx context.Context, namesOrIds []string, options entities.PodStatsOptions) ([]*entities.PodStatsReport, error) {
+func (ic *ContainerEngine) PodStats(ctx context.Context, namesOrIds []string, opts entities.PodStatsOptions) ([]*entities.PodStatsReport, error) {
+	options := new(pods.StatsOptions).WithAll(opts.All)
 	return pods.Stats(ic.ClientCxt, namesOrIds, options)
 }