docker

type ClientOps interface {
	GetClient() (*client.Client, error)
	ResetClient()
}

type ClusterInfoOps interface {
	GetCurrentContext() (string, error)
	GetContainerCount() (int, error)
	GetServiceCount() (int, error)
	GetSwarmCPUCapacity() (float64, error)
	GetSwarmMemCapacity() (int64, error)
	GetSwarmCPUUsage() (string, error)
	GetSwarmMemUsage() (string, error)
	GetSwarmResourceUsage() (cpuPct, memPct string, err error)
	GetDockerVersion() (string, error)
}

type ComposeFile struct {
	Version  string                    `yaml:"version"`
	Services map[string]ComposeService `yaml:"services"`
	Networks map[string]map[string]any `yaml:"networks,omitempty"`
	Volumes  map[string]map[string]any `yaml:"volumes,omitempty"`
	Secrets  map[string]map[string]any `yaml:"secrets,omitempty"`
	Configs  map[string]map[string]any `yaml:"configs,omitempty"`
}

type ComposeService struct {
	Image       string            `yaml:"image,omitempty"`
	Command     any               `yaml:"command,omitempty"` // string or []string
	Entrypoint  any               `yaml:"entrypoint,omitempty"`
	WorkingDir  string            `yaml:"working_dir,omitempty"`
	User        string            `yaml:"user,omitempty"`
	Environment map[string]string `yaml:"environment,omitempty"`
	Labels      map[string]string `yaml:"labels,omitempty"`
	Ports       []string          `yaml:"ports,omitempty"`
	Networks    any               `yaml:"networks,omitempty"` // []string or map
	Volumes     []string          `yaml:"volumes,omitempty"`
	Secrets     []map[string]any  `yaml:"secrets,omitempty"`
	Configs     []map[string]any  `yaml:"configs,omitempty"`
	// Container runtime / security settings that round-trip through
	// `docker stack deploy` (see #430).
	Hostname        string            `yaml:"hostname,omitempty"`
	CapAdd          []string          `yaml:"cap_add,omitempty"`
	CapDrop         []string          `yaml:"cap_drop,omitempty"`
	Sysctls         map[string]string `yaml:"sysctls,omitempty"`
	Ulimits         map[string]any    `yaml:"ulimits,omitempty"`
	ExtraHosts      []string          `yaml:"extra_hosts,omitempty"`
	DNS             []string          `yaml:"dns,omitempty"`
	DNSSearch       []string          `yaml:"dns_search,omitempty"`
	DNSOpt          []string          `yaml:"dns_opt,omitempty"`
	ReadOnly        bool              `yaml:"read_only,omitempty"`
	Init            *bool             `yaml:"init,omitempty"`
	StopSignal      string            `yaml:"stop_signal,omitempty"`
	StopGracePeriod string            `yaml:"stop_grace_period,omitempty"`
	Deploy          map[string]any    `yaml:"deploy,omitempty"`
	Healthcheck     *Healthcheck      `yaml:"healthcheck,omitempty"`
	Logging         *Logging          `yaml:"logging,omitempty"`
	Extra           map[string]any    `yaml:",inline,omitempty"` // fallback
}

type ConfigOps interface {
	ListConfigs(ctx context.Context) ([]swarm.Config, error)
	InspectConfig(ctx context.Context, nameOrID string) (*ConfigWithDecodedData, error)
	CreateConfig(ctx context.Context, name string, data []byte, labels map[string]string) (swarm.Config, error)
	CreateConfigVersion(ctx context.Context, baseConfig swarm.Config, newData []byte) (swarm.Config, error)
	RotateConfigInServices(ctx context.Context, oldCfg *swarm.Config, newCfg swarm.Config) error
	DeleteConfig(ctx context.Context, nameOrID string) error
	// ServicesUsingConfigs answers "which services reference this config" for
	// every config at once, keyed by config ID and name.
	//
	// It replaces per-config lookups in this seam. ListServicesUsingConfigID and
	// ListServicesUsingConfigName still exist on the package for a caller with a
	// single config, but each lists every service and filters, so a loop over
	// them scales the whole service listing by the number of configs.
	ServicesUsingConfigs(ctx context.Context) (map[string][]swarm.Service, error)
}

