container

type Attachment struct {
	// Network is the network's name; "" is the engine's default.
	Network string   `json:"network"`
	Aliases []string `json:"aliases,omitempty"`
}

type Config struct {
	Image      string            `json:"Image"`
	ImageID    string            `json:"-"`
	Entrypoint []string          `json:"Entrypoint"`
	Cmd        []string          `json:"Cmd"`
	Env        []string          `json:"Env"`
	WorkingDir string            `json:"WorkingDir"`
	Labels     map[string]string `json:"Labels"`
	// MemoryLimitBytes bounds linear memory (0 = manager default).
	MemoryLimitBytes int64 `json:"-"`
	// AutoRemove removes the container when it exits (run --rm).
	AutoRemove bool `json:"-"`
	// Mounts are the volumes it mounts (run -v NAME:/path[:ro]).
	Mounts []Mount `json:"-"`
	// Networks are the networks it joins (run --network and
	// --network-alias, network connect), the first one its primary: empty
	// for the engine's default, [{none}] for no network.
	Networks []Attachment `json:"-"`
	// Caps are device capabilities granted to it (run --gpu: "gpu").
	Caps []string `json:"-"`
}

type Container struct {
	// contains filtered or unexported fields
}

type CreateOptions struct {
	Name   string
	Config Config
	// Lower is the image's frozen root filesystem.
	Lower *rootfs.FS
}

type Logs struct {
	// contains filtered or unexported fields
}

type Manager struct {
	// contains filtered or unexported fields
}

type Mount struct {
	Volume   string `json:"volume"`
	Target   string `json:"target"`
	ReadOnly bool   `json:"readOnly,omitempty"`
}

type NetworkInfo struct {
	Network string
	Aliases []string
	// IPAddress is its address there while it runs.
	IPAddress netip.Addr
}

type Options struct {
	Executor runtime.Executor
	// MemoryLimitBytes is the default linear-memory bound per container.
	MemoryLimitBytes int64
	// Timeout is the wall-clock bound of one run (0 = none).
	Timeout time.Duration
	// Quota bounds what one container may write to its filesystem.
	Quota rootfs.Quota
	// MaxLogBytes bounds one container's kept output (default 8 MiB).
	MaxLogBytes int
	// MaxContainers bounds how many containers exist (default 256).
	MaxContainers int
	// Store, when set, keeps containers across restarts: their state,
	// logs and writable layers (see Restore).
	Store state.Store
	// CheckpointEvery is how often a running container's changes are
	// stored (default 2s; negative: only at state changes).
	CheckpointEvery time.Duration
	// Events, when set, receives create, start, die, kill, stop, restart,
	// destroy and prune, with Docker's attributes (image, name, labels,
	// exitCode).
	Events *events.Bus
	// Volume finds a volume's tree by name, for Config.Mounts.
	Volume func(name string) (*rootfs.FS, error)
	// Network attaches a container to one of Config.Networks under its DNS
	// name and aliases; nil means containers have no network.
	Network func(ctx context.Context, network, name string, aliases []string) (netdriver.Endpoint, error)
}

type Record struct {
	Stream byte
	Data   []byte
	Time   time.Time
}

type RestoreReport struct {
	// Restored containers, of which Stopped were running when the engine
	// stopped and are now exited with status 137.
	Restored, Stopped int
	// Removed are --rm containers that had run, removed as they would
	// have been.
	Removed []string
	// Repaired describes what was found corrupted and dropped.
	Repaired []string
}

type Snapshot struct {
	ID         string
	Name       string
	Created    time.Time
	Config     Config
	State      State
	ExitCode   int
	Error      string
	TimedOut   bool
	StartedAt  time.Time
	FinishedAt time.Time
	// Path is the resolved module path (empty until the first start).
	Path string
	// SizeRw is the bytes the container wrote to its filesystem.
	SizeRw int64
	// IPAddress is its address on its primary network while it runs.
	IPAddress netip.Addr
	// Networks are its networks, with their addresses while it runs.
	Networks []NetworkInfo
}

type State string

type Stats struct {
	Read    time.Time
	Running bool
	// MemoryBytes is the guest's linear memory (0 when not running);
	// MemoryLimitBytes the most it may grow to.
	MemoryBytes, MemoryLimitBytes int64
	// WrittenBytes is everything written to its filesystem, ever;
	// SizeRw what its writable layer holds now.
	WrittenBytes, SizeRw int64
	// LogBytes is the output kept.
	LogBytes int64
}

type WaitCondition string