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

 // Backend is all the methods that need to be implemented

 // to provide network specific functionality.

 type Backend interface {

-	GetNetworks(filters.Args, backend.NetworkListConfig) ([]types.NetworkResource, error)

+	GetNetworks(filters.Args, backend.NetworkListConfig) ([]network.Inspect, error)

 	CreateNetwork(nc types.NetworkCreateRequest) (*network.CreateResponse, error)

 	ConnectContainerToNetwork(containerName, networkName string, endpointConfig *network.EndpointSettings) error

 	DisconnectContainerFromNetwork(containerName string, networkName string, force bool) error

@@ -23,9 +23,9 @@ type Backend interface {

 // ClusterBackend is all the methods that need to be implemented

 // to provide cluster network specific functionality.

 type ClusterBackend interface {

-	GetNetworks(filters.Args) ([]types.NetworkResource, error)

-	GetNetwork(name string) (types.NetworkResource, error)

-	GetNetworksByName(name string) ([]types.NetworkResource, error)

+	GetNetworks(filters.Args) ([]network.Inspect, error)

+	GetNetwork(name string) (network.Inspect, error)

+	GetNetworksByName(name string) ([]network.Inspect, error)

 	CreateNetwork(nc types.NetworkCreateRequest) (string, error)

 	RemoveNetwork(name string) error

 }

@@ -32,7 +32,7 @@ func (n *networkRouter) getNetworksList(ctx context.Context, w http.ResponseWrit

 		return err

 	}

-	var list []types.NetworkResource

+	var list []network.Summary

 	nr, err := n.cluster.GetNetworks(filter)

 	if err == nil {

 		list = nr

@@ -60,7 +60,7 @@ func (n *networkRouter) getNetworksList(ctx context.Context, w http.ResponseWrit

 	}

 	if list == nil {

-		list = []types.NetworkResource{}

+		list = []network.Summary{}

 	}

 	return httputils.WriteJSON(w, http.StatusOK, list)

@@ -109,8 +109,8 @@ func (n *networkRouter) getNetwork(ctx context.Context, w http.ResponseWriter, r

 	// For full name and partial ID, save the result first, and process later

 	// in case multiple records was found based on the same term

-	listByFullName := map[string]types.NetworkResource{}

-	listByPartialID := map[string]types.NetworkResource{}

+	listByFullName := map[string]network.Inspect{}

+	listByPartialID := map[string]network.Inspect{}

 	// TODO(@cpuguy83): All this logic for figuring out which network to return does not belong here

 	// Instead there should be a backend function to just get one network.

@@ -311,9 +311,9 @@ func (n *networkRouter) postNetworksPrune(ctx context.Context, w http.ResponseWr

 // For full name and partial ID, save the result first, and process later

 // in case multiple records was found based on the same term

 // TODO (yongtang): should we wrap with version here for backward compatibility?

-func (n *networkRouter) findUniqueNetwork(term string) (types.NetworkResource, error) {

-	listByFullName := map[string]types.NetworkResource{}

-	listByPartialID := map[string]types.NetworkResource{}

+func (n *networkRouter) findUniqueNetwork(term string) (network.Inspect, error) {

+	listByFullName := map[string]network.Inspect{}

+	listByPartialID := map[string]network.Inspect{}

 	filter := filters.NewArgs(filters.Arg("idOrName", term))

 	networks, _ := n.backend.GetNetworks(filter, backend.NetworkListConfig{Detailed: true})

@@ -363,7 +363,7 @@ func (n *networkRouter) findUniqueNetwork(term string) (types.NetworkResource, e

 		}

 	}

 	if len(listByFullName) > 1 {

-		return types.NetworkResource{}, errdefs.InvalidParameter(errors.Errorf("network %s is ambiguous (%d matches found based on name)", term, len(listByFullName)))

+		return network.Inspect{}, errdefs.InvalidParameter(errors.Errorf("network %s is ambiguous (%d matches found based on name)", term, len(listByFullName)))

 	}

 	// Find based on partial ID, returns true only if no duplicates

@@ -373,8 +373,8 @@ func (n *networkRouter) findUniqueNetwork(term string) (types.NetworkResource, e

 		}

 	}

 	if len(listByPartialID) > 1 {

-		return types.NetworkResource{}, errdefs.InvalidParameter(errors.Errorf("network %s is ambiguous (%d matches found based on ID prefix)", term, len(listByPartialID)))

+		return network.Inspect{}, errdefs.InvalidParameter(errors.Errorf("network %s is ambiguous (%d matches found based on ID prefix)", term, len(listByPartialID)))

 	}

-	return types.NetworkResource{}, errdefs.NotFound(libnetwork.ErrNoSuchNetwork(term))

+	return network.Inspect{}, errdefs.NotFound(libnetwork.ErrNoSuchNetwork(term))

 }

@@ -1,6 +1,8 @@

 package network // import "github.com/docker/docker/api/types/network"

 import (

+	"time"

+

 	"github.com/docker/docker/api/types/filters"

 )

@@ -42,6 +44,32 @@ type DisconnectOptions struct {

 	Force     bool

 }

+// Inspect is the body of the "get network" http response message.

+type Inspect struct {

+	Name       string                      // Name is the name of the network

+	ID         string                      `json:"Id"` // ID uniquely identifies a network on a single machine

+	Created    time.Time                   // Created is the time the network created

+	Scope      string                      // Scope describes the level at which the network exists (e.g. `swarm` for cluster-wide or `local` for machine level)

+	Driver     string                      // Driver is the Driver name used to create the network (e.g. `bridge`, `overlay`)

+	EnableIPv6 bool                        // EnableIPv6 represents whether to enable IPv6

+	IPAM       IPAM                        // IPAM is the network's IP Address Management

+	Internal   bool                        // Internal represents if the network is used internal only

+	Attachable bool                        // Attachable represents if the global scope is manually attachable by regular containers from workers in swarm mode.

+	Ingress    bool                        // Ingress indicates the network is providing the routing-mesh for the swarm cluster.

+	ConfigFrom ConfigReference             // ConfigFrom specifies the source which will provide the configuration for this network.

+	ConfigOnly bool                        // ConfigOnly networks are place-holder networks for network configurations to be used by other networks. ConfigOnly networks cannot be used directly to run containers or services.

+	Containers map[string]EndpointResource // Containers contains endpoints belonging to the network

+	Options    map[string]string           // Options holds the network specific options to use for when creating the network

+	Labels     map[string]string           // Labels holds metadata specific to the network being created

+	Peers      []PeerInfo                  `json:",omitempty"` // List of peer nodes for an overlay network

+	Services   map[string]ServiceInfo      `json:",omitempty"`

+}

+

+// Summary is used as response when listing networks. It currently is an alias

+// for [Inspect], but may diverge in the future, as not all information may

+// be included when listing networks.

+type Summary = Inspect

+

 // Address represents an IP address

 type Address struct {

 	Addr      string

@@ -423,27 +423,6 @@ type MountPoint struct {

 	Propagation mount.Propagation

 }

-// NetworkResource is the body of the "get network" http response message

-type NetworkResource struct {

-	Name       string                              // Name is the requested name of the network

-	ID         string                              `json:"Id"` // ID uniquely identifies a network on a single machine

-	Created    time.Time                           // Created is the time the network created

-	Scope      string                              // Scope describes the level at which the network exists (e.g. `swarm` for cluster-wide or `local` for machine level)

-	Driver     string                              // Driver is the Driver name used to create the network (e.g. `bridge`, `overlay`)

-	EnableIPv6 bool                                // EnableIPv6 represents whether to enable IPv6

-	IPAM       network.IPAM                        // IPAM is the network's IP Address Management

-	Internal   bool                                // Internal represents if the network is used internal only

-	Attachable bool                                // Attachable represents if the global scope is manually attachable by regular containers from workers in swarm mode.

-	Ingress    bool                                // Ingress indicates the network is providing the routing-mesh for the swarm cluster.

-	ConfigFrom network.ConfigReference             // ConfigFrom specifies the source which will provide the configuration for this network.

-	ConfigOnly bool                                // ConfigOnly networks are place-holder networks for network configurations to be used by other networks. ConfigOnly networks cannot be used directly to run containers or services.

-	Containers map[string]network.EndpointResource // Containers contains endpoints belonging to the network

-	Options    map[string]string                   // Options holds the network specific options to use for when creating the network

-	Labels     map[string]string                   // Labels holds metadata specific to the network being created

-	Peers      []network.PeerInfo                  `json:",omitempty"` // List of peer nodes for an overlay network

-	Services   map[string]network.ServiceInfo      `json:",omitempty"`

-}

-

 // NetworkCreate is the expected body of the "create network" http request message

 type NetworkCreate struct {

 	// Deprecated: CheckDuplicate is deprecated since API v1.44, but it defaults to true when sent by the client

@@ -33,3 +33,8 @@ type NetworkDisconnect = network.DisconnectOptions

 //

 // Deprecated: use [network.EndpointResource].

 type EndpointResource = network.EndpointResource

+

+// NetworkResource is the body of the "get network" http response message/

+//

+// Deprecated: use [network.Inspect] or [network.Summary] (for list operations).

+type NetworkResource = network.Inspect

@@ -110,9 +110,9 @@ type NetworkAPIClient interface {

 	NetworkConnect(ctx context.Context, network, container string, config *network.EndpointSettings) error

 	NetworkCreate(ctx context.Context, name string, options types.NetworkCreate) (network.CreateResponse, error)

 	NetworkDisconnect(ctx context.Context, network, container string, force bool) error

-	NetworkInspect(ctx context.Context, network string, options network.InspectOptions) (types.NetworkResource, error)

-	NetworkInspectWithRaw(ctx context.Context, network string, options network.InspectOptions) (types.NetworkResource, []byte, error)

-	NetworkList(ctx context.Context, options network.ListOptions) ([]types.NetworkResource, error)

+	NetworkInspect(ctx context.Context, network string, options network.InspectOptions) (network.Inspect, error)

+	NetworkInspectWithRaw(ctx context.Context, network string, options network.InspectOptions) (network.Inspect, []byte, error)

+	NetworkList(ctx context.Context, options network.ListOptions) ([]network.Summary, error)

 	NetworkRemove(ctx context.Context, network string) error

 	NetworksPrune(ctx context.Context, pruneFilter filters.Args) (types.NetworksPruneReport, error)

 }

@@ -7,20 +7,19 @@ import (

 	"io"

 	"net/url"

-	"github.com/docker/docker/api/types"

 	"github.com/docker/docker/api/types/network"

 )

 // NetworkInspect returns the information for a specific network configured in the docker host.

-func (cli *Client) NetworkInspect(ctx context.Context, networkID string, options network.InspectOptions) (types.NetworkResource, error) {

+func (cli *Client) NetworkInspect(ctx context.Context, networkID string, options network.InspectOptions) (network.Inspect, error) {

 	networkResource, _, err := cli.NetworkInspectWithRaw(ctx, networkID, options)

 	return networkResource, err

 }

 // NetworkInspectWithRaw returns the information for a specific network configured in the docker host and its raw representation.

-func (cli *Client) NetworkInspectWithRaw(ctx context.Context, networkID string, options network.InspectOptions) (types.NetworkResource, []byte, error) {

+func (cli *Client) NetworkInspectWithRaw(ctx context.Context, networkID string, options network.InspectOptions) (network.Inspect, []byte, error) {

 	if networkID == "" {

-		return types.NetworkResource{}, nil, objectNotFoundError{object: "network", id: networkID}

+		return network.Inspect{}, nil, objectNotFoundError{object: "network", id: networkID}

 	}

 	query := url.Values{}

 	if options.Verbose {

@@ -33,15 +32,15 @@ func (cli *Client) NetworkInspectWithRaw(ctx context.Context, networkID string,

 	resp, err := cli.get(ctx, "/networks/"+networkID, query, nil)

 	defer ensureReaderClosed(resp)

 	if err != nil {

-		return types.NetworkResource{}, nil, err

+		return network.Inspect{}, nil, err

 	}

 	raw, err := io.ReadAll(resp.body)

 	if err != nil {

-		return types.NetworkResource{}, nil, err

+		return network.Inspect{}, nil, err

 	}

-	var nw types.NetworkResource

+	var nw network.Inspect

 	err = json.NewDecoder(bytes.NewReader(raw)).Decode(&nw)

 	return nw, raw, err

 }

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

 	"strings"

 	"testing"

-	"github.com/docker/docker/api/types"

 	"github.com/docker/docker/api/types/network"

 	"github.com/docker/docker/errdefs"

 	"gotest.tools/v3/assert"

@@ -47,12 +46,12 @@ func TestNetworkInspect(t *testing.T) {

 				s := map[string]network.ServiceInfo{

 					"web": {},

 				}

-				content, err = json.Marshal(types.NetworkResource{

+				content, err = json.Marshal(network.Inspect{

 					Name:     "mynetwork",

 					Services: s,

 				})

 			} else {

-				content, err = json.Marshal(types.NetworkResource{

+				content, err = json.Marshal(network.Inspect{

 					Name: "mynetwork",

 				})

 			}

@@ -5,13 +5,12 @@ import (

 	"encoding/json"

 	"net/url"

-	"github.com/docker/docker/api/types"

 	"github.com/docker/docker/api/types/filters"

 	"github.com/docker/docker/api/types/network"

 )

 // NetworkList returns the list of networks configured in the docker host.

-func (cli *Client) NetworkList(ctx context.Context, options network.ListOptions) ([]types.NetworkResource, error) {

+func (cli *Client) NetworkList(ctx context.Context, options network.ListOptions) ([]network.Summary, error) {

 	query := url.Values{}

 	if options.Filters.Len() > 0 {

 		//nolint:staticcheck // ignore SA1019 for old code

@@ -22,7 +21,7 @@ func (cli *Client) NetworkList(ctx context.Context, options network.ListOptions)

 		query.Set("filters", filterJSON)

 	}

-	var networkResources []types.NetworkResource

+	var networkResources []network.Summary

 	resp, err := cli.get(ctx, "/networks", query, nil)

 	defer ensureReaderClosed(resp)

 	if err != nil {

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

 	"strings"

 	"testing"

-	"github.com/docker/docker/api/types"

 	"github.com/docker/docker/api/types/filters"

 	"github.com/docker/docker/api/types/network"

 	"github.com/docker/docker/errdefs"

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

 				if actualFilters != listCase.expectedFilters {

 					return nil, fmt.Errorf("filters not set in URL query properly. Expected '%s', got %s", listCase.expectedFilters, actualFilters)

 				}

-				content, err := json.Marshal([]types.NetworkResource{

+				content, err := json.Marshal([]network.Summary{

 					{

 						Name:   "network",

 						Driver: "bridge",

@@ -1,8 +1,8 @@

 package daemon // import "github.com/docker/docker/daemon"

 import (

-	apitypes "github.com/docker/docker/api/types"

 	"github.com/docker/docker/api/types/filters"

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

 	lncluster "github.com/docker/docker/libnetwork/cluster"

 )

@@ -21,7 +21,7 @@ type ClusterStatus interface {

 // NetworkManager provides methods to manage networks

 type NetworkManager interface {

-	GetNetwork(input string) (apitypes.NetworkResource, error)

-	GetNetworks(filters.Args) ([]apitypes.NetworkResource, error)

+	GetNetwork(input string) (network.Inspect, error)

+	GetNetworks(filters.Args) ([]network.Inspect, error)

 	RemoveNetwork(input string) error

 }

@@ -137,7 +137,7 @@ func swarmPortConfigToAPIPortConfig(portConfig *swarmapi.PortConfig) types.PortC

 }

 // BasicNetworkFromGRPC converts a grpc Network to a NetworkResource.

-func BasicNetworkFromGRPC(n swarmapi.Network) basictypes.NetworkResource {

+func BasicNetworkFromGRPC(n swarmapi.Network) networktypes.Inspect {

 	spec := n.Spec

 	var ipam networktypes.IPAM

 	if n.IPAM != nil {

@@ -157,7 +157,7 @@ func BasicNetworkFromGRPC(n swarmapi.Network) basictypes.NetworkResource {

 		}

 	}

-	nr := basictypes.NetworkResource{

+	nr := networktypes.Inspect{

 		ID:         n.ID,

 		Name:       n.Spec.Annotations.Name,

 		Scope:      scope.Swarm,

@@ -19,7 +19,7 @@ import (

 )

 // GetNetworks returns all current cluster managed networks.

-func (c *Cluster) GetNetworks(filter filters.Args) ([]apitypes.NetworkResource, error) {

+func (c *Cluster) GetNetworks(filter filters.Args) ([]network.Inspect, error) {

 	var f *swarmapi.ListNetworksRequest_Filters

 	if filter.Len() > 0 {

@@ -44,13 +44,13 @@ func (c *Cluster) GetNetworks(filter filters.Args) ([]apitypes.NetworkResource,

 	return internalnetwork.FilterNetworks(list, filter)

 }

-func filterPredefinedNetworks(networks *[]apitypes.NetworkResource) {

+func filterPredefinedNetworks(networks *[]network.Inspect) {

 	if networks == nil {

 		return

 	}

 	var idxs []int

-	for i, n := range *networks {

-		if v, ok := n.Labels["com.docker.swarm.predefined"]; ok && v == "true" {

+	for i, nw := range *networks {

+		if v, ok := nw.Labels["com.docker.swarm.predefined"]; ok && v == "true" {

 			idxs = append(idxs, i)

 		}

 	}

@@ -60,7 +60,7 @@ func filterPredefinedNetworks(networks *[]apitypes.NetworkResource) {

 	}

 }

-func (c *Cluster) getNetworks(filters *swarmapi.ListNetworksRequest_Filters) ([]apitypes.NetworkResource, error) {

+func (c *Cluster) getNetworks(filters *swarmapi.ListNetworksRequest_Filters) ([]network.Inspect, error) {

 	c.mu.RLock()

 	defer c.mu.RUnlock()

@@ -78,35 +78,35 @@ func (c *Cluster) getNetworks(filters *swarmapi.ListNetworksRequest_Filters) ([]

 		return nil, err

 	}

-	networks := make([]apitypes.NetworkResource, 0, len(r.Networks))

+	networks := make([]network.Inspect, 0, len(r.Networks))

-	for _, network := range r.Networks {

-		networks = append(networks, convert.BasicNetworkFromGRPC(*network))

+	for _, nw := range r.Networks {

+		networks = append(networks, convert.BasicNetworkFromGRPC(*nw))

 	}

 	return networks, nil

 }

 // GetNetwork returns a cluster network by an ID.

-func (c *Cluster) GetNetwork(input string) (apitypes.NetworkResource, error) {

-	var network *swarmapi.Network

+func (c *Cluster) GetNetwork(input string) (network.Inspect, error) {

+	var nw *swarmapi.Network

 	if err := c.lockedManagerAction(func(ctx context.Context, state nodeState) error {

 		n, err := getNetwork(ctx, state.controlClient, input)

 		if err != nil {

 			return err

 		}

-		network = n

+		nw = n

 		return nil

 	}); err != nil {

-		return apitypes.NetworkResource{}, err

+		return network.Inspect{}, err

 	}

-	return convert.BasicNetworkFromGRPC(*network), nil

+	return convert.BasicNetworkFromGRPC(*nw), nil

 }

 // GetNetworksByName returns cluster managed networks by name.

 // It is ok to have multiple networks here. #18864

-func (c *Cluster) GetNetworksByName(name string) ([]apitypes.NetworkResource, error) {

+func (c *Cluster) GetNetworksByName(name string) ([]network.Inspect, error) {

 	// Note that swarmapi.GetNetworkRequest.Name is not functional.

 	// So we cannot just use that with c.GetNetwork.

 	return c.getNetworks(&swarmapi.ListNetworksRequest_Filters{

@@ -295,12 +295,12 @@ func (c *Cluster) CreateNetwork(s apitypes.NetworkCreateRequest) (string, error)

 // RemoveNetwork removes a cluster network.

 func (c *Cluster) RemoveNetwork(input string) error {

 	return c.lockedManagerAction(func(ctx context.Context, state nodeState) error {

-		network, err := getNetwork(ctx, state.controlClient, input)

+		nw, err := getNetwork(ctx, state.controlClient, input)

 		if err != nil {

 			return err

 		}

-		_, err = state.controlClient.RemoveNetwork(ctx, &swarmapi.RemoveNetworkRequest{NetworkID: network.ID})

+		_, err = state.controlClient.RemoveNetwork(ctx, &swarmapi.RemoveNetworkRequest{NetworkID: nw.ID})

 		return err

 	})

 }

@@ -312,10 +312,10 @@ func (c *Cluster) populateNetworkID(ctx context.Context, client swarmapi.Control

 	if len(networks) == 0 {

 		networks = s.Networks //nolint:staticcheck // ignore SA1019: field is deprecated.

 	}

-	for i, n := range networks {

-		apiNetwork, err := getNetwork(ctx, client, n.Target)

+	for i, nw := range networks {

+		apiNetwork, err := getNetwork(ctx, client, nw.Target)

 		if err != nil {

-			ln, _ := c.config.Backend.FindNetwork(n.Target)

+			ln, _ := c.config.Backend.FindNetwork(nw.Target)

 			if ln != nil && runconfig.IsPreDefinedNetwork(ln.Name()) {

 				// Need to retrieve the corresponding predefined swarm network

 				// and use its id for the request.

@@ -565,14 +565,14 @@ func (daemon *Daemon) deleteNetwork(nw *libnetwork.Network, dynamic bool) error

 }

 // GetNetworks returns a list of all networks

-func (daemon *Daemon) GetNetworks(filter filters.Args, config backend.NetworkListConfig) (networks []types.NetworkResource, err error) {

+func (daemon *Daemon) GetNetworks(filter filters.Args, config backend.NetworkListConfig) (networks []network.Inspect, err error) {

 	var idx map[string]*libnetwork.Network

 	if config.Detailed {

 		idx = make(map[string]*libnetwork.Network)

 	}

 	allNetworks := daemon.getAllNetworks()

-	networks = make([]types.NetworkResource, 0, len(allNetworks))

+	networks = make([]network.Inspect, 0, len(allNetworks))

 	for _, n := range allNetworks {

 		nr := buildNetworkResource(n)

 		networks = append(networks, nr)

@@ -600,12 +600,12 @@ func (daemon *Daemon) GetNetworks(filter filters.Args, config backend.NetworkLis

 // buildNetworkResource builds a [types.NetworkResource] from the given

 // [libnetwork.Network], to be returned by the API.

-func buildNetworkResource(nw *libnetwork.Network) types.NetworkResource {

+func buildNetworkResource(nw *libnetwork.Network) network.Inspect {

 	if nw == nil {

-		return types.NetworkResource{}

+		return network.Inspect{}

 	}

-	return types.NetworkResource{

+	return network.Inspect{

 		Name:       nw.Name(),

 		ID:         nw.ID(),

 		Created:    nw.Created(),

@@ -1,8 +1,8 @@

 package network // import "github.com/docker/docker/daemon/network"

 import (

-	"github.com/docker/docker/api/types"

 	"github.com/docker/docker/api/types/filters"

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

 	"github.com/docker/docker/errdefs"

 	"github.com/docker/docker/runconfig"

 	"github.com/pkg/errors"

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

 // FilterNetworks filters network list according to user specified filter

 // and returns user chosen networks

-func FilterNetworks(nws []types.NetworkResource, filter filters.Args) ([]types.NetworkResource, error) {

+func FilterNetworks(nws []network.Inspect, filter filters.Args) ([]network.Inspect, error) {

 	// if filter is empty, return original network list

 	if filter.Len() == 0 {

 		return nws, nil

@@ -71,7 +71,7 @@ func FilterNetworks(nws []types.NetworkResource, filter filters.Args) ([]types.N

 	}

 	if filter.Contains("type") {

-		typeNet := []types.NetworkResource{}

+		typeNet := []network.Inspect{}

 		errFilter := filter.WalkValues("type", func(fval string) error {

 			passList, err := filterNetworkByType(displayNet, fval)

 			if err != nil {

@@ -89,10 +89,10 @@ func FilterNetworks(nws []types.NetworkResource, filter filters.Args) ([]types.N

 	return displayNet, nil

 }

-func filterNetworkByUse(nws []types.NetworkResource, danglingOnly bool) []types.NetworkResource {

-	retNws := []types.NetworkResource{}

+func filterNetworkByUse(nws []network.Inspect, danglingOnly bool) []network.Inspect {

+	retNws := []network.Inspect{}

-	filterFunc := func(nw types.NetworkResource) bool {

+	filterFunc := func(nw network.Inspect) bool {

 		if danglingOnly {

 			return !runconfig.IsPreDefinedNetwork(nw.Name) && len(nw.Containers) == 0 && len(nw.Services) == 0

 		}

@@ -108,8 +108,8 @@ func filterNetworkByUse(nws []types.NetworkResource, danglingOnly bool) []types.

 	return retNws

 }

-func filterNetworkByType(nws []types.NetworkResource, netType string) ([]types.NetworkResource, error) {

-	retNws := []types.NetworkResource{}

+func filterNetworkByType(nws []network.Inspect, netType string) ([]network.Inspect, error) {

+	retNws := []network.Inspect{}

 	switch netType {

 	case "builtin":

 		for _, nw := range nws {

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

 	"strings"

 	"testing"

-	"github.com/docker/docker/api/types"

 	"github.com/docker/docker/api/types/filters"

 	"github.com/docker/docker/api/types/network"

 )

 func TestFilterNetworks(t *testing.T) {

-	networks := []types.NetworkResource{

+	networks := []network.Inspect{

 		{

 			Name:   "host",

 			Driver: "host",

@@ -134,7 +133,7 @@ func TestFilterNetworks(t *testing.T) {

 	for _, testCase := range testCases {

 		t.Run(testCase.name, func(t *testing.T) {

-			ls := make([]types.NetworkResource, 0, len(networks))

+			ls := make([]network.Inspect, 0, len(networks))

 			ls = append(ls, networks...)

 			result, err := FilterNetworks(ls, testCase.filter)

 			if testCase.err != "" {

@@ -218,7 +218,7 @@ func isNetworkAvailable(c *testing.T, name string) bool {

 	defer resp.Body.Close()

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

-	var nJSON []types.NetworkResource

+	var nJSON []network.Inspect

 	err = json.NewDecoder(body).Decode(&nJSON)

 	assert.NilError(c, err)

@@ -240,7 +240,7 @@ func getNetworkIDByName(c *testing.T, name string) string {

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

 	assert.NilError(c, err)

-	var nJSON []types.NetworkResource

+	var nJSON []network.Inspect

 	err = json.NewDecoder(body).Decode(&nJSON)

 	assert.NilError(c, err)

 	var res string

@@ -255,11 +255,11 @@ func getNetworkIDByName(c *testing.T, name string) string {

 	return res

 }

-func getNetworkResource(c *testing.T, id string) *types.NetworkResource {

+func getNetworkResource(c *testing.T, id string) *network.Inspect {

 	_, obj, err := request.Get(testutil.GetContext(c), "/networks/"+id)

 	assert.NilError(c, err)

-	nr := types.NetworkResource{}

+	nr := network.Inspect{}

 	err = json.NewDecoder(obj).Decode(&nr)

 	assert.NilError(c, err)

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

 	"time"

 	"github.com/docker/docker/api/types"

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

 	"github.com/docker/docker/integration-cli/cli"

 	"github.com/docker/docker/integration-cli/daemon"

 	"github.com/docker/docker/libnetwork/driverapi"

@@ -263,9 +264,9 @@ func assertNwList(c *testing.T, out string, expectNws []string) {

 	assert.DeepEqual(c, nwList, expectNws)

 }

-func getNwResource(c *testing.T, name string) *types.NetworkResource {

+func getNwResource(c *testing.T, name string) *network.Inspect {

 	out := cli.DockerCmd(c, "network", "inspect", name).Stdout()

-	var nr []types.NetworkResource

+	var nr []network.Inspect

 	err := json.Unmarshal([]byte(out), &nr)

 	assert.NilError(c, err)

 	return &nr[0]

@@ -418,7 +419,7 @@ func (s *DockerCLINetworkSuite) TestDockerNetworkDeleteMultiple(c *testing.T) {

 func (s *DockerCLINetworkSuite) TestDockerNetworkInspect(c *testing.T) {

 	out := cli.DockerCmd(c, "network", "inspect", "host").Stdout()

-	var networkResources []types.NetworkResource

+	var networkResources []network.Inspect

 	err := json.Unmarshal([]byte(out), &networkResources)

 	assert.NilError(c, err)

 	assert.Equal(c, len(networkResources), 1)

@@ -442,7 +443,7 @@ func (s *DockerCLINetworkSuite) TestDockerInspectMultipleNetwork(c *testing.T) {

 	result := dockerCmdWithResult("network", "inspect", "host", "none")

 	result.Assert(c, icmd.Success)

-	var networkResources []types.NetworkResource

+	var networkResources []network.Inspect

 	err := json.Unmarshal([]byte(result.Stdout()), &networkResources)

 	assert.NilError(c, err)

 	assert.Equal(c, len(networkResources), 2)

@@ -458,7 +459,7 @@ func (s *DockerCLINetworkSuite) TestDockerInspectMultipleNetworksIncludingNonexi

 		Out:      "host",

 	})

-	var networkResources []types.NetworkResource

+	var networkResources []network.Inspect

 	err := json.Unmarshal([]byte(result.Stdout()), &networkResources)

 	assert.NilError(c, err)

 	assert.Equal(c, len(networkResources), 1)

@@ -481,7 +482,7 @@ func (s *DockerCLINetworkSuite) TestDockerInspectMultipleNetworksIncludingNonexi

 		Out:      "host",

 	})

-	networkResources = []types.NetworkResource{}

+	networkResources = []network.Inspect{}

 	err = json.Unmarshal([]byte(result.Stdout()), &networkResources)

 	assert.NilError(c, err)

 	assert.Equal(c, len(networkResources), 1)

@@ -504,7 +505,7 @@ func (s *DockerCLINetworkSuite) TestDockerInspectNetworkWithContainerName(c *tes

 	}()

 	out = cli.DockerCmd(c, "network", "inspect", "brNetForInspect").Stdout()

-	var networkResources []types.NetworkResource

+	var networkResources []network.Inspect

 	err := json.Unmarshal([]byte(out), &networkResources)

 	assert.NilError(c, err)

 	assert.Equal(c, len(networkResources), 1)

@@ -518,7 +519,7 @@ func (s *DockerCLINetworkSuite) TestDockerInspectNetworkWithContainerName(c *tes

 	// check whether network inspect works properly

 	out = cli.DockerCmd(c, "network", "inspect", "brNetForInspect").Stdout()

-	var newNetRes []types.NetworkResource

+	var newNetRes []network.Inspect

 	err = json.Unmarshal([]byte(out), &newNetRes)

 	assert.NilError(c, err)

 	assert.Equal(c, len(newNetRes), 1)

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

 	"context"

 	"testing"

-	"github.com/docker/docker/api/types"

 	networktypes "github.com/docker/docker/api/types/network"

 	dclient "github.com/docker/docker/client"

 	"github.com/docker/docker/integration/internal/network"

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

 	"gotest.tools/v3/skip"

 )

-func containsNetwork(nws []types.NetworkResource, networkID string) bool {

+func containsNetwork(nws []networktypes.Inspect, networkID string) bool {

 	for _, n := range nws {

 		if n.ID == networkID {

 			return true

@@ -152,7 +152,7 @@ func TestNetworkList(t *testing.T) {

 			buf, err := request.ReadBody(body)

 			assert.NilError(t, err)

-			var nws []types.NetworkResource

+			var nws []ntypes.Inspect

 			err = json.Unmarshal(buf, &nws)

 			assert.NilError(t, err)

 			assert.Assert(t, len(nws) > 0)