type ConfigRef struct {
	ConfigID   string `json:"ConfigID"`
	ConfigName string `json:"ConfigName"`
	File       *struct {
		Name string `json:"Name"`
		UID  string `json:"UID,omitempty"`
		GID  string `json:"GID,omitempty"`
		Mode uint32 `json:"Mode,omitempty"`
	} `json:"File,omitempty"`
}

type ConfigWithDecodedData struct {
	Config swarm.Config
	Data   []byte
}

type ContainerSpec struct {
	Image    string            `json:"Image"`
	Args     []string          `json:"Args,omitempty"`
	Command  []string          `json:"Command,omitempty"`
	Env      []string          `json:"Env,omitempty"`
	Dir      string            `json:"Dir,omitempty"`
	User     string            `json:"User,omitempty"`
	Hostname string            `json:"Hostname,omitempty"`
	Labels   map[string]string `json:"Labels,omitempty"`
	Mounts   []Mount           `json:"Mounts,omitempty"`
	Secrets  []SecretRef       `json:"Secrets,omitempty"`
	Configs  []ConfigRef       `json:"Configs,omitempty"`
	// Healthcheck durations arrive as nanosecond integers over the
	// `docker service inspect` CLI JSON.
	Healthcheck *HealthConfigJSON `json:"Healthcheck,omitempty"`
	// Runtime / security fields (see #430). StopGracePeriod is a nanosecond
	// integer; Init is a tri-state pointer (nil = inherit image default).
	CapabilityAdd   []string          `json:"CapabilityAdd,omitempty"`
	CapabilityDrop  []string          `json:"CapabilityDrop,omitempty"`
	Sysctls         map[string]string `json:"Sysctls,omitempty"`
	Ulimits         []Ulimit          `json:"Ulimits,omitempty"`
	Hosts           []string          `json:"Hosts,omitempty"`
	DNSConfig       *DNSConfig        `json:"DNSConfig,omitempty"`
	ReadOnly        bool              `json:"ReadOnly,omitempty"`
	Init            *bool             `json:"Init,omitempty"`
	StopSignal      string            `json:"StopSignal,omitempty"`
	StopGracePeriod int64             `json:"StopGracePeriod,omitempty"`
}

type ContextInfo struct {
	Name        string
	Current     bool
	Description string
	DockerHost  string
	TLS         bool
	Error       string
}

type ContextOps interface {
	ListContexts() ([]ContextInfo, error)
	UseContext(contextName string) error
	ValidateContext(ctx context.Context, contextName string) error
	InspectContext(contextName string) (string, error)
	ExportContext(contextName string) (string, error)
	ExportContextWithForce(contextName string) (string, error)
	CheckContextExportExists(contextName string) bool
	DeleteContext(contextName string) error
	ImportContext(filePath string) (string, error)
	CreateContext(name, dockerHost string) error
	CreateContextWithTLS(name, dockerHost, tlsPath string, skipTLSVerify bool) error
	CreateContextWithCertFiles(name, description, dockerHost, caFile, certFile, keyFile string, skipTLSVerify bool) error
	UpdateContextDescription(name, description string) error
	UpdateContextWithCertFiles(name, description, dockerHost, caFile, certFile, keyFile string, skipTLSVerify bool) error
}

type DNSConfig struct {
	Nameservers []string `json:"Nameservers,omitempty"`
	Search      []string `json:"Search,omitempty"`
	Options     []string `json:"Options,omitempty"`
}

