Updated varlink vendored code

Signed-off-by: baude <bbaude@redhat.com>

Closes: #670
Approved by: mheon

1 files changed, 1023 insertions, 345 deletions

diff --git a/cmd/podman/ioprojectatomicpodman/ioprojectatomicpodman.go b/cmd/podman/ioprojectatomicpodman/ioprojectatomicpodman.go
index efee14daf..687e5e77d 100644
--- a/cmd/podman/ioprojectatomicpodman/ioprojectatomicpodman.go
+++ b/cmd/podman/ioprojectatomicpodman/ioprojectatomicpodman.go
@@ -3,638 +3,1315 @@ package ioprojectatomicpodman
 
 import "github.com/varlink/go/varlink"
 
-type Version struct{
-	Version string `json:"version"`
+// Type declarations
+type Version struct {
+	Version    string `json:"version"`
 	Go_version string `json:"go_version"`
 	Git_commit string `json:"git_commit"`
-	Built int64 `json:"built"`
-	Os_arch string `json:"os_arch"`
+	Built      int64  `json:"built"`
+	Os_arch    string `json:"os_arch"`
 }
 
-type NotImplemented struct{
+type NotImplemented struct {
 	Comment string `json:"comment"`
 }
 
-type StringResponse struct{
+type StringResponse struct {
 	Message string `json:"message"`
 }
 
-type ioprojectatomicpodmanInterface interface {
-	ListContainerProcesses(c VarlinkCall) error
-	UpdateContainer(c VarlinkCall) error
-	HistoryImage(c VarlinkCall) error
-	ExportImage(c VarlinkCall) error
-	CreateContainer(c VarlinkCall) error
-	InspectContainer(c VarlinkCall) error
-	UnpauseContainer(c VarlinkCall) error
-	AttachToContainer(c VarlinkCall) error
-	SearchImage(c VarlinkCall) error
-	ListContainerChanges(c VarlinkCall) error
-	RenameContainer(c VarlinkCall) error
-	RemoveContainer(c VarlinkCall) error
-	PullImage(c VarlinkCall) error
-	Ping(c VarlinkCall) error
-	ListContainers(c VarlinkCall) error
-	PushImage(c VarlinkCall) error
-	TagImage(c VarlinkCall) error
-	RemoveImage(c VarlinkCall) error
-	KillContainer(c VarlinkCall) error
-	InspectImage(c VarlinkCall) error
-	CreateImage(c VarlinkCall) error
-	DeleteUnusedImages(c VarlinkCall) error
-	CreateFromContainer(c VarlinkCall) error
-	ImportImage(c VarlinkCall) error
-	PauseContainer(c VarlinkCall) error
-	ListImages(c VarlinkCall) error
-	DeleteStoppedContainers(c VarlinkCall) error
-	ExportContainer(c VarlinkCall) error
-	StartContainer(c VarlinkCall) error
-	ResizeContainerTty(c VarlinkCall) error
-	RestartContainer(c VarlinkCall) error
-	WaitContainer(c VarlinkCall) error
-	GetVersion(c VarlinkCall) error
-	GetContainerStats(c VarlinkCall) error
-	BuildImage(c VarlinkCall) error
-	GetContainerLogs(c VarlinkCall) error
-	StopContainer(c VarlinkCall) error
+// Client method calls and reply readers
+func UpdateContainer(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.UpdateContainer", nil, more__, oneway__)
 }
 
-type VarlinkCall struct{ varlink.Call }
+func ReadUpdateContainer_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
+}
 
-func (c *VarlinkCall) ReplyActionFailed(reason string) error {
-	var out struct{
-		Reason string `json:"reason"`
+func RemoveContainer(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.RemoveContainer", nil, more__, oneway__)
+}
+
+func ReadRemoveContainer_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
+}
+
+func HistoryImage(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.HistoryImage", nil, more__, oneway__)
+}
+
+func ReadHistoryImage_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
+}
+
+func ListContainerChanges(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.ListContainerChanges", nil, more__, oneway__)
+}
+
+func ReadListContainerChanges_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
+}
+
+func ResizeContainerTty(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.ResizeContainerTty", nil, more__, oneway__)
+}
+
+func ReadResizeContainerTty_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
+}
+
+func RestartContainer(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.RestartContainer", nil, more__, oneway__)
+}
+
+func ReadRestartContainer_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
+}
+
+func BuildImage(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.BuildImage", nil, more__, oneway__)
+}
+
+func ReadBuildImage_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
+}
+
+func ListContainers(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.ListContainers", nil, more__, oneway__)
+}
+
+func ReadListContainers_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
+}
+
+func StartContainer(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.StartContainer", nil, more__, oneway__)
+}
+
+func ReadStartContainer_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
 	}
