varlink info

The varlinfo info returns the same information as podman info but always includes
the so-called debug information.

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

Closes: #745
Approved by: baude

2 files changed, 984 insertions, 789 deletions

diff --git a/cmd/podman/varlink/io.projectatomic.podman.varlink b/cmd/podman/varlink/io.projectatomic.podman.varlink
index 5eaaf79f3..66f6363b9 100644
--- a/cmd/podman/varlink/io.projectatomic.podman.varlink
+++ b/cmd/podman/varlink/io.projectatomic.podman.varlink
@@ -124,6 +124,55 @@ type ContainerNameSpace (
     ipc: string
 )
 
+# InfoHost describes the host stats portion of PodmanInfo
+type InfoHost (
+    mem_free: int,
+    mem_total: int,
+    swap_free: int,
+    swap_total: int,
+    arch: string,
+    cpus: int,
+    hostname: string,
+    kernel: string,
+    os: string,
+    uptime: string
+)
+
+# InfoGraphStatus describes the detailed status of the graph
+type InfoGraphStatus (
+    backing_filesystem: string,
+    native_overlay_diff: string,
+    supports_d_type: string
+)
+
+# InfoStore describes the host's storage informatoin
+type InfoStore (
+    containers: int,
+    images: int,
+    graph_driver_name: string,
+    graph_driver_options: string,
+    graph_root: string,
+    graph_status: InfoGraphStatus,
+    run_root: string
+)
+
+# InfoPodman provides details on the podman binary
+type InfoPodmanBinary (
+    compiler: string,
+    go_version: string,
+    podman_version: string,
+    git_commit: string
+)
+
+# PodmanInfo describes the Podman host and build
+type PodmanInfo (
+    host: InfoHost,
+    registries: []string,
+    insecure_registries: []string,
+    store: InfoStore,
+    podman: InfoPodmanBinary
+)
+
 # Ping provides a response for developers to ensure their varlink setup is working.
 # #### Example
 # ~~~
@@ -140,6 +189,9 @@ method Ping() -> (ping: StringResponse)
 # system.
 method GetVersion() -> (version: Version)
 
+# GetInfo returns a [PodmanInfo](#PodmanInfo) struct that describes podman and its host such as storage stats,
+# build information of Podman, and system-wide registries.
+method GetInfo() -> (info: PodmanInfo)
 
 # ListContainers returns a list of containers in no particular order.  There are
 # returned as an array of ListContainerData structs.  See also [GetContainer](#GetContainer).
diff --git a/cmd/podman/varlink/ioprojectatomicpodman.go b/cmd/podman/varlink/ioprojectatomicpodman.go
index a50c8c49a..2ce0d453f 100644
--- a/cmd/podman/varlink/ioprojectatomicpodman.go
+++ b/cmd/podman/varlink/ioprojectatomicpodman.go
@@ -12,28 +12,13 @@ type Version struct {
 	Os_arch    string `json:"os_arch"`
 }
 
