contract_gen.go

package docker

import (
	context "context"
	"errors"
	"fmt"
	types "github.com/docker/docker/api/types"
	checkpoint "github.com/docker/docker/api/types/checkpoint"
	container "github.com/docker/docker/api/types/container"
	filters "github.com/docker/docker/api/types/filters"
	network "github.com/docker/docker/api/types/network"
	auth "github.com/docker/docker/api/types/registry"
	swarm "github.com/docker/docker/api/types/swarm"
	volume "github.com/docker/docker/api/types/volume"
	"github.com/docker/docker/client"
	ocispec "github.com/opencontainers/image-spec/specs-go/v1"
	io "io"
)

/*autogenerated contract adapter*/

// ContainerResizeRequest represents request
type ContainerResizeRequest struct {
	service_                *client.Client
	ctx                     context.Context
	ContainerID             string
	container.ResizeOptions `json:",inline" yaml:",inline"`
}

// ContainerExecResizeRequest represents request
type ContainerExecResizeRequest struct {
	service_                *client.Client
	ctx                     context.Context
	ExecID                  string
	container.ResizeOptions `json:",inline" yaml:",inline"`
}

// ContainerUpdateRequest represents request
type ContainerUpdateRequest struct {
	service_     *client.Client
	ctx          context.Context
	ContainerID  string
	UpdateConfig container.UpdateConfig
}

// ContainerPauseRequest represents request
type ContainerPauseRequest struct {
	service_    *client.Client
	ctx         context.Context
	ContainerID string
}

// ContainerStatPathRequest represents request
type ContainerStatPathRequest struct {
	service_    *client.Client
	ctx         context.Context
	ContainerID string
	Path        string
}

// CopyToContainerRequest represents request
type CopyToContainerRequest struct {
	service_                     *client.Client
	ctx                          context.Context
	ContainerID                  string
	DstPath                      string
	Content                      io.Reader
	types.CopyToContainerOptions `json:",inline" yaml:",inline"`
}

// ServerVersionRequest represents request
type ServerVersionRequest struct {
	service_ *client.Client
	ctx      context.Context
}

// NodeRemoveRequest represents request
type NodeRemoveRequest struct {
	service_                *client.Client
	ctx                     context.Context
	NodeID                  string
	types.NodeRemoveOptions `json:",inline" yaml:",inline"`
}

// ContainerAttachRequest represents request
type ContainerAttachRequest struct {
	service_                *client.Client
	ctx                     context.Context
	Container               string
	container.AttachOptions `json:",inline" yaml:",inline"`
}

// PingRequest represents request
type PingRequest struct {
	service_ *client.Client
	ctx      context.Context
}

// PluginRemoveRequest represents request
type PluginRemoveRequest struct {
	service_                  *client.Client
	ctx                       context.Context
	Name                      string
	types.PluginRemoveOptions `json:",inline" yaml:",inline"`
}

// ContainerCommitRequest represents request
type ContainerCommitRequest struct {
	service_                *client.Client
	ctx                     context.Context
	Container               string
	container.CommitOptions `json:",inline" yaml:",inline"`
}

// SwarmInitRequest represents request
type SwarmInitRequest struct {
	service_ *client.Client
	ctx      context.Context
	Req      swarm.InitRequest
}

// SecretListRequest represents request
type SecretListRequest struct {
	service_                *client.Client
	ctx                     context.Context
	types.SecretListOptions `json:",inline" yaml:",inline"`
}

// TaskListRequest represents request
type TaskListRequest struct {
	service_              *client.Client
	ctx                   context.Context
	types.TaskListOptions `json:",inline" yaml:",inline"`
}

// SecretRemoveRequest represents request
type SecretRemoveRequest struct {
	service_ *client.Client
	ctx      context.Context
	Id       string
}

// ContainerKillRequest represents request
type ContainerKillRequest struct {
	service_    *client.Client
	ctx         context.Context
	ContainerID string
	Signal      string
}

// VolumeRemoveRequest represents request
type VolumeRemoveRequest struct {
	service_ *client.Client
	ctx      context.Context
	VolumeID string
	Force    bool
}

// NetworkDisconnectRequest represents request
type NetworkDisconnectRequest struct {
	service_    *client.Client
	ctx         context.Context
	NetworkID   string
	ContainerID string
	Force       bool
}

// InfoRequest represents request
type InfoRequest struct {
	service_ *client.Client
	ctx      context.Context
}

// ContainerStartRequest represents request
type ContainerStartRequest struct {
	service_               *client.Client
	ctx                    context.Context
	ContainerID            string
	container.StartOptions `json:",inline" yaml:",inline"`
}

// ImageHistoryRequest represents request
type ImageHistoryRequest struct {
	service_ *client.Client
	ctx      context.Context
	ImageID  string
}

// ImageImportRequest represents request
type ImageImportRequest struct {
	service_ *client.Client
	ctx      context.Context
	types.ImageImportSource
	Ref     string
	Options types.ImageImportOptions `json:",inline" yaml:",inline"`
}

// ContainerExecCreateRequest represents request
type ContainerExecCreateRequest struct {
	service_  *client.Client
	ctx       context.Context
	Container string
	Config    types.ExecConfig
}

// ContainerExecStartRequest represents request
type ContainerExecStartRequest struct {
	service_ *client.Client
	ctx      context.Context
	ExecID   string
	Config   types.ExecStartCheck
}

// ContainerExecAttachRequest represents request
type ContainerExecAttachRequest struct {
	service_ *client.Client
	ctx      context.Context
	ExecID   string
	Config   types.ExecStartCheck
}

// ContainerExecInspectRequest represents request
type ContainerExecInspectRequest struct {
	service_ *client.Client
	ctx      context.Context
	ExecID   string
}

// ContainerStatsRequest represents request
type ContainerStatsRequest struct {
	service_    *client.Client
	ctx         context.Context
	ContainerID string
	Stream      bool
}

// ContainerStatsOneShotRequest represents request
type ContainerStatsOneShotRequest struct {
	service_    *client.Client
	ctx         context.Context
	ContainerID string
}

// PluginInstallRequest represents request
type PluginInstallRequest struct {
	service_                   *client.Client
	ctx                        context.Context
	Name                       string
	types.PluginInstallOptions `json:",inline" yaml:",inline"`
}

// VolumeListRequest represents request
type VolumeListRequest struct {
	service_           *client.Client
	ctx                context.Context
	volume.ListOptions `json:",inline" yaml:",inline"`
}

// ContainerRenameRequest represents request
type ContainerRenameRequest struct {
	service_         *client.Client
	ctx              context.Context
	ContainerID      string
	NewContainerName string
}

// SecretUpdateRequest represents request
type SecretUpdateRequest struct {
	service_ *client.Client
	ctx      context.Context
	Id       string
	Version  swarm.Version
	Secret   swarm.SecretSpec
}

// ServiceRemoveRequest represents request
type ServiceRemoveRequest struct {
	service_  *client.Client
	ctx       context.Context
	ServiceID string
}

// RegistryLoginRequest represents request
type RegistryLoginRequest struct {
	service_ *client.Client
	ctx      context.Context
	Auth     auth.AuthConfig
}