-	out.Reason = reason
-	return c.ReplyError("io.projectatomic.podman.ActionFailed", &out)
+	return continues_, nil
 }
 
-func (c *VarlinkCall) ReplyGetVersion(version Version) error {
-	var out struct{
+func ListImages(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.ListImages", nil, more__, oneway__)
+}
+
+func ReadListImages_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
+}
+
+func GetVersion(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.GetVersion", nil, more__, oneway__)
+}
+
+func ReadGetVersion_(c__ *varlink.Connection, version_ *Version) (bool, error) {
+	var out struct {
 		Version Version `json:"version"`
 	}
-	out.Version = version
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if version_ != nil {
+		*version_ = out.Version
+	}
+	return continues_, nil
 }
 
-func (c *VarlinkCall) ReplyGetContainerStats(notimplemented NotImplemented) error {
-	var out struct{
+func UnpauseContainer(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.UnpauseContainer", nil, more__, oneway__)
+}
+
+func ReadUnpauseContainer_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
+}
+
+func DeleteUnusedImages(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.DeleteUnusedImages", nil, more__, oneway__)
 }
 
-func (c *VarlinkCall) ReplyResizeContainerTty(notimplemented NotImplemented) error {
-	var out struct{
+func ReadDeleteUnusedImages_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
 }
 
-func (c *VarlinkCall) ReplyRestartContainer(notimplemented NotImplemented) error {
-	var out struct{
+func KillContainer(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.KillContainer", nil, more__, oneway__)
+}
+
+func ReadKillContainer_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
+}
+
+func RemoveImage(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.RemoveImage", nil, more__, oneway__)
 }
 
-func (c *VarlinkCall) ReplyWaitContainer(notimplemented NotImplemented) error {
-	var out struct{
+func ReadRemoveImage_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
+}
+
+func CreateContainer(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.CreateContainer", nil, more__, oneway__)
 }
 
-func (c *VarlinkCall) ReplyGetContainerLogs(notimplemented NotImplemented) error {
-	var out struct{
+func ReadCreateContainer_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
 }
 
-func (c *VarlinkCall) ReplyStopContainer(notimplemented NotImplemented) error {
-	var out struct{
+func InspectContainer(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.InspectContainer", nil, more__, oneway__)
+}
+
+func ReadInspectContainer_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
+}
+
+func ExportContainer(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.ExportContainer", nil, more__, oneway__)
 }
 
-func (c *VarlinkCall) ReplyBuildImage(notimplemented NotImplemented) error {
-	var out struct{
+func ReadExportContainer_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
 }
 
-func (c *VarlinkCall) ReplyCreateContainer(notimplemented NotImplemented) error {
-	var out struct{
+func TagImage(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.TagImage", nil, more__, oneway__)
+}
+
+func ReadTagImage_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
+}
+
+func ImportImage(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.ImportImage", nil, more__, oneway__)
 }
 
-func (c *VarlinkCall) ReplyInspectContainer(notimplemented NotImplemented) error {
-	var out struct{
+func ReadImportImage_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
+}
+
+func Ping(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.Ping", nil, more__, oneway__)
+}
+
+func ReadPing_(c__ *varlink.Connection, ping_ *StringResponse) (bool, error) {
+	var out struct {
+		Ping StringResponse `json:"ping"`
+	}
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if ping_ != nil {
+		*ping_ = out.Ping
+	}
+	return continues_, nil
+}
+
+func GetContainerLogs(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.GetContainerLogs", nil, more__, oneway__)
 }
 
-func (c *VarlinkCall) ReplyListContainerProcesses(notimplemented NotImplemented) error {
-	var out struct{
+func ReadGetContainerLogs_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
+}
+
+func AttachToContainer(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.AttachToContainer", nil, more__, oneway__)
 }
 
-func (c *VarlinkCall) ReplyUpdateContainer(notimplemented NotImplemented) error {
-	var out struct{
+func ReadAttachToContainer_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
 }
 
-func (c *VarlinkCall) ReplyHistoryImage(notimplemented NotImplemented) error {
-	var out struct{
+func DeleteStoppedContainers(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.DeleteStoppedContainers", nil, more__, oneway__)
+}
+
+func ReadDeleteStoppedContainers_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
+}
+
+func CreateFromContainer(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.CreateFromContainer", nil, more__, oneway__)
 }
 
-func (c *VarlinkCall) ReplyExportImage(notimplemented NotImplemented) error {
-	var out struct{
+func ReadCreateFromContainer_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
 }
 
-func (c *VarlinkCall) ReplyListContainerChanges(notimplemented NotImplemented) error {
-	var out struct{
+func ExportImage(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.ExportImage", nil, more__, oneway__)
+}
+
+func ReadExportImage_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
+}
+
+func PullImage(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.PullImage", nil, more__, oneway__)
 }
 
-func (c *VarlinkCall) ReplyRenameContainer(notimplemented NotImplemented) error {
-	var out struct{
+func ReadPullImage_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
 }
 
-func (c *VarlinkCall) ReplyUnpauseContainer(notimplemented NotImplemented) error {
-	var out struct{
+func GetContainerStats(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.GetContainerStats", nil, more__, oneway__)
+}
+
+func ReadGetContainerStats_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
 }
 
-func (c *VarlinkCall) ReplyAttachToContainer(notimplemented NotImplemented) error {
-	var out struct{
+func StopContainer(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.StopContainer", nil, more__, oneway__)
+}
+
+func ReadStopContainer_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
+}
+
+func WaitContainer(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.WaitContainer", nil, more__, oneway__)
 }
 
-func (c *VarlinkCall) ReplySearchImage(notimplemented NotImplemented) error {
-	var out struct{
+func ReadWaitContainer_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
 }
 
-func (c *VarlinkCall) ReplyPing(ping StringResponse) error {
-	var out struct{
-		Ping StringResponse `json:"ping"`
+func RenameContainer(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.RenameContainer", nil, more__, oneway__)
+}
+
+func ReadRenameContainer_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
 	}
-	out.Ping = ping
-	return c.Reply(&out)
+	return continues_, nil
 }
 
-func (c *VarlinkCall) ReplyListContainers(notimplemented NotImplemented) error {
-	var out struct{
+func PauseContainer(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.PauseContainer", nil, more__, oneway__)
+}
+
+func ReadPauseContainer_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
+}
+
+func PushImage(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.PushImage", nil, more__, oneway__)
 }
 
-func (c *VarlinkCall) ReplyRemoveContainer(notimplemented NotImplemented) error {
-	var out struct{
+func ReadPushImage_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
+}
+
+func SearchImage(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.SearchImage", nil, more__, oneway__)
 }
 
-func (c *VarlinkCall) ReplyPullImage(notimplemented NotImplemented) error {
-	var out struct{
+func ReadSearchImage_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
 }
 
-func (c *VarlinkCall) ReplyKillContainer(notimplemented NotImplemented) error {
-	var out struct{
+func ListContainerProcesses(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.ListContainerProcesses", nil, more__, oneway__)
+}
+
+func ReadListContainerProcesses_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
 }
 
-func (c *VarlinkCall) ReplyInspectImage(notimplemented NotImplemented) error {
-	var out struct{
+func CreateImage(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.CreateImage", nil, more__, oneway__)
+}
+
+func ReadCreateImage_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
 }
 
-func (c *VarlinkCall) ReplyPushImage(notimplemented NotImplemented) error {
-	var out struct{
+func InspectImage(c__ *varlink.Connection, more__ bool, oneway__ bool) error {
+	return c__.Send("io.projectatomic.podman.InspectImage", nil, more__, oneway__)
+}
+
+func ReadInspectImage_(c__ *varlink.Connection, notimplemented_ *NotImplemented) (bool, error) {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	continues_, err := c__.Receive(&out)
+	if err != nil {
+		return false, err
+	}
+	if notimplemented_ != nil {
+		*notimplemented_ = out.Notimplemented
+	}
+	return continues_, nil
 }
 
-func (c *VarlinkCall) ReplyTagImage(notimplemented NotImplemented) error {
-	var out struct{
+// Service interface with all methods
+type ioprojectatomicpodmanInterface interface {
+	GetVersion(c__ VarlinkCall) error
+	UnpauseContainer(c__ VarlinkCall) error
+	DeleteUnusedImages(c__ VarlinkCall) error
+	CreateContainer(c__ VarlinkCall) error
+	InspectContainer(c__ VarlinkCall) error
+	ExportContainer(c__ VarlinkCall) error
+	KillContainer(c__ VarlinkCall) error
+	RemoveImage(c__ VarlinkCall) error
+	Ping(c__ VarlinkCall) error
+	GetContainerLogs(c__ VarlinkCall) error
+	AttachToContainer(c__ VarlinkCall) error
+	TagImage(c__ VarlinkCall) error
+	ImportImage(c__ VarlinkCall) error
+	PullImage(c__ VarlinkCall) error
+	GetContainerStats(c__ VarlinkCall) error
+	StopContainer(c__ VarlinkCall) error
+	WaitContainer(c__ VarlinkCall) error
+	DeleteStoppedContainers(c__ VarlinkCall) error
+	CreateFromContainer(c__ VarlinkCall) error
+	ExportImage(c__ VarlinkCall) error
+	RenameContainer(c__ VarlinkCall) error
+	PauseContainer(c__ VarlinkCall) error
+	ListContainerProcesses(c__ VarlinkCall) error
+	CreateImage(c__ VarlinkCall) error
+	InspectImage(c__ VarlinkCall) error
+	PushImage(c__ VarlinkCall) error
+	SearchImage(c__ VarlinkCall) error
+	ListContainerChanges(c__ VarlinkCall) error
+	ResizeContainerTty(c__ VarlinkCall) error
+	RestartContainer(c__ VarlinkCall) error
+	UpdateContainer(c__ VarlinkCall) error
+	RemoveContainer(c__ VarlinkCall) error
+	HistoryImage(c__ VarlinkCall) error
+	ListContainers(c__ VarlinkCall) error
+	StartContainer(c__ VarlinkCall) error
+	ListImages(c__ VarlinkCall) error
+	BuildImage(c__ VarlinkCall) error
+}
+
+// Service object with all methods
+type VarlinkCall struct{ varlink.Call }
+
+// Reply methods for all varlink errors
+func (c__ *VarlinkCall) ReplyActionFailed(reason_ string) error {
+	var out struct {
+		Reason string `json:"reason"`
+	}
+	out.Reason = reason_
+	return c__.ReplyError("io.projectatomic.podman.ActionFailed", &out)
+}
+
+// Reply methods for all varlink methods
+func (c__ *VarlinkCall) ReplyRenameContainer(notimplemented_ NotImplemented) error {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyRemoveImage(notimplemented NotImplemented) error {
-	var out struct{
+func (c__ *VarlinkCall) ReplyPauseContainer(notimplemented_ NotImplemented) error {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyPauseContainer(notimplemented NotImplemented) error {
-	var out struct{
+func (c__ *VarlinkCall) ReplyInspectImage(notimplemented_ NotImplemented) error {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyListImages(notimplemented NotImplemented) error {
-	var out struct{
+func (c__ *VarlinkCall) ReplyPushImage(notimplemented_ NotImplemented) error {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyCreateImage(notimplemented NotImplemented) error {
-	var out struct{
+func (c__ *VarlinkCall) ReplySearchImage(notimplemented_ NotImplemented) error {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyDeleteUnusedImages(notimplemented NotImplemented) error {
-	var out struct{
+func (c__ *VarlinkCall) ReplyListContainerProcesses(notimplemented_ NotImplemented) error {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyCreateFromContainer(notimplemented NotImplemented) error {
-	var out struct{
+func (c__ *VarlinkCall) ReplyCreateImage(notimplemented_ NotImplemented) error {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyImportImage(notimplemented NotImplemented) error {
-	var out struct{
+func (c__ *VarlinkCall) ReplyRestartContainer(notimplemented_ NotImplemented) error {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyExportContainer(notimplemented NotImplemented) error {
-	var out struct{
+func (c__ *VarlinkCall) ReplyUpdateContainer(notimplemented_ NotImplemented) error {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyStartContainer(notimplemented NotImplemented) error {
-	var out struct{
+func (c__ *VarlinkCall) ReplyRemoveContainer(notimplemented_ NotImplemented) error {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyDeleteStoppedContainers(notimplemented NotImplemented) error {
-	var out struct{
+func (c__ *VarlinkCall) ReplyHistoryImage(notimplemented_ NotImplemented) error {
+	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Notimplemented = notimplemented
-	return c.Reply(&out)
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) DeleteUnusedImages(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("DeleteUnusedImages")
+func (c__ *VarlinkCall) ReplyListContainerChanges(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) CreateFromContainer(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("CreateFromContainer")
+func (c__ *VarlinkCall) ReplyResizeContainerTty(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) ImportImage(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("ImportImage")
+func (c__ *VarlinkCall) ReplyListImages(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) PauseContainer(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("PauseContainer")
+func (c__ *VarlinkCall) ReplyBuildImage(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) ListImages(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("ListImages")
+func (c__ *VarlinkCall) ReplyListContainers(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) CreateImage(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("CreateImage")
+func (c__ *VarlinkCall) ReplyStartContainer(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) ExportContainer(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("ExportContainer")
+func (c__ *VarlinkCall) ReplyDeleteUnusedImages(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) StartContainer(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("StartContainer")
+func (c__ *VarlinkCall) ReplyGetVersion(version_ Version) error {
+	var out struct {
+		Version Version `json:"version"`
+	}
+	out.Version = version_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) DeleteStoppedContainers(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("DeleteStoppedContainers")
+func (c__ *VarlinkCall) ReplyUnpauseContainer(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) RestartContainer(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("RestartContainer")
+func (c__ *VarlinkCall) ReplyExportContainer(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) WaitContainer(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("WaitContainer")
+func (c__ *VarlinkCall) ReplyKillContainer(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) GetVersion(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("GetVersion")
+func (c__ *VarlinkCall) ReplyRemoveImage(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) GetContainerStats(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("GetContainerStats")
+func (c__ *VarlinkCall) ReplyCreateContainer(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) ResizeContainerTty(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("ResizeContainerTty")
+func (c__ *VarlinkCall) ReplyInspectContainer(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) GetContainerLogs(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("GetContainerLogs")
+func (c__ *VarlinkCall) ReplyAttachToContainer(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) StopContainer(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("StopContainer")
+func (c__ *VarlinkCall) ReplyTagImage(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) BuildImage(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("BuildImage")
+func (c__ *VarlinkCall) ReplyImportImage(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) UpdateContainer(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("UpdateContainer")
+func (c__ *VarlinkCall) ReplyPing(ping_ StringResponse) error {
+	var out struct {
+		Ping StringResponse `json:"ping"`
+	}
+	out.Ping = ping_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) HistoryImage(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("HistoryImage")
+func (c__ *VarlinkCall) ReplyGetContainerLogs(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) ExportImage(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("ExportImage")
+func (c__ *VarlinkCall) ReplyWaitContainer(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) CreateContainer(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("CreateContainer")
+func (c__ *VarlinkCall) ReplyDeleteStoppedContainers(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) InspectContainer(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("InspectContainer")
+func (c__ *VarlinkCall) ReplyCreateFromContainer(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) ListContainerProcesses(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("ListContainerProcesses")
+func (c__ *VarlinkCall) ReplyExportImage(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) AttachToContainer(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("AttachToContainer")
+func (c__ *VarlinkCall) ReplyPullImage(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) SearchImage(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("SearchImage")
+func (c__ *VarlinkCall) ReplyGetContainerStats(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) ListContainerChanges(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("ListContainerChanges")
+func (c__ *VarlinkCall) ReplyStopContainer(notimplemented_ NotImplemented) error {
+	var out struct {
+		Notimplemented NotImplemented `json:"notimplemented"`
+	}
+	out.Notimplemented = notimplemented_
+	return c__.Reply(&out)
 }
 
-func (s *VarlinkInterface) RenameContainer(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("RenameContainer")
+// Dummy methods for all varlink methods
+func (s__ *VarlinkInterface) RenameContainer(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("RenameContainer")
 }
 
-func (s *VarlinkInterface) UnpauseContainer(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("UnpauseContainer")
+func (s__ *VarlinkInterface) PauseContainer(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("PauseContainer")
 }
 
-func (s *VarlinkInterface) PullImage(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("PullImage")
+func (s__ *VarlinkInterface) ListContainerProcesses(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("ListContainerProcesses")
 }
 
-func (s *VarlinkInterface) Ping(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("Ping")
+func (s__ *VarlinkInterface) CreateImage(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("CreateImage")
 }
 
-func (s *VarlinkInterface) ListContainers(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("ListContainers")
+func (s__ *VarlinkInterface) InspectImage(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("InspectImage")
 }
 
-func (s *VarlinkInterface) RemoveContainer(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("RemoveContainer")
+func (s__ *VarlinkInterface) PushImage(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("PushImage")
 }
 
-func (s *VarlinkInterface) TagImage(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("TagImage")
+func (s__ *VarlinkInterface) SearchImage(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("SearchImage")
 }
 
-func (s *VarlinkInterface) RemoveImage(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("RemoveImage")
+func (s__ *VarlinkInterface) ListContainerChanges(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("ListContainerChanges")
 }
 
-func (s *VarlinkInterface) KillContainer(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("KillContainer")
+func (s__ *VarlinkInterface) ResizeContainerTty(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("ResizeContainerTty")
 }
 
-func (s *VarlinkInterface) InspectImage(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("InspectImage")
+func (s__ *VarlinkInterface) RestartContainer(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("RestartContainer")
 }
 
-func (s *VarlinkInterface) PushImage(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("PushImage")
+func (s__ *VarlinkInterface) UpdateContainer(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("UpdateContainer")
 }
 
-func (s *VarlinkInterface) VarlinkDispatch(call varlink.Call, methodname string) error {
-	switch methodname {
-	case "ExportContainer":
-		return s.ioprojectatomicpodmanInterface.ExportContainer(VarlinkCall{call})
+func (s__ *VarlinkInterface) RemoveContainer(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("RemoveContainer")
+}
 
-	case "StartContainer":
-		return s.ioprojectatomicpodmanInterface.StartContainer(VarlinkCall{call})
+func (s__ *VarlinkInterface) HistoryImage(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("HistoryImage")
+}
 
-	case "DeleteStoppedContainers":
-		return s.ioprojectatomicpodmanInterface.DeleteStoppedContainers(VarlinkCall{call})
+func (s__ *VarlinkInterface) ListContainers(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("ListContainers")
+}
 
-	case "GetVersion":
-		return s.ioprojectatomicpodmanInterface.GetVersion(VarlinkCall{call})
+func (s__ *VarlinkInterface) StartContainer(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("StartContainer")
+}
 
-	case "GetContainerStats":
-		return s.ioprojectatomicpodmanInterface.GetContainerStats(VarlinkCall{call})
+func (s__ *VarlinkInterface) ListImages(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("ListImages")
+}
 
-	case "ResizeContainerTty":
-		return s.ioprojectatomicpodmanInterface.ResizeContainerTty(VarlinkCall{call})
+func (s__ *VarlinkInterface) BuildImage(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("BuildImage")
+}
 
-	case "RestartContainer":
-		return s.ioprojectatomicpodmanInterface.RestartContainer(VarlinkCall{call})
+func (s__ *VarlinkInterface) GetVersion(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("GetVersion")
+}
 
-	case "WaitContainer":
-		return s.ioprojectatomicpodmanInterface.WaitContainer(VarlinkCall{call})
+func (s__ *VarlinkInterface) UnpauseContainer(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("UnpauseContainer")
+}
 
-	case "GetContainerLogs":
-		return s.ioprojectatomicpodmanInterface.GetContainerLogs(VarlinkCall{call})
+func (s__ *VarlinkInterface) DeleteUnusedImages(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("DeleteUnusedImages")
+}
 
-	case "StopContainer":
-		return s.ioprojectatomicpodmanInterface.StopContainer(VarlinkCall{call})
+func (s__ *VarlinkInterface) CreateContainer(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("CreateContainer")
+}
 
-	case "BuildImage":
-		return s.ioprojectatomicpodmanInterface.BuildImage(VarlinkCall{call})
+func (s__ *VarlinkInterface) InspectContainer(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("InspectContainer")
+}
 
-	case "CreateContainer":
-		return s.ioprojectatomicpodmanInterface.CreateContainer(VarlinkCall{call})
+func (s__ *VarlinkInterface) ExportContainer(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("ExportContainer")
+}
 
-	case "InspectContainer":
-		return s.ioprojectatomicpodmanInterface.InspectContainer(VarlinkCall{call})
+func (s__ *VarlinkInterface) KillContainer(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("KillContainer")
+}
 
-	case "ListContainerProcesses":
-		return s.ioprojectatomicpodmanInterface.ListContainerProcesses(VarlinkCall{call})
+func (s__ *VarlinkInterface) RemoveImage(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("RemoveImage")
+}
 
-	case "UpdateContainer":
-		return s.ioprojectatomicpodmanInterface.UpdateContainer(VarlinkCall{call})
+func (s__ *VarlinkInterface) Ping(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("Ping")
+}
 
-	case "HistoryImage":
-		return s.ioprojectatomicpodmanInterface.HistoryImage(VarlinkCall{call})
+func (s__ *VarlinkInterface) GetContainerLogs(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("GetContainerLogs")
+}
 
-	case "ExportImage":
-		return s.ioprojectatomicpodmanInterface.ExportImage(VarlinkCall{call})
+func (s__ *VarlinkInterface) AttachToContainer(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("AttachToContainer")
+}
 
-	case "ListContainerChanges":
-		return s.ioprojectatomicpodmanInterface.ListContainerChanges(VarlinkCall{call})
+func (s__ *VarlinkInterface) TagImage(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("TagImage")
+}
 
-	case "RenameContainer":
-		return s.ioprojectatomicpodmanInterface.RenameContainer(VarlinkCall{call})
+func (s__ *VarlinkInterface) ImportImage(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("ImportImage")
+}
 
-	case "UnpauseContainer":
-		return s.ioprojectatomicpodmanInterface.UnpauseContainer(VarlinkCall{call})
+func (s__ *VarlinkInterface) GetContainerStats(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("GetContainerStats")
+}
 
-	case "AttachToContainer":
-		return s.ioprojectatomicpodmanInterface.AttachToContainer(VarlinkCall{call})
+func (s__ *VarlinkInterface) StopContainer(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("StopContainer")
+}
 
-	case "SearchImage":
-		return s.ioprojectatomicpodmanInterface.SearchImage(VarlinkCall{call})
+func (s__ *VarlinkInterface) WaitContainer(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("WaitContainer")
+}
 
-	case "Ping":
-		return s.ioprojectatomicpodmanInterface.Ping(VarlinkCall{call})
+func (s__ *VarlinkInterface) DeleteStoppedContainers(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("DeleteStoppedContainers")
+}
 
-	case "ListContainers":
-		return s.ioprojectatomicpodmanInterface.ListContainers(VarlinkCall{call})
+func (s__ *VarlinkInterface) CreateFromContainer(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("CreateFromContainer")
+}
 
-	case "RemoveContainer":
-		return s.ioprojectatomicpodmanInterface.RemoveContainer(VarlinkCall{call})
+func (s__ *VarlinkInterface) ExportImage(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("ExportImage")
+}
+
+func (s__ *VarlinkInterface) PullImage(c__ VarlinkCall) error {
+	return c__.ReplyMethodNotImplemented("PullImage")
+}
+
+// Method call dispatcher
+func (s__ *VarlinkInterface) VarlinkDispatch(call varlink.Call, methodname string) error {
+	switch methodname {
+	case "ExportImage":
+		return s__.ioprojectatomicpodmanInterface.ExportImage(VarlinkCall{call})
 
 	case "PullImage":
-		return s.ioprojectatomicpodmanInterface.PullImage(VarlinkCall{call})
+		return s__.ioprojectatomicpodmanInterface.PullImage(VarlinkCall{call})
 
-	case "KillContainer":
-		return s.ioprojectatomicpodmanInterface.KillContainer(VarlinkCall{call})
+	case "GetContainerStats":
+		return s__.ioprojectatomicpodmanInterface.GetContainerStats(VarlinkCall{call})
+
+	case "StopContainer":
+		return s__.ioprojectatomicpodmanInterface.StopContainer(VarlinkCall{call})
+
+	case "WaitContainer":
+		return s__.ioprojectatomicpodmanInterface.WaitContainer(VarlinkCall{call})
+
+	case "DeleteStoppedContainers":
+		return s__.ioprojectatomicpodmanInterface.DeleteStoppedContainers(VarlinkCall{call})
+
+	case "CreateFromContainer":
+		return s__.ioprojectatomicpodmanInterface.CreateFromContainer(VarlinkCall{call})
+
+	case "RenameContainer":
+		return s__.ioprojectatomicpodmanInterface.RenameContainer(VarlinkCall{call})
+
+	case "PauseContainer":
+		return s__.ioprojectatomicpodmanInterface.PauseContainer(VarlinkCall{call})
+
+	case "ListContainerProcesses":
+		return s__.ioprojectatomicpodmanInterface.ListContainerProcesses(VarlinkCall{call})
+
+	case "CreateImage":
+		return s__.ioprojectatomicpodmanInterface.CreateImage(VarlinkCall{call})
 
 	case "InspectImage":
-		return s.ioprojectatomicpodmanInterface.InspectImage(VarlinkCall{call})
+		return s__.ioprojectatomicpodmanInterface.InspectImage(VarlinkCall{call})
 
 	case "PushImage":
-		return s.ioprojectatomicpodmanInterface.PushImage(VarlinkCall{call})
+		return s__.ioprojectatomicpodmanInterface.PushImage(VarlinkCall{call})
 
-	case "TagImage":
-		return s.ioprojectatomicpodmanInterface.TagImage(VarlinkCall{call})
+	case "SearchImage":
+		return s__.ioprojectatomicpodmanInterface.SearchImage(VarlinkCall{call})
 
-	case "RemoveImage":
-		return s.ioprojectatomicpodmanInterface.RemoveImage(VarlinkCall{call})
+	case "HistoryImage":
+		return s__.ioprojectatomicpodmanInterface.HistoryImage(VarlinkCall{call})
 
-	case "PauseContainer":
-		return s.ioprojectatomicpodmanInterface.PauseContainer(VarlinkCall{call})
+	case "ListContainerChanges":
+		return s__.ioprojectatomicpodmanInterface.ListContainerChanges(VarlinkCall{call})
+
+	case "ResizeContainerTty":
+		return s__.ioprojectatomicpodmanInterface.ResizeContainerTty(VarlinkCall{call})
+
+	case "RestartContainer":
+		return s__.ioprojectatomicpodmanInterface.RestartContainer(VarlinkCall{call})
+
+	case "UpdateContainer":
+		return s__.ioprojectatomicpodmanInterface.UpdateContainer(VarlinkCall{call})
+
+	case "RemoveContainer":
+		return s__.ioprojectatomicpodmanInterface.RemoveContainer(VarlinkCall{call})
+
+	case "ListContainers":
+		return s__.ioprojectatomicpodmanInterface.ListContainers(VarlinkCall{call})
+
+	case "StartContainer":
+		return s__.ioprojectatomicpodmanInterface.StartContainer(VarlinkCall{call})
 
 	case "ListImages":
-		return s.ioprojectatomicpodmanInterface.ListImages(VarlinkCall{call})
+		return s__.ioprojectatomicpodmanInterface.ListImages(VarlinkCall{call})
 
-	case "CreateImage":
-		return s.ioprojectatomicpodmanInterface.CreateImage(VarlinkCall{call})
+	case "BuildImage":
+		return s__.ioprojectatomicpodmanInterface.BuildImage(VarlinkCall{call})
+
+	case "GetVersion":
+		return s__.ioprojectatomicpodmanInterface.GetVersion(VarlinkCall{call})
+
+	case "UnpauseContainer":
+		return s__.ioprojectatomicpodmanInterface.UnpauseContainer(VarlinkCall{call})
 
 	case "DeleteUnusedImages":
-		return s.ioprojectatomicpodmanInterface.DeleteUnusedImages(VarlinkCall{call})
+		return s__.ioprojectatomicpodmanInterface.DeleteUnusedImages(VarlinkCall{call})
 
-	case "CreateFromContainer":
-		return s.ioprojectatomicpodmanInterface.CreateFromContainer(VarlinkCall{call})
+	case "CreateContainer":
+		return s__.ioprojectatomicpodmanInterface.CreateContainer(VarlinkCall{call})
+
+	case "InspectContainer":
+		return s__.ioprojectatomicpodmanInterface.InspectContainer(VarlinkCall{call})
+
+	case "ExportContainer":
+		return s__.ioprojectatomicpodmanInterface.ExportContainer(VarlinkCall{call})
+
+	case "KillContainer":
+		return s__.ioprojectatomicpodmanInterface.KillContainer(VarlinkCall{call})
+
+	case "RemoveImage":
+		return s__.ioprojectatomicpodmanInterface.RemoveImage(VarlinkCall{call})
+
+	case "Ping":
+		return s__.ioprojectatomicpodmanInterface.Ping(VarlinkCall{call})
+
+	case "GetContainerLogs":
+		return s__.ioprojectatomicpodmanInterface.GetContainerLogs(VarlinkCall{call})
+
+	case "AttachToContainer":
+		return s__.ioprojectatomicpodmanInterface.AttachToContainer(VarlinkCall{call})
+
+	case "TagImage":
+		return s__.ioprojectatomicpodmanInterface.TagImage(VarlinkCall{call})
 
 	case "ImportImage":
-		return s.ioprojectatomicpodmanInterface.ImportImage(VarlinkCall{call})
+		return s__.ioprojectatomicpodmanInterface.ImportImage(VarlinkCall{call})
 
 	default:
 		return call.ReplyMethodNotFound(methodname)
 	}
 }
-func (s *VarlinkInterface) VarlinkGetName() string {
+
+// Varlink interface name
+func (s__ *VarlinkInterface) VarlinkGetName() string {
 	return `io.projectatomic.podman`
 }
 
-func (s *VarlinkInterface) VarlinkGetDescription() string {
+// Varlink interface description
+func (s__ *VarlinkInterface) VarlinkGetDescription() string {
 	return `# Podman Service Interface
 interface io.projectatomic.podman
 
@@ -703,6 +1380,7 @@ error ActionFailed (reason: string)
 `
 }
 
+// Service interface
 type VarlinkInterface struct {
 	ioprojectatomicpodmanInterface
 }