type Deps struct {
	Services    ServiceOps
	Nodes       NodeOps
	Tasks       TaskOps
	Stacks      StackOps
	Configs     ConfigOps
	Secrets     SecretOps
	Networks    NetworkOps
	Volumes     VolumeOps
	Contexts    ContextOps
	Snapshot    SnapshotOps
	ClusterInfo ClusterInfoOps
	Inspect     InspectOps
	Events      EventOps
	Client      ClientOps
	Hostname    HostnameOps
}

type EndpointSpec struct {
	Mode  string       `json:"Mode,omitempty"` // vip/dnsrr
	Ports []PortConfig `json:"Ports,omitempty"`
}

type Event struct {
	Type   string
	Action string
	Err    error
}

type EventOps interface {
	WatchEvent() Event
}

type HealthConfigJSON struct {
	Test          []string `json:"Test,omitempty"`
	Interval      int64    `json:"Interval,omitempty"`
	Timeout       int64    `json:"Timeout,omitempty"`
	StartPeriod   int64    `json:"StartPeriod,omitempty"`
	StartInterval int64    `json:"StartInterval,omitempty"`
	Retries       int      `json:"Retries,omitempty"`
}

type Healthcheck struct {
	Test          []string `json:"test,omitempty" yaml:"test,omitempty"`
	Interval      string   `json:"interval,omitempty" yaml:"interval,omitempty"`
	Timeout       string   `json:"timeout,omitempty" yaml:"timeout,omitempty"`
	StartPeriod   string   `json:"start_period,omitempty" yaml:"start_period,omitempty"`
	StartInterval string   `json:"start_interval,omitempty" yaml:"start_interval,omitempty"`
	Retries       int      `json:"retries,omitempty" yaml:"retries,omitempty"`
	Disable       bool     `json:"disable,omitempty" yaml:"disable,omitempty"`
}

type HostnameOps interface {
	RefreshHostnameCache() error
	GetNodeIDToHostnameMap() (map[string]string, error)
}

type InspectOps interface {
	Inspect(ctx context.Context, t InspectType, id string) (string, error)
}

type InspectType string

type LogDriver struct {
	Name    string            `json:"Name,omitempty"`
	Options map[string]string `json:"Options,omitempty"`
}

type Logging struct {
	Driver  string            `json:"driver,omitempty" yaml:"driver,omitempty"`
	Options map[string]string `json:"options,omitempty" yaml:"options,omitempty"`
}

type Mount struct {
	Type        string `json:"Type"` // bind, volume, tmpfs
	Source      string `json:"Source,omitempty"`
	Target      string `json:"Target,omitempty"`
	ReadOnly    bool   `json:"ReadOnly,omitempty"`
	BindOptions *struct {
		Propagation string `json:"Propagation,omitempty"`
	} `json:"BindOptions,omitempty"`
	VolumeOptions *struct {
		NoCopy       bool              `json:"NoCopy,omitempty"`
		Labels       map[string]string `json:"Labels,omitempty"`
		DriverConfig *struct {
			Name    string            `json:"Name,omitempty"`
			Options map[string]string `json:"Options,omitempty"`
		} `json:"DriverConfig,omitempty"`
	} `json:"VolumeOptions,omitempty"`
	TmpfsOptions *struct {
		SizeBytes int64  `json:"SizeBytes,omitempty"`
		Mode      uint32 `json:"Mode,omitempty"`
	} `json:"TmpfsOptions,omitempty"`
}

type NetRef struct {
	Target  string   `json:"Target"` // network ID
	Aliases []string `json:"Aliases,omitempty"`
}

type NetworkOps interface {
	ListNetworks(ctx context.Context) ([]network.Summary, error)
	InspectNetwork(ctx context.Context, networkID string) (network.Inspect, error)
	RemoveNetwork(ctx context.Context, networkID string) error
	CreateNetwork(ctx context.Context, name string, opts network.CreateOptions) (string, []string, error)
	PruneNetworks(ctx context.Context) (network.PruneReport, error)
	ListServicesUsingNetwork(ctx context.Context, networkID, networkName string) ([]string, error)
}

