@@ -63,8 +63,7 @@ type ContainerAPIClient interface {

 	ContainerDiff(ctx context.Context, container string, options ContainerDiffOptions) (ContainerDiffResult, error)

 	ExecAPIClient

 	ContainerExport(ctx context.Context, container string) (io.ReadCloser, error)

-	ContainerInspect(ctx context.Context, container string) (container.InspectResponse, error)

-	ContainerInspectWithRaw(ctx context.Context, container string, getSize bool) (container.InspectResponse, []byte, error)

+	ContainerInspect(ctx context.Context, container string, options ContainerInspectOptions) (ContainerInspectResult, error)

 	ContainerKill(ctx context.Context, container, signal string) error

 	ContainerList(ctx context.Context, options ContainerListOptions) ([]container.Summary, error)

 	ContainerLogs(ctx context.Context, container string, options ContainerLogsOptions) (io.ReadCloser, error)

@@ -1,57 +1,47 @@

 package client

 import (

-	"bytes"

 	"context"

 	"encoding/json"

-	"io"

 	"net/url"

 	"github.com/moby/moby/api/types/container"

 )

-// ContainerInspect returns the container information.

-func (cli *Client) ContainerInspect(ctx context.Context, containerID string) (container.InspectResponse, error) {

-	containerID, err := trimID("container", containerID)

-	if err != nil {

-		return container.InspectResponse{}, err

-	}

-

-	resp, err := cli.get(ctx, "/containers/"+containerID+"/json", nil, nil)

-	defer ensureReaderClosed(resp)

-	if err != nil {

-		return container.InspectResponse{}, err

-	}

+// ContainerInspectOptions holds options for inspecting a container using

+// the [Client.ConfigInspect] method.

+type ContainerInspectOptions struct {

+	// Size controls whether the container's filesystem size should be calculated.

+	// When set, the [container.InspectResponse.SizeRw] and [container.InspectResponse.SizeRootFs]

+	// fields in [ContainerInspectResult.Container] are populated with the result.

+	//

+	// Calculating the size can be a costly operation, and should not be used

+	// unless needed.

+	Size bool

+}

-	var response container.InspectResponse

-	err = json.NewDecoder(resp.Body).Decode(&response)

-	return response, err

+// ContainerInspectResult holds the result from the [Client.ConfigInspect] method.

+type ContainerInspectResult struct {

+	Container container.InspectResponse

+	Raw       json.RawMessage

 }

-// ContainerInspectWithRaw returns the container information and its raw representation.

-func (cli *Client) ContainerInspectWithRaw(ctx context.Context, containerID string, getSize bool) (container.InspectResponse, []byte, error) {

+// ContainerInspect returns the container information.

+func (cli *Client) ContainerInspect(ctx context.Context, containerID string, options ContainerInspectOptions) (ContainerInspectResult, error) {

 	containerID, err := trimID("container", containerID)

 	if err != nil {

-		return container.InspectResponse{}, nil, err

+		return ContainerInspectResult{}, err

 	}

 	query := url.Values{}

-	if getSize {

+	if options.Size {

 		query.Set("size", "1")

 	}

 	resp, err := cli.get(ctx, "/containers/"+containerID+"/json", query, nil)

-	defer ensureReaderClosed(resp)

-	if err != nil {

-		return container.InspectResponse{}, nil, err

-	}

-

-	body, err := io.ReadAll(resp.Body)

 	if err != nil {

-		return container.InspectResponse{}, nil, err

+		return ContainerInspectResult{}, err

 	}

-

-	var response container.InspectResponse

-	rdr := bytes.NewReader(body)

-	err = json.NewDecoder(rdr).Decode(&response)

-	return response, body, err

+	var out ContainerInspectResult

+	out.Raw, err = decodeWithRaw(resp, &out.Container)

+	return out, err

 }

@@ -1,7 +1,6 @@

 package client

 import (

-	"context"

 	"errors"

 	"net/http"

 	"testing"

@@ -18,14 +17,14 @@ func TestContainerInspectError(t *testing.T) {

 	)

 	assert.NilError(t, err)

-	_, err = client.ContainerInspect(context.Background(), "nothing")

+	_, err = client.ContainerInspect(t.Context(), "nothing", ContainerInspectOptions{})

 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))

-	_, err = client.ContainerInspect(context.Background(), "")

+	_, err = client.ContainerInspect(t.Context(), "", ContainerInspectOptions{})

 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))

 	assert.Check(t, is.ErrorContains(err, "value is empty"))

-	_, err = client.ContainerInspect(context.Background(), "    ")

+	_, err = client.ContainerInspect(t.Context(), "    ", ContainerInspectOptions{})

 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))

 	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

@@ -36,7 +35,7 @@ func TestContainerInspectContainerNotFound(t *testing.T) {

 	)

 	assert.NilError(t, err)

-	_, err = client.ContainerInspect(context.Background(), "unknown")

+	_, err = client.ContainerInspect(t.Context(), "unknown", ContainerInspectOptions{})

 	assert.Check(t, is.ErrorType(err, cerrdefs.IsNotFound))

 }

@@ -48,19 +47,11 @@ func TestContainerInspectWithEmptyID(t *testing.T) {

 	)

 	assert.NilError(t, err)

-	_, err = client.ContainerInspect(context.Background(), "")

+	_, err = client.ContainerInspect(t.Context(), "", ContainerInspectOptions{})

 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))

 	assert.Check(t, is.ErrorContains(err, "value is empty"))

-	_, err = client.ContainerInspect(context.Background(), "    ")

-	assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))

-	assert.Check(t, is.ErrorContains(err, "value is empty"))

-

-	_, _, err = client.ContainerInspectWithRaw(context.Background(), "", false)

-	assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))

-	assert.Check(t, is.ErrorContains(err, "value is empty"))

-

-	_, _, err = client.ContainerInspectWithRaw(context.Background(), "    ", false)