// ContainerListRequest represents request
type ContainerListRequest struct {
	service_              *client.Client
	ctx                   context.Context
	container.ListOptions `json:",inline" yaml:",inline"`
}

// NetworkRemoveRequest represents request
type NetworkRemoveRequest struct {
	service_  *client.Client
	ctx       context.Context
	NetworkID string
}

// ContainerDiffRequest represents request
type ContainerDiffRequest struct {
	service_    *client.Client
	ctx         context.Context
	ContainerID string
}

// ConfigRemoveRequest represents request
type ConfigRemoveRequest struct {
	service_ *client.Client
	ctx      context.Context
	Id       string
}

// PluginDisableRequest represents request
type PluginDisableRequest struct {
	service_                   *client.Client
	ctx                        context.Context
	Name                       string
	types.PluginDisableOptions `json:",inline" yaml:",inline"`
}

// ImageListRequest represents request
type ImageListRequest struct {
	service_               *client.Client
	ctx                    context.Context
	types.ImageListOptions `json:",inline" yaml:",inline"`
}

// PluginPushRequest represents request
type PluginPushRequest struct {
	service_     *client.Client
	ctx          context.Context
	Name         string
	RegistryAuth string
}

// NodeListRequest represents request
type NodeListRequest struct {
	service_              *client.Client
	ctx                   context.Context
	types.NodeListOptions `json:",inline" yaml:",inline"`
}

// ServiceCreateRequest represents request
type ServiceCreateRequest struct {
	service_ *client.Client
	ctx      context.Context
	swarm.ServiceSpec
	Options types.ServiceCreateOptions `json:",inline" yaml:",inline"`
}

// ContainerTopRequest represents request
type ContainerTopRequest struct {
	service_    *client.Client
	ctx         context.Context
	ContainerID string
	Arguments   []string
}

// PluginUpgradeRequest represents request
type PluginUpgradeRequest struct {
	service_                   *client.Client
	ctx                        context.Context
	Name                       string
	types.PluginInstallOptions `json:",inline" yaml:",inline"`
}

// ImagePullRequest represents request
type ImagePullRequest struct {
	service_               *client.Client
	ctx                    context.Context
	RefStr                 string
	types.ImagePullOptions `json:",inline" yaml:",inline"`
}

// NetworkInspectRequest represents request
type NetworkInspectRequest struct {
	service_                    *client.Client
	ctx                         context.Context
	NetworkID                   string
	types.NetworkInspectOptions `json:",inline" yaml:",inline"`
}

// NetworkConnectRequest represents request
type NetworkConnectRequest struct {
	service_    *client.Client
	ctx         context.Context
	NetworkID   string
	ContainerID string
	Config      *network.EndpointSettings
}

// NetworkCreateRequest represents request
type NetworkCreateRequest struct {
	service_            *client.Client
	ctx                 context.Context
	Name                string
	types.NetworkCreate `json:",inline" yaml:",inline"`
}

// PluginListRequest represents request
type PluginListRequest struct {
	service_ *client.Client
	ctx      context.Context
	Filter   filters.Args
}

// PluginCreateRequest represents request
type PluginCreateRequest struct {
	service_                  *client.Client
	ctx                       context.Context
	CreateContext             io.Reader
	types.PluginCreateOptions `json:",inline" yaml:",inline"`
}

// SwarmLeaveRequest represents request
type SwarmLeaveRequest struct {
	service_ *client.Client
	ctx      context.Context
	Force    bool
}

// SwarmUnlockRequest represents request
type SwarmUnlockRequest struct {
	service_ *client.Client
	ctx      context.Context
	Req      swarm.UnlockRequest
}

// ContainersPruneRequest represents request
type ContainersPruneRequest struct {
	service_     *client.Client
	ctx          context.Context
	PruneFilters filters.Args
}

// ServiceLogsRequest represents request
type ServiceLogsRequest struct {
	service_              *client.Client
	ctx                   context.Context
	ServiceID             string
	container.LogsOptions `json:",inline" yaml:",inline"`
}

// ConfigCreateRequest represents request
type ConfigCreateRequest struct {
	service_ *client.Client
	ctx      context.Context
	Config   swarm.ConfigSpec
}

// PluginEnableRequest represents request
type PluginEnableRequest struct {
	service_                  *client.Client
	ctx                       context.Context
	Name                      string
	types.PluginEnableOptions `json:",inline" yaml:",inline"`
}

// NetworkListRequest represents request
type NetworkListRequest struct {
	service_                 *client.Client
	ctx                      context.Context
	types.NetworkListOptions `json:",inline" yaml:",inline"`
}

// ContainerWaitRequest represents request
type ContainerWaitRequest struct {
	service_    *client.Client
	ctx         context.Context
	ContainerID string
	Condition   container.WaitCondition
}

// ImageLoadRequest represents request
type ImageLoadRequest struct {
	service_ *client.Client
	ctx      context.Context
	Input    io.Reader
	Quiet    bool
}

// ImageSaveRequest represents request
type ImageSaveRequest struct {
	service_ *client.Client
	ctx      context.Context
	ImageIDs []string
}

// ImageBuildRequest represents request
type ImageBuildRequest struct {
	service_                *client.Client
	ctx                     context.Context
	BuildContext            io.Reader
	types.ImageBuildOptions `json:",inline" yaml:",inline"`
}

// ContainerCreateRequest represents request
type ContainerCreateRequest struct {
	service_         *client.Client
	ctx              context.Context
	Config           *container.Config
	HostConfig       *container.HostConfig
	NetworkingConfig *network.NetworkingConfig
	Platform         *ocispec.Platform
	ContainerName    string
}

// ImagePushRequest represents request
type ImagePushRequest struct {
	service_               *client.Client
	ctx                    context.Context
	Image                  string
	types.ImagePushOptions `json:",inline" yaml:",inline"`
}

// ImagesPruneRequest represents request
type ImagesPruneRequest struct {
	service_     *client.Client
	ctx          context.Context
	PruneFilters filters.Args
}

// CheckpointCreateRequest represents request
type CheckpointCreateRequest struct {
	service_                 *client.Client
	ctx                      context.Context
	Container                string
	checkpoint.CreateOptions `json:",inline" yaml:",inline"`
}

// ContainerExportRequest represents request
type ContainerExportRequest struct {
	service_    *client.Client
	ctx         context.Context
	ContainerID string
}

// ImageTagRequest represents request
type ImageTagRequest struct {
	service_ *client.Client
	ctx      context.Context
	Source   string
	Target   string
}

// CheckpointListRequest represents request
type CheckpointListRequest struct {
	service_               *client.Client
	ctx                    context.Context
	Container              string
	checkpoint.ListOptions `json:",inline" yaml:",inline"`
}

// SwarmJoinRequest represents request
type SwarmJoinRequest struct {
	service_ *client.Client
	ctx      context.Context
	Req      swarm.JoinRequest
}

// EventsRequest represents request
type EventsRequest struct {
	service_            *client.Client
	ctx                 context.Context
	types.EventsOptions `json:",inline" yaml:",inline"`
}