type NetworkWithUsage struct {
	Network  network.Summary
	Services []string // Services using this network
}

type NodeEntry struct {
	ID            string
	Version       string
	Hostname      string
	Role          string
	State         string
	Availability  string
	Manager       bool
	Addr          string
	Labels        map[string]string
	ManagerStatus string // Leader, Reachable, Unreachable, or ""
}

type NodeOps interface {
	GetNodeIDToHostnameMapFromDocker(ctx context.Context) (map[string]string, error)
	DemoteNode(ctx context.Context, nodeID string) error
	PromoteNode(ctx context.Context, nodeID string) error
	SetNodeAvailability(ctx context.Context, nodeID string, availability swarm.NodeAvailability) error
	AddNodeLabel(ctx context.Context, nodeID, key, value string) error
	RemoveNodeLabel(ctx context.Context, nodeID, key string) error
	RemoveNode(ctx context.Context, nodeID string, force bool) error
}

type PartialListError struct {
	NodeErrors map[string]string // node identifier -> error summary
	Note       string            // optional banner override; takes precedence over NodeErrors
}

type Placement struct {
	Constraints []string `json:"Constraints,omitempty"`
	Preferences []any    `json:"Preferences,omitempty"`
	MaxReplicas *uint64  `json:"MaxReplicas,omitempty"`
}

type PortConfig struct {
	Protocol      string `json:"Protocol,omitempty"` // tcp/udp
	TargetPort    uint32 `json:"TargetPort,omitempty"`
	PublishedPort uint32 `json:"PublishedPort,omitempty"`
	PublishMode   string `json:"PublishMode,omitempty"` // ingress/host
}

type ProgressUpdate struct {
	Replaced int
	Running  int
	Total    int
}

type ResolveImage string

type ResourceSpec struct {
	NanoCPUs    int64 `json:"NanoCPUs,omitempty"`
	MemoryBytes int64 `json:"MemoryBytes,omitempty"`
	Pids        int64 `json:"Pids,omitempty"`
}

type Resources struct {
	Limits       *ResourceSpec `json:"Limits,omitempty"`
	Reservations *ResourceSpec `json:"Reservations,omitempty"`
}

type RestartPolicy struct {
	Condition   string  `json:"Condition,omitempty"`
	Delay       int64   `json:"Delay,omitempty"`
	MaxAttempts *uint64 `json:"MaxAttempts,omitempty"`
	Window      int64   `json:"Window,omitempty"`
}

type SecretOps interface {
	ListSecrets(ctx context.Context) ([]swarm.Secret, error)
	InspectSecret(ctx context.Context, nameOrID string) (*SecretWithDecodedData, error)
	CreateSecret(ctx context.Context, name string, data []byte, labels map[string]string) (swarm.Secret, error)
	CreateSecretVersion(ctx context.Context, baseSecret swarm.Secret, newData []byte) (swarm.Secret, error)
	RotateSecretInServices(ctx context.Context, oldSec *swarm.Secret, newSec swarm.Secret) error
	DeleteSecret(ctx context.Context, nameOrID string) error
	// ServicesUsingSecrets answers "which services reference this secret" for
	// every secret at once, keyed by secret ID and name.
	//
	// It replaces per-secret lookups in this seam. ListServicesUsingSecretID and
	// ListServicesUsingSecretName still exist on the package for a caller with a
	// single secret, but each lists every service and filters, so a loop over
	// them scales the whole service listing by the number of secrets.
	ServicesUsingSecrets(ctx context.Context) (map[string][]swarm.Service, error)
}

type SecretRef struct {
	SecretID   string `json:"SecretID"`
	SecretName string `json:"SecretName"`
	File       *struct {
		Name string `json:"Name"`
		UID  string `json:"UID,omitempty"`
		GID  string `json:"GID,omitempty"`
		Mode uint32 `json:"Mode,omitempty"`
	} `json:"File,omitempty"`
}

