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

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

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

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

-	ocispec "github.com/opencontainers/image-spec/specs-go/v1"

 )

 // APIClient is an interface that clients that talk with a docker server must implement.

@@ -58,10 +57,10 @@ type HijackDialer interface {

 // ContainerAPIClient defines API client methods for the containers

 type ContainerAPIClient interface {

-	ContainerAttach(ctx context.Context, container string, options ContainerAttachOptions) (HijackedResponse, error)

-	ContainerCommit(ctx context.Context, container string, options ContainerCommitOptions) (container.CommitResponse, error)

-	ContainerCreate(ctx context.Context, config *container.Config, hostConfig *container.HostConfig, networkingConfig *network.NetworkingConfig, platform *ocispec.Platform, containerName string) (container.CreateResponse, error)

-	ContainerDiff(ctx context.Context, container string) ([]container.FilesystemChange, error)

+	ContainerAttach(ctx context.Context, container string, options ContainerAttachOptions) (ContainerAttachResult, error)

+	ContainerCommit(ctx context.Context, container string, options ContainerCommitOptions) (ContainerCommitResult, error)

+	ContainerCreate(ctx context.Context, options ContainerCreateOptions) (ContainerCreateResult, error)

+	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)

@@ -16,6 +16,11 @@ type ContainerAttachOptions struct {

 	Logs       bool

 }

+// ContainerAttachResult is the result from attaching to a container.

+type ContainerAttachResult struct {

+	HijackedResponse

+}

+

 // ContainerAttach attaches a connection to a container in the server.

 // It returns a [HijackedResponse] with the hijacked connection

 // and a reader to get output. It's up to the called to close

@@ -44,10 +49,10 @@ type ContainerAttachOptions struct {

 // [stdcopy.StdType]: https://pkg.go.dev/github.com/moby/moby/api/pkg/stdcopy#StdType

 // [Stdout]: https://pkg.go.dev/github.com/moby/moby/api/pkg/stdcopy#Stdout

 // [Stderr]: https://pkg.go.dev/github.com/moby/moby/api/pkg/stdcopy#Stderr

-func (cli *Client) ContainerAttach(ctx context.Context, containerID string, options ContainerAttachOptions) (HijackedResponse, error) {

+func (cli *Client) ContainerAttach(ctx context.Context, containerID string, options ContainerAttachOptions) (ContainerAttachResult, error) {

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

 	if err != nil {

-		return HijackedResponse{}, err

+		return ContainerAttachResult{}, err

 	}

 	query := url.Values{}

@@ -70,7 +75,12 @@ func (cli *Client) ContainerAttach(ctx context.Context, containerID string, opti

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

 	}

-	return cli.postHijacked(ctx, "/containers/"+containerID+"/attach", query, nil, http.Header{

+	hijacked, err := cli.postHijacked(ctx, "/containers/"+containerID+"/attach", query, nil, http.Header{

 		"Content-Type": {"text/plain"},

 	})

+	if err != nil {

+		return ContainerAttachResult{}, err

+	}

+

+	return ContainerAttachResult{HijackedResponse: hijacked}, nil

 }

@@ -20,22 +20,27 @@ type ContainerCommitOptions struct {

 	Config    *container.Config

 }

+// ContainerCommitResult is the result from committing a container.

+type ContainerCommitResult struct {

+	ID string

+}

+

 // ContainerCommit applies changes to a container and creates a new tagged image.

-func (cli *Client) ContainerCommit(ctx context.Context, containerID string, options ContainerCommitOptions) (container.CommitResponse, error) {

+func (cli *Client) ContainerCommit(ctx context.Context, containerID string, options ContainerCommitOptions) (ContainerCommitResult, error) {

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

 	if err != nil {

-		return container.CommitResponse{}, err

+		return ContainerCommitResult{}, err

 	}

 	var repository, tag string

 	if options.Reference != "" {

 		ref, err := reference.ParseNormalizedNamed(options.Reference)

 		if err != nil {

-			return container.CommitResponse{}, err

+			return ContainerCommitResult{}, err

 		}

 		if _, ok := ref.(reference.Digested); ok {

-			return container.CommitResponse{}, errors.New("refusing to create a tag with a digest reference")

+			return ContainerCommitResult{}, errors.New("refusing to create a tag with a digest reference")

 		}

 		ref = reference.TagNameOnly(ref)

@@ -62,9 +67,9 @@ func (cli *Client) ContainerCommit(ctx context.Context, containerID string, opti

 	resp, err := cli.post(ctx, "/commit", query, options.Config, nil)

 	defer ensureReaderClosed(resp)

 	if err != nil {

-		return response, err

+		return ContainerCommitResult{}, err

 	}

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

-	return response, err

+	return ContainerCommitResult{ID: response.ID}, err

 }

@@ -10,49 +10,48 @@ import (

 	cerrdefs "github.com/containerd/errdefs"

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

-	"github.com/moby/moby/api/types/network"

 	ocispec "github.com/opencontainers/image-spec/specs-go/v1"

 )

 // ContainerCreate creates a new container based on the given configuration.

 // It can be associated with a name, but it's not mandatory.

-func (cli *Client) ContainerCreate(ctx context.Context, config *container.Config, hostConfig *container.HostConfig, networkingConfig *network.NetworkingConfig, platform *ocispec.Platform, containerName string) (container.CreateResponse, error) {

-	if config == nil {

-		return container.CreateResponse{}, cerrdefs.ErrInvalidArgument.WithMessage("config is nil")

+func (cli *Client) ContainerCreate(ctx context.Context, options ContainerCreateOptions) (ContainerCreateResult, error) {

+	if options.Config == nil {

+		return ContainerCreateResult{}, cerrdefs.ErrInvalidArgument.WithMessage("config is nil")

 	}

 	var response container.CreateResponse

-	if hostConfig != nil {

-		hostConfig.CapAdd = normalizeCapabilities(hostConfig.CapAdd)

-		hostConfig.CapDrop = normalizeCapabilities(hostConfig.CapDrop)

+	if options.HostConfig != nil {

+		options.HostConfig.CapAdd = normalizeCapabilities(options.HostConfig.CapAdd)

+		options.HostConfig.CapDrop = normalizeCapabilities(options.HostConfig.CapDrop)

 	}

 	query := url.Values{}

-	if platform != nil {

-		if p := formatPlatform(*platform); p != "unknown" {

+	if options.Platform != nil {

+		if p := formatPlatform(*options.Platform); p != "unknown" {

 			query.Set("platform", p)

 		}

 	}

-	if containerName != "" {

-		query.Set("name", containerName)

+	if options.ContainerName != "" {

+		query.Set("name", options.ContainerName)

 	}

 	body := container.CreateRequest{

-		Config:           config,

-		HostConfig:       hostConfig,

-		NetworkingConfig: networkingConfig,

+		Config:           options.Config,

+		HostConfig:       options.HostConfig,

+		NetworkingConfig: options.NetworkingConfig,

 	}

 	resp, err := cli.post(ctx, "/containers/create", query, body, nil)

 	defer ensureReaderClosed(resp)

 	if err != nil {

-		return response, err

+		return ContainerCreateResult{}, err

 	}

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

-	return response, err

+	return ContainerCreateResult{ID: response.ID, Warnings: response.Warnings}, err

 }

 // formatPlatform returns a formatted string representing platform (e.g., "linux/arm/v7").

new file mode 100644

@@ -0,0 +1,22 @@

+package client

+

+import (

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

+	"github.com/moby/moby/api/types/network"

+	ocispec "github.com/opencontainers/image-spec/specs-go/v1"

+)

+

+// ContainerCreateOptions holds parameters to create a container.

+type ContainerCreateOptions struct {

+	Config           *container.Config

+	HostConfig       *container.HostConfig

+	NetworkingConfig *network.NetworkingConfig

+	Platform         *ocispec.Platform

+	ContainerName    string

+}

+

+// ContainerCreateResult is the result from creating a container.

+type ContainerCreateResult struct {

+	ID       string

+	Warnings []string

+}

@@ -22,11 +22,11 @@ func TestContainerCreateError(t *testing.T) {

 	)

 	assert.NilError(t, err)

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

+	_, err = client.ContainerCreate(context.Background(), ContainerCreateOptions{Config: nil, ContainerName: "nothing"})

 	assert.Error(t, err, "config is nil")

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

-	_, err = client.ContainerCreate(context.Background(), &container.Config{}, nil, nil, nil, "nothing")

+	_, err = client.ContainerCreate(context.Background(), ContainerCreateOptions{Config: &container.Config{}, ContainerName: "nothing"})

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

 	// 404 doesn't automatically means an unknown image

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

 	)

 	assert.NilError(t, err)

-	_, err = client.ContainerCreate(context.Background(), &container.Config{}, nil, nil, nil, "nothing")

+	_, err = client.ContainerCreate(context.Background(), ContainerCreateOptions{Config: &container.Config{}, ContainerName: "nothing"})

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

 }

@@ -45,7 +45,7 @@ func TestContainerCreateImageNotFound(t *testing.T) {

 	)

 	assert.NilError(t, err)

-	_, err = client.ContainerCreate(context.Background(), &container.Config{Image: "unknown_image"}, nil, nil, nil, "unknown")

+	_, err = client.ContainerCreate(context.Background(), ContainerCreateOptions{Config: &container.Config{Image: "unknown_image"}, ContainerName: "unknown"})

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

 }

@@ -74,7 +74,7 @@ func TestContainerCreateWithName(t *testing.T) {

 	)

 	assert.NilError(t, err)

-	r, err := client.ContainerCreate(context.Background(), &container.Config{}, nil, nil, nil, "container_name")

+	r, err := client.ContainerCreate(context.Background(), ContainerCreateOptions{Config: &container.Config{}, ContainerName: "container_name"})

 	assert.NilError(t, err)

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

 }

@@ -103,7 +103,7 @@ func TestContainerCreateAutoRemove(t *testing.T) {

 	)

 	assert.NilError(t, err)

-	resp, err := client.ContainerCreate(context.Background(), &container.Config{}, &container.HostConfig{AutoRemove: true}, nil, nil, "")

+	resp, err := client.ContainerCreate(context.Background(), ContainerCreateOptions{Config: &container.Config{}, HostConfig: &container.HostConfig{AutoRemove: true}})

 	assert.NilError(t, err)

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

 }

@@ -116,7 +116,7 @@ func TestContainerCreateConnectionError(t *testing.T) {

 	client, err := NewClientWithOpts(WithAPIVersionNegotiation(), WithHost("tcp://no-such-host.invalid"))

 	assert.NilError(t, err)

-	_, err = client.ContainerCreate(context.Background(), &container.Config{}, nil, nil, nil, "")

+	_, err = client.ContainerCreate(context.Background(), ContainerCreateOptions{Config: &container.Config{}})

 	assert.Check(t, is.ErrorType(err, IsErrConnectionFailed))

 }

@@ -165,6 +165,6 @@ func TestContainerCreateCapabilities(t *testing.T) {

 	)

 	assert.NilError(t, err)

-	_, err = client.ContainerCreate(context.Background(), &container.Config{}, &container.HostConfig{CapAdd: inputCaps, CapDrop: inputCaps}, nil, nil, "")

+	_, err = client.ContainerCreate(context.Background(), ContainerCreateOptions{Config: &container.Config{}, HostConfig: &container.HostConfig{CapAdd: inputCaps, CapDrop: inputCaps}})

 	assert.NilError(t, err)

 }

@@ -9,22 +9,22 @@ import (

 )

 // ContainerDiff shows differences in a container filesystem since it was started.

-func (cli *Client) ContainerDiff(ctx context.Context, containerID string) ([]container.FilesystemChange, error) {

+func (cli *Client) ContainerDiff(ctx context.Context, containerID string, options ContainerDiffOptions) (ContainerDiffResult, error) {

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

 	if err != nil {

-		return nil, err

+		return ContainerDiffResult{}, err

 	}

 	resp, err := cli.get(ctx, "/containers/"+containerID+"/changes", url.Values{}, nil)

 	defer ensureReaderClosed(resp)

 	if err != nil {

-		return nil, err

+		return ContainerDiffResult{}, err

 	}

 	var changes []container.FilesystemChange

 	err = json.NewDecoder(resp.Body).Decode(&changes)

 	if err != nil {

-		return nil, err

+		return ContainerDiffResult{}, err

 	}

-	return changes, err

+	return ContainerDiffResult{Changes: changes}, err

 }

new file mode 100644

@@ -0,0 +1,13 @@

+package client

+

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

+

+// ContainerDiffOptions holds parameters to show differences in a container filesystem.

+type ContainerDiffOptions struct {

+	// Currently no options, but this allows for future extensibility

+}

+

+// ContainerDiffResult is the result from showing differences in a container filesystem.

+type ContainerDiffResult struct {

+	Changes []container.FilesystemChange

+}

@@ -20,14 +20,14 @@ func TestContainerDiffError(t *testing.T) {

 	)

 	assert.NilError(t, err)

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

+	_, err = client.ContainerDiff(context.Background(), "nothing", ContainerDiffOptions{})

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

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

+	_, err = client.ContainerDiff(context.Background(), "", ContainerDiffOptions{})

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

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

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

+	_, err = client.ContainerDiff(context.Background(), "    ", ContainerDiffOptions{})

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

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

 }

@@ -67,7 +67,7 @@ func TestContainerDiff(t *testing.T) {

 	)

 	assert.NilError(t, err)

-	changes, err := client.ContainerDiff(context.Background(), "container_id")

+	result, err := client.ContainerDiff(context.Background(), "container_id", ContainerDiffOptions{})

 	assert.NilError(t, err)

-	assert.Check(t, is.DeepEqual(changes, expected))

+	assert.Check(t, is.DeepEqual(result.Changes, expected))

 }

@@ -130,12 +130,12 @@ func (s *DockerAPISuite) TestContainerAPIGetChanges(c *testing.T) {

 	assert.NilError(c, err)

 	defer apiClient.Close()

-	changes, err := apiClient.ContainerDiff(testutil.GetContext(c), name)

+	result, err := apiClient.ContainerDiff(testutil.GetContext(c), name, client.ContainerDiffOptions{})

 	assert.NilError(c, err)

 	// Check the changelog for removal of /etc/passwd

 	success := false

-	for _, elem := range changes {

+	for _, elem := range result.Changes {

 		if elem.Path == "/etc/passwd" && elem.Kind == 2 {

 			success = true

 		}

@@ -517,7 +517,11 @@ func (s *DockerAPISuite) TestContainerAPIBadPort(c *testing.T) {

 	assert.NilError(c, err)

 	defer apiClient.Close()

-	_, err = apiClient.ContainerCreate(testutil.GetContext(c), &config, &hostConfig, &network.NetworkingConfig{}, nil, "")

+	_, err = apiClient.ContainerCreate(testutil.GetContext(c), client.ContainerCreateOptions{

+		Config:           &config,

+		HostConfig:       &hostConfig,

+		NetworkingConfig: &network.NetworkingConfig{},

+	})

 	assert.ErrorContains(c, err, `invalid port specification: "aa80"`)

 }

@@ -531,7 +535,11 @@ func (s *DockerAPISuite) TestContainerAPICreate(c *testing.T) {

 	assert.NilError(c, err)

 	defer apiClient.Close()

-	ctr, err := apiClient.ContainerCreate(testutil.GetContext(c), &config, &container.HostConfig{}, &network.NetworkingConfig{}, nil, "")

+	ctr, err := apiClient.ContainerCreate(testutil.GetContext(c), client.ContainerCreateOptions{

+		Config:           &config,

+		HostConfig:       &container.HostConfig{},

+		NetworkingConfig: &network.NetworkingConfig{},

+	})

 	assert.NilError(c, err)

 	out := cli.DockerCmd(c, "start", "-a", ctr.ID).Stdout()

@@ -543,7 +551,11 @@ func (s *DockerAPISuite) TestContainerAPICreateEmptyConfig(c *testing.T) {

 	assert.NilError(c, err)

 	defer apiClient.Close()

-	_, err = apiClient.ContainerCreate(testutil.GetContext(c), &container.Config{}, &container.HostConfig{}, &network.NetworkingConfig{}, nil, "")

+	_, err = apiClient.ContainerCreate(testutil.GetContext(c), client.ContainerCreateOptions{

+		Config:           &container.Config{},

+		HostConfig:       &container.HostConfig{},

+		NetworkingConfig: &network.NetworkingConfig{},

+	})

 	assert.ErrorContains(c, err, "no command specified")

 }

@@ -574,7 +586,11 @@ func UtilCreateNetworkMode(t *testing.T, networkMode container.NetworkMode) {

 	assert.NilError(t, err)

 	defer apiClient.Close()

-	ctr, err := apiClient.ContainerCreate(testutil.GetContext(t), &config, &hostConfig, &network.NetworkingConfig{}, nil, "")

+	ctr, err := apiClient.ContainerCreate(testutil.GetContext(t), client.ContainerCreateOptions{

+		Config:           &config,

+		HostConfig:       &hostConfig,

+		NetworkingConfig: &network.NetworkingConfig{},

+	})

 	assert.NilError(t, err)

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

@@ -601,7 +617,11 @@ func (s *DockerAPISuite) TestContainerAPICreateWithCpuSharesCpuset(c *testing.T)

 	assert.NilError(c, err)

 	defer apiClient.Close()

-	ctr, err := apiClient.ContainerCreate(testutil.GetContext(c), &config, &hostConfig, &network.NetworkingConfig{}, nil, "")

+	ctr, err := apiClient.ContainerCreate(testutil.GetContext(c), client.ContainerCreateOptions{

+		Config:           &config,

+		HostConfig:       &hostConfig,

+		NetworkingConfig: &network.NetworkingConfig{},

+	})

 	assert.NilError(c, err)

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

@@ -746,7 +766,12 @@ func (s *DockerAPISuite) TestContainerAPIStart(c *testing.T) {

 	assert.NilError(c, err)

 	defer apiClient.Close()

-	_, err = apiClient.ContainerCreate(testutil.GetContext(c), &config, &container.HostConfig{}, &network.NetworkingConfig{}, nil, name)

+	_, err = apiClient.ContainerCreate(testutil.GetContext(c), client.ContainerCreateOptions{

+		Config:           &config,

+		HostConfig:       &container.HostConfig{},

+		NetworkingConfig: &network.NetworkingConfig{},

+		ContainerName:    name,

+	})

 	assert.NilError(c, err)

 	err = apiClient.ContainerStart(testutil.GetContext(c), name, client.ContainerStartOptions{})

@@ -989,7 +1014,12 @@ func (s *DockerAPISuite) TestPostContainersCreateWithWrongCpusetValues(c *testin

 	}

 	const name = "wrong-cpuset-cpus"

-	_, err = apiClient.ContainerCreate(testutil.GetContext(c), &config, &hostConfig1, &network.NetworkingConfig{}, nil, name)

+	_, err = apiClient.ContainerCreate(testutil.GetContext(c), client.ContainerCreateOptions{

+		Config:           &config,

+		HostConfig:       &hostConfig1,

+		NetworkingConfig: &network.NetworkingConfig{},

+		ContainerName:    name,

+	})

 	expected := "Invalid value 1-42,, for cpuset cpus"

 	assert.ErrorContains(c, err, expected)

@@ -999,7 +1029,12 @@ func (s *DockerAPISuite) TestPostContainersCreateWithWrongCpusetValues(c *testin

 		},

 	}

 	const name2 = "wrong-cpuset-mems"

-	_, err = apiClient.ContainerCreate(testutil.GetContext(c), &config, &hostConfig2, &network.NetworkingConfig{}, nil, name2)

+	_, err = apiClient.ContainerCreate(testutil.GetContext(c), client.ContainerCreateOptions{

+		Config:           &config,

+		HostConfig:       &hostConfig2,

+		NetworkingConfig: &network.NetworkingConfig{},

+		ContainerName:    name2,

+	})

 	expected = "Invalid value 42-3,1-- for cpuset mems"

 	assert.ErrorContains(c, err, expected)

 }

@@ -1015,7 +1050,11 @@ func (s *DockerAPISuite) TestPostContainersCreateMemorySwappinessHostConfigOmitt

 	assert.NilError(c, err)

 	defer apiClient.Close()

-	ctr, err := apiClient.ContainerCreate(testutil.GetContext(c), &config, &container.HostConfig{}, &network.NetworkingConfig{}, nil, "")

+	ctr, err := apiClient.ContainerCreate(testutil.GetContext(c), client.ContainerCreateOptions{

+		Config:           &config,

+		HostConfig:       &container.HostConfig{},

+		NetworkingConfig: &network.NetworkingConfig{},

+	})

 	assert.NilError(c, err)

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

@@ -1042,7 +1081,12 @@ func (s *DockerAPISuite) TestPostContainersCreateWithOomScoreAdjInvalidRange(c *

 	defer apiClient.Close()

 	const name = "oomscoreadj-over"

-	_, err = apiClient.ContainerCreate(testutil.GetContext(c), &config, &hostConfig, &network.NetworkingConfig{}, nil, name)

+	_, err = apiClient.ContainerCreate(testutil.GetContext(c), client.ContainerCreateOptions{

+		Config:           &config,

+		HostConfig:       &hostConfig,

+		NetworkingConfig: &network.NetworkingConfig{},

+		ContainerName:    name,

+	})

 	expected := "Invalid value 1001, range for oom score adj is [-1000, 1000]"

 	assert.ErrorContains(c, err, expected)

@@ -1052,7 +1096,12 @@ func (s *DockerAPISuite) TestPostContainersCreateWithOomScoreAdjInvalidRange(c *

 	}

 	const name2 = "oomscoreadj-low"

-	_, err = apiClient.ContainerCreate(testutil.GetContext(c), &config, &hostConfig, &network.NetworkingConfig{}, nil, name2)

+	_, err = apiClient.ContainerCreate(testutil.GetContext(c), client.ContainerCreateOptions{

+		Config:           &config,

+		HostConfig:       &hostConfig,

+		NetworkingConfig: &network.NetworkingConfig{},

+		ContainerName:    name2,

+	})

 	expected = "Invalid value -1001, range for oom score adj is [-1000, 1000]"

 	assert.ErrorContains(c, err, expected)

@@ -1085,7 +1134,12 @@ func (s *DockerAPISuite) TestContainerAPIStatsWithNetworkDisabled(c *testing.T)

 	assert.NilError(c, err)

 	defer apiClient.Close()

-	_, err = apiClient.ContainerCreate(testutil.GetContext(c), &config, &container.HostConfig{}, &network.NetworkingConfig{}, nil, name)

+	_, err = apiClient.ContainerCreate(testutil.GetContext(c), client.ContainerCreateOptions{

+		Config:           &config,

+		HostConfig:       &container.HostConfig{},

+		NetworkingConfig: &network.NetworkingConfig{},

+		ContainerName:    name,

+	})

 	assert.NilError(c, err)

 	err = apiClient.ContainerStart(testutil.GetContext(c), name, client.ContainerStartOptions{})

@@ -1421,7 +1475,11 @@ func (s *DockerAPISuite) TestContainersAPICreateMountsValidation(c *testing.T) {

 	// TODO add checks for statuscode returned by API

 	for i, tc := range tests {

 		c.Run(fmt.Sprintf("case %d", i), func(c *testing.T) {

-			_, err = apiClient.ContainerCreate(testutil.GetContext(c), &tc.config, &tc.hostConfig, &network.NetworkingConfig{}, nil, "")

+			_, err = apiClient.ContainerCreate(testutil.GetContext(c), client.ContainerCreateOptions{

+				Config:           &tc.config,

+				HostConfig:       &tc.hostConfig,

+				NetworkingConfig: &network.NetworkingConfig{},

+			})

 			if tc.msg != "" {

 				assert.ErrorContains(c, err, tc.msg, "%v", tests[i].config)

 			} else {

@@ -1454,7 +1512,12 @@ func (s *DockerAPISuite) TestContainerAPICreateMountsBindRead(c *testing.T) {

 	assert.NilError(c, err)

 	defer apiClient.Close()

-	_, err = apiClient.ContainerCreate(testutil.GetContext(c), &config, &hostConfig, &network.NetworkingConfig{}, nil, "test")

+	_, err = apiClient.ContainerCreate(testutil.GetContext(c), client.ContainerCreateOptions{

+		Config:           &config,

+		HostConfig:       &hostConfig,

+		NetworkingConfig: &network.NetworkingConfig{},

+		ContainerName:    "test",

+	})

 	assert.NilError(c, err)

 	out := cli.DockerCmd(c, "start", "-a", "test").Combined()

@@ -1590,11 +1653,11 @@ func (s *DockerAPISuite) TestContainersAPICreateMountsCreate(c *testing.T) {

 		c.Run(fmt.Sprintf("%d config: %v", i, tc.spec), func(c *testing.T) {

 			ctr, err := apiclient.ContainerCreate(

 				ctx,

-				&container.Config{Image: testImg},

-				&container.HostConfig{Mounts: []mount.Mount{tc.spec}},

-				&network.NetworkingConfig{},

-				nil,

-				"")

+				client.ContainerCreateOptions{

+					Config:           &container.Config{Image: testImg},

+					HostConfig:       &container.HostConfig{Mounts: []mount.Mount{tc.spec}},

+					NetworkingConfig: &network.NetworkingConfig{},

+				})

 			assert.NilError(c, err)

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

@@ -1705,7 +1768,12 @@ func (s *DockerAPISuite) TestContainersAPICreateMountsTmpfs(c *testing.T) {

 			Mounts: []mount.Mount{x.cfg},

 		}

-		_, err = apiClient.ContainerCreate(testutil.GetContext(c), &config, &hostConfig, &network.NetworkingConfig{}, nil, cName)

+		_, err = apiClient.ContainerCreate(testutil.GetContext(c), client.ContainerCreateOptions{

+			Config:           &config,

+			HostConfig:       &hostConfig,

+			NetworkingConfig: &network.NetworkingConfig{},

+			ContainerName:    cName,

+		})

 		assert.NilError(c, err)

 		out := cli.DockerCmd(c, "start", "-a", cName).Combined()

 		for _, option := range x.expectedOptions {

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

 	"github.com/Microsoft/go-winio"

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

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

+	"github.com/moby/moby/api/types/network"

 	"github.com/moby/moby/client"

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

 	"github.com/pkg/errors"

@@ -51,19 +52,23 @@ func (s *DockerAPISuite) TestContainersAPICreateMountsBindNamedPipe(c *testing.T

 	ctx := testutil.GetContext(c)

 	apiClient := testEnv.APIClient()

 	_, err = apiClient.ContainerCreate(ctx,

-		&container.Config{

-			Image: testEnv.PlatformDefaults.BaseImage,

-			Cmd:   []string{"cmd", "/c", cmd},

-		}, &container.HostConfig{

-			Mounts: []mount.Mount{

-				{

-					Type:   "npipe",

-					Source: hostPipeName,

-					Target: containerPipeName,

+		client.ContainerCreateOptions{

+			Config: &container.Config{

+				Image: testEnv.PlatformDefaults.BaseImage,

+				Cmd:   []string{"cmd", "/c", cmd},

+			},

+			HostConfig: &container.HostConfig{

+				Mounts: []mount.Mount{

+					{

+						Type:   "npipe",

+						Source: hostPipeName,

+						Target: containerPipeName,

+					},

 				},

 			},

-		},

-		nil, nil, name)

+			NetworkingConfig: &network.NetworkingConfig{},

+			ContainerName:    name,

+		})

 	assert.NilError(c, err)

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

@@ -596,7 +596,12 @@ func (s *DockerCLIVolumeSuite) TestDuplicateMountpointsForVolumesFromAndMounts(c

 			},

 		},

 	}

-	_, err = apiClient.ContainerCreate(testutil.GetContext(c), &config, &hostConfig, &network.NetworkingConfig{}, nil, "app")

+	_, err = apiClient.ContainerCreate(testutil.GetContext(c), client.ContainerCreateOptions{

+		Config:           &config,

+		HostConfig:       &hostConfig,

+		NetworkingConfig: &network.NetworkingConfig{},

+		ContainerName:    "app",

+	})

 	assert.NilError(c, err)

@@ -41,17 +41,15 @@ func TestAttach(t *testing.T) {

 			t.Parallel()

 			ctx := testutil.StartSpan(ctx, t)

-			resp, err := apiClient.ContainerCreate(ctx,

-				&container.Config{

+			resp, err := apiClient.ContainerCreate(ctx, client.ContainerCreateOptions{

+				Config: &container.Config{

 					Image: "busybox",

 					Cmd:   []string{"echo", "hello"},

 					Tty:   tc.tty,

 				},

-				&container.HostConfig{},

-				&network.NetworkingConfig{},

-				nil,

-				"",

-			)

+				HostConfig:       &container.HostConfig{},

+				NetworkingConfig: &network.NetworkingConfig{},

+			})

 			assert.NilError(t, err)

 			attach, err := apiClient.ContainerAttach(ctx, resp.ID, client.ContainerAttachOptions{

 				Stdout: true,

@@ -81,16 +79,14 @@ func TestAttachDisconnectLeak(t *testing.T) {

 	apiClient := d.NewClientT(t)

-	resp, err := apiClient.ContainerCreate(ctx,

-		&container.Config{

+	resp, err := apiClient.ContainerCreate(ctx, client.ContainerCreateOptions{

+		Config: &container.Config{

 			Image: "busybox",

 			Cmd:   []string{"/bin/sh", "-c", "while true; usleep 100000; done"},

 		},

-		&container.HostConfig{},

-		&network.NetworkingConfig{},

-		nil,

-		"",

-	)

+		HostConfig:       &container.HostConfig{},

+		NetworkingConfig: &network.NetworkingConfig{},

+	})

 	assert.NilError(t, err)

 	cID := resp.ID

 	defer apiClient.ContainerRemove(ctx, cID, client.ContainerRemoveOptions{

@@ -59,13 +59,11 @@ func TestCreateFailsWhenIdentifierDoesNotExist(t *testing.T) {

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

 			t.Parallel()

 			ctx := testutil.StartSpan(ctx, t)

-			_, err := apiClient.ContainerCreate(ctx,

-				&container.Config{Image: tc.image},

-				&container.HostConfig{},

-				&network.NetworkingConfig{},

-				nil,

-				"",

-			)

+			_, err := apiClient.ContainerCreate(ctx, client.ContainerCreateOptions{

+				Config:           &container.Config{Image: tc.image},

+				HostConfig:       &container.HostConfig{},

+				NetworkingConfig: &network.NetworkingConfig{},

+			})

 			assert.Check(t, is.ErrorContains(err, tc.expectedError))

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

 		})

@@ -125,15 +123,11 @@ func TestCreateByImageID(t *testing.T) {

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

 			t.Parallel()

 			ctx := testutil.StartSpan(ctx, t)

-			resp, err := apiClient.ContainerCreate(ctx,

-				&container.Config{Image: tc.image},

-				&container.HostConfig{},

-				&network.NetworkingConfig{},

-				nil,

-				"",

-			)

+			resp, err := apiClient.ContainerCreate(ctx, client.ContainerCreateOptions{

+				Config: &container.Config{Image: tc.image},

+			})

 			if tc.expectedErr != "" {

-				assert.Check(t, is.DeepEqual(resp, container.CreateResponse{}))

+				assert.Check(t, is.DeepEqual(resp, client.ContainerCreateResult{}))

 				assert.Check(t, is.Error(err, tc.expectedErr))

 				assert.Check(t, is.ErrorType(err, tc.expectedErrType))

 			} else {

@@ -154,17 +148,14 @@ func TestCreateLinkToNonExistingContainer(t *testing.T) {

 	ctx := setupTest(t)

 	apiClient := testEnv.APIClient()

-	_, err := apiClient.ContainerCreate(ctx,

-		&container.Config{

+	_, err := apiClient.ContainerCreate(ctx, client.ContainerCreateOptions{

+		Config: &container.Config{

 			Image: "busybox",

 		},

-		&container.HostConfig{

+		HostConfig: &container.HostConfig{

 			Links: []string{"no-such-container"},

 		},

-		&network.NetworkingConfig{},

-		nil,

-		"",

-	)

+	})

 	assert.Check(t, is.ErrorContains(err, "could not get container for no-such-container"))

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

 }

@@ -195,16 +186,12 @@ func TestCreateWithInvalidEnv(t *testing.T) {

 		t.Run(strconv.Itoa(index), func(t *testing.T) {

 			t.Parallel()

 			ctx := testutil.StartSpan(ctx, t)

-			_, err := apiClient.ContainerCreate(ctx,

-				&container.Config{

+			_, err := apiClient.ContainerCreate(ctx, client.ContainerCreateOptions{

+				Config: &container.Config{

 					Image: "busybox",

 					Env:   []string{tc.env},

 				},

-				&container.HostConfig{},

-				&network.NetworkingConfig{},

-				nil,

-				"",

-			)

+			})

 			assert.Check(t, is.ErrorContains(err, tc.expectedError))

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

 		})

@@ -241,17 +228,14 @@ func TestCreateTmpfsMountsTarget(t *testing.T) {

 	}

 	for _, tc := range testCases {

-		_, err := apiClient.ContainerCreate(ctx,

-			&container.Config{

+		_, err := apiClient.ContainerCreate(ctx, client.ContainerCreateOptions{

+			Config: &container.Config{

 				Image: "busybox",

 			},

-			&container.HostConfig{

+			HostConfig: &container.HostConfig{

 				Tmpfs: map[string]string{tc.target: ""},

 			},

-			&network.NetworkingConfig{},

-			nil,

-			"",

-		)

+		})

 		assert.Check(t, is.ErrorContains(err, tc.expectedError))

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

 	}

@@ -298,19 +282,17 @@ func TestCreateWithCustomMaskedPaths(t *testing.T) {

 			t.Parallel()

 			// Create the container.

-			ctr, err := apiClient.ContainerCreate(ctx,

-				&container.Config{

+			ctr, err := apiClient.ContainerCreate(ctx, client.ContainerCreateOptions{

+				Config: &container.Config{

 					Image: "busybox",

 					Cmd:   []string{"true"},

 				},

-				&container.HostConfig{

+				HostConfig: &container.HostConfig{

 					Privileged:  tc.privileged,

 					MaskedPaths: tc.maskedPaths,

 				},

-				nil,

-				nil,

-				fmt.Sprintf("create-masked-paths-%d", i),

-			)

+				ContainerName: fmt.Sprintf("create-masked-paths-%d", i),

+			})

 			assert.NilError(t, err)

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

@@ -371,19 +353,17 @@ func TestCreateWithCustomReadonlyPaths(t *testing.T) {

 	for i, tc := range testCases {

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

 			t.Parallel()

-			ctr, err := apiClient.ContainerCreate(ctx,

-				&container.Config{

+			ctr, err := apiClient.ContainerCreate(ctx, client.ContainerCreateOptions{

+				Config: &container.Config{

 					Image: "busybox",

 					Cmd:   []string{"true"},

 				},

-				&container.HostConfig{

+				HostConfig: &container.HostConfig{

 					Privileged:    tc.privileged,

 					ReadonlyPaths: tc.readonlyPaths,

 				},

-				nil,

-				nil,

-				fmt.Sprintf("create-readonly-paths-%d", i),

-			)

+				ContainerName: fmt.Sprintf("create-readonly-paths-%d", i),

+			})

 			assert.NilError(t, err)

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

@@ -482,7 +462,9 @@ func TestCreateWithInvalidHealthcheckParams(t *testing.T) {

 				cfg.Healthcheck.StartPeriod = tc.startPeriod

 			}

-			resp, err := apiClient.ContainerCreate(ctx, &cfg, &container.HostConfig{}, nil, nil, "")

+			resp, err := apiClient.ContainerCreate(ctx, client.ContainerCreateOptions{

+				Config: &cfg,

+			})

 			assert.Check(t, is.Equal(len(resp.Warnings), 0))

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

 			assert.ErrorContains(t, err, tc.expectedErr)

@@ -553,7 +535,10 @@ func TestCreateDifferentPlatform(t *testing.T) {

 			Architecture: img.Architecture,

 			Variant:      img.Variant,

 		}

-		_, err := apiClient.ContainerCreate(ctx, &container.Config{Image: "busybox:latest"}, &container.HostConfig{}, nil, &p, "")

+		_, err := apiClient.ContainerCreate(ctx, client.ContainerCreateOptions{

+			Config:   &container.Config{Image: "busybox:latest"},

+			Platform: &p,

+		})

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

 	})

 	t.Run("different cpu arch", func(t *testing.T) {

@@ -563,7 +548,10 @@ func TestCreateDifferentPlatform(t *testing.T) {

 			Architecture: img.Architecture + "DifferentArch",

 			Variant:      img.Variant,

 		}

-		_, err := apiClient.ContainerCreate(ctx, &container.Config{Image: "busybox:latest"}, &container.HostConfig{}, nil, &p, "")

+		_, err := apiClient.ContainerCreate(ctx, client.ContainerCreateOptions{

+			Config:   &container.Config{Image: "busybox:latest"},

+			Platform: &p,

+		})

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

 	})

 }

@@ -574,12 +562,10 @@ func TestCreateVolumesFromNonExistingContainer(t *testing.T) {

 	_, err := apiClient.ContainerCreate(

 		ctx,

-		&container.Config{Image: "busybox"},

-		&container.HostConfig{VolumesFrom: []string{"nosuchcontainer"}},

-		nil,

-		nil,

-		"",

-	)

+		client.ContainerCreateOptions{

+			Config:     &container.Config{Image: "busybox"},

+			HostConfig: &container.HostConfig{VolumesFrom: []string{"nosuchcontainer"}},

+		})