// DialHijackRequest represents request
type DialHijackRequest struct {
	service_ *client.Client
	ctx      context.Context
	Url      string
	Proto    string
	Meta     map[string][]string
}

// PluginSetRequest represents request
type PluginSetRequest struct {
	service_ *client.Client
	ctx      context.Context
	Name     string
	Args     []string
}

// ContainerRemoveRequest represents request
type ContainerRemoveRequest struct {
	service_                *client.Client
	ctx                     context.Context
	ContainerID             string
	container.RemoveOptions `json:",inline" yaml:",inline"`
}

// SecretCreateRequest represents request
type SecretCreateRequest struct {
	service_ *client.Client
	ctx      context.Context
	Secret   swarm.SecretSpec
}

// SwarmUpdateRequest represents request
type SwarmUpdateRequest struct {
	service_ *client.Client
	ctx      context.Context
	Version  swarm.Version
	Swarm    swarm.Spec
	Flags    swarm.UpdateFlags
}

// DiskUsageRequest represents request
type DiskUsageRequest struct {
	service_               *client.Client
	ctx                    context.Context
	types.DiskUsageOptions `json:",inline" yaml:",inline"`
}

// DistributionInspectRequest represents request
type DistributionInspectRequest struct {
	service_            *client.Client
	ctx                 context.Context
	Image               string
	EncodedRegistryAuth string
}

// SwarmGetUnlockKeyRequest represents request
type SwarmGetUnlockKeyRequest struct {
	service_ *client.Client
	ctx      context.Context
}

// VolumeCreateRequest represents request
type VolumeCreateRequest struct {
	service_             *client.Client
	ctx                  context.Context
	volume.CreateOptions `json:",inline" yaml:",inline"`
}

// ContainerRestartRequest represents request
type ContainerRestartRequest struct {
	service_              *client.Client
	ctx                   context.Context
	ContainerID           string
	container.StopOptions `json:",inline" yaml:",inline"`
}

// ServiceUpdateRequest represents request
type ServiceUpdateRequest struct {
	service_  *client.Client
	ctx       context.Context
	ServiceID string
	swarm.Version
	Service swarm.ServiceSpec
	Options types.ServiceUpdateOptions `json:",inline" yaml:",inline"`
}

// VolumeUpdateRequest represents request
type VolumeUpdateRequest struct {
	service_ *client.Client
	ctx      context.Context
	VolumeID string
	swarm.Version
	Options volume.UpdateOptions `json:",inline" yaml:",inline"`
}

// ContainerInspectRequest represents request
type ContainerInspectRequest struct {
	service_    *client.Client
	ctx         context.Context
	ContainerID string
}

// CheckpointDeleteRequest represents request
type CheckpointDeleteRequest struct {
	service_                 *client.Client
	ctx                      context.Context
	ContainerID              string
	checkpoint.DeleteOptions `json:",inline" yaml:",inline"`
}

// BuildCachePruneRequest represents request
type BuildCachePruneRequest struct {
	service_ *client.Client
	ctx      context.Context
	Opts     types.BuildCachePruneOptions
}

// ConfigListRequest represents request
type ConfigListRequest struct {
	service_                *client.Client
	ctx                     context.Context
	types.ConfigListOptions `json:",inline" yaml:",inline"`
}

// VolumeInspectRequest represents request
type VolumeInspectRequest struct {
	service_ *client.Client
	ctx      context.Context
	VolumeID string
}

// ContainerStopRequest represents request
type ContainerStopRequest struct {
	service_              *client.Client
	ctx                   context.Context
	ContainerID           string
	container.StopOptions `json:",inline" yaml:",inline"`
}

// ImageSearchRequest represents request
type ImageSearchRequest struct {
	service_                 *client.Client
	ctx                      context.Context
	Term                     string
	types.ImageSearchOptions `json:",inline" yaml:",inline"`
}

// ContainerUnpauseRequest represents request
type ContainerUnpauseRequest struct {
	service_    *client.Client
	ctx         context.Context
	ContainerID string
}

// ServiceListRequest represents request
type ServiceListRequest struct {
	service_                 *client.Client
	ctx                      context.Context
	types.ServiceListOptions `json:",inline" yaml:",inline"`
}

// VolumesPruneRequest represents request
type VolumesPruneRequest struct {
	service_     *client.Client
	ctx          context.Context
	PruneFilters filters.Args
}

// ConfigUpdateRequest represents request
type ConfigUpdateRequest struct {
	service_ *client.Client
	ctx      context.Context
	Id       string
	Version  swarm.Version
	Config   swarm.ConfigSpec
}

// NegotiateAPIVersionRequest represents request
type NegotiateAPIVersionRequest struct {
	service_ *client.Client
	ctx      context.Context
}

// SwarmInspectRequest represents request
type SwarmInspectRequest struct {
	service_ *client.Client
	ctx      context.Context
}

// BuildCancelRequest represents request
type BuildCancelRequest struct {
	service_ *client.Client
	ctx      context.Context
	Id       string
}

// ContainerLogsRequest represents request
type ContainerLogsRequest struct {
	service_              *client.Client
	ctx                   context.Context
	Container             string
	container.LogsOptions `json:",inline" yaml:",inline"`
}

// ImageRemoveRequest represents request
type ImageRemoveRequest struct {
	service_                 *client.Client
	ctx                      context.Context
	ImageID                  string
	types.ImageRemoveOptions `json:",inline" yaml:",inline"`
}

// TaskLogsRequest represents request
type TaskLogsRequest struct {
	service_              *client.Client
	ctx                   context.Context
	TaskID                string
	container.LogsOptions `json:",inline" yaml:",inline"`
}

// NetworksPruneRequest represents request
type NetworksPruneRequest struct {
	service_     *client.Client
	ctx          context.Context
	PruneFilters filters.Args
}

// NodeUpdateRequest represents request
type NodeUpdateRequest struct {
	service_ *client.Client
	ctx      context.Context
	NodeID   string
	Version  swarm.Version
	Node     swarm.NodeSpec
}

// ImageCreateRequest represents request
type ImageCreateRequest struct {
	service_                 *client.Client
	ctx                      context.Context
	ParentReference          string
	types.ImageCreateOptions `json:",inline" yaml:",inline"`
}

// NewVersionErrorRequest represents request
type NewVersionErrorRequest struct {
	service_    *client.Client
	ctx         context.Context
	APIrequired string
	Feature     string
}

