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:"-"`
	// Ports are its exposed ports and their host bindings (run -p,
	// --expose, the image's ExposedPorts); PublishAll gives each exposed
	// port without a binding one the system picks (run -P).
	Ports      portmap.Map `json:"-"`
	PublishAll bool        `json:"-"`
	// Restart is its restart policy (run --restart; see restart.go).
	Restart RestartPolicy `json:"-"`
	// Healthcheck is its health check (the image's, or run --health-*;
	// see health.go); nil or NONE for none.
	Healthcheck *HealthConfig `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 Exec struct {
	ID          string
	ContainerID string
	Config      ExecConfig
	// contains filtered or unexported fields
}

type ExecConfig struct {
	Cmd        []string
	Env        []string
	WorkingDir string
	// User must be empty, "root" or "0": a WebAssembly container has no
	// users.
	User                                    string
	Tty                                     bool
	AttachStdin, AttachStdout, AttachStderr bool
	// ConsoleSize is the initial terminal size, height then width (0, 0:
	// 80x24).
	ConsoleSize [2]uint16
}

type ExecIO struct {
	Stdin          io.Reader
	Stdout, Stderr io.Writer
}

type ExecInfo struct {
	ID, ContainerID string
	Config          ExecConfig
	Running         bool
	ExitCode        int
	// Started reports whether a start was asked; Ended, that it has
	// ended (or failed to start): ExitCode is meaningful then.
	Started, Ended bool
	Pid            uint32
}

type Health struct {
	Status        string
	FailingStreak int
	Log           []HealthResult
}

type HealthConfig struct {
	Test          []string      `json:"test,omitempty"`
	Interval      time.Duration `json:"interval,omitempty"`
	Timeout       time.Duration `json:"timeout,omitempty"`
	StartPeriod   time.Duration `json:"startPeriod,omitempty"`
	StartInterval time.Duration `json:"startInterval,omitempty"`
	Retries       int           `json:"retries,omitempty"`
}

type HealthResult struct {
	Start, End time.Time
	ExitCode   int
	Output     string
}

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)
	// Ports is where published ports listen (wctrd: portmap.OS); nil
	// means this engine cannot publish them, and a container that asks
	// is refused at start.
	Ports portmap.Host
	// PortLimits bound each published port (zero: portmap.DefaultLimits).
	PortLimits portmap.Limits
}

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

type RestartPolicy struct {
	Name              string `json:"name,omitempty"`
	MaximumRetryCount int    `json:"maximumRetryCount,omitempty"`
}

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
	// Ports are the published ports while it runs, as bound (a picked
	// host port as picked); nil otherwise.
	Ports portmap.Map
	// RestartCount is how many times its policy restarted it since a user
	// last started it.
	RestartCount int
	// Health is its health state, nil without a check.
	Health *Health
}

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