type SecretWithDecodedData struct {
	Secret swarm.Secret
	Data   []byte // This will typically be nil/empty as secrets data cannot be retrieved
}

type ServiceConvergence struct {
	Name string
	Mode string
	// Running counts tasks that are actually running, on an active node.
	Running int
	// Desired is the target count over active nodes.
	Desired int
	// Completed counts tasks that ran to completion on an active node. Only
	// meaningful together with Job: for a long-running service a completed task
	// is one swarm is about to replace, not one that finished its work.
	Completed int
	// Job reports a service swarm will not restart after a clean exit — a
	// restart policy of "none" or "on-failure". Such a service is *supposed* to
	// end with no task running, so Running < Desired is its success state, not
	// a failure to converge (issue #443).
	//
	// A task that exits non-zero and exhausts its restart budget ends Failed,
	// never Complete, so counting only completed tasks keeps the distinction
	// that matters: finished versus broken.
	Job bool
	// UpdateState is the raw swarm UpdateStatus.State, empty when the service
	// has never been updated. Note that a nil UpdateStatus means "no rollout has
	// ever run", NOT "the rollout finished".
	UpdateState string
	// Monitor is UpdateConfig.Monitor: the window after a task is created during
	// which its failure still counts against the rollout. Zero when unset.
	Monitor time.Duration
	// NewestTaskAge is how long the newest running task has been alive, measured
	// from task creation — the same instant swarm measures Monitor from.
	//
	// A caller waiting out the monitor window needs it: a task only reports
	// running once its healthcheck passes, so by then start_period and the
	// checks that followed have already consumed part of the window, and
	// sometimes all of it. Zero when nothing is running.
	NewestTaskAge time.Duration
}

type ServiceEntry struct {
	StackName      string
	ServiceName    string
	ServiceID      string
	ReplicasOnNode int
	ReplicasTotal  int
	// UpToDate counts the replicas running the service's *current* generation.
	// ReplicasOnNode counts every running task, superseded ones included, so it
	// matches `docker service ls` — which means a start-first rollout reads as
	// fully converged while the outgoing generation is what is actually up. The
	// two together say what one ratio cannot: how many replicas are serving, and
	// how many of those are the version being rolled out (issue #480).
	UpToDate int
	// RollingOut reports a rollout in flight — updating, paused, or either
	// rollback state. It gates the display of UpToDate: outside a rollout a
	// replica short of the current generation is a restart, not a stale version.
	RollingOut bool
	Status     string
	Mode       string
	Image      string
	Ports      string
	// Health is an aggregate health summary for the service's running replicas
	// (e.g. "2/2 healthy"); "" when unknown. The swarm API does not expose
	// container health, so the default loaders leave it empty; it is an
	// extension point populated by a ServiceOps decorator that can reach
	// per-node container state.
	Health string
	// PullProgress summarizes an image pull in flight for this service's tasks
	// (e.g. "pulling · 3/12 layers · 412 MB"); "" when nothing is being pulled or
	// the progress is unavailable. Like Health it is an extension point populated
	// by a ServiceOps decorator that can reach the nodes performing the pull; the
	// services view shows it in place of Status while it is set, since a service
	// whose image is still downloading otherwise reads as a bare "active".
	PullProgress string
	CreatedAt    time.Time
	UpdatedAt    time.Time
}

type ServiceInspect struct {
	Spec ServiceSpec `json:"Spec"`
}

type ServiceMode struct {
	Replicated *struct {
		Replicas *uint64 `json:"Replicas"`
	} `json:"Replicated,omitempty"`
	Global any `json:"Global,omitempty"`
}