func init() {
	register(&ContainerResizeRequest{})
	register(&ContainerExecResizeRequest{})
	register(&ContainerUpdateRequest{})
	register(&ContainerPauseRequest{})
	register(&ContainerStatPathRequest{})
	register(&CopyToContainerRequest{})
	register(&ServerVersionRequest{})
	register(&NodeRemoveRequest{})
	register(&ContainerAttachRequest{})
	register(&PingRequest{})
	register(&PluginRemoveRequest{})
	register(&ContainerCommitRequest{})
	register(&SwarmInitRequest{})
	register(&SecretListRequest{})
	register(&TaskListRequest{})
	register(&SecretRemoveRequest{})
	register(&ContainerKillRequest{})
	register(&VolumeRemoveRequest{})
	register(&NetworkDisconnectRequest{})
	register(&InfoRequest{})
	register(&ContainerStartRequest{})
	register(&ImageHistoryRequest{})
	register(&ImageImportRequest{})
	register(&ContainerExecCreateRequest{})
	register(&ContainerExecStartRequest{})
	register(&ContainerExecAttachRequest{})
	register(&ContainerExecInspectRequest{})
	register(&ContainerStatsRequest{})
	register(&ContainerStatsOneShotRequest{})
	register(&PluginInstallRequest{})
	register(&VolumeListRequest{})
	register(&ContainerRenameRequest{})
	register(&SecretUpdateRequest{})
	register(&ServiceRemoveRequest{})
	register(&RegistryLoginRequest{})
	register(&ContainerListRequest{})
	register(&NetworkRemoveRequest{})
	register(&ContainerDiffRequest{})
	register(&ConfigRemoveRequest{})
	register(&PluginDisableRequest{})
	register(&ImageListRequest{})
	register(&PluginPushRequest{})
	register(&NodeListRequest{})
	register(&ServiceCreateRequest{})
	register(&ContainerTopRequest{})
	register(&PluginUpgradeRequest{})
	register(&ImagePullRequest{})
	register(&NetworkInspectRequest{})
	register(&NetworkConnectRequest{})
	register(&NetworkCreateRequest{})
	register(&PluginListRequest{})
	register(&PluginCreateRequest{})
	register(&SwarmLeaveRequest{})
	register(&SwarmUnlockRequest{})
	register(&ContainersPruneRequest{})
	register(&ServiceLogsRequest{})
	register(&ConfigCreateRequest{})
	register(&PluginEnableRequest{})
	register(&NetworkListRequest{})
	register(&ContainerWaitRequest{})
	register(&ImageLoadRequest{})
	register(&ImageSaveRequest{})
	register(&ImageBuildRequest{})
	register(&ContainerCreateRequest{})
	register(&ImagePushRequest{})
	register(&ImagesPruneRequest{})
	register(&CheckpointCreateRequest{})
	register(&ContainerExportRequest{})
	register(&ImageTagRequest{})
	register(&CheckpointListRequest{})
	register(&SwarmJoinRequest{})
	register(&EventsRequest{})
	register(&DialHijackRequest{})
	register(&PluginSetRequest{})
	register(&ContainerRemoveRequest{})
	register(&SecretCreateRequest{})
	register(&SwarmUpdateRequest{})
	register(&DiskUsageRequest{})
	register(&DistributionInspectRequest{})
	register(&SwarmGetUnlockKeyRequest{})
	register(&VolumeCreateRequest{})
	register(&ContainerRestartRequest{})
	register(&ServiceUpdateRequest{})
	register(&VolumeUpdateRequest{})
	register(&ContainerInspectRequest{})
	register(&CheckpointDeleteRequest{})
	register(&BuildCachePruneRequest{})
	register(&ConfigListRequest{})
	register(&VolumeInspectRequest{})
	register(&ContainerStopRequest{})
	register(&ImageSearchRequest{})
	register(&ContainerUnpauseRequest{})
	register(&ServiceListRequest{})
	register(&VolumesPruneRequest{})
	register(&ConfigUpdateRequest{})
	register(&NegotiateAPIVersionRequest{})
	register(&SwarmInspectRequest{})
	register(&BuildCancelRequest{})
	register(&ContainerLogsRequest{})
	register(&ImageRemoveRequest{})
	register(&TaskLogsRequest{})
	register(&NetworksPruneRequest{})
	register(&NodeUpdateRequest{})
	register(&ImageCreateRequest{})
	register(&NewVersionErrorRequest{})
}

// SetContext sets context
func (r *ContainerResizeRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerResizeRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerResizeRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.ContainerResize(r.ctx, r.ContainerID, r.ResizeOptions)
	return result, err
}

// GetId returns request id
func (r *ContainerResizeRequest) GetId() string {
	return "containerResizeRequest"
}

// SetContext sets context
func (r *ContainerExecResizeRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerExecResizeRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerExecResizeRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.ContainerExecResize(r.ctx, r.ExecID, r.ResizeOptions)
	return result, err
}

// GetId returns request id
func (r *ContainerExecResizeRequest) GetId() string {
	return "containerExecResizeRequest"
}

// SetContext sets context
func (r *ContainerUpdateRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerUpdateRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerUpdateRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ContainerUpdate(r.ctx, r.ContainerID, r.UpdateConfig)
	return result, err
}

// GetId returns request id
func (r *ContainerUpdateRequest) GetId() string {
	return "containerUpdateRequest"
}

// SetContext sets context
func (r *ContainerPauseRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerPauseRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerPauseRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.ContainerPause(r.ctx, r.ContainerID)
	return result, err
}

// GetId returns request id
func (r *ContainerPauseRequest) GetId() string {
	return "containerPauseRequest"
}

// SetContext sets context
func (r *ContainerStatPathRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerStatPathRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerStatPathRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ContainerStatPath(r.ctx, r.ContainerID, r.Path)
	return result, err
}

// GetId returns request id
func (r *ContainerStatPathRequest) GetId() string {
	return "containerStatPathRequest"
}

// SetContext sets context
func (r *CopyToContainerRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *CopyToContainerRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *CopyToContainerRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.CopyToContainer(r.ctx, r.ContainerID, r.DstPath, r.Content, r.CopyToContainerOptions)
	return result, err
}

// GetId returns request id
func (r *CopyToContainerRequest) GetId() string {
	return "copyToContainerRequest"
}

// SetContext sets context
func (r *ServerVersionRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ServerVersionRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ServerVersionRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ServerVersion(r.ctx)
	return result, err
}

// GetId returns request id
func (r *ServerVersionRequest) GetId() string {
	return "serverVersionRequest"
}

// SetContext sets context
func (r *NodeRemoveRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *NodeRemoveRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *NodeRemoveRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.NodeRemove(r.ctx, r.NodeID, r.NodeRemoveOptions)
	return result, err
}

// GetId returns request id
func (r *NodeRemoveRequest) GetId() string {
	return "nodeRemoveRequest"
}

// SetContext sets context
func (r *ContainerAttachRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerAttachRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerAttachRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ContainerAttach(r.ctx, r.Container, r.AttachOptions)
	return result, err
}

// GetId returns request id
func (r *ContainerAttachRequest) GetId() string {
	return "containerAttachRequest"
}

// SetContext sets context
func (r *PingRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *PingRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *PingRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.Ping(r.ctx)
	return result, err
}

// GetId returns request id
func (r *PingRequest) GetId() string {
	return "pingRequest"
}

// SetContext sets context
func (r *PluginRemoveRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *PluginRemoveRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *PluginRemoveRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.PluginRemove(r.ctx, r.Name, r.PluginRemoveOptions)
	return result, err
}

// GetId returns request id
func (r *PluginRemoveRequest) GetId() string {
	return "pluginRemoveRequest"
}

// SetContext sets context
func (r *ContainerCommitRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerCommitRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerCommitRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ContainerCommit(r.ctx, r.Container, r.CommitOptions)
	return result, err
}

// GetId returns request id
func (r *ContainerCommitRequest) GetId() string {
	return "containerCommitRequest"
}