+	_, err = client.ContainerInspect(t.Context(), "    ", ContainerInspectOptions{})

 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))

 	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

@@ -81,9 +72,9 @@ func TestContainerInspect(t *testing.T) {

 	)

 	assert.NilError(t, err)

-	r, err := client.ContainerInspect(context.Background(), "container_id")

+	res, err := client.ContainerInspect(t.Context(), "container_id", ContainerInspectOptions{})

 	assert.NilError(t, err)

-	assert.Check(t, is.Equal(r.ID, "container_id"))

-	assert.Check(t, is.Equal(r.Image, "image"))

-	assert.Check(t, is.Equal(r.Name, "name"))

+	assert.Check(t, is.Equal(res.Container.ID, "container_id"))

+	assert.Check(t, is.Equal(res.Container.Image, "image"))

+	assert.Check(t, is.Equal(res.Container.Name, "name"))

 }

@@ -593,10 +593,10 @@ func UtilCreateNetworkMode(t *testing.T, networkMode container.NetworkMode) {

 	})

 	assert.NilError(t, err)

-	containerJSON, err := apiClient.ContainerInspect(testutil.GetContext(t), ctr.ID)

+	res, err := apiClient.ContainerInspect(testutil.GetContext(t), ctr.ID, client.ContainerInspectOptions{})

 	assert.NilError(t, err)

-	assert.Equal(t, containerJSON.HostConfig.NetworkMode, networkMode, "Mismatched NetworkMode")

+	assert.Equal(t, res.Container.HostConfig.NetworkMode, networkMode, "Mismatched NetworkMode")

 }

 func (s *DockerAPISuite) TestContainerAPICreateWithCpuSharesCpuset(c *testing.T) {

@@ -624,13 +624,13 @@ func (s *DockerAPISuite) TestContainerAPICreateWithCpuSharesCpuset(c *testing.T)

 	})

 	assert.NilError(c, err)

-	containerJSON, err := apiClient.ContainerInspect(testutil.GetContext(c), ctr.ID)

+	res, err := apiClient.ContainerInspect(testutil.GetContext(c), ctr.ID, client.ContainerInspectOptions{})

 	assert.NilError(c, err)

-	out := inspectField(c, containerJSON.ID, "HostConfig.CpuShares")

+	out := inspectField(c, res.Container.ID, "HostConfig.CpuShares")

 	assert.Equal(c, out, "512")

-	outCpuset := inspectField(c, containerJSON.ID, "HostConfig.CpusetCpus")

+	outCpuset := inspectField(c, res.Container.ID, "HostConfig.CpusetCpus")

 	assert.Equal(c, outCpuset, "0")

 }

@@ -913,10 +913,10 @@ func (s *DockerAPISuite) TestContainerAPIDeleteRemoveVolume(c *testing.T) {

 	assert.NilError(c, err)

 	defer apiClient.Close()

-	ctrInspect, err := apiClient.ContainerInspect(testutil.GetContext(c), id)

+	res, err := apiClient.ContainerInspect(testutil.GetContext(c), id, client.ContainerInspectOptions{})

 	assert.NilError(c, err)

-	assert.Assert(c, is.Len(ctrInspect.Mounts, 1), "expected to have 1 mount")

-	mnt := ctrInspect.Mounts[0]

+	assert.Assert(c, is.Len(res.Container.Mounts, 1), "expected to have 1 mount")

+	mnt := res.Container.Mounts[0]

 	assert.Equal(c, mnt.Destination, testVol)

 	_, err = os.Stat(mnt.Source)

@@ -949,7 +949,7 @@ func (s *DockerAPISuite) TestContainerAPIChunkedEncoding(c *testing.T) {

 		req.ContentLength = -1

 		return nil

 	}))

-	assert.Assert(c, err == nil, "error creating container with chunked encoding")

+	assert.NilError(c, err, "error creating container with chunked encoding")

 	defer resp.Body.Close()

 	assert.Equal(c, resp.StatusCode, http.StatusCreated)

 }

@@ -1057,10 +1057,10 @@ func (s *DockerAPISuite) TestPostContainersCreateMemorySwappinessHostConfigOmitt

 	})

 	assert.NilError(c, err)

-	containerJSON, err := apiClient.ContainerInspect(testutil.GetContext(c), ctr.ID)

+	res, err := apiClient.ContainerInspect(testutil.GetContext(c), ctr.ID, client.ContainerInspectOptions{})

 	assert.NilError(c, err)

-	assert.Assert(c, is.Nil(containerJSON.HostConfig.MemorySwappiness))

+	assert.Assert(c, is.Nil(res.Container.HostConfig.MemorySwappiness))

 }

 // check validation is done daemon side and not only in cli

@@ -1660,9 +1660,9 @@ func (s *DockerAPISuite) TestContainersAPICreateMountsCreate(c *testing.T) {

 				})

 			assert.NilError(c, err)

-			containerInspect, err := apiclient.ContainerInspect(ctx, ctr.ID)

+			res, err := apiclient.ContainerInspect(ctx, ctr.ID, client.ContainerInspectOptions{})

 			assert.NilError(c, err)

-			mps := containerInspect.Mounts

+			mps := res.Container.Mounts

 			assert.Assert(c, is.Len(mps, 1))

 			mountPoint := mps[0]