type ServiceOps interface {
	ScaleService(ctx context.Context, serviceID string, replicas uint64) error
	ScaleServiceByName(ctx context.Context, serviceName string, replicas uint64) error
	RestartService(ctx context.Context, serviceName string) error
	RemoveService(ctx context.Context, serviceName string) error
	RollbackService(ctx context.Context, serviceName string) error
	RestartServiceAndWait(ctx context.Context, serviceName string) error
	RestartServiceWithProgress(ctx context.Context, serviceName string, progressCh chan<- ProgressUpdate) error
	LoadNodeServices(nodeID string) []ServiceEntry
	LoadStackServices(stackName string) []ServiceEntry
	LoadAllServices() []ServiceEntry
	GetServiceLogs(ctx context.Context, serviceID string) (string, error)
	GetServiceTaskDiagnostics(ctx context.Context, serviceID string) (string, error)
	CreateService(ctx context.Context, spec swarm.ServiceSpec) (string, error)
}

type ServiceSpec struct {
	Name           string            `json:"Name"`
	Labels         map[string]string `json:"Labels"`
	TaskTemplate   TaskTemplate      `json:"TaskTemplate"`
	Mode           ServiceMode       `json:"Mode"`
	Networks       []NetRef          `json:"Networks"`
	EndpointSpec   *EndpointSpec     `json:"EndpointSpec,omitempty"`
	UpdateConfig   *UpdateConfig     `json:"UpdateConfig,omitempty"`
	RollbackConfig *UpdateConfig     `json:"RollbackConfig,omitempty"`
}

type ServiceSummary struct {
	Name            string            `json:"name"`
	ID              string            `json:"id"`
	Image           string            `json:"image"`
	Mode            string            `json:"mode"`
	Replicas        string            `json:"replicas"`
	Ports           []string          `json:"ports,omitempty"`
	Secrets         []string          `json:"secrets,omitempty"`
	Configs         []string          `json:"configs,omitempty"`
	Labels          map[string]string `json:"labels,omitempty"`
	ContainerLabels map[string]string `json:"container_labels,omitempty"`
	Healthcheck     *Healthcheck      `json:"healthcheck,omitempty"`
	Logging         *Logging          `json:"logging,omitempty"`
	CreatedAt       time.Time         `json:"created_at"`
	UpdatedAt       time.Time         `json:"updated_at"`
}

type SnapshotOps interface {
	GetSnapshot() *SwarmSnapshot
	SetSnapshot(s *SwarmSnapshot)
	InvalidateSnapshot()
	RefreshSnapshot() (*SwarmSnapshot, error)
	RefreshSnapshotAsync()
	TriggerRefreshIfNeeded()
	GetOrRefreshSnapshot() (*SwarmSnapshot, error)
}

type Stack struct {
	Name         string
	ServiceCount int
}

type StackEntry struct {
	Name         string
	ServiceCount int
	NodeCount    int
}

type StackInspection struct {
	Name         string           `json:"name"`
	Services     []ServiceSummary `json:"services"`
	Networks     []string         `json:"networks,omitempty"`
	Volumes      []string         `json:"volumes,omitempty"`
	Secrets      []string         `json:"secrets,omitempty"`
	Configs      []string         `json:"configs,omitempty"`
	ServiceCount int              `json:"service_count"`
	TaskCount    int              `json:"task_count"`
	CreatedAt    time.Time        `json:"created_at,omitempty"`
	UpdatedAt    time.Time        `json:"updated_at,omitempty"`
}

type StackOps interface {
	RemoveStack(ctx context.Context, stackName string) error
	RemoveStackNetworks(ctx context.Context, stackName string) error
	DeployStack(stackName string, yamlContent string) error
	ValidateStackYAML(content string) error
	InspectStack(stackName string) (string, error)
	ReconstructStackCompose(stackName string) (string, error)
}

type StackService struct {
	NodeID         string
	StackName      string
	ServiceName    string
	ServiceID      string
	ReplicasOnNode int
	ReplicasTotal  int
}

type SwarmNode struct {
	ID            string
	Hostname      string
	Status        string
	Availability  string
	ManagerStatus string
}