// SetContext sets context
func (r *SwarmInitRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *SwarmInitRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *SwarmInitRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.SwarmInit(r.ctx, r.Req)
	return result, err
}

// GetId returns request id
func (r *SwarmInitRequest) GetId() string {
	return "swarmInitRequest"
}

// SetContext sets context
func (r *SecretListRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *SecretListRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *SecretListRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.SecretList(r.ctx, r.SecretListOptions)
	return result, err
}

// GetId returns request id
func (r *SecretListRequest) GetId() string {
	return "secretListRequest"
}

// SetContext sets context
func (r *TaskListRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *TaskListRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *TaskListRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.TaskList(r.ctx, r.TaskListOptions)
	return result, err
}

// GetId returns request id
func (r *TaskListRequest) GetId() string {
	return "taskListRequest"
}

// SetContext sets context
func (r *SecretRemoveRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *SecretRemoveRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *SecretRemoveRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.SecretRemove(r.ctx, r.Id)
	return result, err
}

// GetId returns request id
func (r *SecretRemoveRequest) GetId() string {
	return "secretRemoveRequest"
}

// SetContext sets context
func (r *ContainerKillRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerKillRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerKillRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.ContainerKill(r.ctx, r.ContainerID, r.Signal)
	return result, err
}

// GetId returns request id
func (r *ContainerKillRequest) GetId() string {
	return "containerKillRequest"
}

// SetContext sets context
func (r *VolumeRemoveRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *VolumeRemoveRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *VolumeRemoveRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.VolumeRemove(r.ctx, r.VolumeID, r.Force)
	return result, err
}

// GetId returns request id
func (r *VolumeRemoveRequest) GetId() string {
	return "volumeRemoveRequest"
}

// SetContext sets context
func (r *NetworkDisconnectRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *NetworkDisconnectRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *NetworkDisconnectRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.NetworkDisconnect(r.ctx, r.NetworkID, r.ContainerID, r.Force)
	return result, err
}

// GetId returns request id
func (r *NetworkDisconnectRequest) GetId() string {
	return "networkDisconnectRequest"
}

// SetContext sets context
func (r *InfoRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *InfoRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *InfoRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.Info(r.ctx)
	return result, err
}

// GetId returns request id
func (r *InfoRequest) GetId() string {
	return "infoRequest"
}

// SetContext sets context
func (r *ContainerStartRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerStartRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerStartRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.ContainerStart(r.ctx, r.ContainerID, r.StartOptions)
	return result, err
}

// GetId returns request id
func (r *ContainerStartRequest) GetId() string {
	return "containerStartRequest"
}

// SetContext sets context
func (r *ImageHistoryRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ImageHistoryRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ImageHistoryRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ImageHistory(r.ctx, r.ImageID)
	return result, err
}

// GetId returns request id
func (r *ImageHistoryRequest) GetId() string {
	return "imageHistoryRequest"
}

// SetContext sets context
func (r *ImageImportRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ImageImportRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ImageImportRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ImageImport(r.ctx, r.ImageImportSource, r.Ref, r.Options)
	return result, err
}

// GetId returns request id
func (r *ImageImportRequest) GetId() string {
	return "imageImportRequest"
}

// SetContext sets context
func (r *ContainerExecCreateRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerExecCreateRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerExecCreateRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ContainerExecCreate(r.ctx, r.Container, r.Config)
	return result, err
}

// GetId returns request id
func (r *ContainerExecCreateRequest) GetId() string {
	return "containerExecCreateRequest"
}

// SetContext sets context
func (r *ContainerExecStartRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerExecStartRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerExecStartRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.ContainerExecStart(r.ctx, r.ExecID, r.Config)
	return result, err
}

// GetId returns request id
func (r *ContainerExecStartRequest) GetId() string {
	return "containerExecStartRequest"
}

// SetContext sets context
func (r *ContainerExecAttachRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerExecAttachRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerExecAttachRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ContainerExecAttach(r.ctx, r.ExecID, r.Config)
	return result, err
}

// GetId returns request id
func (r *ContainerExecAttachRequest) GetId() string {
	return "containerExecAttachRequest"
}

// SetContext sets context
func (r *ContainerExecInspectRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerExecInspectRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerExecInspectRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ContainerExecInspect(r.ctx, r.ExecID)
	return result, err
}

// GetId returns request id
func (r *ContainerExecInspectRequest) GetId() string {
	return "containerExecInspectRequest"
}

// SetContext sets context
func (r *ContainerStatsRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerStatsRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerStatsRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ContainerStats(r.ctx, r.ContainerID, r.Stream)
	return result, err
}

// GetId returns request id
func (r *ContainerStatsRequest) GetId() string {
	return "containerStatsRequest"
}

// SetContext sets context
func (r *ContainerStatsOneShotRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerStatsOneShotRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerStatsOneShotRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ContainerStatsOneShot(r.ctx, r.ContainerID)
	return result, err
}

// GetId returns request id
func (r *ContainerStatsOneShotRequest) GetId() string {
	return "containerStatsOneShotRequest"
}

// SetContext sets context
func (r *PluginInstallRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *PluginInstallRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *PluginInstallRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.PluginInstall(r.ctx, r.Name, r.PluginInstallOptions)
	return result, err
}

// GetId returns request id
func (r *PluginInstallRequest) GetId() string {
	return "pluginInstallRequest"
}

// SetContext sets context
func (r *VolumeListRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *VolumeListRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *VolumeListRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.VolumeList(r.ctx, r.ListOptions)
	return result, err
}

// GetId returns request id
func (r *VolumeListRequest) GetId() string {
	return "volumeListRequest"
}

// SetContext sets context
func (r *ContainerRenameRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerRenameRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerRenameRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.ContainerRename(r.ctx, r.ContainerID, r.NewContainerName)
	return result, err
}

// GetId returns request id
func (r *ContainerRenameRequest) GetId() string {
	return "containerRenameRequest"
}

// SetContext sets context
func (r *SecretUpdateRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *SecretUpdateRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *SecretUpdateRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.SecretUpdate(r.ctx, r.Id, r.Version, r.Secret)
	return result, err
}

// GetId returns request id
func (r *SecretUpdateRequest) GetId() string {
	return "secretUpdateRequest"
}

// SetContext sets context
func (r *ServiceRemoveRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ServiceRemoveRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ServiceRemoveRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.ServiceRemove(r.ctx, r.ServiceID)
	return result, err
}

// GetId returns request id
func (r *ServiceRemoveRequest) GetId() string {
	return "serviceRemoveRequest"
}

// SetContext sets context
func (r *RegistryLoginRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *RegistryLoginRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *RegistryLoginRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.RegistryLogin(r.ctx, r.Auth)
	return result, err
}

// GetId returns request id
func (r *RegistryLoginRequest) GetId() string {
	return "registryLoginRequest"
}

// SetContext sets context
func (r *ContainerListRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerListRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerListRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ContainerList(r.ctx, r.ListOptions)
	return result, err
}

// GetId returns request id
func (r *ContainerListRequest) GetId() string {
	return "containerListRequest"
}