@@ -1713,13 +1713,13 @@ func (s *DockerAPISuite) TestContainersAPICreateMountsCreate(c *testing.T) {

 func containerExit(ctx context.Context, apiclient client.APIClient, name string) func(poll.LogT) poll.Result {

 	return func(logT poll.LogT) poll.Result {

-		ctr, err := apiclient.ContainerInspect(ctx, name)

+		res, err := apiclient.ContainerInspect(ctx, name, client.ContainerInspectOptions{})

 		if err != nil {

 			return poll.Error(err)

 		}

-		switch ctr.State.Status {

+		switch s := res.Container.State.Status; s {

 		case container.StateCreated, container.StateRunning:

-			return poll.Continue("container %s is %s, waiting for exit", name, ctr.State.Status)

+			return poll.Continue("container %s is %s, waiting for exit", name, s)

 		case container.StatePaused, container.StateRestarting, container.StateRemoving, container.StateExited, container.StateDead:

 			// done

 		}

@@ -10,6 +10,7 @@ import (

 	"strings"

 	"testing"

+	"github.com/moby/moby/client"

 	"github.com/moby/moby/v2/integration-cli/cli"

 	"github.com/moby/moby/v2/internal/testutil"

 	"gotest.tools/v3/assert"

@@ -190,14 +191,14 @@ func assertPortList(t *testing.T, out string, expected []string) {

 }

 func assertPortRange(ctx context.Context, id string, expectedTCP, expectedUDP []int) error {

-	client := testEnv.APIClient()

-	inspect, err := client.ContainerInspect(ctx, id)

+	apiClient := testEnv.APIClient()

+	res, err := apiClient.ContainerInspect(ctx, id, client.ContainerInspectOptions{})

 	if err != nil {

 		return err

 	}

 	var validTCP, validUDP bool

-	for port, binding := range inspect.NetworkSettings.Ports {

+	for port, binding := range res.Container.NetworkSettings.Ports {

 		if port.Proto() == "tcp" && len(expectedTCP) == 0 {

 			continue

 		}

@@ -3689,10 +3689,10 @@ func (s *DockerCLIRunSuite) TestRunNamedVolumesFromNotRemoved(c *testing.T) {

 	assert.NilError(c, err)

 	defer apiClient.Close()

-	container, err := apiClient.ContainerInspect(testutil.GetContext(c), strings.TrimSpace(cid))

+	inspect, err := apiClient.ContainerInspect(testutil.GetContext(c), strings.TrimSpace(cid), client.ContainerInspectOptions{})

 	assert.NilError(c, err)

 	var vname string

-	for _, v := range container.Mounts {

+	for _, v := range inspect.Container.Mounts {

 		if v.Name != "test" {

 			vname = v.Name

 		}

@@ -1560,9 +1560,9 @@ func (s *DockerCLIRunSuite) TestRunWithNanoCPUs(c *testing.T) {

 	clt, err := client.NewClientWithOpts(client.FromEnv)

 	assert.NilError(c, err)

-	inspect, err := clt.ContainerInspect(testutil.GetContext(c), "test")

+	res, err := clt.ContainerInspect(testutil.GetContext(c), "test", client.ContainerInspectOptions{})

 	assert.NilError(c, err)

-	assert.Equal(c, inspect.HostConfig.NanoCPUs, int64(500000000))

+	assert.Equal(c, res.Container.HostConfig.NanoCPUs, int64(500000000))

 	out = inspectField(c, "test", "HostConfig.CpuQuota")

 	assert.Equal(c, out, "0", "CPU CFS quota should be 0")

@@ -266,9 +266,9 @@ func (s *DockerCLIUpdateSuite) TestUpdateWithNanoCPUs(c *testing.T) {

 	clt, err := client.NewClientWithOpts(client.FromEnv)

 	assert.NilError(c, err)

-	inspect, err := clt.ContainerInspect(testutil.GetContext(c), "top")

+	res, err := clt.ContainerInspect(testutil.GetContext(c), "top", client.ContainerInspectOptions{})

 	assert.NilError(c, err)

-	assert.Equal(c, inspect.HostConfig.NanoCPUs, int64(500000000))

+	assert.Equal(c, res.Container.HostConfig.NanoCPUs, int64(500000000))

 	out = inspectField(c, "top", "HostConfig.CpuQuota")

 	assert.Equal(c, out, "0", "CPU CFS quota should be 0")

@@ -280,9 +280,9 @@ func (s *DockerCLIUpdateSuite) TestUpdateWithNanoCPUs(c *testing.T) {

 	assert.Assert(c, is.Contains(out, "Conflicting options: CPU Quota cannot be updated as NanoCPUs has already been set"))

 	cli.DockerCmd(c, "update", "--cpus", "0.8", "top")

-	inspect, err = clt.ContainerInspect(testutil.GetContext(c), "top")

+	res, err = clt.ContainerInspect(testutil.GetContext(c), "top", client.ContainerInspectOptions{})

 	assert.NilError(c, err)

-	assert.Equal(c, inspect.HostConfig.NanoCPUs, int64(800000000))

+	assert.Equal(c, res.Container.HostConfig.NanoCPUs, int64(800000000))

 	out = inspectField(c, "top", "HostConfig.CpuQuota")

 	assert.Equal(c, out, "0", "CPU CFS quota should be 0")

@@ -251,14 +251,14 @@ func waitInspect(name, expr, expected string, timeout time.Duration) error {

 	return daemon.WaitInspectWithArgs(dockerBinary, name, expr, expected, timeout)

 }

-func getInspectBody(t *testing.T, version, id string) []byte {

+func getInspectBody(t *testing.T, version, id string) json.RawMessage {

 	t.Helper()

 	apiClient, err := client.NewClientWithOpts(client.FromEnv, client.WithVersion(version))

 	assert.NilError(t, err)

 	defer apiClient.Close()

-	_, body, err := apiClient.ContainerInspectWithRaw(testutil.GetContext(t), id, false)

+	inspect, err := apiClient.ContainerInspect(testutil.GetContext(t), id, client.ContainerInspectOptions{})

 	assert.NilError(t, err)

-	return body

+	return inspect.Raw

 }

 // Run a long running idle task in a background container using the

@@ -42,7 +42,7 @@ func TestCreateWithCDIDevices(t *testing.T) {

 	)

 	defer apiClient.ContainerRemove(ctx, id, client.ContainerRemoveOptions{Force: true})

-	inspect, err := apiClient.ContainerInspect(ctx, id)

+	res, err := apiClient.ContainerInspect(ctx, id, client.ContainerInspectOptions{})

 	assert.NilError(t, err)

 	expectedRequests := []containertypes.DeviceRequest{

@@ -51,7 +51,7 @@ func TestCreateWithCDIDevices(t *testing.T) {

 			DeviceIDs: []string{"vendor1.com/device=foo"},

 		},

 	}

-	assert.Check(t, is.DeepEqual(inspect.HostConfig.DeviceRequests, expectedRequests))

+	assert.Check(t, is.DeepEqual(res.Container.HostConfig.DeviceRequests, expectedRequests))

 	poll.WaitOn(t, container.IsStopped(ctx, apiClient, id))

 	reader, err := apiClient.ContainerLogs(ctx, id, client.ContainerLogsOptions{

@@ -73,9 +73,9 @@ func TestCheckpoint(t *testing.T) {

 	}

 	assert.NilError(t, err)

-	inspect, err := apiClient.ContainerInspect(ctx, cID)

+	inspect, err := apiClient.ContainerInspect(ctx, cID, client.ContainerInspectOptions{})

 	assert.NilError(t, err)

-	assert.Check(t, is.Equal(true, inspect.State.Running))

+	assert.Check(t, is.Equal(true, inspect.Container.State.Running))

 	res, err := apiClient.CheckpointList(ctx, cID, client.CheckpointListOptions{})

 	assert.NilError(t, err)

@@ -98,9 +98,9 @@ func TestCheckpoint(t *testing.T) {

 	poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, containertypes.StateExited))

-	inspect, err = apiClient.ContainerInspect(ctx, cID)

+	inspect, err = apiClient.ContainerInspect(ctx, cID, client.ContainerInspectOptions{})

 	assert.NilError(t, err)

-	assert.Check(t, is.Equal(false, inspect.State.Running))

+	assert.Check(t, is.Equal(false, inspect.Container.State.Running))

 	// Check that both checkpoints are listed.

 	res, err = apiClient.CheckpointList(ctx, cID, client.CheckpointListOptions{})

@@ -121,9 +121,9 @@ func TestCheckpoint(t *testing.T) {

 	})

 	assert.NilError(t, err)

-	inspect, err = apiClient.ContainerInspect(ctx, cID)

+	inspect, err = apiClient.ContainerInspect(ctx, cID, client.ContainerInspectOptions{})

 	assert.NilError(t, err)

-	assert.Check(t, is.Equal(true, inspect.State.Running))

+	assert.Check(t, is.Equal(true, inspect.Container.State.Running))

 	// Check that the test file has been restored.

 	cmd = []string{"test", "-f", "/tmp/test-file"}

@@ -295,9 +295,9 @@ func TestCreateWithCustomMaskedPaths(t *testing.T) {

 			})

 			assert.NilError(t, err)

-			ctrInspect, err := apiClient.ContainerInspect(ctx, ctr.ID)

+			inspect, err := apiClient.ContainerInspect(ctx, ctr.ID, client.ContainerInspectOptions{})

 			assert.NilError(t, err)

-			assert.DeepEqual(t, ctrInspect.HostConfig.MaskedPaths, tc.expected)

+			assert.DeepEqual(t, inspect.Container.HostConfig.MaskedPaths, tc.expected)

 			// Start the container.

 			err = apiClient.ContainerStart(ctx, ctr.ID, client.ContainerStartOptions{})

@@ -307,9 +307,9 @@ func TestCreateWithCustomMaskedPaths(t *testing.T) {

 			err = apiClient.ContainerStop(ctx, ctr.ID, client.ContainerStopOptions{})

 			assert.NilError(t, err)

-			ctrInspect, err = apiClient.ContainerInspect(ctx, ctr.ID)

+			inspect, err = apiClient.ContainerInspect(ctx, ctr.ID, client.ContainerInspectOptions{})

 			assert.NilError(t, err)

-			assert.DeepEqual(t, ctrInspect.HostConfig.MaskedPaths, tc.expected)

+			assert.DeepEqual(t, inspect.Container.HostConfig.MaskedPaths, tc.expected)

 		})

 	}

 }

@@ -366,9 +366,9 @@ func TestCreateWithCustomReadonlyPaths(t *testing.T) {

 			})

 			assert.NilError(t, err)

-			ctrInspect, err := apiClient.ContainerInspect(ctx, ctr.ID)

+			ctrInspect, err := apiClient.ContainerInspect(ctx, ctr.ID, client.ContainerInspectOptions{})

 			assert.NilError(t, err)

-			assert.DeepEqual(t, ctrInspect.HostConfig.ReadonlyPaths, tc.expected)

+			assert.DeepEqual(t, ctrInspect.Container.HostConfig.ReadonlyPaths, tc.expected)

 			// Start the container.

 			err = apiClient.ContainerStart(ctx, ctr.ID, client.ContainerStartOptions{})

@@ -378,9 +378,9 @@ func TestCreateWithCustomReadonlyPaths(t *testing.T) {

 			err = apiClient.ContainerStop(ctx, ctr.ID, client.ContainerStopOptions{})

 			assert.NilError(t, err)

-			ctrInspect, err = apiClient.ContainerInspect(ctx, ctr.ID)

+			ctrInspect, err = apiClient.ContainerInspect(ctx, ctr.ID, client.ContainerInspectOptions{})

 			assert.NilError(t, err)

-			assert.DeepEqual(t, ctrInspect.HostConfig.ReadonlyPaths, tc.expected)

+			assert.DeepEqual(t, ctrInspect.Container.HostConfig.ReadonlyPaths, tc.expected)

 		})

 	}

 }

@@ -492,11 +492,11 @@ func TestCreateTmpfsOverrideAnonymousVolume(t *testing.T) {

 		assert.NilError(t, err)

 	}()

-	inspect, err := apiClient.ContainerInspect(ctx, id)

+	inspect, err := apiClient.ContainerInspect(ctx, id, client.ContainerInspectOptions{})

 	assert.NilError(t, err)

 	// tmpfs do not currently get added to inspect.Mounts

 	// Normally an anonymous volume would, except now tmpfs should prevent that.

-	assert.Assert(t, is.Len(inspect.Mounts, 0))

+	assert.Assert(t, is.Len(inspect.Container.Mounts, 0))

 	chWait, chErr := apiClient.ContainerWait(ctx, id, container.WaitConditionNextExit)

 	assert.NilError(t, apiClient.ContainerStart(ctx, id, client.ContainerStartOptions{}))

@@ -52,15 +52,15 @@ func TestContainerStartOnDaemonRestart(t *testing.T) {

 	err := c.ContainerStart(ctx, cID, client.ContainerStartOptions{})

 	assert.Check(t, err, "error starting test container")

-	inspect, err := c.ContainerInspect(ctx, cID)

+	inspect, err := c.ContainerInspect(ctx, cID, client.ContainerInspectOptions{})

 	assert.Check(t, err, "error getting inspect data")

-	ppid := getContainerdShimPid(t, inspect)

+	ppid := getContainerdShimPid(t, inspect.Container)

 	err = d.Kill()

 	assert.Check(t, err, "failed to kill test daemon")

-	err = unix.Kill(inspect.State.Pid, unix.SIGKILL)

+	err = unix.Kill(inspect.Container.State.Pid, unix.SIGKILL)

 	assert.Check(t, err, "failed to kill container process")

 	err = unix.Kill(ppid, unix.SIGKILL)

@@ -107,25 +107,25 @@ func TestDaemonRestartIpcMode(t *testing.T) {

 	)

 	defer c.ContainerRemove(ctx, cID, client.ContainerRemoveOptions{Force: true})

-	inspect, err := c.ContainerInspect(ctx, cID)

+	inspect, err := c.ContainerInspect(ctx, cID, client.ContainerInspectOptions{})

 	assert.NilError(t, err)

-	assert.Check(t, is.Equal(string(inspect.HostConfig.IpcMode), "private"))

+	assert.Check(t, is.Equal(string(inspect.Container.HostConfig.IpcMode), "private"))

 	// restart the daemon with shareable default ipc mode

 	d.Restart(t, "--iptables=false", "--ip6tables=false", "--default-ipc-mode=shareable")

 	// check the container is still having private ipc mode

-	inspect, err = c.ContainerInspect(ctx, cID)

+	inspect, err = c.ContainerInspect(ctx, cID, client.ContainerInspectOptions{})

 	assert.NilError(t, err)

-	assert.Check(t, is.Equal(string(inspect.HostConfig.IpcMode), "private"))

+	assert.Check(t, is.Equal(string(inspect.Container.HostConfig.IpcMode), "private"))

 	// check a new container is created with shareable ipc mode as per new daemon default

 	cID = container.Run(ctx, t, c)

 	defer c.ContainerRemove(ctx, cID, client.ContainerRemoveOptions{Force: true})

-	inspect, err = c.ContainerInspect(ctx, cID)

+	inspect, err = c.ContainerInspect(ctx, cID, client.ContainerInspectOptions{})

 	assert.NilError(t, err)

-	assert.Check(t, is.Equal(string(inspect.HostConfig.IpcMode), "shareable"))

+	assert.Check(t, is.Equal(string(inspect.Container.HostConfig.IpcMode), "shareable"))

 }

 // TestDaemonHostGatewayIP verifies that when a magic string "host-gateway" is passed

@@ -267,11 +267,11 @@ func TestHardRestartWhenContainerIsRunning(t *testing.T) {

 		ctx := testutil.StartSpan(ctx, t)

 		ctx, cancel := context.WithTimeout(ctx, 5*time.Second)

 		defer cancel()

-		inspect, err := apiClient.ContainerInspect(ctx, noPolicy)

+		inspect, err := apiClient.ContainerInspect(ctx, noPolicy, client.ContainerInspectOptions{})

 		assert.NilError(t, err)

-		assert.Check(t, is.Equal(inspect.State.Status, containertypes.StateExited))

-		assert.Check(t, is.Equal(inspect.State.ExitCode, 255))

-		finishedAt, err := time.Parse(time.RFC3339Nano, inspect.State.FinishedAt)

+		assert.Check(t, is.Equal(inspect.Container.State.Status, containertypes.StateExited))

+		assert.Check(t, is.Equal(inspect.Container.State.ExitCode, 255))

+		finishedAt, err := time.Parse(time.RFC3339Nano, inspect.Container.State.FinishedAt)

 		if assert.Check(t, err) {

 			assert.Check(t, is.DeepEqual(finishedAt, time.Now(), opt.TimeWithThreshold(time.Minute)))

 		}

@@ -281,11 +281,11 @@ func TestHardRestartWhenContainerIsRunning(t *testing.T) {

 		ctx := testutil.StartSpan(ctx, t)

 		ctx, cancel := context.WithTimeout(ctx, 5*time.Second)

 		defer cancel()

-		inspect, err := apiClient.ContainerInspect(ctx, onFailure)

+		inspect, err := apiClient.ContainerInspect(ctx, onFailure, client.ContainerInspectOptions{})

 		assert.NilError(t, err)

-		assert.Check(t, is.Equal(inspect.State.Status, containertypes.StateRunning))

-		assert.Check(t, is.Equal(inspect.State.ExitCode, 0))

-		finishedAt, err := time.Parse(time.RFC3339Nano, inspect.State.FinishedAt)

+		assert.Check(t, is.Equal(inspect.Container.State.Status, containertypes.StateRunning))

+		assert.Check(t, is.Equal(inspect.Container.State.ExitCode, 0))

+		finishedAt, err := time.Parse(time.RFC3339Nano, inspect.Container.State.FinishedAt)

 		if assert.Check(t, err) {

 			assert.Check(t, is.DeepEqual(finishedAt, time.Now(), opt.TimeWithThreshold(time.Minute)))

 		}

@@ -40,16 +40,16 @@ func TestContainerKillOnDaemonStart(t *testing.T) {

 		assert.NilError(t, err)

 	}()

-	inspect, err := apiClient.ContainerInspect(ctx, id)

+	inspect, err := apiClient.ContainerInspect(ctx, id, client.ContainerInspectOptions{})

 	assert.NilError(t, err)

-	assert.Assert(t, inspect.State.Running)

+	assert.Assert(t, inspect.Container.State.Running)

 	assert.NilError(t, d.Kill())

 	d.Start(t, "--iptables=false", "--ip6tables=false")

-	inspect, err = apiClient.ContainerInspect(ctx, id)

+	inspect, err = apiClient.ContainerInspect(ctx, id, client.ContainerInspectOptions{})

 	assert.Check(t, is.Nil(err))

-	assert.Assert(t, !inspect.State.Running)

+	assert.Assert(t, !inspect.Container.State.Running)

 }

 // When the daemon doesn't stop in a clean way (eg. it crashes, the host has a power failure, etc..), or if it's started

@@ -84,18 +84,18 @@ func TestNetworkStateCleanupOnDaemonStart(t *testing.T) {

 		assert.NilError(t, err)

 	}()

-	inspect, err := apiClient.ContainerInspect(ctx, cid)

+	inspect, err := apiClient.ContainerInspect(ctx, cid, client.ContainerInspectOptions{})

 	assert.NilError(t, err)

-	assert.Assert(t, inspect.NetworkSettings.SandboxID != "")

-	assert.Assert(t, inspect.NetworkSettings.SandboxKey != "")

-	assert.Assert(t, inspect.NetworkSettings.Ports[mappedPort] != nil)

+	assert.Assert(t, inspect.Container.NetworkSettings.SandboxID != "")

+	assert.Assert(t, inspect.Container.NetworkSettings.SandboxKey != "")

+	assert.Assert(t, inspect.Container.NetworkSettings.Ports[mappedPort] != nil)

 	assert.NilError(t, d.Kill())

 	d.Start(t)

-	inspect, err = apiClient.ContainerInspect(ctx, cid)

+	inspect, err = apiClient.ContainerInspect(ctx, cid, client.ContainerInspectOptions{})

 	assert.NilError(t, err)

-	assert.Assert(t, inspect.NetworkSettings.SandboxID == "")

-	assert.Assert(t, inspect.NetworkSettings.SandboxKey == "")

-	assert.Assert(t, is.Nil(inspect.NetworkSettings.Ports[mappedPort]))

+	assert.Assert(t, inspect.Container.NetworkSettings.SandboxID == "")

+	assert.Assert(t, inspect.Container.NetworkSettings.SandboxKey == "")

+	assert.Assert(t, is.Nil(inspect.Container.NetworkSettings.Ports[mappedPort]))

 }

@@ -131,13 +131,13 @@ func TestHealthStartInterval(t *testing.T) {

 		if ctxPoll.Err() != nil {

 			return poll.Error(ctxPoll.Err())

 		}

-		inspect, err := apiClient.ContainerInspect(ctxPoll, id)

+		inspect, err := apiClient.ContainerInspect(ctxPoll, id, client.ContainerInspectOptions{})

 		if err != nil {

 			return poll.Error(err)

 		}

-		if inspect.State.Health.Status != containertypes.Healthy {

-			if len(inspect.State.Health.Log) > 0 {

-				t.Log(inspect.State.Health.Log[len(inspect.State.Health.Log)-1])

+		if inspect.Container.State.Health.Status != containertypes.Healthy {

+			if len(inspect.Container.State.Health.Log) > 0 {

+				t.Log(inspect.Container.State.Health.Log[len(inspect.Container.State.Health.Log)-1])

 			}

 			return poll.Continue("waiting on container to be ready")

 		}

@@ -150,19 +150,19 @@ func TestHealthStartInterval(t *testing.T) {

 	dl, _ = ctxPoll.Deadline()

 	poll.WaitOn(t, func(log poll.LogT) poll.Result {

-		inspect, err := apiClient.ContainerInspect(ctxPoll, id)

+		inspect, err := apiClient.ContainerInspect(ctxPoll, id, client.ContainerInspectOptions{})

 		if err != nil {

 			return poll.Error(err)

 		}

-		hLen := len(inspect.State.Health.Log)

+		hLen := len(inspect.Container.State.Health.Log)

 		if hLen < 2 {

 			return poll.Continue("waiting for more healthcheck results")

 		}

-		h1 := inspect.State.Health.Log[hLen-1]

-		h2 := inspect.State.Health.Log[hLen-2]

-		if h1.Start.Sub(h2.Start) >= inspect.Config.Healthcheck.Interval {

+		h1 := inspect.Container.State.Health.Log[hLen-1]

+		h2 := inspect.Container.State.Health.Log[hLen-2]

+		if h1.Start.Sub(h2.Start) >= inspect.Container.Config.Healthcheck.Interval {

 			return poll.Success()

 		}

 		t.Log(h1.Start.Sub(h2.Start))

@@ -170,15 +170,15 @@ func TestHealthStartInterval(t *testing.T) {

 	}, poll.WithDelay(time.Second), poll.WithTimeout(time.Until(dl)))

 }

-func pollForHealthCheckLog(ctx context.Context, client client.APIClient, containerID string, expected string) func(log poll.LogT) poll.Result {

+func pollForHealthCheckLog(ctx context.Context, apiClient client.APIClient, containerID string, expected string) func(log poll.LogT) poll.Result {

 	return func(log poll.LogT) poll.Result {

-		inspect, err := client.ContainerInspect(ctx, containerID)

+		inspect, err := apiClient.ContainerInspect(ctx, containerID, client.ContainerInspectOptions{})

 		if err != nil {

 			return poll.Error(err)

 		}

-		healthChecksTotal := len(inspect.State.Health.Log)

+		healthChecksTotal := len(inspect.Container.State.Health.Log)

 		if healthChecksTotal > 0 {

-			output := inspect.State.Health.Log[healthChecksTotal-1].Output

+			output := inspect.Container.State.Health.Log[healthChecksTotal-1].Output

 			if output == expected {

 				return poll.Success()

 			}

@@ -188,14 +188,14 @@ func pollForHealthCheckLog(ctx context.Context, client client.APIClient, contain

 	}

 }

-func pollForHealthStatus(ctx context.Context, client client.APIClient, containerID string, healthStatus containertypes.HealthStatus) func(log poll.LogT) poll.Result {

+func pollForHealthStatus(ctx context.Context, apiClient client.APIClient, containerID string, healthStatus containertypes.HealthStatus) func(log poll.LogT) poll.Result {

 	return func(log poll.LogT) poll.Result {

-		inspect, err := client.ContainerInspect(ctx, containerID)

+		inspect, err := apiClient.ContainerInspect(ctx, containerID, client.ContainerInspectOptions{})

 		switch {

 		case err != nil:

 			return poll.Error(err)

-		case inspect.State.Health.Status == healthStatus:

+		case inspect.Container.State.Health.Status == healthStatus:

 			return poll.Success()

 		default:

 			return poll.Continue("waiting for container to become %s", healthStatus)

@@ -33,9 +33,9 @@ func TestInspectAnnotations(t *testing.T) {

 		},

 	)

-	inspect, err := apiClient.ContainerInspect(ctx, id)

+	inspect, err := apiClient.ContainerInspect(ctx, id, client.ContainerInspectOptions{})

 	assert.NilError(t, err)

-	assert.Check(t, is.DeepEqual(inspect.HostConfig.Annotations, annotations))

+	assert.Check(t, is.DeepEqual(inspect.Container.HostConfig.Annotations, annotations))

 }

 // TestNetworkAliasesAreEmpty verifies that network-scoped aliases are not set

@@ -165,12 +165,14 @@ func TestContainerInspectWithRaw(t *testing.T) {

 	}

 	for _, tc := range tests {

 		t.Run(tc.doc, func(t *testing.T) {

-			ctrInspect, raw, err := apiClient.ContainerInspectWithRaw(ctx, ctrID, tc.withSize)

+			inspect, err := apiClient.ContainerInspect(ctx, ctrID, client.ContainerInspectOptions{

+				Size: tc.withSize,

+			})

 			assert.NilError(t, err)

-			assert.Check(t, is.Equal(ctrInspect.ID, ctrID))

+			assert.Check(t, is.Equal(inspect.Container.ID, ctrID))

 			var rawInspect map[string]any

-			err = json.Unmarshal(raw, &rawInspect)

+			err = json.Unmarshal(inspect.Raw, &rawInspect)

 			assert.NilError(t, err, "Should produce valid JSON")

 			if tc.withSize {

@@ -179,12 +181,12 @@ func TestContainerInspectWithRaw(t *testing.T) {

 					// See https://github.com/moby/moby/blob/2837112c8ead55cdad36eaac61bafc713b4f669a/daemon/images/image_windows.go#L12-L16

 					t.Log("skip checking SizeRw, SizeRootFs on windows as it's not yet implemented")

 				} else {

-					if assert.Check(t, ctrInspect.SizeRw != nil) {

+					if assert.Check(t, inspect.Container.SizeRw != nil) {

 						// RW-layer size can be zero.

-						assert.Check(t, *ctrInspect.SizeRw >= 0, "Should have a size: %d", *ctrInspect.SizeRw)

+						assert.Check(t, *inspect.Container.SizeRw >= 0, "Should have a size: %d", *inspect.Container.SizeRw)

 					}

-					if assert.Check(t, ctrInspect.SizeRootFs != nil) {

-						assert.Check(t, *ctrInspect.SizeRootFs > 0, "Should have a size: %d", *ctrInspect.SizeRootFs)

+					if assert.Check(t, inspect.Container.SizeRootFs != nil) {

+						assert.Check(t, *inspect.Container.SizeRootFs > 0, "Should have a size: %d", *inspect.Container.SizeRootFs)

 					}

 				}

@@ -193,12 +195,12 @@ func TestContainerInspectWithRaw(t *testing.T) {

 				_, ok = rawInspect["SizeRootFs"]

 				assert.Check(t, ok)

 			} else {

-				assert.Check(t, is.Nil(ctrInspect.SizeRw))

-				assert.Check(t, is.Nil(ctrInspect.SizeRootFs))

+				assert.Check(t, is.Nil(inspect.Container.SizeRw))

+				assert.Check(t, is.Nil(inspect.Container.SizeRootFs))

 				_, ok := rawInspect["SizeRw"]

-				assert.Check(t, !ok, "Should not contain SizeRw:\n%s", string(raw))

+				assert.Check(t, !ok, "Should not contain SizeRw:\n%s", string(inspect.Raw))

 				_, ok = rawInspect["SizeRootFs"]

-				assert.Check(t, !ok, "Should not contain SizeRootFs:\n%s", string(raw))

+				assert.Check(t, !ok, "Should not contain SizeRootFs:\n%s", string(inspect.Raw))

 			}

 		})

 	}

@@ -323,15 +323,15 @@ func TestIpcModeOlderClient(t *testing.T) {

 	// pre-check: default ipc mode in daemon is private

 	cID := container.Create(ctx, t, apiClient, container.WithAutoRemove)

-	inspect, err := apiClient.ContainerInspect(ctx, cID)

+	inspect, err := apiClient.ContainerInspect(ctx, cID, client.ContainerInspectOptions{})

 	assert.NilError(t, err)

-	assert.Check(t, is.Equal(string(inspect.HostConfig.IpcMode), "private"))

+	assert.Check(t, is.Equal(string(inspect.Container.HostConfig.IpcMode), "private"))

 	// main check: using older client creates "shareable" container

 	apiClient = request.NewAPIClient(t, client.WithVersion("1.39"))

 	cID = container.Create(ctx, t, apiClient, container.WithAutoRemove)

-	inspect, err = apiClient.ContainerInspect(ctx, cID)

+	inspect, err = apiClient.ContainerInspect(ctx, cID, client.ContainerInspectOptions{})

 	assert.NilError(t, err)

-	assert.Check(t, is.Equal(string(inspect.HostConfig.IpcMode), "shareable"))

+	assert.Check(t, is.Equal(string(inspect.Container.HostConfig.IpcMode), "shareable"))

 }

@@ -5,6 +5,7 @@ import (

 	"testing"

 	containertypes "github.com/moby/moby/api/types/container"

+	"github.com/moby/moby/client"

 	"github.com/moby/moby/v2/integration/internal/container"

 	"github.com/moby/moby/v2/internal/testutil"

 	"github.com/moby/moby/v2/internal/testutil/request"

@@ -160,9 +161,9 @@ func TestInspectOomKilledTrue(t *testing.T) {

 	poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, containertypes.StateExited))

-	inspect, err := apiClient.ContainerInspect(ctx, cID)

+	inspect, err := apiClient.ContainerInspect(ctx, cID, client.ContainerInspectOptions{})

 	assert.NilError(t, err)

-	assert.Check(t, is.Equal(true, inspect.State.OOMKilled))

+	assert.Check(t, is.Equal(true, inspect.Container.State.OOMKilled))

 }

 func TestInspectOomKilledFalse(t *testing.T) {

@@ -175,7 +176,7 @@ func TestInspectOomKilledFalse(t *testing.T) {

 	poll.WaitOn(t, container.IsInState(ctx, apiClient, cID, containertypes.StateExited))

-	inspect, err := apiClient.ContainerInspect(ctx, cID)

+	inspect, err := apiClient.ContainerInspect(ctx, cID, client.ContainerInspectOptions{})

 	assert.NilError(t, err)

-	assert.Check(t, is.Equal(false, inspect.State.OOMKilled))

+	assert.Check(t, is.Equal(false, inspect.Container.State.OOMKilled))

 }

@@ -207,15 +207,15 @@ func TestMountDaemonRoot(t *testing.T) {

 						}

 					}()

-					inspect, err := apiClient.ContainerInspect(ctx, c.ID)

+					inspect, err := apiClient.ContainerInspect(ctx, c.ID, client.ContainerInspectOptions{})

 					if err != nil {

 						t.Fatal(err)

 					}

-					if len(inspect.Mounts) != 1 {

-						t.Fatalf("unexpected number of mounts: %+v", inspect.Mounts)

+					if len(inspect.Container.Mounts) != 1 {

+						t.Fatalf("unexpected number of mounts: %+v", inspect.Container.Mounts)

 					}

-					m := inspect.Mounts[0]

+					m := inspect.Container.Mounts[0]

 					if m.Propagation != test.expected {

 						t.Fatalf("got unexpected propagation mode, expected %q, got: %v", test.expected, m.Propagation)

 					}

@@ -30,9 +30,9 @@ func TestPause(t *testing.T) {

 	err := apiClient.ContainerPause(ctx, cID)

 	assert.NilError(t, err)

-	inspect, err := apiClient.ContainerInspect(ctx, cID)

+	inspect, err := apiClient.ContainerInspect(ctx, cID, client.ContainerInspectOptions{})

 	assert.NilError(t, err)

-	assert.Check(t, is.Equal(true, inspect.State.Paused))

+	assert.Check(t, is.Equal(true, inspect.Container.State.Paused))

 	err = apiClient.ContainerUnpause(ctx, cID)

 	assert.NilError(t, err)

@@ -44,7 +44,7 @@ func TestRemoveContainerWithRemovedVolume(t *testing.T) {

 	})

 	assert.NilError(t, err)

-	_, err = apiClient.ContainerInspect(ctx, cID)

+	_, err = apiClient.ContainerInspect(ctx, cID, client.ContainerInspectOptions{})

 	assert.Check(t, is.ErrorType(err, cerrdefs.IsNotFound))

 	assert.Check(t, is.ErrorContains(err, "No such container"))

 }

@@ -58,10 +58,10 @@ func TestRemoveContainerWithVolume(t *testing.T) {

 	cID := container.Run(ctx, t, apiClient, container.WithVolume(prefix+slash+"srv"))

-	ctrInspect, err := apiClient.ContainerInspect(ctx, cID)

+	inspect, err := apiClient.ContainerInspect(ctx, cID, client.ContainerInspectOptions{})

 	assert.NilError(t, err)

-	assert.Check(t, is.Equal(1, len(ctrInspect.Mounts)))

-	volName := ctrInspect.Mounts[0].Name

+	assert.Check(t, is.Equal(1, len(inspect.Container.Mounts)))

+	volName := inspect.Container.Mounts[0].Name

 	_, err = apiClient.VolumeInspect(ctx, volName, client.VolumeInspectOptions{})

 	assert.NilError(t, err)

@@ -37,9 +37,9 @@ func TestRenameLinkedContainer(t *testing.T) {

 	bID = container.Run(ctx, t, apiClient, container.WithName(bName), container.WithLinks(aName))

-	inspect, err := apiClient.ContainerInspect(ctx, bID)

+	inspect, err := apiClient.ContainerInspect(ctx, bID, client.ContainerInspectOptions{})

 	assert.NilError(t, err)