type SwarmSnapshot struct {
	Nodes     []swarm.Node
	Services  []swarm.Service
	Tasks     []swarm.Task
	Fetched   time.Time
	ClusterID string
	// Locked is true when the swarm is reachable but encrypted/locked. In that
	// case the entity lists are empty until the swarm is unlocked.
	Locked bool
}

type TaskEntry struct {
	ID   string
	Name string
	// Slot is the replica this task belongs to, so two tasks of the same slot
	// read as one replica being replaced rather than as two replicas. Zero for a
	// global service, whose tasks carry no slot and are identified by node.
	Slot         int
	ServiceName  string
	Image        string
	NodeName     string
	ContainerID  string
	DesiredState string
	CurrentState string
	Error        string
	Ports        string
	// Health is the container-level health status (e.g. "healthy",
	// "unhealthy", "starting"); "" when the container has no healthcheck or
	// the status is unknown. The swarm task snapshot does not carry it, so the
	// default loaders leave it empty; it is an extension point populated by a
	// TaskOps decorator that can reach per-node container state.
	Health string
	// ContainerState is the container's live lifecycle state as reported by the
	// on-node agent (e.g. "running", "restarting", "exited", "dead"); "" by
	// default. Like Health it is an extension point populated by a TaskOps
	// decorator. Unlike CurrentState (the swarm task state) it reflects the
	// container's `docker ps` state, which the remote Swarm API cannot report;
	// the services view shows it as a fallback when Health is empty so container
	// errors surface even for images without a healthcheck.
	ContainerState string
	// PullProgress summarizes the image pull the task's node is currently
	// performing for it (e.g. "pulling · 3/12 layers · 412 MB"); "" when nothing
	// is being pulled or the progress is unavailable. A task whose image is still
	// downloading sits in "preparing" with no further detail — the Swarm API
	// carries no pull progress at all — so the default loaders leave this empty;
	// it is an extension point populated by a TaskOps decorator that can reach
	// the node performing the pull.
	PullProgress string
	CreatedAt    time.Time
	UpdatedAt    time.Time
}

type TaskOps interface {
	GetTasksForStack(stackName string) ([]TaskEntry, error)
	GetTasksForService(serviceID string) ([]TaskEntry, error)
}

type TaskTemplate struct {
	ContainerSpec *ContainerSpec `json:"ContainerSpec,omitempty"`
	Resources     *Resources     `json:"Resources,omitempty"`
	RestartPolicy *RestartPolicy `json:"RestartPolicy,omitempty"`
	Placement     *Placement     `json:"Placement,omitempty"`
	Networks      []NetRef       `json:"Networks,omitempty"`
	ForceUpdate   uint64         `json:"ForceUpdate,omitempty"`
	LogDriver     *LogDriver     `json:"LogDriver,omitempty"`
}

type Ulimit struct {
	Name string `json:"Name"`
	Hard int64  `json:"Hard"`
	Soft int64  `json:"Soft"`
}

type UpdateConfig struct {
	Parallelism     uint64  `json:"Parallelism,omitempty"`
	Delay           int64   `json:"Delay,omitempty"`
	FailureAction   string  `json:"FailureAction,omitempty"`
	Monitor         int64   `json:"Monitor,omitempty"`
	MaxFailureRatio float32 `json:"MaxFailureRatio,omitempty"`
	Order           string  `json:"Order,omitempty"`
}

type VolumeInfo struct {
	Name       string
	Stack      string // com.docker.stack.namespace label, "" if not stack-managed
	Driver     string
	Mountpoint string
	Created    time.Time
	Host       string // node hostname the volume lives on (display)
	NodeID     string // swarm node ID the volume lives on; "" for the CE single-node impl, filled by aggregating implementations for node-addressed actions
	Labels     map[string]string
	Raw        *volume.Volume // underlying SDK object, for inspect
}

type VolumeOps interface {
	ListVolumes(ctx context.Context) ([]VolumeInfo, error)
	InspectVolume(ctx context.Context, name string) (volume.Volume, error)
}