// SetContext sets context
func (r *NetworkRemoveRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *NetworkRemoveRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *NetworkRemoveRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.NetworkRemove(r.ctx, r.NetworkID)
	return result, err
}

// GetId returns request id
func (r *NetworkRemoveRequest) GetId() string {
	return "networkRemoveRequest"
}

// SetContext sets context
func (r *ContainerDiffRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerDiffRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerDiffRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ContainerDiff(r.ctx, r.ContainerID)
	return result, err
}

// GetId returns request id
func (r *ContainerDiffRequest) GetId() string {
	return "containerDiffRequest"
}

// SetContext sets context
func (r *ConfigRemoveRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ConfigRemoveRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ConfigRemoveRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.ConfigRemove(r.ctx, r.Id)
	return result, err
}

// GetId returns request id
func (r *ConfigRemoveRequest) GetId() string {
	return "configRemoveRequest"
}

// SetContext sets context
func (r *PluginDisableRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *PluginDisableRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *PluginDisableRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.PluginDisable(r.ctx, r.Name, r.PluginDisableOptions)
	return result, err
}

// GetId returns request id
func (r *PluginDisableRequest) GetId() string {
	return "pluginDisableRequest"
}

// SetContext sets context
func (r *ImageListRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ImageListRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ImageListRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ImageList(r.ctx, r.ImageListOptions)
	return result, err
}

// GetId returns request id
func (r *ImageListRequest) GetId() string {
	return "imageListRequest"
}

// SetContext sets context
func (r *PluginPushRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *PluginPushRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *PluginPushRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.PluginPush(r.ctx, r.Name, r.RegistryAuth)
	return result, err
}

// GetId returns request id
func (r *PluginPushRequest) GetId() string {
	return "pluginPushRequest"
}

// SetContext sets context
func (r *NodeListRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *NodeListRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *NodeListRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.NodeList(r.ctx, r.NodeListOptions)
	return result, err
}

// GetId returns request id
func (r *NodeListRequest) GetId() string {
	return "nodeListRequest"
}

// SetContext sets context
func (r *ServiceCreateRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ServiceCreateRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ServiceCreateRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ServiceCreate(r.ctx, r.ServiceSpec, r.Options)
	return result, err
}

// GetId returns request id
func (r *ServiceCreateRequest) GetId() string {
	return "serviceCreateRequest"
}

// SetContext sets context
func (r *ContainerTopRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerTopRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerTopRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ContainerTop(r.ctx, r.ContainerID, r.Arguments)
	return result, err
}

// GetId returns request id
func (r *ContainerTopRequest) GetId() string {
	return "containerTopRequest"
}

// SetContext sets context
func (r *PluginUpgradeRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *PluginUpgradeRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *PluginUpgradeRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.PluginUpgrade(r.ctx, r.Name, r.PluginInstallOptions)
	return result, err
}

// GetId returns request id
func (r *PluginUpgradeRequest) GetId() string {
	return "pluginUpgradeRequest"
}

// SetContext sets context
func (r *ImagePullRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ImagePullRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ImagePullRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ImagePull(r.ctx, r.RefStr, r.ImagePullOptions)
	return result, err
}

// GetId returns request id
func (r *ImagePullRequest) GetId() string {
	return "imagePullRequest"
}

// SetContext sets context
func (r *NetworkInspectRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *NetworkInspectRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *NetworkInspectRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.NetworkInspect(r.ctx, r.NetworkID, r.NetworkInspectOptions)
	return result, err
}

// GetId returns request id
func (r *NetworkInspectRequest) GetId() string {
	return "networkInspectRequest"
}

// SetContext sets context
func (r *NetworkConnectRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *NetworkConnectRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *NetworkConnectRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.NetworkConnect(r.ctx, r.NetworkID, r.ContainerID, r.Config)
	return result, err
}

// GetId returns request id
func (r *NetworkConnectRequest) GetId() string {
	return "networkConnectRequest"
}

// SetContext sets context
func (r *NetworkCreateRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *NetworkCreateRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *NetworkCreateRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.NetworkCreate(r.ctx, r.Name, r.NetworkCreate)
	return result, err
}

// GetId returns request id
func (r *NetworkCreateRequest) GetId() string {
	return "networkCreateRequest"
}

// SetContext sets context
func (r *PluginListRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *PluginListRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *PluginListRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.PluginList(r.ctx, r.Filter)
	return result, err
}

// GetId returns request id
func (r *PluginListRequest) GetId() string {
	return "pluginListRequest"
}

// SetContext sets context
func (r *PluginCreateRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *PluginCreateRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *PluginCreateRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.PluginCreate(r.ctx, r.CreateContext, r.PluginCreateOptions)
	return result, err
}

// GetId returns request id
func (r *PluginCreateRequest) GetId() string {
	return "pluginCreateRequest"
}

// SetContext sets context
func (r *SwarmLeaveRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *SwarmLeaveRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *SwarmLeaveRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.SwarmLeave(r.ctx, r.Force)
	return result, err
}

// GetId returns request id
func (r *SwarmLeaveRequest) GetId() string {
	return "swarmLeaveRequest"
}

// SetContext sets context
func (r *SwarmUnlockRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *SwarmUnlockRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *SwarmUnlockRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.SwarmUnlock(r.ctx, r.Req)
	return result, err
}

// GetId returns request id
func (r *SwarmUnlockRequest) GetId() string {
	return "swarmUnlockRequest"
}

// SetContext sets context
func (r *ContainersPruneRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainersPruneRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainersPruneRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ContainersPrune(r.ctx, r.PruneFilters)
	return result, err
}

// GetId returns request id
func (r *ContainersPruneRequest) GetId() string {
	return "containersPruneRequest"
}

// SetContext sets context
func (r *ServiceLogsRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ServiceLogsRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ServiceLogsRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ServiceLogs(r.ctx, r.ServiceID, r.LogsOptions)
	return result, err
}

// GetId returns request id
func (r *ServiceLogsRequest) GetId() string {
	return "serviceLogsRequest"
}

// SetContext sets context
func (r *ConfigCreateRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ConfigCreateRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ConfigCreateRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ConfigCreate(r.ctx, r.Config)
	return result, err
}

// GetId returns request id
func (r *ConfigCreateRequest) GetId() string {
	return "configCreateRequest"
}

// SetContext sets context
func (r *PluginEnableRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *PluginEnableRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *PluginEnableRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.PluginEnable(r.ctx, r.Name, r.PluginEnableOptions)
	return result, err
}

// GetId returns request id
func (r *PluginEnableRequest) GetId() string {
	return "pluginEnableRequest"
}

// SetContext sets context
func (r *NetworkListRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *NetworkListRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *NetworkListRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.NetworkList(r.ctx, r.NetworkListOptions)
	return result, err
}

// GetId returns request id
func (r *NetworkListRequest) GetId() string {
	return "networkListRequest"
}

// SetContext sets context
func (r *ContainerWaitRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerWaitRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerWaitRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, _ = r.service_.ContainerWait(r.ctx, r.ContainerID, r.Condition)
	return result, err
}

// GetId returns request id
func (r *ContainerWaitRequest) GetId() string {
	return "containerWaitRequest"
}