-type NotImplemented struct {
-	Comment string `json:"comment"`
-}
-
-type ImageInList struct {
-	Id          string            `json:"id"`
-	ParentId    string            `json:"parentId"`
-	RepoTags    []string          `json:"repoTags"`
-	RepoDigests []string          `json:"repoDigests"`
-	Created     string            `json:"created"`
-	Size        int64             `json:"size"`
-	VirtualSize int64             `json:"virtualSize"`
-	Containers  int64             `json:"containers"`
-	Labels      map[string]string `json:"labels"`
-}
-
-type ImageSearch struct {
-	Description  string `json:"description"`
-	Is_official  bool   `json:"is_official"`
-	Is_automated bool   `json:"is_automated"`
-	Name         string `json:"name"`
-	Star_count   int64  `json:"star_count"`
+type ImageHistory struct {
+	Id        string   `json:"id"`
+	Created   string   `json:"created"`
+	CreatedBy string   `json:"createdBy"`
+	Tags      []string `json:"tags"`
+	Size      int64    `json:"size"`
+	Comment   string   `json:"comment"`
 }
 
 type ContainerPortMappings struct {
@@ -43,15 +28,25 @@ type ContainerPortMappings struct {
 	Container_port string `json:"container_port"`
 }
 
-type ContainerNameSpace struct {
-	User   string `json:"user"`
-	Uts    string `json:"uts"`
-	Pidns  string `json:"pidns"`
-	Pid    string `json:"pid"`
-	Cgroup string `json:"cgroup"`
-	Net    string `json:"net"`
-	Mnt    string `json:"mnt"`
-	Ipc    string `json:"ipc"`
+type InfoGraphStatus struct {
+	Backing_filesystem  string `json:"backing_filesystem"`
+	Native_overlay_diff string `json:"native_overlay_diff"`
+	Supports_d_type     string `json:"supports_d_type"`
+}
+
+type InfoPodmanBinary struct {
+	Compiler       string `json:"compiler"`
+	Go_version     string `json:"go_version"`
+	Podman_version string `json:"podman_version"`
+	Git_commit     string `json:"git_commit"`
+}
+
+type PodmanInfo struct {
+	Host                InfoHost         `json:"host"`
+	Registries          []string         `json:"registries"`
+	Insecure_registries []string         `json:"insecure_registries"`
+	Store               InfoStore        `json:"store"`
+	Podman              InfoPodmanBinary `json:"podman"`
 }
 
 type StringResponse struct {
@@ -64,31 +59,12 @@ type ContainerChanges struct {
 	Deleted []string `json:"deleted"`
 }
 
-type ImageHistory struct {
-	Id        string   `json:"id"`
-	Created   string   `json:"created"`
-	CreatedBy string   `json:"createdBy"`
-	Tags      []string `json:"tags"`
-	Size      int64    `json:"size"`
-	Comment   string   `json:"comment"`
-}
-
-type ListContainerData struct {
-	Id               string                  `json:"id"`
-	Image            string                  `json:"image"`
-	Imageid          string                  `json:"imageid"`
-	Command          []string                `json:"command"`
-	Createdat        string                  `json:"createdat"`
-	Runningfor       string                  `json:"runningfor"`
-	Status           string                  `json:"status"`
-	Ports            []ContainerPortMappings `json:"ports"`
-	Rootfssize       int64                   `json:"rootfssize"`
-	Rwsize           int64                   `json:"rwsize"`
-	Names            string                  `json:"names"`
-	Labels           map[string]string       `json:"labels"`
-	Mounts           []ContainerMount        `json:"mounts"`
-	Containerrunning bool                    `json:"containerrunning"`
-	Namespaces       ContainerNameSpace      `json:"namespaces"`
+type ImageSearch struct {
+	Description  string `json:"description"`
+	Is_official  bool   `json:"is_official"`
+	Is_automated bool   `json:"is_automated"`
+	Name         string `json:"name"`
+	Star_count   int64  `json:"star_count"`
 }
 
 type ContainerStats struct {
@@ -107,6 +83,31 @@ type ContainerStats struct {
 	Pids         int64   `json:"pids"`
 }
 
+type InfoHost struct {
+	Mem_free   int64  `json:"mem_free"`
+	Mem_total  int64  `json:"mem_total"`
+	Swap_free  int64  `json:"swap_free"`
+	Swap_total int64  `json:"swap_total"`
+	Arch       string `json:"arch"`
+	Cpus       int64  `json:"cpus"`
+	Hostname   string `json:"hostname"`
+	Kernel     string `json:"kernel"`
+	Os         string `json:"os"`
+	Uptime     string `json:"uptime"`
+}
+
+type ImageInList struct {
+	Id          string            `json:"id"`
+	ParentId    string            `json:"parentId"`
+	RepoTags    []string          `json:"repoTags"`
+	RepoDigests []string          `json:"repoDigests"`
+	Created     string            `json:"created"`
+	Size        int64             `json:"size"`
+	VirtualSize int64             `json:"virtualSize"`
+	Containers  int64             `json:"containers"`
+	Labels      map[string]string `json:"labels"`
+}
+
 type ContainerMount struct {
 	Destination string   `json:"destination"`
 	Type        string   `json:"type"`
@@ -114,78 +115,86 @@ type ContainerMount struct {
 	Options     []string `json:"options"`
 }
 
-// Client method calls
-type PullImage_methods struct{}
+type InfoStore struct {
+	Containers           int64           `json:"containers"`
+	Images               int64           `json:"images"`
+	Graph_driver_name    string          `json:"graph_driver_name"`
+	Graph_driver_options string          `json:"graph_driver_options"`
+	Graph_root           string          `json:"graph_root"`
+	Graph_status         InfoGraphStatus `json:"graph_status"`
+	Run_root             string          `json:"run_root"`
+}
 
-func PullImage() PullImage_methods { return PullImage_methods{} }
+type NotImplemented struct {
+	Comment string `json:"comment"`
+}
 
-func (m PullImage_methods) Call(c *varlink.Connection, name_in_ string) (id_out_ string, err_ error) {
-	receive, err_ := m.Send(c, 0, name_in_)
-	if err_ != nil {
-		return
-	}
-	id_out_, _, err_ = receive()
-	return
+type ListContainerData struct {
+	Id               string                  `json:"id"`
+	Image            string                  `json:"image"`
+	Imageid          string                  `json:"imageid"`
+	Command          []string                `json:"command"`
+	Createdat        string                  `json:"createdat"`
+	Runningfor       string                  `json:"runningfor"`
+	Status           string                  `json:"status"`
+	Ports            []ContainerPortMappings `json:"ports"`
+	Rootfssize       int64                   `json:"rootfssize"`
+	Rwsize           int64                   `json:"rwsize"`
+	Names            string                  `json:"names"`
+	Labels           map[string]string       `json:"labels"`
+	Mounts           []ContainerMount        `json:"mounts"`
+	Containerrunning bool                    `json:"containerrunning"`
+	Namespaces       ContainerNameSpace      `json:"namespaces"`
 }
 
-func (m PullImage_methods) Send(c *varlink.Connection, flags uint64, name_in_ string) (func() (string, uint64, error), error) {
-	var in struct {
-		Name string `json:"name"`
-	}
-	in.Name = name_in_
-	receive, err := c.Send("io.projectatomic.podman.PullImage", in, flags)
-	if err != nil {
-		return nil, err
-	}
-	return func() (id_out_ string, flags uint64, err error) {
-		var out struct {
-			Id string `json:"id"`
-		}
-		flags, err = receive(&out)
-		if err != nil {
-			return
-		}
-		id_out_ = out.Id
-		return
-	}, nil
+type ContainerNameSpace struct {
+	User   string `json:"user"`
+	Uts    string `json:"uts"`
+	Pidns  string `json:"pidns"`
+	Pid    string `json:"pid"`
+	Cgroup string `json:"cgroup"`
+	Net    string `json:"net"`
+	Mnt    string `json:"mnt"`
+	Ipc    string `json:"ipc"`
 }
 
-type Ping_methods struct{}
+// Client method calls
+type GetVersion_methods struct{}
 
-func Ping() Ping_methods { return Ping_methods{} }
+func GetVersion() GetVersion_methods { return GetVersion_methods{} }
 
-func (m Ping_methods) Call(c *varlink.Connection) (ping_out_ StringResponse, err_ error) {
+func (m GetVersion_methods) Call(c *varlink.Connection) (version_out_ Version, err_ error) {
 	receive, err_ := m.Send(c, 0)
 	if err_ != nil {
 		return
 	}
-	ping_out_, _, err_ = receive()
+	version_out_, _, err_ = receive()
 	return
 }
 
-func (m Ping_methods) Send(c *varlink.Connection, flags uint64) (func() (StringResponse, uint64, error), error) {
-	receive, err := c.Send("io.projectatomic.podman.Ping", nil, flags)
+func (m GetVersion_methods) Send(c *varlink.Connection, flags uint64) (func() (Version, uint64, error), error) {
+	receive, err := c.Send("io.projectatomic.podman.GetVersion", nil, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (ping_out_ StringResponse, flags uint64, err error) {
+	return func() (version_out_ Version, flags uint64, err error) {
 		var out struct {
-			Ping StringResponse `json:"ping"`
+			Version Version `json:"version"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		ping_out_ = out.Ping
+		version_out_ = out.Version
 		return
 	}, nil
 }
 
-type GetContainerLogs_methods struct{}
+type PauseContainer_methods struct{}
 
-func GetContainerLogs() GetContainerLogs_methods { return GetContainerLogs_methods{} }
+func PauseContainer() PauseContainer_methods { return PauseContainer_methods{} }
 
-func (m GetContainerLogs_methods) Call(c *varlink.Connection, name_in_ string) (container_out_ []string, err_ error) {
+func (m PauseContainer_methods) Call(c *varlink.Connection, name_in_ string) (container_out_ string, err_ error) {
 	receive, err_ := m.Send(c, 0, name_in_)
 	if err_ != nil {
 		return
@@ -194,86 +203,24 @@ func (m GetContainerLogs_methods) Call(c *varlink.Connection, name_in_ string) (
 	return
 }
 
-func (m GetContainerLogs_methods) Send(c *varlink.Connection, flags uint64, name_in_ string) (func() ([]string, uint64, error), error) {
+func (m PauseContainer_methods) Send(c *varlink.Connection, flags uint64, name_in_ string) (func() (string, uint64, error), error) {
 	var in struct {
 		Name string `json:"name"`
 	}
 	in.Name = name_in_
-	receive, err := c.Send("io.projectatomic.podman.GetContainerLogs", in, flags)
-	if err != nil {
-		return nil, err
-	}
-	return func() (container_out_ []string, flags uint64, err error) {
-		var out struct {
-			Container []string `json:"container"`
-		}
-		flags, err = receive(&out)
-		if err != nil {
-			return
-		}
-		container_out_ = []string(out.Container)
-		return
-	}, nil
-}
-
-type RenameContainer_methods struct{}
-
-func RenameContainer() RenameContainer_methods { return RenameContainer_methods{} }
-
-func (m RenameContainer_methods) Call(c *varlink.Connection) (notimplemented_out_ NotImplemented, err_ error) {
-	receive, err_ := m.Send(c, 0)
-	if err_ != nil {
-		return
-	}
-	notimplemented_out_, _, err_ = receive()
-	return
-}
-
-func (m RenameContainer_methods) Send(c *varlink.Connection, flags uint64) (func() (NotImplemented, uint64, error), error) {
-	receive, err := c.Send("io.projectatomic.podman.RenameContainer", nil, flags)
-	if err != nil {
-		return nil, err
-	}
-	return func() (notimplemented_out_ NotImplemented, flags uint64, err error) {
-		var out struct {
-			Notimplemented NotImplemented `json:"notimplemented"`
-		}
-		flags, err = receive(&out)
-		if err != nil {
-			return
-		}
-		notimplemented_out_ = out.Notimplemented
-		return
-	}, nil
-}
-
-type AttachToContainer_methods struct{}
-
-func AttachToContainer() AttachToContainer_methods { return AttachToContainer_methods{} }
-
-func (m AttachToContainer_methods) Call(c *varlink.Connection) (notimplemented_out_ NotImplemented, err_ error) {
-	receive, err_ := m.Send(c, 0)
-	if err_ != nil {
-		return
-	}
-	notimplemented_out_, _, err_ = receive()
-	return
-}
-
-func (m AttachToContainer_methods) Send(c *varlink.Connection, flags uint64) (func() (NotImplemented, uint64, error), error) {
-	receive, err := c.Send("io.projectatomic.podman.AttachToContainer", nil, flags)
+	receive, err := c.Send("io.projectatomic.podman.PauseContainer", in, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (notimplemented_out_ NotImplemented, flags uint64, err error) {
+	return func() (container_out_ string, flags uint64, err error) {
 		var out struct {
-			Notimplemented NotImplemented `json:"notimplemented"`
+			Container string `json:"container"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		notimplemented_out_ = out.Notimplemented
+		container_out_ = out.Container
 		return
 	}, nil
 }
@@ -309,12 +256,12 @@ func (m BuildImage_methods) Send(c *varlink.Connection, flags uint64) (func() (N
 	}, nil
 }
 
-type InspectImage_methods struct{}
+type TagImage_methods struct{}
 
-func InspectImage() InspectImage_methods { return InspectImage_methods{} }
+func TagImage() TagImage_methods { return TagImage_methods{} }
 
-func (m InspectImage_methods) Call(c *varlink.Connection, name_in_ string) (image_out_ string, err_ error) {
-	receive, err_ := m.Send(c, 0, name_in_)
+func (m TagImage_methods) Call(c *varlink.Connection, name_in_ string, tagged_in_ string) (image_out_ string, err_ error) {
+	receive, err_ := m.Send(c, 0, name_in_, tagged_in_)
 	if err_ != nil {
 		return
 	}
@@ -322,12 +269,14 @@ func (m InspectImage_methods) Call(c *varlink.Connection, name_in_ string) (imag
 	return
 }
 
-func (m InspectImage_methods) Send(c *varlink.Connection, flags uint64, name_in_ string) (func() (string, uint64, error), error) {
+func (m TagImage_methods) Send(c *varlink.Connection, flags uint64, name_in_ string, tagged_in_ string) (func() (string, uint64, error), error) {
 	var in struct {
-		Name string `json:"name"`
+		Name   string `json:"name"`
+		Tagged string `json:"tagged"`
 	}
 	in.Name = name_in_
-	receive, err := c.Send("io.projectatomic.podman.InspectImage", in, flags)
+	in.Tagged = tagged_in_
+	receive, err := c.Send("io.projectatomic.podman.TagImage", in, flags)
 	if err != nil {
 		return nil, err
 	}
@@ -375,49 +324,43 @@ func (m DeleteUnusedImages_methods) Send(c *varlink.Connection, flags uint64) (f
 	}, nil
 }
 
-type StopContainer_methods struct{}
+type CreateFromContainer_methods struct{}
 
-func StopContainer() StopContainer_methods { return StopContainer_methods{} }
+func CreateFromContainer() CreateFromContainer_methods { return CreateFromContainer_methods{} }
 
-func (m StopContainer_methods) Call(c *varlink.Connection, name_in_ string, timeout_in_ int64) (container_out_ string, err_ error) {
-	receive, err_ := m.Send(c, 0, name_in_, timeout_in_)
+func (m CreateFromContainer_methods) Call(c *varlink.Connection) (notimplemented_out_ NotImplemented, err_ error) {
+	receive, err_ := m.Send(c, 0)
 	if err_ != nil {
 		return
 	}
-	container_out_, _, err_ = receive()
+	notimplemented_out_, _, err_ = receive()
 	return
 }
 
-func (m StopContainer_methods) Send(c *varlink.Connection, flags uint64, name_in_ string, timeout_in_ int64) (func() (string, uint64, error), error) {
-	var in struct {
-		Name    string `json:"name"`
-		Timeout int64  `json:"timeout"`
-	}
-	in.Name = name_in_
-	in.Timeout = timeout_in_
-	receive, err := c.Send("io.projectatomic.podman.StopContainer", in, flags)
+func (m CreateFromContainer_methods) Send(c *varlink.Connection, flags uint64) (func() (NotImplemented, uint64, error), error) {
+	receive, err := c.Send("io.projectatomic.podman.CreateFromContainer", nil, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (container_out_ string, flags uint64, err error) {
+	return func() (notimplemented_out_ NotImplemented, flags uint64, err error) {
 		var out struct {
-			Container string `json:"container"`
+			Notimplemented NotImplemented `json:"notimplemented"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		container_out_ = out.Container
+		notimplemented_out_ = out.Notimplemented
 		return
 	}, nil
 }
 
-type RestartContainer_methods struct{}
+type ListContainerChanges_methods struct{}
 
-func RestartContainer() RestartContainer_methods { return RestartContainer_methods{} }
+func ListContainerChanges() ListContainerChanges_methods { return ListContainerChanges_methods{} }
 
-func (m RestartContainer_methods) Call(c *varlink.Connection, name_in_ string, timeout_in_ int64) (container_out_ string, err_ error) {
-	receive, err_ := m.Send(c, 0, name_in_, timeout_in_)
+func (m ListContainerChanges_methods) Call(c *varlink.Connection, name_in_ string) (container_out_ ContainerChanges, err_ error) {
+	receive, err_ := m.Send(c, 0, name_in_)
 	if err_ != nil {
 		return
 	}
@@ -425,20 +368,18 @@ func (m RestartContainer_methods) Call(c *varlink.Connection, name_in_ string, t
 	return
 }
 
-func (m RestartContainer_methods) Send(c *varlink.Connection, flags uint64, name_in_ string, timeout_in_ int64) (func() (string, uint64, error), error) {
+func (m ListContainerChanges_methods) Send(c *varlink.Connection, flags uint64, name_in_ string) (func() (ContainerChanges, uint64, error), error) {
 	var in struct {
-		Name    string `json:"name"`
-		Timeout int64  `json:"timeout"`
+		Name string `json:"name"`
 	}
 	in.Name = name_in_
-	in.Timeout = timeout_in_
-	receive, err := c.Send("io.projectatomic.podman.RestartContainer", in, flags)
+	receive, err := c.Send("io.projectatomic.podman.ListContainerChanges", in, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (container_out_ string, flags uint64, err error) {
+	return func() (container_out_ ContainerChanges, flags uint64, err error) {
 		var out struct {
-			Container string `json:"container"`
+			Container ContainerChanges `json:"container"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
@@ -449,49 +390,43 @@ func (m RestartContainer_methods) Send(c *varlink.Connection, flags uint64, name
 	}, nil
 }
 
-type RemoveContainer_methods struct{}
+type StartContainer_methods struct{}
 
-func RemoveContainer() RemoveContainer_methods { return RemoveContainer_methods{} }
+func StartContainer() StartContainer_methods { return StartContainer_methods{} }
 
-func (m RemoveContainer_methods) Call(c *varlink.Connection, name_in_ string, force_in_ bool) (container_out_ string, err_ error) {
-	receive, err_ := m.Send(c, 0, name_in_, force_in_)
+func (m StartContainer_methods) Call(c *varlink.Connection) (notimplemented_out_ NotImplemented, err_ error) {
+	receive, err_ := m.Send(c, 0)
 	if err_ != nil {
 		return
 	}
-	container_out_, _, err_ = receive()
+	notimplemented_out_, _, err_ = receive()
 	return
 }
 
-func (m RemoveContainer_methods) Send(c *varlink.Connection, flags uint64, name_in_ string, force_in_ bool) (func() (string, uint64, error), error) {
-	var in struct {
-		Name  string `json:"name"`
-		Force bool   `json:"force"`
-	}
-	in.Name = name_in_
-	in.Force = force_in_
-	receive, err := c.Send("io.projectatomic.podman.RemoveContainer", in, flags)
+func (m StartContainer_methods) Send(c *varlink.Connection, flags uint64) (func() (NotImplemented, uint64, error), error) {
+	receive, err := c.Send("io.projectatomic.podman.StartContainer", nil, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (container_out_ string, flags uint64, err error) {
+	return func() (notimplemented_out_ NotImplemented, flags uint64, err error) {
 		var out struct {
-			Container string `json:"container"`
+			Notimplemented NotImplemented `json:"notimplemented"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		container_out_ = out.Container
+		notimplemented_out_ = out.Notimplemented
 		return
 	}, nil
 }
 
-type ListContainerProcesses_methods struct{}
+type InspectContainer_methods struct{}
 
-func ListContainerProcesses() ListContainerProcesses_methods { return ListContainerProcesses_methods{} }
+func InspectContainer() InspectContainer_methods { return InspectContainer_methods{} }
 
-func (m ListContainerProcesses_methods) Call(c *varlink.Connection, name_in_ string, opts_in_ []string) (container_out_ []string, err_ error) {
-	receive, err_ := m.Send(c, 0, name_in_, opts_in_)
+func (m InspectContainer_methods) Call(c *varlink.Connection, name_in_ string) (container_out_ string, err_ error) {
+	receive, err_ := m.Send(c, 0, name_in_)
 	if err_ != nil {
 		return
 	}
@@ -499,35 +434,33 @@ func (m ListContainerProcesses_methods) Call(c *varlink.Connection, name_in_ str
 	return
 }
 
-func (m ListContainerProcesses_methods) Send(c *varlink.Connection, flags uint64, name_in_ string, opts_in_ []string) (func() ([]string, uint64, error), error) {
+func (m InspectContainer_methods) Send(c *varlink.Connection, flags uint64, name_in_ string) (func() (string, uint64, error), error) {
 	var in struct {
-		Name string   `json:"name"`
-		Opts []string `json:"opts"`
+		Name string `json:"name"`
 	}
 	in.Name = name_in_
-	in.Opts = []string(opts_in_)
-	receive, err := c.Send("io.projectatomic.podman.ListContainerProcesses", in, flags)
+	receive, err := c.Send("io.projectatomic.podman.InspectContainer", in, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (container_out_ []string, flags uint64, err error) {
+	return func() (container_out_ string, flags uint64, err error) {
 		var out struct {
-			Container []string `json:"container"`
+			Container string `json:"container"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		container_out_ = []string(out.Container)
+		container_out_ = out.Container
 		return
 	}, nil
 }
 
-type PauseContainer_methods struct{}
+type GetContainerLogs_methods struct{}
 
-func PauseContainer() PauseContainer_methods { return PauseContainer_methods{} }
+func GetContainerLogs() GetContainerLogs_methods { return GetContainerLogs_methods{} }
 
-func (m PauseContainer_methods) Call(c *varlink.Connection, name_in_ string) (container_out_ string, err_ error) {
+func (m GetContainerLogs_methods) Call(c *varlink.Connection, name_in_ string) (container_out_ []string, err_ error) {
 	receive, err_ := m.Send(c, 0, name_in_)
 	if err_ != nil {
 		return
@@ -536,34 +469,34 @@ func (m PauseContainer_methods) Call(c *varlink.Connection, name_in_ string) (co
 	return
 }
 
-func (m PauseContainer_methods) Send(c *varlink.Connection, flags uint64, name_in_ string) (func() (string, uint64, error), error) {
+func (m GetContainerLogs_methods) Send(c *varlink.Connection, flags uint64, name_in_ string) (func() ([]string, uint64, error), error) {
 	var in struct {
 		Name string `json:"name"`
 	}
 	in.Name = name_in_
-	receive, err := c.Send("io.projectatomic.podman.PauseContainer", in, flags)
+	receive, err := c.Send("io.projectatomic.podman.GetContainerLogs", in, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (container_out_ string, flags uint64, err error) {
+	return func() (container_out_ []string, flags uint64, err error) {
 		var out struct {
-			Container string `json:"container"`
+			Container []string `json:"container"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		container_out_ = out.Container
+		container_out_ = []string(out.Container)
 		return
 	}, nil
 }
 
-type UnpauseContainer_methods struct{}
+type StopContainer_methods struct{}
 
-func UnpauseContainer() UnpauseContainer_methods { return UnpauseContainer_methods{} }
+func StopContainer() StopContainer_methods { return StopContainer_methods{} }
 
-func (m UnpauseContainer_methods) Call(c *varlink.Connection, name_in_ string) (container_out_ string, err_ error) {
-	receive, err_ := m.Send(c, 0, name_in_)
+func (m StopContainer_methods) Call(c *varlink.Connection, name_in_ string, timeout_in_ int64) (container_out_ string, err_ error) {
+	receive, err_ := m.Send(c, 0, name_in_, timeout_in_)
 	if err_ != nil {
 		return
 	}
@@ -571,12 +504,14 @@ func (m UnpauseContainer_methods) Call(c *varlink.Connection, name_in_ string) (
 	return
 }
 
-func (m UnpauseContainer_methods) Send(c *varlink.Connection, flags uint64, name_in_ string) (func() (string, uint64, error), error) {
+func (m StopContainer_methods) Send(c *varlink.Connection, flags uint64, name_in_ string, timeout_in_ int64) (func() (string, uint64, error), error) {
 	var in struct {
-		Name string `json:"name"`
+		Name    string `json:"name"`
+		Timeout int64  `json:"timeout"`
 	}
 	in.Name = name_in_
-	receive, err := c.Send("io.projectatomic.podman.UnpauseContainer", in, flags)
+	in.Timeout = timeout_in_
+	receive, err := c.Send("io.projectatomic.podman.StopContainer", in, flags)
 	if err != nil {
 		return nil, err
 	}
@@ -626,360 +561,360 @@ func (m DeleteStoppedContainers_methods) Send(c *varlink.Connection, flags uint6
 	}, nil
 }
 
-type ResizeContainerTty_methods struct{}
+type RemoveImage_methods struct{}
 
-func ResizeContainerTty() ResizeContainerTty_methods { return ResizeContainerTty_methods{} }
+func RemoveImage() RemoveImage_methods { return RemoveImage_methods{} }
 
-func (m ResizeContainerTty_methods) Call(c *varlink.Connection) (notimplemented_out_ NotImplemented, err_ error) {
-	receive, err_ := m.Send(c, 0)
+func (m RemoveImage_methods) Call(c *varlink.Connection, name_in_ string, force_in_ bool) (image_out_ string, err_ error) {
+	receive, err_ := m.Send(c, 0, name_in_, force_in_)
 	if err_ != nil {
 		return
 	}
-	notimplemented_out_, _, err_ = receive()
+	image_out_, _, err_ = receive()
 	return
 }
 
-func (m ResizeContainerTty_methods) Send(c *varlink.Connection, flags uint64) (func() (NotImplemented, uint64, error), error) {
-	receive, err := c.Send("io.projectatomic.podman.ResizeContainerTty", nil, flags)
+func (m RemoveImage_methods) Send(c *varlink.Connection, flags uint64, name_in_ string, force_in_ bool) (func() (string, uint64, error), error) {
+	var in struct {
+		Name  string `json:"name"`
+		Force bool   `json:"force"`
+	}
+	in.Name = name_in_
+	in.Force = force_in_
+	receive, err := c.Send("io.projectatomic.podman.RemoveImage", in, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (notimplemented_out_ NotImplemented, flags uint64, err error) {
+	return func() (image_out_ string, flags uint64, err error) {
 		var out struct {
-			Notimplemented NotImplemented `json:"notimplemented"`
+			Image string `json:"image"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		notimplemented_out_ = out.Notimplemented
+		image_out_ = out.Image
 		return
 	}, nil
 }
 
-type WaitContainer_methods struct{}
+type ListContainers_methods struct{}
 
-func WaitContainer() WaitContainer_methods { return WaitContainer_methods{} }
+func ListContainers() ListContainers_methods { return ListContainers_methods{} }
 
-func (m WaitContainer_methods) Call(c *varlink.Connection, name_in_ string) (exitcode_out_ int64, err_ error) {
-	receive, err_ := m.Send(c, 0, name_in_)
+func (m ListContainers_methods) Call(c *varlink.Connection) (containers_out_ []ListContainerData, err_ error) {
+	receive, err_ := m.Send(c, 0)
 	if err_ != nil {
 		return
 	}
-	exitcode_out_, _, err_ = receive()
+	containers_out_, _, err_ = receive()
 	return
 }
 
-func (m WaitContainer_methods) Send(c *varlink.Connection, flags uint64, name_in_ string) (func() (int64, uint64, error), error) {
-	var in struct {
-		Name string `json:"name"`
-	}
-	in.Name = name_in_
-	receive, err := c.Send("io.projectatomic.podman.WaitContainer", in, flags)
+func (m ListContainers_methods) Send(c *varlink.Connection, flags uint64) (func() ([]ListContainerData, uint64, error), error) {
+	receive, err := c.Send("io.projectatomic.podman.ListContainers", nil, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (exitcode_out_ int64, flags uint64, err error) {
+	return func() (containers_out_ []ListContainerData, flags uint64, err error) {
 		var out struct {
-			Exitcode int64 `json:"exitcode"`
+			Containers []ListContainerData `json:"containers"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		exitcode_out_ = out.Exitcode
+		containers_out_ = []ListContainerData(out.Containers)
 		return
 	}, nil
 }
 
-type PushImage_methods struct{}
+type GetContainer_methods struct{}
 
-func PushImage() PushImage_methods { return PushImage_methods{} }
+func GetContainer() GetContainer_methods { return GetContainer_methods{} }
 
-func (m PushImage_methods) Call(c *varlink.Connection, name_in_ string, tag_in_ string, tlsverify_in_ bool) (image_out_ string, err_ error) {
-	receive, err_ := m.Send(c, 0, name_in_, tag_in_, tlsverify_in_)
+func (m GetContainer_methods) Call(c *varlink.Connection, name_in_ string) (container_out_ ListContainerData, err_ error) {
+	receive, err_ := m.Send(c, 0, name_in_)
 	if err_ != nil {
 		return
 	}
-	image_out_, _, err_ = receive()
+	container_out_, _, err_ = receive()
 	return
 }
 
-func (m PushImage_methods) Send(c *varlink.Connection, flags uint64, name_in_ string, tag_in_ string, tlsverify_in_ bool) (func() (string, uint64, error), error) {
+func (m GetContainer_methods) Send(c *varlink.Connection, flags uint64, name_in_ string) (func() (ListContainerData, uint64, error), error) {
 	var in struct {
-		Name      string `json:"name"`
-		Tag       string `json:"tag"`
-		Tlsverify bool   `json:"tlsverify"`
+		Name string `json:"name"`
 	}
 	in.Name = name_in_
-	in.Tag = tag_in_
-	in.Tlsverify = tlsverify_in_
-	receive, err := c.Send("io.projectatomic.podman.PushImage", in, flags)
+	receive, err := c.Send("io.projectatomic.podman.GetContainer", in, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (image_out_ string, flags uint64, err error) {
+	return func() (container_out_ ListContainerData, flags uint64, err error) {
 		var out struct {
-			Image string `json:"image"`
+			Container ListContainerData `json:"container"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		image_out_ = out.Image
+		container_out_ = out.Container
 		return
 	}, nil
 }
 
-type RemoveImage_methods struct{}
+type GetContainerStats_methods struct{}
 
-func RemoveImage() RemoveImage_methods { return RemoveImage_methods{} }
+func GetContainerStats() GetContainerStats_methods { return GetContainerStats_methods{} }
 
-func (m RemoveImage_methods) Call(c *varlink.Connection, name_in_ string, force_in_ bool) (image_out_ string, err_ error) {
-	receive, err_ := m.Send(c, 0, name_in_, force_in_)
+func (m GetContainerStats_methods) Call(c *varlink.Connection, name_in_ string) (container_out_ ContainerStats, err_ error) {
+	receive, err_ := m.Send(c, 0, name_in_)
 	if err_ != nil {
 		return
 	}
-	image_out_, _, err_ = receive()
+	container_out_, _, err_ = receive()
 	return
 }
 
-func (m RemoveImage_methods) Send(c *varlink.Connection, flags uint64, name_in_ string, force_in_ bool) (func() (string, uint64, error), error) {
+func (m GetContainerStats_methods) Send(c *varlink.Connection, flags uint64, name_in_ string) (func() (ContainerStats, uint64, error), error) {
 	var in struct {
-		Name  string `json:"name"`
-		Force bool   `json:"force"`
+		Name string `json:"name"`
 	}
 	in.Name = name_in_
-	in.Force = force_in_
-	receive, err := c.Send("io.projectatomic.podman.RemoveImage", in, flags)
+	receive, err := c.Send("io.projectatomic.podman.GetContainerStats", in, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (image_out_ string, flags uint64, err error) {
+	return func() (container_out_ ContainerStats, flags uint64, err error) {
 		var out struct {
-			Image string `json:"image"`
+			Container ContainerStats `json:"container"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		image_out_ = out.Image
+		container_out_ = out.Container
 		return
 	}, nil
 }
 
-type ImportImage_methods struct{}
+type RenameContainer_methods struct{}
 
-func ImportImage() ImportImage_methods { return ImportImage_methods{} }
+func RenameContainer() RenameContainer_methods { return RenameContainer_methods{} }
 
-func (m ImportImage_methods) Call(c *varlink.Connection, source_in_ string, reference_in_ string, message_in_ string, changes_in_ []string) (image_out_ string, err_ error) {
-	receive, err_ := m.Send(c, 0, source_in_, reference_in_, message_in_, changes_in_)
+func (m RenameContainer_methods) Call(c *varlink.Connection) (notimplemented_out_ NotImplemented, err_ error) {
+	receive, err_ := m.Send(c, 0)
 	if err_ != nil {
 		return
 	}
-	image_out_, _, err_ = receive()
+	notimplemented_out_, _, err_ = receive()
 	return
 }
 
-func (m ImportImage_methods) Send(c *varlink.Connection, flags uint64, source_in_ string, reference_in_ string, message_in_ string, changes_in_ []string) (func() (string, uint64, error), error) {
-	var in struct {
-		Source    string   `json:"source"`
-		Reference string   `json:"reference"`
-		Message   string   `json:"message"`
-		Changes   []string `json:"changes"`
-	}
-	in.Source = source_in_
-	in.Reference = reference_in_
-	in.Message = message_in_
-	in.Changes = []string(changes_in_)
-	receive, err := c.Send("io.projectatomic.podman.ImportImage", in, flags)
+func (m RenameContainer_methods) Send(c *varlink.Connection, flags uint64) (func() (NotImplemented, uint64, error), error) {
+	receive, err := c.Send("io.projectatomic.podman.RenameContainer", nil, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (image_out_ string, flags uint64, err error) {
+	return func() (notimplemented_out_ NotImplemented, flags uint64, err error) {
 		var out struct {
-			Image string `json:"image"`
+			Notimplemented NotImplemented `json:"notimplemented"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		image_out_ = out.Image
+		notimplemented_out_ = out.Notimplemented
 		return
 	}, nil
 }
 
-type ListContainers_methods struct{}
+type UnpauseContainer_methods struct{}
 
-func ListContainers() ListContainers_methods { return ListContainers_methods{} }
+func UnpauseContainer() UnpauseContainer_methods { return UnpauseContainer_methods{} }
 
-func (m ListContainers_methods) Call(c *varlink.Connection) (containers_out_ []ListContainerData, err_ error) {
-	receive, err_ := m.Send(c, 0)
+func (m UnpauseContainer_methods) Call(c *varlink.Connection, name_in_ string) (container_out_ string, err_ error) {
+	receive, err_ := m.Send(c, 0, name_in_)
 	if err_ != nil {
 		return
 	}
-	containers_out_, _, err_ = receive()
+	container_out_, _, err_ = receive()
 	return
 }
 
-func (m ListContainers_methods) Send(c *varlink.Connection, flags uint64) (func() ([]ListContainerData, uint64, error), error) {
-	receive, err := c.Send("io.projectatomic.podman.ListContainers", nil, flags)
+func (m UnpauseContainer_methods) Send(c *varlink.Connection, flags uint64, name_in_ string) (func() (string, uint64, error), error) {
+	var in struct {
+		Name string `json:"name"`
+	}
+	in.Name = name_in_
+	receive, err := c.Send("io.projectatomic.podman.UnpauseContainer", in, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (containers_out_ []ListContainerData, flags uint64, err error) {
+	return func() (container_out_ string, flags uint64, err error) {
 		var out struct {
-			Containers []ListContainerData `json:"containers"`
+			Container string `json:"container"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		containers_out_ = []ListContainerData(out.Containers)
+		container_out_ = out.Container
 		return
 	}, nil
 }
 
-type GetContainer_methods struct{}
+type HistoryImage_methods struct{}
 
-func GetContainer() GetContainer_methods { return GetContainer_methods{} }
+func HistoryImage() HistoryImage_methods { return HistoryImage_methods{} }
 
-func (m GetContainer_methods) Call(c *varlink.Connection, name_in_ string) (container_out_ ListContainerData, err_ error) {
+func (m HistoryImage_methods) Call(c *varlink.Connection, name_in_ string) (history_out_ []ImageHistory, err_ error) {
 	receive, err_ := m.Send(c, 0, name_in_)
 	if err_ != nil {
 		return
 	}
-	container_out_, _, err_ = receive()
+	history_out_, _, err_ = receive()
 	return
 }
 
-func (m GetContainer_methods) Send(c *varlink.Connection, flags uint64, name_in_ string) (func() (ListContainerData, uint64, error), error) {
+func (m HistoryImage_methods) Send(c *varlink.Connection, flags uint64, name_in_ string) (func() ([]ImageHistory, uint64, error), error) {
 	var in struct {
 		Name string `json:"name"`
 	}
 	in.Name = name_in_
-	receive, err := c.Send("io.projectatomic.podman.GetContainer", in, flags)
+	receive, err := c.Send("io.projectatomic.podman.HistoryImage", in, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (container_out_ ListContainerData, flags uint64, err error) {
+	return func() (history_out_ []ImageHistory, flags uint64, err error) {
 		var out struct {
-			Container ListContainerData `json:"container"`
+			History []ImageHistory `json:"history"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		container_out_ = out.Container
+		history_out_ = []ImageHistory(out.History)
 		return
 	}, nil
 }
 
-type SearchImage_methods struct{}
+type ExportContainer_methods struct{}
 
-func SearchImage() SearchImage_methods { return SearchImage_methods{} }
+func ExportContainer() ExportContainer_methods { return ExportContainer_methods{} }
 
-func (m SearchImage_methods) Call(c *varlink.Connection, name_in_ string, limit_in_ int64) (images_out_ []ImageSearch, err_ error) {
-	receive, err_ := m.Send(c, 0, name_in_, limit_in_)
+func (m ExportContainer_methods) Call(c *varlink.Connection, name_in_ string, path_in_ string) (tarfile_out_ string, err_ error) {
+	receive, err_ := m.Send(c, 0, name_in_, path_in_)
 	if err_ != nil {
 		return
 	}
-	images_out_, _, err_ = receive()
+	tarfile_out_, _, err_ = receive()
 	return
 }
 
-func (m SearchImage_methods) Send(c *varlink.Connection, flags uint64, name_in_ string, limit_in_ int64) (func() ([]ImageSearch, uint64, error), error) {
+func (m ExportContainer_methods) Send(c *varlink.Connection, flags uint64, name_in_ string, path_in_ string) (func() (string, uint64, error), error) {
 	var in struct {
-		Name  string `json:"name"`
-		Limit int64  `json:"limit"`
+		Name string `json:"name"`
+		Path string `json:"path"`
 	}
 	in.Name = name_in_
-	in.Limit = limit_in_
-	receive, err := c.Send("io.projectatomic.podman.SearchImage", in, flags)
+	in.Path = path_in_
+	receive, err := c.Send("io.projectatomic.podman.ExportContainer", in, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (images_out_ []ImageSearch, flags uint64, err error) {
+	return func() (tarfile_out_ string, flags uint64, err error) {
 		var out struct {
-			Images []ImageSearch `json:"images"`
+			Tarfile string `json:"tarfile"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		images_out_ = []ImageSearch(out.Images)
+		tarfile_out_ = out.Tarfile
 		return
 	}, nil
 }
 
-type CreateFromContainer_methods struct{}
+type RestartContainer_methods struct{}
 
-func CreateFromContainer() CreateFromContainer_methods { return CreateFromContainer_methods{} }
+func RestartContainer() RestartContainer_methods { return RestartContainer_methods{} }
 
-func (m CreateFromContainer_methods) Call(c *varlink.Connection) (notimplemented_out_ NotImplemented, err_ error) {
-	receive, err_ := m.Send(c, 0)
+func (m RestartContainer_methods) Call(c *varlink.Connection, name_in_ string, timeout_in_ int64) (container_out_ string, err_ error) {
+	receive, err_ := m.Send(c, 0, name_in_, timeout_in_)
 	if err_ != nil {
 		return
 	}
-	notimplemented_out_, _, err_ = receive()
+	container_out_, _, err_ = receive()
 	return
 }
 
-func (m CreateFromContainer_methods) Send(c *varlink.Connection, flags uint64) (func() (NotImplemented, uint64, error), error) {
-	receive, err := c.Send("io.projectatomic.podman.CreateFromContainer", nil, flags)
+func (m RestartContainer_methods) Send(c *varlink.Connection, flags uint64, name_in_ string, timeout_in_ int64) (func() (string, uint64, error), error) {
+	var in struct {
+		Name    string `json:"name"`
+		Timeout int64  `json:"timeout"`
+	}
+	in.Name = name_in_
+	in.Timeout = timeout_in_
+	receive, err := c.Send("io.projectatomic.podman.RestartContainer", in, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (notimplemented_out_ NotImplemented, flags uint64, err error) {
+	return func() (container_out_ string, flags uint64, err error) {
 		var out struct {
-			Notimplemented NotImplemented `json:"notimplemented"`
+			Container string `json:"container"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		notimplemented_out_ = out.Notimplemented
+		container_out_ = out.Container
 		return
 	}, nil
 }
 
-type CreateContainer_methods struct{}
+type WaitContainer_methods struct{}
 
-func CreateContainer() CreateContainer_methods { return CreateContainer_methods{} }
+func WaitContainer() WaitContainer_methods { return WaitContainer_methods{} }
 
-func (m CreateContainer_methods) Call(c *varlink.Connection) (notimplemented_out_ NotImplemented, err_ error) {
-	receive, err_ := m.Send(c, 0)
+func (m WaitContainer_methods) Call(c *varlink.Connection, name_in_ string) (exitcode_out_ int64, err_ error) {
+	receive, err_ := m.Send(c, 0, name_in_)
 	if err_ != nil {
 		return
 	}
-	notimplemented_out_, _, err_ = receive()
+	exitcode_out_, _, err_ = receive()
 	return
 }
 
-func (m CreateContainer_methods) Send(c *varlink.Connection, flags uint64) (func() (NotImplemented, uint64, error), error) {
-	receive, err := c.Send("io.projectatomic.podman.CreateContainer", nil, flags)
+func (m WaitContainer_methods) Send(c *varlink.Connection, flags uint64, name_in_ string) (func() (int64, uint64, error), error) {
+	var in struct {
+		Name string `json:"name"`
+	}
+	in.Name = name_in_
+	receive, err := c.Send("io.projectatomic.podman.WaitContainer", in, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (notimplemented_out_ NotImplemented, flags uint64, err error) {
+	return func() (exitcode_out_ int64, flags uint64, err error) {
 		var out struct {
-			Notimplemented NotImplemented `json:"notimplemented"`
+			Exitcode int64 `json:"exitcode"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		notimplemented_out_ = out.Notimplemented
+		exitcode_out_ = out.Exitcode
 		return
 	}, nil
 }
 
-type InspectContainer_methods struct{}
+type RemoveContainer_methods struct{}
 
-func InspectContainer() InspectContainer_methods { return InspectContainer_methods{} }
+func RemoveContainer() RemoveContainer_methods { return RemoveContainer_methods{} }
 
-func (m InspectContainer_methods) Call(c *varlink.Connection, name_in_ string) (container_out_ string, err_ error) {
-	receive, err_ := m.Send(c, 0, name_in_)
+func (m RemoveContainer_methods) Call(c *varlink.Connection, name_in_ string, force_in_ bool) (container_out_ string, err_ error) {
+	receive, err_ := m.Send(c, 0, name_in_, force_in_)
 	if err_ != nil {
 		return
 	}
@@ -987,12 +922,14 @@ func (m InspectContainer_methods) Call(c *varlink.Connection, name_in_ string) (
 	return
 }
 
-func (m InspectContainer_methods) Send(c *varlink.Connection, flags uint64, name_in_ string) (func() (string, uint64, error), error) {
+func (m RemoveContainer_methods) Send(c *varlink.Connection, flags uint64, name_in_ string, force_in_ bool) (func() (string, uint64, error), error) {
 	var in struct {
-		Name string `json:"name"`
+		Name  string `json:"name"`
+		Force bool   `json:"force"`
 	}
 	in.Name = name_in_
-	receive, err := c.Send("io.projectatomic.podman.InspectContainer", in, flags)
+	in.Force = force_in_
+	receive, err := c.Send("io.projectatomic.podman.RemoveContainer", in, flags)
 	if err != nil {
 		return nil, err
 	}
@@ -1009,108 +946,112 @@ func (m InspectContainer_methods) Send(c *varlink.Connection, flags uint64, name
 	}, nil
 }
 
-type ListContainerChanges_methods struct{}
+type CreateImage_methods struct{}
 
-func ListContainerChanges() ListContainerChanges_methods { return ListContainerChanges_methods{} }
+func CreateImage() CreateImage_methods { return CreateImage_methods{} }
 
-func (m ListContainerChanges_methods) Call(c *varlink.Connection, name_in_ string) (container_out_ ContainerChanges, err_ error) {
-	receive, err_ := m.Send(c, 0, name_in_)
+func (m CreateImage_methods) Call(c *varlink.Connection) (notimplemented_out_ NotImplemented, err_ error) {
+	receive, err_ := m.Send(c, 0)
 	if err_ != nil {
 		return
 	}
-	container_out_, _, err_ = receive()
+	notimplemented_out_, _, err_ = receive()
 	return
 }
 
-func (m ListContainerChanges_methods) Send(c *varlink.Connection, flags uint64, name_in_ string) (func() (ContainerChanges, uint64, error), error) {
-	var in struct {
-		Name string `json:"name"`
-	}
-	in.Name = name_in_
-	receive, err := c.Send("io.projectatomic.podman.ListContainerChanges", in, flags)
+func (m CreateImage_methods) Send(c *varlink.Connection, flags uint64) (func() (NotImplemented, uint64, error), error) {
+	receive, err := c.Send("io.projectatomic.podman.CreateImage", nil, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (container_out_ ContainerChanges, flags uint64, err error) {
+	return func() (notimplemented_out_ NotImplemented, flags uint64, err error) {
 		var out struct {
-			Container ContainerChanges `json:"container"`
+			Notimplemented NotImplemented `json:"notimplemented"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		container_out_ = out.Container
+		notimplemented_out_ = out.Notimplemented
 		return
 	}, nil
 }
 
-type UpdateContainer_methods struct{}
+type PushImage_methods struct{}
 
-func UpdateContainer() UpdateContainer_methods { return UpdateContainer_methods{} }
+func PushImage() PushImage_methods { return PushImage_methods{} }
 
-func (m UpdateContainer_methods) Call(c *varlink.Connection) (notimplemented_out_ NotImplemented, err_ error) {
-	receive, err_ := m.Send(c, 0)
+func (m PushImage_methods) Call(c *varlink.Connection, name_in_ string, tag_in_ string, tlsverify_in_ bool) (image_out_ string, err_ error) {
+	receive, err_ := m.Send(c, 0, name_in_, tag_in_, tlsverify_in_)
 	if err_ != nil {
 		return
 	}
-	notimplemented_out_, _, err_ = receive()
+	image_out_, _, err_ = receive()
 	return
 }
 
-func (m UpdateContainer_methods) Send(c *varlink.Connection, flags uint64) (func() (NotImplemented, uint64, error), error) {
-	receive, err := c.Send("io.projectatomic.podman.UpdateContainer", nil, flags)
+func (m PushImage_methods) Send(c *varlink.Connection, flags uint64, name_in_ string, tag_in_ string, tlsverify_in_ bool) (func() (string, uint64, error), error) {
+	var in struct {
+		Name      string `json:"name"`
+		Tag       string `json:"tag"`
+		Tlsverify bool   `json:"tlsverify"`
+	}
+	in.Name = name_in_
+	in.Tag = tag_in_
+	in.Tlsverify = tlsverify_in_
+	receive, err := c.Send("io.projectatomic.podman.PushImage", in, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (notimplemented_out_ NotImplemented, flags uint64, err error) {
+	return func() (image_out_ string, flags uint64, err error) {
 		var out struct {
-			Notimplemented NotImplemented `json:"notimplemented"`
+			Image string `json:"image"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		notimplemented_out_ = out.Notimplemented
+		image_out_ = out.Image
 		return
 	}, nil
 }
 
-type ListImages_methods struct{}
+type Ping_methods struct{}
 
-func ListImages() ListImages_methods { return ListImages_methods{} }
+func Ping() Ping_methods { return Ping_methods{} }
 
-func (m ListImages_methods) Call(c *varlink.Connection) (images_out_ []ImageInList, err_ error) {
+func (m Ping_methods) Call(c *varlink.Connection) (ping_out_ StringResponse, err_ error) {
 	receive, err_ := m.Send(c, 0)
 	if err_ != nil {
 		return
 	}
-	images_out_, _, err_ = receive()
+	ping_out_, _, err_ = receive()
 	return
 }
 
-func (m ListImages_methods) Send(c *varlink.Connection, flags uint64) (func() ([]ImageInList, uint64, error), error) {
-	receive, err := c.Send("io.projectatomic.podman.ListImages", nil, flags)
+func (m Ping_methods) Send(c *varlink.Connection, flags uint64) (func() (StringResponse, uint64, error), error) {
+	receive, err := c.Send("io.projectatomic.podman.Ping", nil, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (images_out_ []ImageInList, flags uint64, err error) {
+	return func() (ping_out_ StringResponse, flags uint64, err error) {
 		var out struct {
-			Images []ImageInList `json:"images"`
+			Ping StringResponse `json:"ping"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		images_out_ = []ImageInList(out.Images)
+		ping_out_ = out.Ping
 		return
 	}, nil
 }
 
-type CreateImage_methods struct{}
+type UpdateContainer_methods struct{}
 
-func CreateImage() CreateImage_methods { return CreateImage_methods{} }
+func UpdateContainer() UpdateContainer_methods { return UpdateContainer_methods{} }
 
-func (m CreateImage_methods) Call(c *varlink.Connection) (notimplemented_out_ NotImplemented, err_ error) {
+func (m UpdateContainer_methods) Call(c *varlink.Connection) (notimplemented_out_ NotImplemented, err_ error) {
 	receive, err_ := m.Send(c, 0)
 	if err_ != nil {
 		return
@@ -1119,8 +1060,8 @@ func (m CreateImage_methods) Call(c *varlink.Connection) (notimplemented_out_ No
 	return
 }
 
-func (m CreateImage_methods) Send(c *varlink.Connection, flags uint64) (func() (NotImplemented, uint64, error), error) {
-	receive, err := c.Send("io.projectatomic.podman.CreateImage", nil, flags)
+func (m UpdateContainer_methods) Send(c *varlink.Connection, flags uint64) (func() (NotImplemented, uint64, error), error) {
+	receive, err := c.Send("io.projectatomic.podman.UpdateContainer", nil, flags)
 	if err != nil {
 		return nil, err
 	}
@@ -1137,151 +1078,143 @@ func (m CreateImage_methods) Send(c *varlink.Connection, flags uint64) (func() (
 	}, nil
 }
 
-type TagImage_methods struct{}
+type AttachToContainer_methods struct{}
 
-func TagImage() TagImage_methods { return TagImage_methods{} }
+func AttachToContainer() AttachToContainer_methods { return AttachToContainer_methods{} }
 
-func (m TagImage_methods) Call(c *varlink.Connection, name_in_ string, tagged_in_ string) (image_out_ string, err_ error) {
-	receive, err_ := m.Send(c, 0, name_in_, tagged_in_)
+func (m AttachToContainer_methods) Call(c *varlink.Connection) (notimplemented_out_ NotImplemented, err_ error) {
+	receive, err_ := m.Send(c, 0)
 	if err_ != nil {
 		return
 	}
-	image_out_, _, err_ = receive()
+	notimplemented_out_, _, err_ = receive()
 	return
 }
 
-func (m TagImage_methods) Send(c *varlink.Connection, flags uint64, name_in_ string, tagged_in_ string) (func() (string, uint64, error), error) {
-	var in struct {
-		Name   string `json:"name"`
-		Tagged string `json:"tagged"`
-	}
-	in.Name = name_in_
-	in.Tagged = tagged_in_
-	receive, err := c.Send("io.projectatomic.podman.TagImage", in, flags)
+func (m AttachToContainer_methods) Send(c *varlink.Connection, flags uint64) (func() (NotImplemented, uint64, error), error) {
+	receive, err := c.Send("io.projectatomic.podman.AttachToContainer", nil, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (image_out_ string, flags uint64, err error) {
+	return func() (notimplemented_out_ NotImplemented, flags uint64, err error) {
 		var out struct {
-			Image string `json:"image"`
+			Notimplemented NotImplemented `json:"notimplemented"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		image_out_ = out.Image
+		notimplemented_out_ = out.Notimplemented
 		return
 	}, nil
 }
 
-type GetVersion_methods struct{}
+type ListImages_methods struct{}
 
-func GetVersion() GetVersion_methods { return GetVersion_methods{} }
+func ListImages() ListImages_methods { return ListImages_methods{} }
 
-func (m GetVersion_methods) Call(c *varlink.Connection) (version_out_ Version, err_ error) {
+func (m ListImages_methods) Call(c *varlink.Connection) (images_out_ []ImageInList, err_ error) {
 	receive, err_ := m.Send(c, 0)
 	if err_ != nil {
 		return
 	}
-	version_out_, _, err_ = receive()
+	images_out_, _, err_ = receive()
 	return
 }
 
-func (m GetVersion_methods) Send(c *varlink.Connection, flags uint64) (func() (Version, uint64, error), error) {
-	receive, err := c.Send("io.projectatomic.podman.GetVersion", nil, flags)
+func (m ListImages_methods) Send(c *varlink.Connection, flags uint64) (func() ([]ImageInList, uint64, error), error) {
+	receive, err := c.Send("io.projectatomic.podman.ListImages", nil, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (version_out_ Version, flags uint64, err error) {
+	return func() (images_out_ []ImageInList, flags uint64, err error) {
 		var out struct {
-			Version Version `json:"version"`
+			Images []ImageInList `json:"images"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		version_out_ = out.Version
+		images_out_ = []ImageInList(out.Images)
 		return
 	}, nil
 }
 
-type ExportContainer_methods struct{}
+type InspectImage_methods struct{}
 
-func ExportContainer() ExportContainer_methods { return ExportContainer_methods{} }
+func InspectImage() InspectImage_methods { return InspectImage_methods{} }
 
-func (m ExportContainer_methods) Call(c *varlink.Connection, name_in_ string, path_in_ string) (tarfile_out_ string, err_ error) {
-	receive, err_ := m.Send(c, 0, name_in_, path_in_)
+func (m InspectImage_methods) Call(c *varlink.Connection, name_in_ string) (image_out_ string, err_ error) {
+	receive, err_ := m.Send(c, 0, name_in_)
 	if err_ != nil {
 		return
 	}
-	tarfile_out_, _, err_ = receive()
+	image_out_, _, err_ = receive()
 	return
 }
 
-func (m ExportContainer_methods) Send(c *varlink.Connection, flags uint64, name_in_ string, path_in_ string) (func() (string, uint64, error), error) {
+func (m InspectImage_methods) Send(c *varlink.Connection, flags uint64, name_in_ string) (func() (string, uint64, error), error) {
 	var in struct {
 		Name string `json:"name"`
-		Path string `json:"path"`
 	}
 	in.Name = name_in_
-	in.Path = path_in_
-	receive, err := c.Send("io.projectatomic.podman.ExportContainer", in, flags)
+	receive, err := c.Send("io.projectatomic.podman.InspectImage", in, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (tarfile_out_ string, flags uint64, err error) {
+	return func() (image_out_ string, flags uint64, err error) {
 		var out struct {
-			Tarfile string `json:"tarfile"`
+			Image string `json:"image"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		tarfile_out_ = out.Tarfile
+		image_out_ = out.Image
 		return
 	}, nil
 }
 
-type GetContainerStats_methods struct{}
+type PullImage_methods struct{}
 
-func GetContainerStats() GetContainerStats_methods { return GetContainerStats_methods{} }
+func PullImage() PullImage_methods { return PullImage_methods{} }
 
-func (m GetContainerStats_methods) Call(c *varlink.Connection, name_in_ string) (container_out_ ContainerStats, err_ error) {
+func (m PullImage_methods) Call(c *varlink.Connection, name_in_ string) (id_out_ string, err_ error) {
 	receive, err_ := m.Send(c, 0, name_in_)
 	if err_ != nil {
 		return
 	}
-	container_out_, _, err_ = receive()
+	id_out_, _, err_ = receive()
 	return
 }
 
-func (m GetContainerStats_methods) Send(c *varlink.Connection, flags uint64, name_in_ string) (func() (ContainerStats, uint64, error), error) {
+func (m PullImage_methods) Send(c *varlink.Connection, flags uint64, name_in_ string) (func() (string, uint64, error), error) {
 	var in struct {
 		Name string `json:"name"`
 	}
 	in.Name = name_in_
-	receive, err := c.Send("io.projectatomic.podman.GetContainerStats", in, flags)
+	receive, err := c.Send("io.projectatomic.podman.PullImage", in, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (container_out_ ContainerStats, flags uint64, err error) {
+	return func() (id_out_ string, flags uint64, err error) {
 		var out struct {
-			Container ContainerStats `json:"container"`
+			Id string `json:"id"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		container_out_ = out.Container
+		id_out_ = out.Id
 		return
 	}, nil
 }
 
-type StartContainer_methods struct{}
+type CreateContainer_methods struct{}
 
-func StartContainer() StartContainer_methods { return StartContainer_methods{} }
+func CreateContainer() CreateContainer_methods { return CreateContainer_methods{} }
 
-func (m StartContainer_methods) Call(c *varlink.Connection) (notimplemented_out_ NotImplemented, err_ error) {
+func (m CreateContainer_methods) Call(c *varlink.Connection) (notimplemented_out_ NotImplemented, err_ error) {
 	receive, err_ := m.Send(c, 0)
 	if err_ != nil {
 		return
@@ -1290,8 +1223,39 @@ func (m StartContainer_methods) Call(c *varlink.Connection) (notimplemented_out_
 	return
 }
 
-func (m StartContainer_methods) Send(c *varlink.Connection, flags uint64) (func() (NotImplemented, uint64, error), error) {
-	receive, err := c.Send("io.projectatomic.podman.StartContainer", nil, flags)
+func (m CreateContainer_methods) Send(c *varlink.Connection, flags uint64) (func() (NotImplemented, uint64, error), error) {
+	receive, err := c.Send("io.projectatomic.podman.CreateContainer", nil, flags)
+	if err != nil {
+		return nil, err
+	}
+	return func() (notimplemented_out_ NotImplemented, flags uint64, err error) {
+		var out struct {
+			Notimplemented NotImplemented `json:"notimplemented"`
+		}
+		flags, err = receive(&out)
+		if err != nil {
+			return
+		}
+		notimplemented_out_ = out.Notimplemented
+		return
+	}, nil
+}
+
+type ResizeContainerTty_methods struct{}
+
+func ResizeContainerTty() ResizeContainerTty_methods { return ResizeContainerTty_methods{} }
+
+func (m ResizeContainerTty_methods) Call(c *varlink.Connection) (notimplemented_out_ NotImplemented, err_ error) {
+	receive, err_ := m.Send(c, 0)
+	if err_ != nil {
+		return
+	}
+	notimplemented_out_, _, err_ = receive()
+	return
+}
+
+func (m ResizeContainerTty_methods) Send(c *varlink.Connection, flags uint64) (func() (NotImplemented, uint64, error), error) {
+	receive, err := c.Send("io.projectatomic.podman.ResizeContainerTty", nil, flags)
 	if err != nil {
 		return nil, err
 	}
@@ -1345,37 +1309,43 @@ func (m KillContainer_methods) Send(c *varlink.Connection, flags uint64, name_in
 	}, nil
 }
 
-type HistoryImage_methods struct{}
+type ImportImage_methods struct{}
 
-func HistoryImage() HistoryImage_methods { return HistoryImage_methods{} }
+func ImportImage() ImportImage_methods { return ImportImage_methods{} }
 
-func (m HistoryImage_methods) Call(c *varlink.Connection, name_in_ string) (history_out_ []ImageHistory, err_ error) {
-	receive, err_ := m.Send(c, 0, name_in_)
+func (m ImportImage_methods) Call(c *varlink.Connection, source_in_ string, reference_in_ string, message_in_ string, changes_in_ []string) (image_out_ string, err_ error) {
+	receive, err_ := m.Send(c, 0, source_in_, reference_in_, message_in_, changes_in_)
 	if err_ != nil {
 		return
 	}
-	history_out_, _, err_ = receive()
+	image_out_, _, err_ = receive()
 	return
 }
 
-func (m HistoryImage_methods) Send(c *varlink.Connection, flags uint64, name_in_ string) (func() ([]ImageHistory, uint64, error), error) {
+func (m ImportImage_methods) Send(c *varlink.Connection, flags uint64, source_in_ string, reference_in_ string, message_in_ string, changes_in_ []string) (func() (string, uint64, error), error) {
 	var in struct {
-		Name string `json:"name"`
+		Source    string   `json:"source"`
+		Reference string   `json:"reference"`
+		Message   string   `json:"message"`
+		Changes   []string `json:"changes"`
 	}
-	in.Name = name_in_
-	receive, err := c.Send("io.projectatomic.podman.HistoryImage", in, flags)
+	in.Source = source_in_
+	in.Reference = reference_in_
+	in.Message = message_in_
+	in.Changes = []string(changes_in_)
+	receive, err := c.Send("io.projectatomic.podman.ImportImage", in, flags)
 	if err != nil {
 		return nil, err
 	}
-	return func() (history_out_ []ImageHistory, flags uint64, err error) {
+	return func() (image_out_ string, flags uint64, err error) {
 		var out struct {
-			History []ImageHistory `json:"history"`
+			Image string `json:"image"`
 		}
 		flags, err = receive(&out)
 		if err != nil {
 			return
 		}
-		history_out_ = []ImageHistory(out.History)
+		image_out_ = out.Image
 		return
 	}, nil
 }
@@ -1419,45 +1389,151 @@ func (m ExportImage_methods) Send(c *varlink.Connection, flags uint64, name_in_
 	}, nil
 }
 
+type GetInfo_methods struct{}
+
+func GetInfo() GetInfo_methods { return GetInfo_methods{} }
+
+func (m GetInfo_methods) Call(c *varlink.Connection) (info_out_ PodmanInfo, err_ error) {
+	receive, err_ := m.Send(c, 0)
+	if err_ != nil {
+		return
+	}
+	info_out_, _, err_ = receive()
+	return
+}
+
+func (m GetInfo_methods) Send(c *varlink.Connection, flags uint64) (func() (PodmanInfo, uint64, error), error) {
+	receive, err := c.Send("io.projectatomic.podman.GetInfo", nil, flags)
+	if err != nil {
+		return nil, err
+	}
+	return func() (info_out_ PodmanInfo, flags uint64, err error) {
+		var out struct {
+			Info PodmanInfo `json:"info"`
+		}
+		flags, err = receive(&out)
+		if err != nil {
+			return
+		}
+		info_out_ = out.Info
+		return
+	}, nil
+}
+
+type ListContainerProcesses_methods struct{}
+
+func ListContainerProcesses() ListContainerProcesses_methods { return ListContainerProcesses_methods{} }
+
+func (m ListContainerProcesses_methods) Call(c *varlink.Connection, name_in_ string, opts_in_ []string) (container_out_ []string, err_ error) {
+	receive, err_ := m.Send(c, 0, name_in_, opts_in_)
+	if err_ != nil {
+		return
+	}
+	container_out_, _, err_ = receive()
+	return
+}
+
+func (m ListContainerProcesses_methods) Send(c *varlink.Connection, flags uint64, name_in_ string, opts_in_ []string) (func() ([]string, uint64, error), error) {
+	var in struct {
+		Name string   `json:"name"`
+		Opts []string `json:"opts"`
+	}
+	in.Name = name_in_
+	in.Opts = []string(opts_in_)
+	receive, err := c.Send("io.projectatomic.podman.ListContainerProcesses", in, flags)
+	if err != nil {
+		return nil, err
+	}
+	return func() (container_out_ []string, flags uint64, err error) {
+		var out struct {
+			Container []string `json:"container"`
+		}
+		flags, err = receive(&out)
+		if err != nil {
+			return
+		}
+		container_out_ = []string(out.Container)
+		return
+	}, nil
+}
+
+type SearchImage_methods struct{}
+
+func SearchImage() SearchImage_methods { return SearchImage_methods{} }
+
+func (m SearchImage_methods) Call(c *varlink.Connection, name_in_ string, limit_in_ int64) (images_out_ []ImageSearch, err_ error) {
+	receive, err_ := m.Send(c, 0, name_in_, limit_in_)
+	if err_ != nil {
+		return
+	}
+	images_out_, _, err_ = receive()
+	return
+}
+
+func (m SearchImage_methods) Send(c *varlink.Connection, flags uint64, name_in_ string, limit_in_ int64) (func() ([]ImageSearch, uint64, error), error) {
+	var in struct {
+		Name  string `json:"name"`
+		Limit int64  `json:"limit"`
+	}
+	in.Name = name_in_
+	in.Limit = limit_in_
+	receive, err := c.Send("io.projectatomic.podman.SearchImage", in, flags)
+	if err != nil {
+		return nil, err
+	}
+	return func() (images_out_ []ImageSearch, flags uint64, err error) {
+		var out struct {
+			Images []ImageSearch `json:"images"`
+		}
+		flags, err = receive(&out)
+		if err != nil {
+			return
+		}
+		images_out_ = []ImageSearch(out.Images)
+		return
+	}, nil
+}
+
 // Service interface with all methods
 type ioprojectatomicpodmanInterface interface {
-	PullImage(c VarlinkCall, name_ string) error
-	BuildImage(c VarlinkCall) error
-	InspectImage(c VarlinkCall, name_ string) error
-	DeleteUnusedImages(c VarlinkCall) error
-	Ping(c VarlinkCall) error
+	InspectContainer(c VarlinkCall, name_ string) error
 	GetContainerLogs(c VarlinkCall, name_ string) error
-	RenameContainer(c VarlinkCall) error
-	AttachToContainer(c VarlinkCall) error
 	StopContainer(c VarlinkCall, name_ string, timeout_ int64) error
-	RestartContainer(c VarlinkCall, name_ string, timeout_ int64) error
-	RemoveContainer(c VarlinkCall, name_ string, force_ bool) error
-	ListContainerProcesses(c VarlinkCall, name_ string, opts_ []string) error
-	PauseContainer(c VarlinkCall, name_ string) error
-	UnpauseContainer(c VarlinkCall, name_ string) error
 	DeleteStoppedContainers(c VarlinkCall) error
-	ImportImage(c VarlinkCall, source_ string, reference_ string, message_ string, changes_ []string) error
-	ResizeContainerTty(c VarlinkCall) error
-	WaitContainer(c VarlinkCall, name_ string) error
-	PushImage(c VarlinkCall, name_ string, tag_ string, tlsverify_ bool) error
 	RemoveImage(c VarlinkCall, name_ string, force_ bool) error
+	HistoryImage(c VarlinkCall, name_ string) error
 	ListContainers(c VarlinkCall) error
 	GetContainer(c VarlinkCall, name_ string) error
-	SearchImage(c VarlinkCall, name_ string, limit_ int64) error
-	CreateFromContainer(c VarlinkCall) error
-	ListImages(c VarlinkCall) error
+	GetContainerStats(c VarlinkCall, name_ string) error
+	RenameContainer(c VarlinkCall) error
+	UnpauseContainer(c VarlinkCall, name_ string) error
+	PushImage(c VarlinkCall, name_ string, tag_ string, tlsverify_ bool) error
+	ExportContainer(c VarlinkCall, name_ string, path_ string) error
+	RestartContainer(c VarlinkCall, name_ string, timeout_ int64) error
+	WaitContainer(c VarlinkCall, name_ string) error
+	RemoveContainer(c VarlinkCall, name_ string, force_ bool) error
 	CreateImage(c VarlinkCall) error
-	TagImage(c VarlinkCall, name_ string, tagged_ string) error
-	CreateContainer(c VarlinkCall) error
-	InspectContainer(c VarlinkCall, name_ string) error
-	ListContainerChanges(c VarlinkCall, name_ string) error
+	PullImage(c VarlinkCall, name_ string) error
+	Ping(c VarlinkCall) error
 	UpdateContainer(c VarlinkCall) error
+	AttachToContainer(c VarlinkCall) error
+	ListImages(c VarlinkCall) error
+	InspectImage(c VarlinkCall, name_ string) error
+	CreateContainer(c VarlinkCall) error
+	ResizeContainerTty(c VarlinkCall) error
 	KillContainer(c VarlinkCall, name_ string, signal_ int64) error
-	HistoryImage(c VarlinkCall, name_ string) error
+	ImportImage(c VarlinkCall, source_ string, reference_ string, message_ string, changes_ []string) error
 	ExportImage(c VarlinkCall, name_ string, destination_ string, compress_ bool) error
+	GetInfo(c VarlinkCall) error
+	ListContainerProcesses(c VarlinkCall, name_ string, opts_ []string) error
+	SearchImage(c VarlinkCall, name_ string, limit_ int64) error
+	CreateFromContainer(c VarlinkCall) error
 	GetVersion(c VarlinkCall) error
-	ExportContainer(c VarlinkCall, name_ string, path_ string) error
-	GetContainerStats(c VarlinkCall, name_ string) error
+	PauseContainer(c VarlinkCall, name_ string) error
+	BuildImage(c VarlinkCall) error
+	TagImage(c VarlinkCall, name_ string, tagged_ string) error
+	DeleteUnusedImages(c VarlinkCall) error
+	ListContainerChanges(c VarlinkCall, name_ string) error
 	StartContainer(c VarlinkCall) error
 }
 
@@ -1465,14 +1541,6 @@ type ioprojectatomicpodmanInterface interface {
 type VarlinkCall struct{ varlink.Call }
 
 // Reply methods for all varlink errors
-func (c *VarlinkCall) ReplyImageNotFound(name_ string) error {
-	var out struct {
-		Name string `json:"name"`
-	}
-	out.Name = name_
-	return c.ReplyError("io.projectatomic.podman.ImageNotFound", &out)
-}
-
 func (c *VarlinkCall) ReplyContainerNotFound(name_ string) error {
 	var out struct {
 		Name string `json:"name"`
@@ -1497,48 +1565,24 @@ func (c *VarlinkCall) ReplyRuntimeError(reason_ string) error {
 	return c.ReplyError("io.projectatomic.podman.RuntimeError", &out)
 }
 
-// Reply methods for all varlink methods
-func (c *VarlinkCall) ReplyDeleteUnusedImages(images_ []string) error {
-	var out struct {
-		Images []string `json:"images"`
-	}
-	out.Images = []string(images_)
-	return c.Reply(&out)
-}
-
-func (c *VarlinkCall) ReplyPing(ping_ StringResponse) error {
-	var out struct {
-		Ping StringResponse `json:"ping"`
-	}
-	out.Ping = ping_
-	return c.Reply(&out)
-}
-
-func (c *VarlinkCall) ReplyGetContainerLogs(container_ []string) error {
-	var out struct {
-		Container []string `json:"container"`
-	}
-	out.Container = []string(container_)
-	return c.Reply(&out)
-}
-
-func (c *VarlinkCall) ReplyRenameContainer(notimplemented_ NotImplemented) error {
+func (c *VarlinkCall) ReplyImageNotFound(name_ string) error {
 	var out struct {
-		Notimplemented NotImplemented `json:"notimplemented"`
+		Name string `json:"name"`
 	}
-	out.Notimplemented = notimplemented_
-	return c.Reply(&out)
+	out.Name = name_
+	return c.ReplyError("io.projectatomic.podman.ImageNotFound", &out)
 }
 
-func (c *VarlinkCall) ReplyAttachToContainer(notimplemented_ NotImplemented) error {
+// Reply methods for all varlink methods
+func (c *VarlinkCall) ReplyRemoveContainer(container_ string) error {
 	var out struct {
-		Notimplemented NotImplemented `json:"notimplemented"`
+		Container string `json:"container"`
 	}
-	out.Notimplemented = notimplemented_
+	out.Container = container_
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyBuildImage(notimplemented_ NotImplemented) error {
+func (c *VarlinkCall) ReplyCreateImage(notimplemented_ NotImplemented) error {
 	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
@@ -1546,7 +1590,7 @@ func (c *VarlinkCall) ReplyBuildImage(notimplemented_ NotImplemented) error {
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyInspectImage(image_ string) error {
+func (c *VarlinkCall) ReplyPushImage(image_ string) error {
 	var out struct {
 		Image string `json:"image"`
 	}
@@ -1554,11 +1598,11 @@ func (c *VarlinkCall) ReplyInspectImage(image_ string) error {
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyStopContainer(container_ string) error {
+func (c *VarlinkCall) ReplyExportContainer(tarfile_ string) error {
 	var out struct {
-		Container string `json:"container"`
+		Tarfile string `json:"tarfile"`
 	}
-	out.Container = container_
+	out.Tarfile = tarfile_
 	return c.Reply(&out)
 }
 
@@ -1570,47 +1614,47 @@ func (c *VarlinkCall) ReplyRestartContainer(container_ string) error {
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyRemoveContainer(container_ string) error {
+func (c *VarlinkCall) ReplyWaitContainer(exitcode_ int64) error {
 	var out struct {
-		Container string `json:"container"`
+		Exitcode int64 `json:"exitcode"`
 	}
-	out.Container = container_
+	out.Exitcode = exitcode_
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyListContainerProcesses(container_ []string) error {
+func (c *VarlinkCall) ReplyListImages(images_ []ImageInList) error {
 	var out struct {
-		Container []string `json:"container"`
+		Images []ImageInList `json:"images"`
 	}
-	out.Container = []string(container_)
+	out.Images = []ImageInList(images_)
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyPauseContainer(container_ string) error {
+func (c *VarlinkCall) ReplyInspectImage(image_ string) error {
 	var out struct {
-		Container string `json:"container"`
+		Image string `json:"image"`
 	}
-	out.Container = container_
+	out.Image = image_
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyUnpauseContainer(container_ string) error {
+func (c *VarlinkCall) ReplyPullImage(id_ string) error {
 	var out struct {
-		Container string `json:"container"`
+		Id string `json:"id"`
 	}
-	out.Container = container_
+	out.Id = id_
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyDeleteStoppedContainers(containers_ []string) error {
+func (c *VarlinkCall) ReplyPing(ping_ StringResponse) error {
 	var out struct {
-		Containers []string `json:"containers"`
+		Ping StringResponse `json:"ping"`
 	}
-	out.Containers = []string(containers_)
+	out.Ping = ping_
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyResizeContainerTty(notimplemented_ NotImplemented) error {
+func (c *VarlinkCall) ReplyUpdateContainer(notimplemented_ NotImplemented) error {
 	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
@@ -1618,15 +1662,15 @@ func (c *VarlinkCall) ReplyResizeContainerTty(notimplemented_ NotImplemented) er
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyWaitContainer(exitcode_ int64) error {
+func (c *VarlinkCall) ReplyAttachToContainer(notimplemented_ NotImplemented) error {
 	var out struct {
-		Exitcode int64 `json:"exitcode"`
+		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Exitcode = exitcode_
+	out.Notimplemented = notimplemented_
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyPushImage(image_ string) error {
+func (c *VarlinkCall) ReplyImportImage(image_ string) error {
 	var out struct {
 		Image string `json:"image"`
 	}
@@ -1634,7 +1678,7 @@ func (c *VarlinkCall) ReplyPushImage(image_ string) error {
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyRemoveImage(image_ string) error {
+func (c *VarlinkCall) ReplyExportImage(image_ string) error {
 	var out struct {
 		Image string `json:"image"`
 	}
@@ -1642,43 +1686,51 @@ func (c *VarlinkCall) ReplyRemoveImage(image_ string) error {
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyImportImage(image_ string) error {
+func (c *VarlinkCall) ReplyCreateContainer(notimplemented_ NotImplemented) error {
 	var out struct {
-		Image string `json:"image"`
+		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Image = image_
+	out.Notimplemented = notimplemented_
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyListContainers(containers_ []ListContainerData) error {
+func (c *VarlinkCall) ReplyResizeContainerTty(notimplemented_ NotImplemented) error {
 	var out struct {
-		Containers []ListContainerData `json:"containers"`
+		Notimplemented NotImplemented `json:"notimplemented"`
 	}
-	out.Containers = []ListContainerData(containers_)
+	out.Notimplemented = notimplemented_
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyGetContainer(container_ ListContainerData) error {
+func (c *VarlinkCall) ReplyKillContainer(container_ string) error {
 	var out struct {
-		Container ListContainerData `json:"container"`
+		Container string `json:"container"`
 	}
 	out.Container = container_
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplySearchImage(images_ []ImageSearch) error {
+func (c *VarlinkCall) ReplyGetInfo(info_ PodmanInfo) error {
 	var out struct {
-		Images []ImageSearch `json:"images"`
+		Info PodmanInfo `json:"info"`
 	}
-	out.Images = []ImageSearch(images_)
+	out.Info = info_
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyCreateFromContainer(notimplemented_ NotImplemented) error {
+func (c *VarlinkCall) ReplyListContainerProcesses(container_ []string) error {
 	var out struct {
-		Notimplemented NotImplemented `json:"notimplemented"`
+		Container []string `json:"container"`
 	}
-	out.Notimplemented = notimplemented_
+	out.Container = []string(container_)
+	return c.Reply(&out)
+}
+
+func (c *VarlinkCall) ReplySearchImage(images_ []ImageSearch) error {
+	var out struct {
+		Images []ImageSearch `json:"images"`
+	}
+	out.Images = []ImageSearch(images_)
 	return c.Reply(&out)
 }
 
@@ -1690,7 +1742,15 @@ func (c *VarlinkCall) ReplyTagImage(image_ string) error {
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyCreateContainer(notimplemented_ NotImplemented) error {
+func (c *VarlinkCall) ReplyDeleteUnusedImages(images_ []string) error {
+	var out struct {
+		Images []string `json:"images"`
+	}
+	out.Images = []string(images_)
+	return c.Reply(&out)
+}
+
+func (c *VarlinkCall) ReplyCreateFromContainer(notimplemented_ NotImplemented) error {
 	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
@@ -1698,23 +1758,23 @@ func (c *VarlinkCall) ReplyCreateContainer(notimplemented_ NotImplemented) error
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyInspectContainer(container_ string) error {
+func (c *VarlinkCall) ReplyGetVersion(version_ Version) error {
 	var out struct {
-		Container string `json:"container"`
+		Version Version `json:"version"`
 	}
-	out.Container = container_
+	out.Version = version_
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyListContainerChanges(container_ ContainerChanges) error {
+func (c *VarlinkCall) ReplyPauseContainer(container_ string) error {
 	var out struct {
-		Container ContainerChanges `json:"container"`
+		Container string `json:"container"`
 	}
 	out.Container = container_
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyUpdateContainer(notimplemented_ NotImplemented) error {
+func (c *VarlinkCall) ReplyBuildImage(notimplemented_ NotImplemented) error {
 	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
@@ -1722,15 +1782,15 @@ func (c *VarlinkCall) ReplyUpdateContainer(notimplemented_ NotImplemented) error
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyListImages(images_ []ImageInList) error {
+func (c *VarlinkCall) ReplyListContainerChanges(container_ ContainerChanges) error {
 	var out struct {
-		Images []ImageInList `json:"images"`
+		Container ContainerChanges `json:"container"`
 	}
-	out.Images = []ImageInList(images_)
+	out.Container = container_
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyCreateImage(notimplemented_ NotImplemented) error {
+func (c *VarlinkCall) ReplyStartContainer(notimplemented_ NotImplemented) error {
 	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
@@ -1738,7 +1798,15 @@ func (c *VarlinkCall) ReplyCreateImage(notimplemented_ NotImplemented) error {
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyExportImage(image_ string) error {
+func (c *VarlinkCall) ReplyDeleteStoppedContainers(containers_ []string) error {
+	var out struct {
+		Containers []string `json:"containers"`
+	}
+	out.Containers = []string(containers_)
+	return c.Reply(&out)
+}
+
+func (c *VarlinkCall) ReplyRemoveImage(image_ string) error {
 	var out struct {
 		Image string `json:"image"`
 	}
@@ -1746,31 +1814,31 @@ func (c *VarlinkCall) ReplyExportImage(image_ string) error {
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyGetVersion(version_ Version) error {
+func (c *VarlinkCall) ReplyInspectContainer(container_ string) error {
 	var out struct {
-		Version Version `json:"version"`
+		Container string `json:"container"`
 	}
-	out.Version = version_
+	out.Container = container_
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyExportContainer(tarfile_ string) error {
+func (c *VarlinkCall) ReplyGetContainerLogs(container_ []string) error {
 	var out struct {
-		Tarfile string `json:"tarfile"`
+		Container []string `json:"container"`
 	}
-	out.Tarfile = tarfile_
+	out.Container = []string(container_)
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyGetContainerStats(container_ ContainerStats) error {
+func (c *VarlinkCall) ReplyStopContainer(container_ string) error {
 	var out struct {
-		Container ContainerStats `json:"container"`
+		Container string `json:"container"`
 	}
 	out.Container = container_
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyStartContainer(notimplemented_ NotImplemented) error {
+func (c *VarlinkCall) ReplyRenameContainer(notimplemented_ NotImplemented) error {
 	var out struct {
 		Notimplemented NotImplemented `json:"notimplemented"`
 	}
@@ -1778,7 +1846,7 @@ func (c *VarlinkCall) ReplyStartContainer(notimplemented_ NotImplemented) error
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyKillContainer(container_ string) error {
+func (c *VarlinkCall) ReplyUnpauseContainer(container_ string) error {
 	var out struct {
 		Container string `json:"container"`
 	}
@@ -1794,218 +1862,227 @@ func (c *VarlinkCall) ReplyHistoryImage(history_ []ImageHistory) error {
 	return c.Reply(&out)
 }
 
-func (c *VarlinkCall) ReplyPullImage(id_ string) error {
+func (c *VarlinkCall) ReplyListContainers(containers_ []ListContainerData) error {
 	var out struct {
-		Id string `json:"id"`
+		Containers []ListContainerData `json:"containers"`
 	}
-	out.Id = id_
+	out.Containers = []ListContainerData(containers_)
 	return c.Reply(&out)
 }
 
-// Dummy implementations for all varlink methods
-func (s *VarlinkInterface) GetContainer(c VarlinkCall, name_ string) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.GetContainer")
+func (c *VarlinkCall) ReplyGetContainer(container_ ListContainerData) error {
+	var out struct {
+		Container ListContainerData `json:"container"`
+	}
+	out.Container = container_
+	return c.Reply(&out)
 }
 
-func (s *VarlinkInterface) SearchImage(c VarlinkCall, name_ string, limit_ int64) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.SearchImage")
+func (c *VarlinkCall) ReplyGetContainerStats(container_ ContainerStats) error {
+	var out struct {
+		Container ContainerStats `json:"container"`
+	}
+	out.Container = container_
+	return c.Reply(&out)
 }
 
-func (s *VarlinkInterface) CreateFromContainer(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.CreateFromContainer")
+// Dummy implementations for all varlink methods
+func (s *VarlinkInterface) ListContainerChanges(c VarlinkCall, name_ string) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.ListContainerChanges")
 }
 
-func (s *VarlinkInterface) ListContainers(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.ListContainers")
+func (s *VarlinkInterface) StartContainer(c VarlinkCall) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.StartContainer")
 }
 
 func (s *VarlinkInterface) InspectContainer(c VarlinkCall, name_ string) error {
 	return c.ReplyMethodNotImplemented("io.projectatomic.podman.InspectContainer")
 }
 
-func (s *VarlinkInterface) ListContainerChanges(c VarlinkCall, name_ string) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.ListContainerChanges")
-}
-
-func (s *VarlinkInterface) UpdateContainer(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.UpdateContainer")
+func (s *VarlinkInterface) GetContainerLogs(c VarlinkCall, name_ string) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.GetContainerLogs")
 }
 
-func (s *VarlinkInterface) ListImages(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.ListImages")
+func (s *VarlinkInterface) StopContainer(c VarlinkCall, name_ string, timeout_ int64) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.StopContainer")
 }
 
-func (s *VarlinkInterface) CreateImage(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.CreateImage")
+func (s *VarlinkInterface) DeleteStoppedContainers(c VarlinkCall) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.DeleteStoppedContainers")
 }
 
-func (s *VarlinkInterface) TagImage(c VarlinkCall, name_ string, tagged_ string) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.TagImage")
+func (s *VarlinkInterface) RemoveImage(c VarlinkCall, name_ string, force_ bool) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.RemoveImage")
 }
 
-func (s *VarlinkInterface) CreateContainer(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.CreateContainer")
+func (s *VarlinkInterface) ListContainers(c VarlinkCall) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.ListContainers")
 }
 
-func (s *VarlinkInterface) ExportContainer(c VarlinkCall, name_ string, path_ string) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.ExportContainer")
+func (s *VarlinkInterface) GetContainer(c VarlinkCall, name_ string) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.GetContainer")
 }
 
 func (s *VarlinkInterface) GetContainerStats(c VarlinkCall, name_ string) error {
 	return c.ReplyMethodNotImplemented("io.projectatomic.podman.GetContainerStats")
 }
 
-func (s *VarlinkInterface) StartContainer(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.StartContainer")
+func (s *VarlinkInterface) RenameContainer(c VarlinkCall) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.RenameContainer")
 }
 
-func (s *VarlinkInterface) KillContainer(c VarlinkCall, name_ string, signal_ int64) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.KillContainer")
+func (s *VarlinkInterface) UnpauseContainer(c VarlinkCall, name_ string) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.UnpauseContainer")
 }
 
 func (s *VarlinkInterface) HistoryImage(c VarlinkCall, name_ string) error {
 	return c.ReplyMethodNotImplemented("io.projectatomic.podman.HistoryImage")
 }
 
-func (s *VarlinkInterface) ExportImage(c VarlinkCall, name_ string, destination_ string, compress_ bool) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.ExportImage")
+func (s *VarlinkInterface) ExportContainer(c VarlinkCall, name_ string, path_ string) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.ExportContainer")
 }
 
-func (s *VarlinkInterface) GetVersion(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.GetVersion")
+func (s *VarlinkInterface) RestartContainer(c VarlinkCall, name_ string, timeout_ int64) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.RestartContainer")
 }
 
-func (s *VarlinkInterface) PullImage(c VarlinkCall, name_ string) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.PullImage")
+func (s *VarlinkInterface) WaitContainer(c VarlinkCall, name_ string) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.WaitContainer")
 }
 
-func (s *VarlinkInterface) GetContainerLogs(c VarlinkCall, name_ string) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.GetContainerLogs")
+func (s *VarlinkInterface) RemoveContainer(c VarlinkCall, name_ string, force_ bool) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.RemoveContainer")
 }
 
-func (s *VarlinkInterface) RenameContainer(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.RenameContainer")
+func (s *VarlinkInterface) CreateImage(c VarlinkCall) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.CreateImage")
+}
+
+func (s *VarlinkInterface) PushImage(c VarlinkCall, name_ string, tag_ string, tlsverify_ bool) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.PushImage")
+}
+
+func (s *VarlinkInterface) Ping(c VarlinkCall) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.Ping")
+}
+
+func (s *VarlinkInterface) UpdateContainer(c VarlinkCall) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.UpdateContainer")
 }
 
 func (s *VarlinkInterface) AttachToContainer(c VarlinkCall) error {
 	return c.ReplyMethodNotImplemented("io.projectatomic.podman.AttachToContainer")
 }
 
-func (s *VarlinkInterface) BuildImage(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.BuildImage")
+func (s *VarlinkInterface) ListImages(c VarlinkCall) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.ListImages")
 }
 
 func (s *VarlinkInterface) InspectImage(c VarlinkCall, name_ string) error {
 	return c.ReplyMethodNotImplemented("io.projectatomic.podman.InspectImage")
 }
 
-func (s *VarlinkInterface) DeleteUnusedImages(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.DeleteUnusedImages")
-}
-
-func (s *VarlinkInterface) Ping(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.Ping")
+func (s *VarlinkInterface) PullImage(c VarlinkCall, name_ string) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.PullImage")
 }
 
-func (s *VarlinkInterface) RestartContainer(c VarlinkCall, name_ string, timeout_ int64) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.RestartContainer")
+func (s *VarlinkInterface) CreateContainer(c VarlinkCall) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.CreateContainer")
 }
 
-func (s *VarlinkInterface) RemoveContainer(c VarlinkCall, name_ string, force_ bool) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.RemoveContainer")
+func (s *VarlinkInterface) ResizeContainerTty(c VarlinkCall) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.ResizeContainerTty")
 }
 
-func (s *VarlinkInterface) StopContainer(c VarlinkCall, name_ string, timeout_ int64) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.StopContainer")
+func (s *VarlinkInterface) KillContainer(c VarlinkCall, name_ string, signal_ int64) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.KillContainer")
 }
 
-func (s *VarlinkInterface) PauseContainer(c VarlinkCall, name_ string) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.PauseContainer")
+func (s *VarlinkInterface) ImportImage(c VarlinkCall, source_ string, reference_ string, message_ string, changes_ []string) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.ImportImage")
 }
 
-func (s *VarlinkInterface) UnpauseContainer(c VarlinkCall, name_ string) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.UnpauseContainer")
+func (s *VarlinkInterface) ExportImage(c VarlinkCall, name_ string, destination_ string, compress_ bool) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.ExportImage")
 }
 
-func (s *VarlinkInterface) DeleteStoppedContainers(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.DeleteStoppedContainers")
+func (s *VarlinkInterface) GetInfo(c VarlinkCall) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.GetInfo")
 }
 
 func (s *VarlinkInterface) ListContainerProcesses(c VarlinkCall, name_ string, opts_ []string) error {
 	return c.ReplyMethodNotImplemented("io.projectatomic.podman.ListContainerProcesses")
 }
 
-func (s *VarlinkInterface) WaitContainer(c VarlinkCall, name_ string) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.WaitContainer")
+func (s *VarlinkInterface) SearchImage(c VarlinkCall, name_ string, limit_ int64) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.SearchImage")
 }
 
-func (s *VarlinkInterface) PushImage(c VarlinkCall, name_ string, tag_ string, tlsverify_ bool) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.PushImage")
+func (s *VarlinkInterface) GetVersion(c VarlinkCall) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.GetVersion")
 }
 
-func (s *VarlinkInterface) RemoveImage(c VarlinkCall, name_ string, force_ bool) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.RemoveImage")
+func (s *VarlinkInterface) PauseContainer(c VarlinkCall, name_ string) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.PauseContainer")
 }
 
-func (s *VarlinkInterface) ImportImage(c VarlinkCall, source_ string, reference_ string, message_ string, changes_ []string) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.ImportImage")
+func (s *VarlinkInterface) BuildImage(c VarlinkCall) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.BuildImage")
 }
 
-func (s *VarlinkInterface) ResizeContainerTty(c VarlinkCall) error {
-	return c.ReplyMethodNotImplemented("io.projectatomic.podman.ResizeContainerTty")
+func (s *VarlinkInterface) TagImage(c VarlinkCall, name_ string, tagged_ string) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.TagImage")
+}
+
+func (s *VarlinkInterface) DeleteUnusedImages(c VarlinkCall) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.DeleteUnusedImages")
+}
+
+func (s *VarlinkInterface) CreateFromContainer(c VarlinkCall) error {
+	return c.ReplyMethodNotImplemented("io.projectatomic.podman.CreateFromContainer")
 }
 
 // Method call dispatcher
 func (s *VarlinkInterface) VarlinkDispatch(call varlink.Call, methodname string) error {
 	switch methodname {
-	case "StopContainer":
-		var in struct {
-			Name    string `json:"name"`
-			Timeout int64  `json:"timeout"`
-		}
-		err := call.GetParameters(&in)
-		if err != nil {
-			return call.ReplyInvalidParameter("parameters")
-		}
-		return s.ioprojectatomicpodmanInterface.StopContainer(VarlinkCall{call}, in.Name, in.Timeout)
+	case "ListContainers":
+		return s.ioprojectatomicpodmanInterface.ListContainers(VarlinkCall{call})
 
-	case "RestartContainer":
+	case "GetContainer":
 		var in struct {
-			Name    string `json:"name"`
-			Timeout int64  `json:"timeout"`
+			Name string `json:"name"`
 		}
 		err := call.GetParameters(&in)
 		if err != nil {
 			return call.ReplyInvalidParameter("parameters")
 		}
-		return s.ioprojectatomicpodmanInterface.RestartContainer(VarlinkCall{call}, in.Name, in.Timeout)
+		return s.ioprojectatomicpodmanInterface.GetContainer(VarlinkCall{call}, in.Name)
 
-	case "RemoveContainer":
+	case "GetContainerStats":
 		var in struct {
-			Name  string `json:"name"`
-			Force bool   `json:"force"`
+			Name string `json:"name"`
 		}
 		err := call.GetParameters(&in)
 		if err != nil {
 			return call.ReplyInvalidParameter("parameters")
 		}
-		return s.ioprojectatomicpodmanInterface.RemoveContainer(VarlinkCall{call}, in.Name, in.Force)
+		return s.ioprojectatomicpodmanInterface.GetContainerStats(VarlinkCall{call}, in.Name)
 
-	case "DeleteStoppedContainers":
-		return s.ioprojectatomicpodmanInterface.DeleteStoppedContainers(VarlinkCall{call})
+	case "RenameContainer":
+		return s.ioprojectatomicpodmanInterface.RenameContainer(VarlinkCall{call})
 
-	case "ListContainerProcesses":
+	case "UnpauseContainer":
 		var in struct {
-			Name string   `json:"name"`
-			Opts []string `json:"opts"`
+			Name string `json:"name"`
 		}
 		err := call.GetParameters(&in)
 		if err != nil {
 			return call.ReplyInvalidParameter("parameters")
 		}
-		return s.ioprojectatomicpodmanInterface.ListContainerProcesses(VarlinkCall{call}, in.Name, []string(in.Opts))
+		return s.ioprojectatomicpodmanInterface.UnpauseContainer(VarlinkCall{call}, in.Name)
 
-	case "PauseContainer":
+	case "HistoryImage":
 		var in struct {
 			Name string `json:"name"`
 		}
@@ -2013,54 +2090,53 @@ func (s *VarlinkInterface) VarlinkDispatch(call varlink.Call, methodname string)
 		if err != nil {
 			return call.ReplyInvalidParameter("parameters")
 		}
-		return s.ioprojectatomicpodmanInterface.PauseContainer(VarlinkCall{call}, in.Name)
+		return s.ioprojectatomicpodmanInterface.HistoryImage(VarlinkCall{call}, in.Name)
 
-	case "UnpauseContainer":
+	case "ExportContainer":
 		var in struct {
 			Name string `json:"name"`
+			Path string `json:"path"`
 		}
 		err := call.GetParameters(&in)
 		if err != nil {
 			return call.ReplyInvalidParameter("parameters")
 		}
-		return s.ioprojectatomicpodmanInterface.UnpauseContainer(VarlinkCall{call}, in.Name)
+		return s.ioprojectatomicpodmanInterface.ExportContainer(VarlinkCall{call}, in.Name, in.Path)
 
-	case "RemoveImage":
+	case "RestartContainer":
 		var in struct {
-			Name  string `json:"name"`
-			Force bool   `json:"force"`
+			Name    string `json:"name"`
+			Timeout int64  `json:"timeout"`
 		}
 		err := call.GetParameters(&in)
 		if err != nil {
 			return call.ReplyInvalidParameter("parameters")
 		}
-		return s.ioprojectatomicpodmanInterface.RemoveImage(VarlinkCall{call}, in.Name, in.Force)
+		return s.ioprojectatomicpodmanInterface.RestartContainer(VarlinkCall{call}, in.Name, in.Timeout)
 
-	case "ImportImage":
+	case "WaitContainer":
 		var in struct {
-			Source    string   `json:"source"`
-			Reference string   `json:"reference"`
-			Message   string   `json:"message"`
-			Changes   []string `json:"changes"`
+			Name string `json:"name"`
 		}
 		err := call.GetParameters(&in)
 		if err != nil {
 			return call.ReplyInvalidParameter("parameters")
 		}
-		return s.ioprojectatomicpodmanInterface.ImportImage(VarlinkCall{call}, in.Source, in.Reference, in.Message, []string(in.Changes))
-
-	case "ResizeContainerTty":
-		return s.ioprojectatomicpodmanInterface.ResizeContainerTty(VarlinkCall{call})
+		return s.ioprojectatomicpodmanInterface.WaitContainer(VarlinkCall{call}, in.Name)
 
-	case "WaitContainer":
+	case "RemoveContainer":
 		var in struct {
-			Name string `json:"name"`
+			Name  string `json:"name"`
+			Force bool   `json:"force"`
 		}
 		err := call.GetParameters(&in)
 		if err != nil {
 			return call.ReplyInvalidParameter("parameters")
 		}
-		return s.ioprojectatomicpodmanInterface.WaitContainer(VarlinkCall{call}, in.Name)
+		return s.ioprojectatomicpodmanInterface.RemoveContainer(VarlinkCall{call}, in.Name, in.Force)
+
+	case "CreateImage":
+		return s.ioprojectatomicpodmanInterface.CreateImage(VarlinkCall{call})
 
 	case "PushImage":
 		var in struct {
@@ -2074,13 +2150,19 @@ func (s *VarlinkInterface) VarlinkDispatch(call varlink.Call, methodname string)
 		}
 		return s.ioprojectatomicpodmanInterface.PushImage(VarlinkCall{call}, in.Name, in.Tag, in.Tlsverify)
 
-	case "CreateFromContainer":
-		return s.ioprojectatomicpodmanInterface.CreateFromContainer(VarlinkCall{call})
+	case "Ping":
+		return s.ioprojectatomicpodmanInterface.Ping(VarlinkCall{call})
 
-	case "ListContainers":
-		return s.ioprojectatomicpodmanInterface.ListContainers(VarlinkCall{call})
+	case "UpdateContainer":
+		return s.ioprojectatomicpodmanInterface.UpdateContainer(VarlinkCall{call})
 
-	case "GetContainer":
+	case "AttachToContainer":
+		return s.ioprojectatomicpodmanInterface.AttachToContainer(VarlinkCall{call})
+
+	case "ListImages":
+		return s.ioprojectatomicpodmanInterface.ListImages(VarlinkCall{call})
+
+	case "InspectImage":
 		var in struct {
 			Name string `json:"name"`
 		}
@@ -2088,113 +2170,119 @@ func (s *VarlinkInterface) VarlinkDispatch(call varlink.Call, methodname string)
 		if err != nil {
 			return call.ReplyInvalidParameter("parameters")
 		}
-		return s.ioprojectatomicpodmanInterface.GetContainer(VarlinkCall{call}, in.Name)
+		return s.ioprojectatomicpodmanInterface.InspectImage(VarlinkCall{call}, in.Name)
 
-	case "SearchImage":
+	case "PullImage":
 		var in struct {
-			Name  string `json:"name"`
-			Limit int64  `json:"limit"`
+			Name string `json:"name"`
 		}
 		err := call.GetParameters(&in)
 		if err != nil {
 			return call.ReplyInvalidParameter("parameters")
 		}
-		return s.ioprojectatomicpodmanInterface.SearchImage(VarlinkCall{call}, in.Name, in.Limit)
-
-	case "UpdateContainer":
-		return s.ioprojectatomicpodmanInterface.UpdateContainer(VarlinkCall{call})
+		return s.ioprojectatomicpodmanInterface.PullImage(VarlinkCall{call}, in.Name)
 
-	case "ListImages":
-		return s.ioprojectatomicpodmanInterface.ListImages(VarlinkCall{call})
+	case "CreateContainer":
+		return s.ioprojectatomicpodmanInterface.CreateContainer(VarlinkCall{call})
 
-	case "CreateImage":
-		return s.ioprojectatomicpodmanInterface.CreateImage(VarlinkCall{call})
+	case "ResizeContainerTty":
+		return s.ioprojectatomicpodmanInterface.ResizeContainerTty(VarlinkCall{call})
 
-	case "TagImage":
+	case "KillContainer":
 		var in struct {
 			Name   string `json:"name"`
-			Tagged string `json:"tagged"`
+			Signal int64  `json:"signal"`
 		}
 		err := call.GetParameters(&in)
 		if err != nil {
 			return call.ReplyInvalidParameter("parameters")
 		}
-		return s.ioprojectatomicpodmanInterface.TagImage(VarlinkCall{call}, in.Name, in.Tagged)
-
-	case "CreateContainer":
-		return s.ioprojectatomicpodmanInterface.CreateContainer(VarlinkCall{call})
+		return s.ioprojectatomicpodmanInterface.KillContainer(VarlinkCall{call}, in.Name, in.Signal)
 
-	case "InspectContainer":
+	case "ImportImage":
 		var in struct {
-			Name string `json:"name"`
+			Source    string   `json:"source"`
+			Reference string   `json:"reference"`
+			Message   string   `json:"message"`
+			Changes   []string `json:"changes"`
 		}
 		err := call.GetParameters(&in)
 		if err != nil {
 			return call.ReplyInvalidParameter("parameters")
 		}
-		return s.ioprojectatomicpodmanInterface.InspectContainer(VarlinkCall{call}, in.Name)
+		return s.ioprojectatomicpodmanInterface.ImportImage(VarlinkCall{call}, in.Source, in.Reference, in.Message, []string(in.Changes))
 
-	case "ListContainerChanges":
+	case "ExportImage":
 		var in struct {
-			Name string `json:"name"`
+			Name        string `json:"name"`
+			Destination string `json:"destination"`
+			Compress    bool   `json:"compress"`
 		}
 		err := call.GetParameters(&in)
 		if err != nil {
 			return call.ReplyInvalidParameter("parameters")
 		}
-		return s.ioprojectatomicpodmanInterface.ListContainerChanges(VarlinkCall{call}, in.Name)
+		return s.ioprojectatomicpodmanInterface.ExportImage(VarlinkCall{call}, in.Name, in.Destination, in.Compress)
 
-	case "StartContainer":
-		return s.ioprojectatomicpodmanInterface.StartContainer(VarlinkCall{call})
+	case "GetInfo":
+		return s.ioprojectatomicpodmanInterface.GetInfo(VarlinkCall{call})
 
-	case "KillContainer":
+	case "ListContainerProcesses":
 		var in struct {
-			Name   string `json:"name"`
-			Signal int64  `json:"signal"`
+			Name string   `json:"name"`
+			Opts []string `json:"opts"`
 		}
 		err := call.GetParameters(&in)
 		if err != nil {
 			return call.ReplyInvalidParameter("parameters")
 		}
-		return s.ioprojectatomicpodmanInterface.KillContainer(VarlinkCall{call}, in.Name, in.Signal)
+		return s.ioprojectatomicpodmanInterface.ListContainerProcesses(VarlinkCall{call}, in.Name, []string(in.Opts))
 
-	case "HistoryImage":
+	case "SearchImage":
 		var in struct {
-			Name string `json:"name"`
+			Name  string `json:"name"`
+			Limit int64  `json:"limit"`
 		}
 		err := call.GetParameters(&in)
 		if err != nil {
 			return call.ReplyInvalidParameter("parameters")
 		}
-		return s.ioprojectatomicpodmanInterface.HistoryImage(VarlinkCall{call}, in.Name)
+		return s.ioprojectatomicpodmanInterface.SearchImage(VarlinkCall{call}, in.Name, in.Limit)
 
-	case "ExportImage":
+	case "GetVersion":
+		return s.ioprojectatomicpodmanInterface.GetVersion(VarlinkCall{call})
+
+	case "PauseContainer":
 		var in struct {
-			Name        string `json:"name"`
-			Destination string `json:"destination"`
-			Compress    bool   `json:"compress"`
+			Name string `json:"name"`
 		}
 		err := call.GetParameters(&in)
 		if err != nil {
 			return call.ReplyInvalidParameter("parameters")
 		}
-		return s.ioprojectatomicpodmanInterface.ExportImage(VarlinkCall{call}, in.Name, in.Destination, in.Compress)
+		return s.ioprojectatomicpodmanInterface.PauseContainer(VarlinkCall{call}, in.Name)
 
-	case "GetVersion":
-		return s.ioprojectatomicpodmanInterface.GetVersion(VarlinkCall{call})
+	case "BuildImage":
+		return s.ioprojectatomicpodmanInterface.BuildImage(VarlinkCall{call})
 
-	case "ExportContainer":
+	case "TagImage":
 		var in struct {
-			Name string `json:"name"`
-			Path string `json:"path"`
+			Name   string `json:"name"`
+			Tagged string `json:"tagged"`
 		}
 		err := call.GetParameters(&in)
 		if err != nil {
 			return call.ReplyInvalidParameter("parameters")
 		}
-		return s.ioprojectatomicpodmanInterface.ExportContainer(VarlinkCall{call}, in.Name, in.Path)
+		return s.ioprojectatomicpodmanInterface.TagImage(VarlinkCall{call}, in.Name, in.Tagged)
 
-	case "GetContainerStats":
+	case "DeleteUnusedImages":
+		return s.ioprojectatomicpodmanInterface.DeleteUnusedImages(VarlinkCall{call})
+
+	case "CreateFromContainer":
+		return s.ioprojectatomicpodmanInterface.CreateFromContainer(VarlinkCall{call})
+
+	case "ListContainerChanges":
 		var in struct {
 			Name string `json:"name"`
 		}
@@ -2202,9 +2290,12 @@ func (s *VarlinkInterface) VarlinkDispatch(call varlink.Call, methodname string)
 		if err != nil {
 			return call.ReplyInvalidParameter("parameters")
 		}
-		return s.ioprojectatomicpodmanInterface.GetContainerStats(VarlinkCall{call}, in.Name)
+		return s.ioprojectatomicpodmanInterface.ListContainerChanges(VarlinkCall{call}, in.Name)
 
-	case "PullImage":
+	case "StartContainer":
+		return s.ioprojectatomicpodmanInterface.StartContainer(VarlinkCall{call})
+
+	case "InspectContainer":
 		var in struct {
 			Name string `json:"name"`
 		}
@@ -2212,15 +2303,9 @@ func (s *VarlinkInterface) VarlinkDispatch(call varlink.Call, methodname string)
 		if err != nil {
 			return call.ReplyInvalidParameter("parameters")
 		}
-		return s.ioprojectatomicpodmanInterface.PullImage(VarlinkCall{call}, in.Name)
-
-	case "AttachToContainer":
-		return s.ioprojectatomicpodmanInterface.AttachToContainer(VarlinkCall{call})
-
-	case "BuildImage":
-		return s.ioprojectatomicpodmanInterface.BuildImage(VarlinkCall{call})
+		return s.ioprojectatomicpodmanInterface.InspectContainer(VarlinkCall{call}, in.Name)
 
-	case "InspectImage":
+	case "GetContainerLogs":
 		var in struct {
 			Name string `json:"name"`
 		}
@@ -2228,26 +2313,32 @@ func (s *VarlinkInterface) VarlinkDispatch(call varlink.Call, methodname string)
 		if err != nil {
 			return call.ReplyInvalidParameter("parameters")
 		}
-		return s.ioprojectatomicpodmanInterface.InspectImage(VarlinkCall{call}, in.Name)
+		return s.ioprojectatomicpodmanInterface.GetContainerLogs(VarlinkCall{call}, in.Name)
 
-	case "DeleteUnusedImages":
-		return s.ioprojectatomicpodmanInterface.DeleteUnusedImages(VarlinkCall{call})
+	case "StopContainer":
+		var in struct {
+			Name    string `json:"name"`
+			Timeout int64  `json:"timeout"`
+		}
+		err := call.GetParameters(&in)
+		if err != nil {
+			return call.ReplyInvalidParameter("parameters")
+		}
+		return s.ioprojectatomicpodmanInterface.StopContainer(VarlinkCall{call}, in.Name, in.Timeout)
 
-	case "Ping":
-		return s.ioprojectatomicpodmanInterface.Ping(VarlinkCall{call})
+	case "DeleteStoppedContainers":
+		return s.ioprojectatomicpodmanInterface.DeleteStoppedContainers(VarlinkCall{call})
 
-	case "GetContainerLogs":
+	case "RemoveImage":
 		var in struct {
-			Name string `json:"name"`
+			Name  string `json:"name"`
+			Force bool   `json:"force"`
 		}
 		err := call.GetParameters(&in)
 		if err != nil {
 			return call.ReplyInvalidParameter("parameters")
 		}
-		return s.ioprojectatomicpodmanInterface.GetContainerLogs(VarlinkCall{call}, in.Name)
-
-	case "RenameContainer":
-		return s.ioprojectatomicpodmanInterface.RenameContainer(VarlinkCall{call})
+		return s.ioprojectatomicpodmanInterface.RemoveImage(VarlinkCall{call}, in.Name, in.Force)
 
 	default:
 		return call.ReplyMethodNotFound(methodname)
@@ -2387,6 +2478,55 @@ type ContainerNameSpace (
     ipc: string
 )
 
+# InfoHost describes the host stats portion of PodmanInfo
+type InfoHost (
+    mem_free: int,
+    mem_total: int,
+    swap_free: int,
+    swap_total: int,
+    arch: string,
+    cpus: int,
+    hostname: string,
+    kernel: string,
+    os: string,
+    uptime: string
+)
+
+# InfoGraphStatus describes the detailed status of the graph
+type InfoGraphStatus (
+    backing_filesystem: string,
+    native_overlay_diff: string,
+    supports_d_type: string
+)
+
+# InfoStore describes the host's storage informatoin
+type InfoStore (
+    containers: int,
+    images: int,
+    graph_driver_name: string,
+    graph_driver_options: string,
+    graph_root: string,
+    graph_status: InfoGraphStatus,
+    run_root: string
+)
+
+# InfoPodman provides details on the podman binary
+type InfoPodmanBinary (
+    compiler: string,
+    go_version: string,
+    podman_version: string,
+    git_commit: string
+)
+
+# PodmanInfo describes the Podman host and build
+type PodmanInfo (
+    host: InfoHost,
+    registries: []string,
+    insecure_registries: []string,
+    store: InfoStore,
+    podman: InfoPodmanBinary
+)
+
 # Ping provides a response for developers to ensure their varlink setup is working.
 # #### Example
 # ~~~
@@ -2403,6 +2543,9 @@ method Ping() -> (ping: StringResponse)
 # system.
 method GetVersion() -> (version: Version)
 
+# GetInfo returns a [PodmanInfo](#PodmanInfo) struct that describes podman and its host such as storage stats,
+# build information of Podman, and system-wide registries.
+method GetInfo() -> (info: PodmanInfo)
 
 # ListContainers returns a list of containers in no particular order.  There are
 # returned as an array of ListContainerData structs.  See also [GetContainer](#GetContainer).