// SetContext sets context
func (r *ImageLoadRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ImageLoadRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ImageLoadRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ImageLoad(r.ctx, r.Input, r.Quiet)
	return result, err
}

// GetId returns request id
func (r *ImageLoadRequest) GetId() string {
	return "imageLoadRequest"
}

// SetContext sets context
func (r *ImageSaveRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ImageSaveRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ImageSaveRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ImageSave(r.ctx, r.ImageIDs)
	return result, err
}

// GetId returns request id
func (r *ImageSaveRequest) GetId() string {
	return "imageSaveRequest"
}

// SetContext sets context
func (r *ImageBuildRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ImageBuildRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ImageBuildRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ImageBuild(r.ctx, r.BuildContext, r.ImageBuildOptions)
	return result, err
}

// GetId returns request id
func (r *ImageBuildRequest) GetId() string {
	return "imageBuildRequest"
}

// SetContext sets context
func (r *ContainerCreateRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerCreateRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerCreateRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ContainerCreate(r.ctx, r.Config, r.HostConfig, r.NetworkingConfig, r.Platform, r.ContainerName)
	return result, err
}

// GetId returns request id
func (r *ContainerCreateRequest) GetId() string {
	return "containerCreateRequest"
}

// SetContext sets context
func (r *ImagePushRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ImagePushRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ImagePushRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ImagePush(r.ctx, r.Image, r.ImagePushOptions)
	return result, err
}

// GetId returns request id
func (r *ImagePushRequest) GetId() string {
	return "imagePushRequest"
}

// SetContext sets context
func (r *ImagesPruneRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ImagesPruneRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ImagesPruneRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ImagesPrune(r.ctx, r.PruneFilters)
	return result, err
}

// GetId returns request id
func (r *ImagesPruneRequest) GetId() string {
	return "imagesPruneRequest"
}

// SetContext sets context
func (r *CheckpointCreateRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *CheckpointCreateRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *CheckpointCreateRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.CheckpointCreate(r.ctx, r.Container, r.CreateOptions)
	return result, err
}

// GetId returns request id
func (r *CheckpointCreateRequest) GetId() string {
	return "checkpointCreateRequest"
}

// SetContext sets context
func (r *ContainerExportRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerExportRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerExportRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ContainerExport(r.ctx, r.ContainerID)
	return result, err
}

// GetId returns request id
func (r *ContainerExportRequest) GetId() string {
	return "containerExportRequest"
}

// SetContext sets context
func (r *ImageTagRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ImageTagRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ImageTagRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.ImageTag(r.ctx, r.Source, r.Target)
	return result, err
}

// GetId returns request id
func (r *ImageTagRequest) GetId() string {
	return "imageTagRequest"
}

// SetContext sets context
func (r *CheckpointListRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *CheckpointListRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *CheckpointListRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.CheckpointList(r.ctx, r.Container, r.ListOptions)
	return result, err
}

// GetId returns request id
func (r *CheckpointListRequest) GetId() string {
	return "checkpointListRequest"
}

// SetContext sets context
func (r *SwarmJoinRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *SwarmJoinRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *SwarmJoinRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.SwarmJoin(r.ctx, r.Req)
	return result, err
}

// GetId returns request id
func (r *SwarmJoinRequest) GetId() string {
	return "swarmJoinRequest"
}

// SetContext sets context
func (r *EventsRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *EventsRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *EventsRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, _ = r.service_.Events(r.ctx, r.EventsOptions)
	return result, err
}

// GetId returns request id
func (r *EventsRequest) GetId() string {
	return "eventsRequest"
}

// SetContext sets context
func (r *DialHijackRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *DialHijackRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *DialHijackRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.DialHijack(r.ctx, r.Url, r.Proto, r.Meta)
	return result, err
}

// GetId returns request id
func (r *DialHijackRequest) GetId() string {
	return "dialHijackRequest"
}

// SetContext sets context
func (r *PluginSetRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *PluginSetRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *PluginSetRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.PluginSet(r.ctx, r.Name, r.Args)
	return result, err
}

// GetId returns request id
func (r *PluginSetRequest) GetId() string {
	return "pluginSetRequest"
}

// SetContext sets context
func (r *ContainerRemoveRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerRemoveRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerRemoveRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.ContainerRemove(r.ctx, r.ContainerID, r.RemoveOptions)
	return result, err
}

// GetId returns request id
func (r *ContainerRemoveRequest) GetId() string {
	return "containerRemoveRequest"
}

// SetContext sets context
func (r *SecretCreateRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *SecretCreateRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *SecretCreateRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.SecretCreate(r.ctx, r.Secret)
	return result, err
}

// GetId returns request id
func (r *SecretCreateRequest) GetId() string {
	return "secretCreateRequest"
}

// SetContext sets context
func (r *SwarmUpdateRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *SwarmUpdateRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *SwarmUpdateRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.SwarmUpdate(r.ctx, r.Version, r.Swarm, r.Flags)
	return result, err
}

// GetId returns request id
func (r *SwarmUpdateRequest) GetId() string {
	return "swarmUpdateRequest"
}

// SetContext sets context
func (r *DiskUsageRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *DiskUsageRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *DiskUsageRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.DiskUsage(r.ctx, r.DiskUsageOptions)
	return result, err
}

// GetId returns request id
func (r *DiskUsageRequest) GetId() string {
	return "diskUsageRequest"
}

// SetContext sets context
func (r *DistributionInspectRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *DistributionInspectRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *DistributionInspectRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.DistributionInspect(r.ctx, r.Image, r.EncodedRegistryAuth)
	return result, err
}

// GetId returns request id
func (r *DistributionInspectRequest) GetId() string {
	return "distributionInspectRequest"
}

// SetContext sets context
func (r *SwarmGetUnlockKeyRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *SwarmGetUnlockKeyRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *SwarmGetUnlockKeyRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.SwarmGetUnlockKey(r.ctx)
	return result, err
}

// GetId returns request id
func (r *SwarmGetUnlockKeyRequest) GetId() string {
	return "swarmGetUnlockKeyRequest"
}

// SetContext sets context
func (r *VolumeCreateRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *VolumeCreateRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *VolumeCreateRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.VolumeCreate(r.ctx, r.CreateOptions)
	return result, err
}

// GetId returns request id
func (r *VolumeCreateRequest) GetId() string {
	return "volumeCreateRequest"
}

// SetContext sets context
func (r *ContainerRestartRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerRestartRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerRestartRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.ContainerRestart(r.ctx, r.ContainerID, r.StopOptions)
	return result, err
}

// GetId returns request id
func (r *ContainerRestartRequest) GetId() string {
	return "containerRestartRequest"
}

// SetContext sets context
func (r *ServiceUpdateRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ServiceUpdateRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ServiceUpdateRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ServiceUpdate(r.ctx, r.ServiceID, r.Version, r.Service, r.Options)
	return result, err
}

// GetId returns request id
func (r *ServiceUpdateRequest) GetId() string {
	return "serviceUpdateRequest"
}

// SetContext sets context
func (r *VolumeUpdateRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *VolumeUpdateRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *VolumeUpdateRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.VolumeUpdate(r.ctx, r.VolumeID, r.Version, r.Options)
	return result, err
}

// GetId returns request id
func (r *VolumeUpdateRequest) GetId() string {
	return "volumeUpdateRequest"
}

// SetContext sets context
func (r *ContainerInspectRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerInspectRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerInspectRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ContainerInspect(r.ctx, r.ContainerID)
	return result, err
}

// GetId returns request id
func (r *ContainerInspectRequest) GetId() string {
	return "containerInspectRequest"
}

// SetContext sets context
func (r *CheckpointDeleteRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *CheckpointDeleteRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *CheckpointDeleteRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.CheckpointDelete(r.ctx, r.ContainerID, r.DeleteOptions)
	return result, err
}

// GetId returns request id
func (r *CheckpointDeleteRequest) GetId() string {
	return "checkpointDeleteRequest"
}

// SetContext sets context
func (r *BuildCachePruneRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *BuildCachePruneRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *BuildCachePruneRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.BuildCachePrune(r.ctx, r.Opts)
	return result, err
}

// GetId returns request id
func (r *BuildCachePruneRequest) GetId() string {
	return "buildCachePruneRequest"
}

// SetContext sets context
func (r *ConfigListRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ConfigListRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ConfigListRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ConfigList(r.ctx, r.ConfigListOptions)
	return result, err
}

// GetId returns request id
func (r *ConfigListRequest) GetId() string {
	return "configListRequest"
}

// SetContext sets context
func (r *VolumeInspectRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *VolumeInspectRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *VolumeInspectRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.VolumeInspect(r.ctx, r.VolumeID)
	return result, err
}

// GetId returns request id
func (r *VolumeInspectRequest) GetId() string {
	return "volumeInspectRequest"
}

// SetContext sets context
func (r *ContainerStopRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerStopRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerStopRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.ContainerStop(r.ctx, r.ContainerID, r.StopOptions)
	return result, err
}

// GetId returns request id
func (r *ContainerStopRequest) GetId() string {
	return "containerStopRequest"
}

// SetContext sets context
func (r *ImageSearchRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ImageSearchRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ImageSearchRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ImageSearch(r.ctx, r.Term, r.ImageSearchOptions)
	return result, err
}

// GetId returns request id
func (r *ImageSearchRequest) GetId() string {
	return "imageSearchRequest"
}

// SetContext sets context
func (r *ContainerUnpauseRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerUnpauseRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerUnpauseRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.ContainerUnpause(r.ctx, r.ContainerID)
	return result, err
}

// GetId returns request id
func (r *ContainerUnpauseRequest) GetId() string {
	return "containerUnpauseRequest"
}

// SetContext sets context
func (r *ServiceListRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ServiceListRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ServiceListRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ServiceList(r.ctx, r.ServiceListOptions)
	return result, err
}

// GetId returns request id
func (r *ServiceListRequest) GetId() string {
	return "serviceListRequest"
}

// SetContext sets context
func (r *VolumesPruneRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *VolumesPruneRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *VolumesPruneRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.VolumesPrune(r.ctx, r.PruneFilters)
	return result, err
}

// GetId returns request id
func (r *VolumesPruneRequest) GetId() string {
	return "volumesPruneRequest"
}

// SetContext sets context
func (r *ConfigUpdateRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ConfigUpdateRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ConfigUpdateRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.ConfigUpdate(r.ctx, r.Id, r.Version, r.Config)
	return result, err
}

// GetId returns request id
func (r *ConfigUpdateRequest) GetId() string {
	return "configUpdateRequest"
}

// SetContext sets context
func (r *NegotiateAPIVersionRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *NegotiateAPIVersionRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *NegotiateAPIVersionRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	r.service_.NegotiateAPIVersion(r.ctx)
	return result, err
}

// GetId returns request id
func (r *NegotiateAPIVersionRequest) GetId() string {
	return "negotiateAPIVersionRequest"
}

// SetContext sets context
func (r *SwarmInspectRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *SwarmInspectRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *SwarmInspectRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.SwarmInspect(r.ctx)
	return result, err
}

// GetId returns request id
func (r *SwarmInspectRequest) GetId() string {
	return "swarmInspectRequest"
}

// SetContext sets context
func (r *BuildCancelRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *BuildCancelRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *BuildCancelRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.BuildCancel(r.ctx, r.Id)
	return result, err
}

// GetId returns request id
func (r *BuildCancelRequest) GetId() string {
	return "buildCancelRequest"
}

// SetContext sets context
func (r *ContainerLogsRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ContainerLogsRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ContainerLogsRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ContainerLogs(r.ctx, r.Container, r.LogsOptions)
	return result, err
}

// GetId returns request id
func (r *ContainerLogsRequest) GetId() string {
	return "containerLogsRequest"
}

// SetContext sets context
func (r *ImageRemoveRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ImageRemoveRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ImageRemoveRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ImageRemove(r.ctx, r.ImageID, r.ImageRemoveOptions)
	return result, err
}

// GetId returns request id
func (r *ImageRemoveRequest) GetId() string {
	return "imageRemoveRequest"
}

// SetContext sets context
func (r *TaskLogsRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *TaskLogsRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *TaskLogsRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.TaskLogs(r.ctx, r.TaskID, r.LogsOptions)
	return result, err
}

// GetId returns request id
func (r *TaskLogsRequest) GetId() string {
	return "taskLogsRequest"
}

// SetContext sets context
func (r *NetworksPruneRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *NetworksPruneRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *NetworksPruneRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.NetworksPrune(r.ctx, r.PruneFilters)
	return result, err
}

// GetId returns request id
func (r *NetworksPruneRequest) GetId() string {
	return "networksPruneRequest"
}

// SetContext sets context
func (r *NodeUpdateRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *NodeUpdateRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *NodeUpdateRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.NodeUpdate(r.ctx, r.NodeID, r.Version, r.Node)
	return result, err
}

// GetId returns request id
func (r *NodeUpdateRequest) GetId() string {
	return "nodeUpdateRequest"
}

// SetContext sets context
func (r *ImageCreateRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *ImageCreateRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *ImageCreateRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	result, err = r.service_.ImageCreate(r.ctx, r.ParentReference, r.ImageCreateOptions)
	return result, err
}

// GetId returns request id
func (r *ImageCreateRequest) GetId() string {
	return "imageCreateRequest"
}

// SetContext sets context
func (r *NewVersionErrorRequest) SetContext(ctx context.Context) {
	r.ctx = ctx
}

// SetService sets service
func (r *NewVersionErrorRequest) SetService(service interface{}) error {
	var ok bool
	if r.service_, ok = service.(*client.Client); !ok {
		return fmt.Errorf("invalid service type: %T, expected: *client.Client", service)
	}
	return nil
}

// Call calls service
func (r *NewVersionErrorRequest) Call() (result interface{}, err error) {
	if r.service_ == nil {
		return nil, errors.New("service was empty")
	}
	err = r.service_.NewVersionError(r.ctx, r.APIrequired, r.Feature)
	return result, err
}

// GetId returns request id
func (r *NewVersionErrorRequest) GetId() string {
	return "newVersionErrorRequest"
}