visor/runsc/boot/zap.go

// Copyright 2026 The gVisor Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Code generated by zip; DO NOT EDIT.

package boot

import (
	"encoding/binary"
	"fmt"
	"net"
	"strings"
	"time"

	zap "github.com/zap-proto/go"
	checkpoint "gvisor.dev/gvisor/pkg/sentry/checkpoint"
	control "gvisor.dev/gvisor/pkg/sentry/control"
	seccheck "gvisor.dev/gvisor/pkg/sentry/seccheck"
	procfs "gvisor.dev/gvisor/runsc/boot/procfs"
	config "gvisor.dev/gvisor/runsc/config"
	specutils "gvisor.dev/gvisor/runsc/specutils"
)

// ---- CPU ---------------------------------------------------------------

const (
	cPUUsageAt = 0
	cPUSize    = 8
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*CPU)(nil)

// MarshalZAP writes CPU from constant offsets.
func (x *CPU) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(cPUSize + 256)
	ob := b.StartObject(cPUSize)
	innerUsage, err := x.Usage.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(cPUUsageAt, innerUsage)
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads CPU out of the buffer that arrived.
func (x *CPU) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("CPU: %w", err)
	}
	o := m.Root()
	if raw := o.Bytes(cPUUsageAt); len(raw) > 0 {
		if err := x.Usage.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	return nil
}

// ---- CPUUsage ----------------------------------------------------------

const (
	cPUUsageKernelAt = 0
	cPUUsageUserAt   = 8
	cPUUsageTotalAt  = 16
	cPUUsagePerCPUAt = 24
	cPUUsageSize     = 32
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*CPUUsage)(nil)

// MarshalZAP writes CPUUsage from constant offsets.
func (x *CPUUsage) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(cPUUsageSize + 256)
	perCPUAt, perCPUN := 0, len(x.PerCPU)
	if perCPUN > 0 {
		var blob []byte
		for i := range x.PerCPU {
			var full [8]byte
			binary.LittleEndian.PutUint64(full[:], uint64(x.PerCPU[i]))
			enc := full[:8]
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		perCPUAt = b.WriteBytes(blob)
	}
	ob := b.StartObject(cPUUsageSize)
	ob.SetUint64(cPUUsageKernelAt, uint64(x.Kernel))
	ob.SetUint64(cPUUsageUserAt, uint64(x.User))
	ob.SetUint64(cPUUsageTotalAt, uint64(x.Total))
	if perCPUN > 0 {
		ob.SetList(cPUUsagePerCPUAt, perCPUAt, perCPUN)
	}
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads CPUUsage out of the buffer that arrived.
func (x *CPUUsage) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("CPUUsage: %w", err)
	}
	o := m.Root()
	x.Kernel = uint64(o.Uint64(cPUUsageKernelAt))
	x.User = uint64(o.Uint64(cPUUsageUserAt))
	x.Total = uint64(o.Uint64(cPUUsageTotalAt))
	if l := o.List(cPUUsagePerCPUAt); l.Len() > 0 {
		rows := make([]uint64, l.Len())
		for i := range rows {
			var full [8]byte
			copy(full[:], l.BytesAt(i))
			rows[i] = uint64(binary.LittleEndian.Uint64(full[:]))
		}
		x.PerCPU = rows
	}
	return nil
}

// ---- CreateArgs --------------------------------------------------------

const (
	createArgsCIDAt         = 0
	createArgsFilePayloadAt = 8
	createArgsSize          = 16
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*CreateArgs)(nil)

// MarshalZAP writes CreateArgs from constant offsets.
func (x *CreateArgs) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(createArgsSize + 256)
	ob := b.StartObject(createArgsSize)
	ob.SetText(createArgsCIDAt, string(x.CID))
	innerFilePayload, err := x.FilePayload.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(createArgsFilePayloadAt, innerFilePayload)
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads CreateArgs out of the buffer that arrived.
func (x *CreateArgs) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("CreateArgs: %w", err)
	}
	o := m.Root()
	x.CID = string(strings.Clone(o.Text(createArgsCIDAt)))
	if raw := o.Bytes(createArgsFilePayloadAt); len(raw) > 0 {
		if err := x.FilePayload.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	return nil
}

// ---- CreateLinksAndRoutesArgs ------------------------------------------

const (
	createLinksAndRoutesArgsFilePayloadAt             = 0
	createLinksAndRoutesArgsLoopbackLinksAt           = 8
	createLinksAndRoutesArgsFDBasedLinksAt            = 16
	createLinksAndRoutesArgsXDPLinksAt                = 24
	createLinksAndRoutesArgsDefaultv4GatewayAt        = 32
	createLinksAndRoutesArgsDefaultv6GatewayAt        = 40
	createLinksAndRoutesArgsPCAPAt                    = 48
	createLinksAndRoutesArgsLogPacketsAt              = 49
	createLinksAndRoutesArgsNATBlobAt                 = 50
	createLinksAndRoutesArgsPauseExternalNetworkingAt = 51
	createLinksAndRoutesArgsAllowConnectedOnSaveAt    = 52
	createLinksAndRoutesArgsIsRestoreAt               = 53
	createLinksAndRoutesArgsSize                      = 56
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*CreateLinksAndRoutesArgs)(nil)

// MarshalZAP writes CreateLinksAndRoutesArgs from constant offsets.
func (x *CreateLinksAndRoutesArgs) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(createLinksAndRoutesArgsSize + 256)
	loopbackLinksAt, loopbackLinksN := 0, len(x.LoopbackLinks)
	if loopbackLinksN > 0 {
		var blob []byte
		for i := range x.LoopbackLinks {
			enc, err := x.LoopbackLinks[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		loopbackLinksAt = b.WriteBytes(blob)
	}
	fDBasedLinksAt, fDBasedLinksN := 0, len(x.FDBasedLinks)
	if fDBasedLinksN > 0 {
		var blob []byte
		for i := range x.FDBasedLinks {
			enc, err := x.FDBasedLinks[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		fDBasedLinksAt = b.WriteBytes(blob)
	}
	xDPLinksAt, xDPLinksN := 0, len(x.XDPLinks)
	if xDPLinksN > 0 {
		var blob []byte
		for i := range x.XDPLinks {
			enc, err := x.XDPLinks[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		xDPLinksAt = b.WriteBytes(blob)
	}
	ob := b.StartObject(createLinksAndRoutesArgsSize)
	innerFilePayload, err := x.FilePayload.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(createLinksAndRoutesArgsFilePayloadAt, innerFilePayload)
	innerDefaultv4Gateway, err := x.Defaultv4Gateway.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(createLinksAndRoutesArgsDefaultv4GatewayAt, innerDefaultv4Gateway)
	innerDefaultv6Gateway, err := x.Defaultv6Gateway.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(createLinksAndRoutesArgsDefaultv6GatewayAt, innerDefaultv6Gateway)
	ob.SetBool(createLinksAndRoutesArgsPCAPAt, bool(x.PCAP))
	ob.SetBool(createLinksAndRoutesArgsLogPacketsAt, bool(x.LogPackets))
	ob.SetBool(createLinksAndRoutesArgsNATBlobAt, bool(x.NATBlob))
	ob.SetBool(createLinksAndRoutesArgsPauseExternalNetworkingAt, bool(x.PauseExternalNetworking))
	ob.SetBool(createLinksAndRoutesArgsAllowConnectedOnSaveAt, bool(x.AllowConnectedOnSave))
	ob.SetBool(createLinksAndRoutesArgsIsRestoreAt, bool(x.IsRestore))
	if loopbackLinksN > 0 {
		ob.SetList(createLinksAndRoutesArgsLoopbackLinksAt, loopbackLinksAt, loopbackLinksN)
	}
	if fDBasedLinksN > 0 {
		ob.SetList(createLinksAndRoutesArgsFDBasedLinksAt, fDBasedLinksAt, fDBasedLinksN)
	}
	if xDPLinksN > 0 {
		ob.SetList(createLinksAndRoutesArgsXDPLinksAt, xDPLinksAt, xDPLinksN)
	}
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads CreateLinksAndRoutesArgs out of the buffer that arrived.
func (x *CreateLinksAndRoutesArgs) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("CreateLinksAndRoutesArgs: %w", err)
	}
	o := m.Root()
	if raw := o.Bytes(createLinksAndRoutesArgsFilePayloadAt); len(raw) > 0 {
		if err := x.FilePayload.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	if l := o.List(createLinksAndRoutesArgsLoopbackLinksAt); l.Len() > 0 {
		rows := make([]LoopbackLink, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.LoopbackLinks = rows
	}
	if l := o.List(createLinksAndRoutesArgsFDBasedLinksAt); l.Len() > 0 {
		rows := make([]FDBasedLink, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.FDBasedLinks = rows
	}
	if l := o.List(createLinksAndRoutesArgsXDPLinksAt); l.Len() > 0 {
		rows := make([]XDPLink, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.XDPLinks = rows
	}
	if raw := o.Bytes(createLinksAndRoutesArgsDefaultv4GatewayAt); len(raw) > 0 {
		if err := x.Defaultv4Gateway.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	if raw := o.Bytes(createLinksAndRoutesArgsDefaultv6GatewayAt); len(raw) > 0 {
		if err := x.Defaultv6Gateway.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	x.PCAP = bool(o.Bool(createLinksAndRoutesArgsPCAPAt))
	x.LogPackets = bool(o.Bool(createLinksAndRoutesArgsLogPacketsAt))
	x.NATBlob = bool(o.Bool(createLinksAndRoutesArgsNATBlobAt))
	x.PauseExternalNetworking = bool(o.Bool(createLinksAndRoutesArgsPauseExternalNetworkingAt))
	x.AllowConnectedOnSave = bool(o.Bool(createLinksAndRoutesArgsAllowConnectedOnSaveAt))
	x.IsRestore = bool(o.Bool(createLinksAndRoutesArgsIsRestoreAt))
	return nil
}

// ---- CreateTraceSessionArgs --------------------------------------------

const (
	createTraceSessionArgsConfigAt      = 0
	createTraceSessionArgsForceAt       = 8
	createTraceSessionArgsFilePayloadAt = 16
	createTraceSessionArgsSize          = 24
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*CreateTraceSessionArgs)(nil)

// MarshalZAP writes CreateTraceSessionArgs from constant offsets.
func (x *CreateTraceSessionArgs) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(createTraceSessionArgsSize + 256)
	ob := b.StartObject(createTraceSessionArgsSize)
	innerConfig, err := x.Config.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(createTraceSessionArgsConfigAt, innerConfig)
	ob.SetBool(createTraceSessionArgsForceAt, bool(x.Force))
	innerFilePayload, err := x.FilePayload.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(createTraceSessionArgsFilePayloadAt, innerFilePayload)
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads CreateTraceSessionArgs out of the buffer that arrived.
func (x *CreateTraceSessionArgs) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("CreateTraceSessionArgs: %w", err)
	}
	o := m.Root()
	if raw := o.Bytes(createTraceSessionArgsConfigAt); len(raw) > 0 {
		if err := x.Config.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	x.Force = bool(o.Bool(createTraceSessionArgsForceAt))
	if raw := o.Bytes(createTraceSessionArgsFilePayloadAt); len(raw) > 0 {
		if err := x.FilePayload.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	return nil
}

// ---- DefaultRoute ------------------------------------------------------

const (
	defaultRouteRouteAt = 0
	defaultRouteNameAt  = 8
	defaultRouteSize    = 16
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*DefaultRoute)(nil)

// MarshalZAP writes DefaultRoute from constant offsets.
func (x *DefaultRoute) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(defaultRouteSize + 256)
	ob := b.StartObject(defaultRouteSize)
	innerRoute, err := x.Route.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(defaultRouteRouteAt, innerRoute)
	ob.SetText(defaultRouteNameAt, string(x.Name))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads DefaultRoute out of the buffer that arrived.
func (x *DefaultRoute) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("DefaultRoute: %w", err)
	}
	o := m.Root()
	if raw := o.Bytes(defaultRouteRouteAt); len(raw) > 0 {
		if err := x.Route.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	x.Name = string(strings.Clone(o.Text(defaultRouteNameAt)))
	return nil
}

// ---- DeleteTraceSessionArgs --------------------------------------------

const (
	deleteTraceSessionArgsNameAt = 0
	deleteTraceSessionArgsSize   = 8
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*DeleteTraceSessionArgs)(nil)

// MarshalZAP writes DeleteTraceSessionArgs from constant offsets.
func (x *DeleteTraceSessionArgs) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(deleteTraceSessionArgsSize + 256)
	ob := b.StartObject(deleteTraceSessionArgsSize)
	ob.SetText(deleteTraceSessionArgsNameAt, string(x.Name))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads DeleteTraceSessionArgs out of the buffer that arrived.
func (x *DeleteTraceSessionArgs) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("DeleteTraceSessionArgs: %w", err)
	}
	o := m.Root()
	x.Name = string(strings.Clone(o.Text(deleteTraceSessionArgsNameAt)))
	return nil
}

// ---- Event -------------------------------------------------------------

const (
	eventTypeAt = 0
	eventIDAt   = 8
	eventDataAt = 16
	eventSize   = 24
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*Event)(nil)

// MarshalZAP writes Event from constant offsets.
func (x *Event) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(eventSize + 256)
	ob := b.StartObject(eventSize)
	ob.SetText(eventTypeAt, string(x.Type))
	ob.SetText(eventIDAt, string(x.ID))
	innerData, err := x.Data.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(eventDataAt, innerData)
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads Event out of the buffer that arrived.
func (x *Event) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("Event: %w", err)
	}
	o := m.Root()
	x.Type = string(strings.Clone(o.Text(eventTypeAt)))
	x.ID = string(strings.Clone(o.Text(eventIDAt)))
	if raw := o.Bytes(eventDataAt); len(raw) > 0 {
		if err := x.Data.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	return nil
}

// ---- EventOut ----------------------------------------------------------

const (
	eventOutEventAt          = 0
	eventOutContainerUsageAt = 8
	eventOutSize             = 16
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*EventOut)(nil)

// MarshalZAP writes EventOut from constant offsets.
func (x *EventOut) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(eventOutSize + 256)
	containerUsageAt, containerUsageN := 0, len(x.ContainerUsage)
	if containerUsageN > 0 {
		var blob []byte
		for i := range x.ContainerUsage {
			enc, err := x.ContainerUsage[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		containerUsageAt = b.WriteBytes(blob)
	}
	ob := b.StartObject(eventOutSize)
	innerEvent, err := x.Event.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(eventOutEventAt, innerEvent)
	if containerUsageN > 0 {
		ob.SetList(eventOutContainerUsageAt, containerUsageAt, containerUsageN)
	}
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads EventOut out of the buffer that arrived.
func (x *EventOut) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("EventOut: %w", err)
	}
	o := m.Root()
	if raw := o.Bytes(eventOutEventAt); len(raw) > 0 {
		if err := x.Event.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	if l := o.List(eventOutContainerUsageAt); l.Len() > 0 {
		rows := make([]Usage, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.ContainerUsage = rows
	}
	return nil
}

// ---- ExecResult --------------------------------------------------------

const (
	execResultPIDAt = 0
	execResultSize  = 8
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*ExecResult)(nil)

// MarshalZAP writes ExecResult from constant offsets.
func (x *ExecResult) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(execResultSize + 256)
	ob := b.StartObject(execResultSize)
	ob.SetInt32(execResultPIDAt, int32(x.PID))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads ExecResult out of the buffer that arrived.
func (x *ExecResult) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("ExecResult: %w", err)
	}
	o := m.Root()
	x.PID = int32(o.Int32(execResultPIDAt))
	return nil
}

// ---- FDBasedLink -------------------------------------------------------

const (
	fDBasedLinkNameAt                 = 0
	fDBasedLinkInterfaceIndexAt       = 8
	fDBasedLinkMTUAt                  = 16
	fDBasedLinkAddressesAt            = 24
	fDBasedLinkRoutesAt               = 32
	fDBasedLinkGSOMaxSizeAt           = 40
	fDBasedLinkGVisorGSOEnabledAt     = 44
	fDBasedLinkGVisorGROAt            = 45
	fDBasedLinkTXChecksumOffloadAt    = 46
	fDBasedLinkRXChecksumOffloadAt    = 47
	fDBasedLinkLinkAddressAt          = 48
	fDBasedLinkQDiscAt                = 56
	fDBasedLinkTBFRateAt              = 64
	fDBasedLinkTBFBurstAt             = 72
	fDBasedLinkNeighborsAt            = 80
	fDBasedLinkNumChannelsAt          = 88
	fDBasedLinkProcessorsPerChannelAt = 96
	fDBasedLinkIsPacketAt             = 104
	fDBasedLinkPreConfiguredAt        = 112
	fDBasedLinkSize                   = 120
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*FDBasedLink)(nil)

// MarshalZAP writes FDBasedLink from constant offsets.
func (x *FDBasedLink) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(fDBasedLinkSize + 256)
	addressesAt, addressesN := 0, len(x.Addresses)
	if addressesN > 0 {
		var blob []byte
		for i := range x.Addresses {
			enc, err := x.Addresses[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		addressesAt = b.WriteBytes(blob)
	}
	routesAt, routesN := 0, len(x.Routes)
	if routesN > 0 {
		var blob []byte
		for i := range x.Routes {
			enc, err := x.Routes[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		routesAt = b.WriteBytes(blob)
	}
	neighborsAt, neighborsN := 0, len(x.Neighbors)
	if neighborsN > 0 {
		var blob []byte
		for i := range x.Neighbors {
			enc, err := x.Neighbors[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		neighborsAt = b.WriteBytes(blob)
	}
	isPacketAt, isPacketN := 0, len(x.IsPacket)
	if isPacketN > 0 {
		var blob []byte
		for i := range x.IsPacket {
			enc := []byte{0}
			if x.IsPacket[i] {
				enc[0] = 1
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		isPacketAt = b.WriteBytes(blob)
	}
	ob := b.StartObject(fDBasedLinkSize)
	ob.SetText(fDBasedLinkNameAt, string(x.Name))
	ob.SetInt64(fDBasedLinkInterfaceIndexAt, int64(x.InterfaceIndex))
	ob.SetInt64(fDBasedLinkMTUAt, int64(x.MTU))
	ob.SetUint32(fDBasedLinkGSOMaxSizeAt, uint32(x.GSOMaxSize))
	ob.SetBool(fDBasedLinkGVisorGSOEnabledAt, bool(x.GVisorGSOEnabled))
	ob.SetBool(fDBasedLinkGVisorGROAt, bool(x.GVisorGRO))
	ob.SetBool(fDBasedLinkTXChecksumOffloadAt, bool(x.TXChecksumOffload))
	ob.SetBool(fDBasedLinkRXChecksumOffloadAt, bool(x.RXChecksumOffload))
	ob.SetBytes(fDBasedLinkLinkAddressAt, []byte(x.LinkAddress))
	ob.SetInt64(fDBasedLinkQDiscAt, int64(x.QDisc))
	ob.SetUint64(fDBasedLinkTBFRateAt, uint64(x.TBFRate))
	ob.SetUint32(fDBasedLinkTBFBurstAt, uint32(x.TBFBurst))
	ob.SetInt64(fDBasedLinkNumChannelsAt, int64(x.NumChannels))
	ob.SetInt64(fDBasedLinkProcessorsPerChannelAt, int64(x.ProcessorsPerChannel))
	ob.SetBool(fDBasedLinkPreConfiguredAt, bool(x.PreConfigured))
	if addressesN > 0 {
		ob.SetList(fDBasedLinkAddressesAt, addressesAt, addressesN)
	}
	if routesN > 0 {
		ob.SetList(fDBasedLinkRoutesAt, routesAt, routesN)
	}
	if neighborsN > 0 {
		ob.SetList(fDBasedLinkNeighborsAt, neighborsAt, neighborsN)
	}
	if isPacketN > 0 {
		ob.SetList(fDBasedLinkIsPacketAt, isPacketAt, isPacketN)
	}
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads FDBasedLink out of the buffer that arrived.
func (x *FDBasedLink) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("FDBasedLink: %w", err)
	}
	o := m.Root()
	x.Name = string(strings.Clone(o.Text(fDBasedLinkNameAt)))
	x.InterfaceIndex = int(o.Int64(fDBasedLinkInterfaceIndexAt))
	x.MTU = int(o.Int64(fDBasedLinkMTUAt))
	if l := o.List(fDBasedLinkAddressesAt); l.Len() > 0 {
		rows := make([]IPWithPrefix, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.Addresses = rows
	}
	if l := o.List(fDBasedLinkRoutesAt); l.Len() > 0 {
		rows := make([]Route, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.Routes = rows
	}
	x.GSOMaxSize = uint32(o.Uint32(fDBasedLinkGSOMaxSizeAt))
	x.GVisorGSOEnabled = bool(o.Bool(fDBasedLinkGVisorGSOEnabledAt))
	x.GVisorGRO = bool(o.Bool(fDBasedLinkGVisorGROAt))
	x.TXChecksumOffload = bool(o.Bool(fDBasedLinkTXChecksumOffloadAt))
	x.RXChecksumOffload = bool(o.Bool(fDBasedLinkRXChecksumOffloadAt))
	x.LinkAddress = net.HardwareAddr(append([]byte(nil), o.Bytes(fDBasedLinkLinkAddressAt)...))
	x.QDisc = config.QueueingDiscipline(o.Int64(fDBasedLinkQDiscAt))
	x.TBFRate = uint64(o.Uint64(fDBasedLinkTBFRateAt))
	x.TBFBurst = uint32(o.Uint32(fDBasedLinkTBFBurstAt))
	if l := o.List(fDBasedLinkNeighborsAt); l.Len() > 0 {
		rows := make([]Neighbor, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.Neighbors = rows
	}
	x.NumChannels = int(o.Int64(fDBasedLinkNumChannelsAt))
	x.ProcessorsPerChannel = int(o.Int64(fDBasedLinkProcessorsPerChannelAt))
	if l := o.List(fDBasedLinkIsPacketAt); l.Len() > 0 {
		rows := make([]bool, l.Len())
		for i := range rows {
			raw := l.BytesAt(i)
			rows[i] = bool(len(raw) > 0 && raw[0] != 0)
		}
		x.IsPacket = rows
	}
	x.PreConfigured = bool(o.Bool(fDBasedLinkPreConfiguredAt))
	return nil
}

// ---- FSSaveArgs --------------------------------------------------------

const (
	fSSaveArgsFilePayloadAt        = 0
	fSSaveArgsPathsAt              = 8
	fSSaveArgsExitAfterSavingAt    = 16
	fSSaveArgsUseCheckpointGoferAt = 17
	fSSaveArgsSize                 = 24
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*FSSaveArgs)(nil)

// MarshalZAP writes FSSaveArgs from constant offsets.
func (x *FSSaveArgs) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(fSSaveArgsSize + 256)
	pathsAt, pathsN := 0, len(x.Paths)
	if pathsN > 0 {
		var blob []byte
		for i := range x.Paths {
			enc, err := x.Paths[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		pathsAt = b.WriteBytes(blob)
	}
	ob := b.StartObject(fSSaveArgsSize)
	innerFilePayload, err := x.FilePayload.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(fSSaveArgsFilePayloadAt, innerFilePayload)
	ob.SetBool(fSSaveArgsExitAfterSavingAt, bool(x.ExitAfterSaving))
	ob.SetBool(fSSaveArgsUseCheckpointGoferAt, bool(x.UseCheckpointGofer))
	if pathsN > 0 {
		ob.SetList(fSSaveArgsPathsAt, pathsAt, pathsN)
	}
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads FSSaveArgs out of the buffer that arrived.
func (x *FSSaveArgs) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("FSSaveArgs: %w", err)
	}
	o := m.Root()
	if raw := o.Bytes(fSSaveArgsFilePayloadAt); len(raw) > 0 {
		if err := x.FilePayload.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	if l := o.List(fSSaveArgsPathsAt); l.Len() > 0 {
		rows := make([]checkpoint.ResourceID, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.Paths = rows
	}
	x.ExitAfterSaving = bool(o.Bool(fSSaveArgsExitAfterSavingAt))
	x.UseCheckpointGofer = bool(o.Bool(fSSaveArgsUseCheckpointGoferAt))
	return nil
}

// ---- IPWithPrefix ------------------------------------------------------

const (
	iPWithPrefixAddressAt   = 0
	iPWithPrefixPrefixLenAt = 8
	iPWithPrefixSize        = 16
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*IPWithPrefix)(nil)

// MarshalZAP writes IPWithPrefix from constant offsets.
func (x *IPWithPrefix) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(iPWithPrefixSize + 256)
	ob := b.StartObject(iPWithPrefixSize)
	ob.SetBytes(iPWithPrefixAddressAt, []byte(x.Address))
	ob.SetInt64(iPWithPrefixPrefixLenAt, int64(x.PrefixLen))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads IPWithPrefix out of the buffer that arrived.
func (x *IPWithPrefix) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("IPWithPrefix: %w", err)
	}
	o := m.Root()
	x.Address = net.IP(append([]byte(nil), o.Bytes(iPWithPrefixAddressAt)...))
	x.PrefixLen = int(o.Int64(iPWithPrefixPrefixLenAt))
	return nil
}

// ---- InitPluginStackArgs -----------------------------------------------

const (
	initPluginStackArgsFilePayloadAt = 0
	initPluginStackArgsInitStrAt     = 8
	initPluginStackArgsSize          = 16
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*InitPluginStackArgs)(nil)

// MarshalZAP writes InitPluginStackArgs from constant offsets.
func (x *InitPluginStackArgs) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(initPluginStackArgsSize + 256)
	ob := b.StartObject(initPluginStackArgsSize)
	innerFilePayload, err := x.FilePayload.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(initPluginStackArgsFilePayloadAt, innerFilePayload)
	ob.SetText(initPluginStackArgsInitStrAt, string(x.InitStr))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads InitPluginStackArgs out of the buffer that arrived.
func (x *InitPluginStackArgs) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("InitPluginStackArgs: %w", err)
	}
	o := m.Root()
	if raw := o.Bytes(initPluginStackArgsFilePayloadAt); len(raw) > 0 {
		if err := x.FilePayload.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	x.InitStr = string(strings.Clone(o.Text(initPluginStackArgsInitStrAt)))
	return nil
}

// ---- LoopbackLink ------------------------------------------------------

const (
	loopbackLinkNameAt      = 0
	loopbackLinkAddressesAt = 8
	loopbackLinkRoutesAt    = 16
	loopbackLinkGVisorGROAt = 24
	loopbackLinkSize        = 32
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*LoopbackLink)(nil)

// MarshalZAP writes LoopbackLink from constant offsets.
func (x *LoopbackLink) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(loopbackLinkSize + 256)
	addressesAt, addressesN := 0, len(x.Addresses)
	if addressesN > 0 {
		var blob []byte
		for i := range x.Addresses {
			enc, err := x.Addresses[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		addressesAt = b.WriteBytes(blob)
	}
	routesAt, routesN := 0, len(x.Routes)
	if routesN > 0 {
		var blob []byte
		for i := range x.Routes {
			enc, err := x.Routes[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		routesAt = b.WriteBytes(blob)
	}
	ob := b.StartObject(loopbackLinkSize)
	ob.SetText(loopbackLinkNameAt, string(x.Name))
	ob.SetBool(loopbackLinkGVisorGROAt, bool(x.GVisorGRO))
	if addressesN > 0 {
		ob.SetList(loopbackLinkAddressesAt, addressesAt, addressesN)
	}
	if routesN > 0 {
		ob.SetList(loopbackLinkRoutesAt, routesAt, routesN)
	}
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads LoopbackLink out of the buffer that arrived.
func (x *LoopbackLink) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("LoopbackLink: %w", err)
	}
	o := m.Root()
	x.Name = string(strings.Clone(o.Text(loopbackLinkNameAt)))
	if l := o.List(loopbackLinkAddressesAt); l.Len() > 0 {
		rows := make([]IPWithPrefix, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.Addresses = rows
	}
	if l := o.List(loopbackLinkRoutesAt); l.Len() > 0 {
		rows := make([]Route, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.Routes = rows
	}
	x.GVisorGRO = bool(o.Bool(loopbackLinkGVisorGROAt))
	return nil
}

// ---- Memory ------------------------------------------------------------

const (
	memoryCacheAt     = 0
	memoryUsageAt     = 8
	memorySwapAt      = 16
	memoryKernelAt    = 24
	memoryKernelTCPAt = 32
	memoryRawAt       = 40
	memorySize        = 48
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*Memory)(nil)

// MarshalZAP writes Memory from constant offsets.
func (x *Memory) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(memorySize + 256)
	rawAt, rawN := 0, len(x.Raw)
	if rawN > 0 {
		var blob []byte
		for i := range x.Raw {
			enc, err := x.Raw[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		rawAt = b.WriteBytes(blob)
	}
	ob := b.StartObject(memorySize)
	ob.SetUint64(memoryCacheAt, uint64(x.Cache))
	innerUsage, err := x.Usage.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(memoryUsageAt, innerUsage)
	innerSwap, err := x.Swap.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(memorySwapAt, innerSwap)
	innerKernel, err := x.Kernel.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(memoryKernelAt, innerKernel)
	innerKernelTCP, err := x.KernelTCP.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(memoryKernelTCPAt, innerKernelTCP)
	if rawN > 0 {
		ob.SetList(memoryRawAt, rawAt, rawN)
	}
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads Memory out of the buffer that arrived.
func (x *Memory) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("Memory: %w", err)
	}
	o := m.Root()
	x.Cache = uint64(o.Uint64(memoryCacheAt))
	if raw := o.Bytes(memoryUsageAt); len(raw) > 0 {
		if err := x.Usage.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	if raw := o.Bytes(memorySwapAt); len(raw) > 0 {
		if err := x.Swap.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	if raw := o.Bytes(memoryKernelAt); len(raw) > 0 {
		if err := x.Kernel.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	if raw := o.Bytes(memoryKernelTCPAt); len(raw) > 0 {
		if err := x.KernelTCP.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	if l := o.List(memoryRawAt); l.Len() > 0 {
		rows := make([]Stat, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.Raw = rows
	}
	return nil
}

// ---- MemoryEntry -------------------------------------------------------

const (
	memoryEntryLimitAt   = 0
	memoryEntryUsageAt   = 8
	memoryEntryMaxAt     = 16
	memoryEntryFailcntAt = 24
	memoryEntrySize      = 32
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*MemoryEntry)(nil)

// MarshalZAP writes MemoryEntry from constant offsets.
func (x *MemoryEntry) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(memoryEntrySize + 256)
	ob := b.StartObject(memoryEntrySize)
	ob.SetUint64(memoryEntryLimitAt, uint64(x.Limit))
	ob.SetUint64(memoryEntryUsageAt, uint64(x.Usage))
	ob.SetUint64(memoryEntryMaxAt, uint64(x.Max))
	ob.SetUint64(memoryEntryFailcntAt, uint64(x.Failcnt))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads MemoryEntry out of the buffer that arrived.
func (x *MemoryEntry) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("MemoryEntry: %w", err)
	}
	o := m.Root()
	x.Limit = uint64(o.Uint64(memoryEntryLimitAt))
	x.Usage = uint64(o.Uint64(memoryEntryUsageAt))
	x.Max = uint64(o.Uint64(memoryEntryMaxAt))
	x.Failcnt = uint64(o.Uint64(memoryEntryFailcntAt))
	return nil
}

// ---- MountArgs ---------------------------------------------------------

const (
	mountArgsContainerIDAt = 0
	mountArgsSourceAt      = 8
	mountArgsDestinationAt = 16
	mountArgsFsTypeAt      = 24
	mountArgsFilePayloadAt = 32
	mountArgsSize          = 40
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*MountArgs)(nil)

// MarshalZAP writes MountArgs from constant offsets.
func (x *MountArgs) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(mountArgsSize + 256)
	ob := b.StartObject(mountArgsSize)
	ob.SetText(mountArgsContainerIDAt, string(x.ContainerID))
	ob.SetText(mountArgsSourceAt, string(x.Source))
	ob.SetText(mountArgsDestinationAt, string(x.Destination))
	ob.SetText(mountArgsFsTypeAt, string(x.FsType))
	innerFilePayload, err := x.FilePayload.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(mountArgsFilePayloadAt, innerFilePayload)
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads MountArgs out of the buffer that arrived.
func (x *MountArgs) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("MountArgs: %w", err)
	}
	o := m.Root()
	x.ContainerID = string(strings.Clone(o.Text(mountArgsContainerIDAt)))
	x.Source = string(strings.Clone(o.Text(mountArgsSourceAt)))
	x.Destination = string(strings.Clone(o.Text(mountArgsDestinationAt)))
	x.FsType = string(strings.Clone(o.Text(mountArgsFsTypeAt)))
	if raw := o.Bytes(mountArgsFilePayloadAt); len(raw) > 0 {
		if err := x.FilePayload.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	return nil
}

// ---- Neighbor ----------------------------------------------------------

const (
	neighborIPAt           = 0
	neighborHardwareAddrAt = 8
	neighborSize           = 16
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*Neighbor)(nil)

// MarshalZAP writes Neighbor from constant offsets.
func (x *Neighbor) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(neighborSize + 256)
	ob := b.StartObject(neighborSize)
	ob.SetBytes(neighborIPAt, []byte(x.IP))
	ob.SetBytes(neighborHardwareAddrAt, []byte(x.HardwareAddr))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads Neighbor out of the buffer that arrived.
func (x *Neighbor) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("Neighbor: %w", err)
	}
	o := m.Root()
	x.IP = net.IP(append([]byte(nil), o.Bytes(neighborIPAt)...))
	x.HardwareAddr = net.HardwareAddr(append([]byte(nil), o.Bytes(neighborHardwareAddrAt)...))
	return nil
}

// ---- NetworkInterface --------------------------------------------------

const (
	networkInterfaceNameAt      = 0
	networkInterfaceRxBytesAt   = 8
	networkInterfaceRxPacketsAt = 16
	networkInterfaceRxErrorsAt  = 24
	networkInterfaceRxDroppedAt = 32
	networkInterfaceTxBytesAt   = 40
	networkInterfaceTxPacketsAt = 48
	networkInterfaceTxErrorsAt  = 56
	networkInterfaceTxDroppedAt = 64
	networkInterfaceSize        = 72
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*NetworkInterface)(nil)

// MarshalZAP writes NetworkInterface from constant offsets.
func (x *NetworkInterface) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(networkInterfaceSize + 256)
	ob := b.StartObject(networkInterfaceSize)
	ob.SetText(networkInterfaceNameAt, string(x.Name))
	ob.SetUint64(networkInterfaceRxBytesAt, uint64(x.RxBytes))
	ob.SetUint64(networkInterfaceRxPacketsAt, uint64(x.RxPackets))
	ob.SetUint64(networkInterfaceRxErrorsAt, uint64(x.RxErrors))
	ob.SetUint64(networkInterfaceRxDroppedAt, uint64(x.RxDropped))
	ob.SetUint64(networkInterfaceTxBytesAt, uint64(x.TxBytes))
	ob.SetUint64(networkInterfaceTxPacketsAt, uint64(x.TxPackets))
	ob.SetUint64(networkInterfaceTxErrorsAt, uint64(x.TxErrors))
	ob.SetUint64(networkInterfaceTxDroppedAt, uint64(x.TxDropped))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads NetworkInterface out of the buffer that arrived.
func (x *NetworkInterface) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("NetworkInterface: %w", err)
	}
	o := m.Root()
	x.Name = string(strings.Clone(o.Text(networkInterfaceNameAt)))
	x.RxBytes = uint64(o.Uint64(networkInterfaceRxBytesAt))
	x.RxPackets = uint64(o.Uint64(networkInterfaceRxPacketsAt))
	x.RxErrors = uint64(o.Uint64(networkInterfaceRxErrorsAt))
	x.RxDropped = uint64(o.Uint64(networkInterfaceRxDroppedAt))
	x.TxBytes = uint64(o.Uint64(networkInterfaceTxBytesAt))
	x.TxPackets = uint64(o.Uint64(networkInterfaceTxPacketsAt))
	x.TxErrors = uint64(o.Uint64(networkInterfaceTxErrorsAt))
	x.TxDropped = uint64(o.Uint64(networkInterfaceTxDroppedAt))
	return nil
}

// ---- Pids --------------------------------------------------------------

const (
	pidsCurrentAt = 0
	pidsLimitAt   = 8
	pidsSize      = 16
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*Pids)(nil)

// MarshalZAP writes Pids from constant offsets.
func (x *Pids) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(pidsSize + 256)
	ob := b.StartObject(pidsSize)
	ob.SetUint64(pidsCurrentAt, uint64(x.Current))
	ob.SetUint64(pidsLimitAt, uint64(x.Limit))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads Pids out of the buffer that arrived.
func (x *Pids) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("Pids: %w", err)
	}
	o := m.Root()
	x.Current = uint64(o.Uint64(pidsCurrentAt))
	x.Limit = uint64(o.Uint64(pidsLimitAt))
	return nil
}

// ---- PortForwardOpts ---------------------------------------------------

const (
	portForwardOptsFilePayloadAt = 0
	portForwardOptsContainerIDAt = 8
	portForwardOptsPortAt        = 16
	portForwardOptsSize          = 24
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*PortForwardOpts)(nil)

// MarshalZAP writes PortForwardOpts from constant offsets.
func (x *PortForwardOpts) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(portForwardOptsSize + 256)
	ob := b.StartObject(portForwardOptsSize)
	innerFilePayload, err := x.FilePayload.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(portForwardOptsFilePayloadAt, innerFilePayload)
	ob.SetText(portForwardOptsContainerIDAt, string(x.ContainerID))
	ob.SetUint16(portForwardOptsPortAt, uint16(x.Port))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads PortForwardOpts out of the buffer that arrived.
func (x *PortForwardOpts) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("PortForwardOpts: %w", err)
	}
	o := m.Root()
	if raw := o.Bytes(portForwardOptsFilePayloadAt); len(raw) > 0 {
		if err := x.FilePayload.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	x.ContainerID = string(strings.Clone(o.Text(portForwardOptsContainerIDAt)))
	x.Port = uint16(o.Uint16(portForwardOptsPortAt))
	return nil
}

// ---- ProcessesResult ---------------------------------------------------

const (
	processesResultProcessesAt = 0
	processesResultSize        = 8
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*ProcessesResult)(nil)

// MarshalZAP writes ProcessesResult from constant offsets.
func (x *ProcessesResult) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(processesResultSize + 256)
	processesAt, processesN := 0, len(x.Processes)
	if processesN > 0 {
		var blob []byte
		for i := range x.Processes {
			elem := x.Processes[i]
			if elem == nil {
				elem = new(control.Process)
			}
			enc, err := elem.MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		processesAt = b.WriteBytes(blob)
	}
	ob := b.StartObject(processesResultSize)
	if processesN > 0 {
		ob.SetList(processesResultProcessesAt, processesAt, processesN)
	}
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads ProcessesResult out of the buffer that arrived.
func (x *ProcessesResult) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("ProcessesResult: %w", err)
	}
	o := m.Root()
	if l := o.List(processesResultProcessesAt); l.Len() > 0 {
		rows := make([]*control.Process, l.Len())
		for i := range rows {
			rows[i] = new(control.Process)
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.Processes = rows
	}
	return nil
}

// ---- ProcfsResult ------------------------------------------------------

const (
	procfsResultProcessesAt = 0
	procfsResultSize        = 8
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*ProcfsResult)(nil)

// MarshalZAP writes ProcfsResult from constant offsets.
func (x *ProcfsResult) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(procfsResultSize + 256)
	processesAt, processesN := 0, len(x.Processes)
	if processesN > 0 {
		var blob []byte
		for i := range x.Processes {
			enc, err := x.Processes[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		processesAt = b.WriteBytes(blob)
	}
	ob := b.StartObject(procfsResultSize)
	if processesN > 0 {
		ob.SetList(procfsResultProcessesAt, processesAt, processesN)
	}
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads ProcfsResult out of the buffer that arrived.
func (x *ProcfsResult) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("ProcfsResult: %w", err)
	}
	o := m.Root()
	if l := o.List(procfsResultProcessesAt); l.Len() > 0 {
		rows := make([]procfs.ProcessProcfsDump, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.Processes = rows
	}
	return nil
}

// ---- Route -------------------------------------------------------------

const (
	routeDestinationAt = 0
	routeGatewayAt     = 8
	routeMTUAt         = 16
	routeSize          = 24
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*Route)(nil)

// MarshalZAP writes Route from constant offsets.
func (x *Route) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(routeSize + 256)
	ob := b.StartObject(routeSize)
	innerDestination, err := x.Destination.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(routeDestinationAt, innerDestination)
	ob.SetBytes(routeGatewayAt, []byte(x.Gateway))
	ob.SetUint32(routeMTUAt, uint32(x.MTU))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads Route out of the buffer that arrived.
func (x *Route) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("Route: %w", err)
	}
	o := m.Root()
	if raw := o.Bytes(routeDestinationAt); len(raw) > 0 {
		if err := x.Destination.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	x.Gateway = net.IP(append([]byte(nil), o.Bytes(routeGatewayAt)...))
	x.MTU = uint32(o.Uint32(routeMTUAt))
	return nil
}

// ---- RuntimeStateResult ------------------------------------------------

const (
	runtimeStateResultStateAt = 0
	runtimeStateResultSize    = 8
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*RuntimeStateResult)(nil)

// MarshalZAP writes RuntimeStateResult from constant offsets.
func (x *RuntimeStateResult) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(runtimeStateResultSize + 256)
	ob := b.StartObject(runtimeStateResultSize)
	ob.SetInt64(runtimeStateResultStateAt, int64(x.State))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads RuntimeStateResult out of the buffer that arrived.
func (x *RuntimeStateResult) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("RuntimeStateResult: %w", err)
	}
	o := m.Root()
	x.State = ContainerRuntimeState(o.Int64(runtimeStateResultStateAt))
	return nil
}

// ---- Savings -----------------------------------------------------------

const (
	savingsCPUTimeSavedAt  = 0
	savingsWallTimeSavedAt = 8
	savingsSize            = 16
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*Savings)(nil)

// MarshalZAP writes Savings from constant offsets.
func (x *Savings) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(savingsSize + 256)
	ob := b.StartObject(savingsSize)
	ob.SetInt64(savingsCPUTimeSavedAt, int64(x.CPUTimeSaved))
	ob.SetInt64(savingsWallTimeSavedAt, int64(x.WallTimeSaved))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads Savings out of the buffer that arrived.
func (x *Savings) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("Savings: %w", err)
	}
	o := m.Root()
	x.CPUTimeSaved = time.Duration(o.Int64(savingsCPUTimeSavedAt))
	x.WallTimeSaved = time.Duration(o.Int64(savingsWallTimeSavedAt))
	return nil
}

// ---- SignalArgs --------------------------------------------------------

const (
	signalArgsCIDAt   = 0
	signalArgsSignoAt = 8
	signalArgsPIDAt   = 12
	signalArgsModeAt  = 16
	signalArgsSize    = 24
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*SignalArgs)(nil)

// MarshalZAP writes SignalArgs from constant offsets.
func (x *SignalArgs) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(signalArgsSize + 256)
	ob := b.StartObject(signalArgsSize)
	ob.SetText(signalArgsCIDAt, string(x.CID))
	ob.SetInt32(signalArgsSignoAt, int32(x.Signo))
	ob.SetInt32(signalArgsPIDAt, int32(x.PID))
	ob.SetInt64(signalArgsModeAt, int64(x.Mode))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads SignalArgs out of the buffer that arrived.
func (x *SignalArgs) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("SignalArgs: %w", err)
	}
	o := m.Root()
	x.CID = string(strings.Clone(o.Text(signalArgsCIDAt)))
	x.Signo = int32(o.Int32(signalArgsSignoAt))
	x.PID = int32(o.Int32(signalArgsPIDAt))
	x.Mode = SignalDeliveryMode(o.Int64(signalArgsModeAt))
	return nil
}

// ---- Stacks ------------------------------------------------------------

const (
	stacksTextAt = 0
	stacksSize   = 8
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*Stacks)(nil)

// MarshalZAP writes Stacks from constant offsets.
func (x *Stacks) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(stacksSize + 256)
	ob := b.StartObject(stacksSize)
	ob.SetText(stacksTextAt, string(x.Text))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads Stacks out of the buffer that arrived.
func (x *Stacks) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("Stacks: %w", err)
	}
	o := m.Root()
	x.Text = string(strings.Clone(o.Text(stacksTextAt)))
	return nil
}

// ---- StartArgs ---------------------------------------------------------

const (
	startArgsSpecAt                        = 0
	startArgsConfAt                        = 8
	startArgsCIDAt                         = 16
	startArgsNumGoferFilestoreFDsAt        = 24
	startArgsIsDevIoFilePresentAt          = 32
	startArgsGoferMountConfsAt             = 40
	startArgsIsRootfsUpperTarFilePresentAt = 48
	startArgsFilePayloadAt                 = 56
	startArgsSize                          = 64
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*StartArgs)(nil)

// MarshalZAP writes StartArgs from constant offsets.
func (x *StartArgs) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(startArgsSize + 256)
	goferMountConfsAt, goferMountConfsN := 0, len(x.GoferMountConfs)
	if goferMountConfsN > 0 {
		var blob []byte
		for i := range x.GoferMountConfs {
			enc, err := x.GoferMountConfs[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		goferMountConfsAt = b.WriteBytes(blob)
	}
	ob := b.StartObject(startArgsSize)
	ob.SetBytes(startArgsSpecAt, []byte(x.Spec))
	if x.Conf != nil {
		innerConf, err := x.Conf.MarshalZAP()
		if err != nil {
			return nil, err
		}
		ob.SetBytes(startArgsConfAt, innerConf)
	}
	ob.SetText(startArgsCIDAt, string(x.CID))
	ob.SetInt64(startArgsNumGoferFilestoreFDsAt, int64(x.NumGoferFilestoreFDs))
	ob.SetBool(startArgsIsDevIoFilePresentAt, bool(x.IsDevIoFilePresent))
	ob.SetBool(startArgsIsRootfsUpperTarFilePresentAt, bool(x.IsRootfsUpperTarFilePresent))
	innerFilePayload, err := x.FilePayload.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(startArgsFilePayloadAt, innerFilePayload)
	if goferMountConfsN > 0 {
		ob.SetList(startArgsGoferMountConfsAt, goferMountConfsAt, goferMountConfsN)
	}
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads StartArgs out of the buffer that arrived.
func (x *StartArgs) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("StartArgs: %w", err)
	}
	o := m.Root()
	x.Spec = []uint8(append([]byte(nil), o.Bytes(startArgsSpecAt)...))
	if raw := o.Bytes(startArgsConfAt); len(raw) > 0 {
		var v config.Config
		if err := v.UnmarshalZAP(raw); err != nil {
			return err
		}
		x.Conf = &v
	}
	x.CID = string(strings.Clone(o.Text(startArgsCIDAt)))
	x.NumGoferFilestoreFDs = int(o.Int64(startArgsNumGoferFilestoreFDsAt))
	x.IsDevIoFilePresent = bool(o.Bool(startArgsIsDevIoFilePresentAt))
	if l := o.List(startArgsGoferMountConfsAt); l.Len() > 0 {
		rows := make([]specutils.GoferMountConf, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.GoferMountConfs = rows
	}
	x.IsRootfsUpperTarFilePresent = bool(o.Bool(startArgsIsRootfsUpperTarFilePresentAt))
	if raw := o.Bytes(startArgsFilePayloadAt); len(raw) > 0 {
		if err := x.FilePayload.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	return nil
}

// ---- Stat --------------------------------------------------------------

const (
	statNameAt  = 0
	statValueAt = 8
	statSize    = 16
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*Stat)(nil)

// MarshalZAP writes Stat from constant offsets.
func (x *Stat) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(statSize + 256)
	ob := b.StartObject(statSize)
	ob.SetText(statNameAt, string(x.Name))
	ob.SetUint64(statValueAt, uint64(x.Value))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads Stat out of the buffer that arrived.
func (x *Stat) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("Stat: %w", err)
	}
	o := m.Root()
	x.Name = string(strings.Clone(o.Text(statNameAt)))
	x.Value = uint64(o.Uint64(statValueAt))
	return nil
}

// ---- Stats -------------------------------------------------------------

const (
	statsCPUAt               = 0
	statsMemoryAt            = 8
	statsPidsAt              = 16
	statsNetworkInterfacesAt = 24
	statsSize                = 32
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*Stats)(nil)

// MarshalZAP writes Stats from constant offsets.
func (x *Stats) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(statsSize + 256)
	networkInterfacesAt, networkInterfacesN := 0, len(x.NetworkInterfaces)
	if networkInterfacesN > 0 {
		var blob []byte
		for i := range x.NetworkInterfaces {
			elem := x.NetworkInterfaces[i]
			if elem == nil {
				elem = new(NetworkInterface)
			}
			enc, err := elem.MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		networkInterfacesAt = b.WriteBytes(blob)
	}
	ob := b.StartObject(statsSize)
	innerCPU, err := x.CPU.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(statsCPUAt, innerCPU)
	innerMemory, err := x.Memory.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(statsMemoryAt, innerMemory)
	innerPids, err := x.Pids.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(statsPidsAt, innerPids)
	if networkInterfacesN > 0 {
		ob.SetList(statsNetworkInterfacesAt, networkInterfacesAt, networkInterfacesN)
	}
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads Stats out of the buffer that arrived.
func (x *Stats) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("Stats: %w", err)
	}
	o := m.Root()
	if raw := o.Bytes(statsCPUAt); len(raw) > 0 {
		if err := x.CPU.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	if raw := o.Bytes(statsMemoryAt); len(raw) > 0 {
		if err := x.Memory.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	if raw := o.Bytes(statsPidsAt); len(raw) > 0 {
		if err := x.Pids.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	if l := o.List(statsNetworkInterfacesAt); l.Len() > 0 {
		rows := make([]*NetworkInterface, l.Len())
		for i := range rows {
			rows[i] = new(NetworkInterface)
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.NetworkInterfaces = rows
	}
	return nil
}

// ---- Subnet ------------------------------------------------------------

const (
	subnetIPAt   = 0
	subnetMaskAt = 8
	subnetSize   = 16
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*Subnet)(nil)

// MarshalZAP writes Subnet from constant offsets.
func (x *Subnet) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(subnetSize + 256)
	ob := b.StartObject(subnetSize)
	ob.SetBytes(subnetIPAt, []byte(x.IP))
	ob.SetBytes(subnetMaskAt, []byte(x.Mask))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads Subnet out of the buffer that arrived.
func (x *Subnet) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("Subnet: %w", err)
	}
	o := m.Root()
	x.IP = net.IP(append([]byte(nil), o.Bytes(subnetIPAt)...))
	x.Mask = net.IPMask(append([]byte(nil), o.Bytes(subnetMaskAt)...))
	return nil
}

// ---- TraceSessionsResult -----------------------------------------------

const (
	traceSessionsResultSessionsAt = 0
	traceSessionsResultSize       = 8
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*TraceSessionsResult)(nil)

// MarshalZAP writes TraceSessionsResult from constant offsets.
func (x *TraceSessionsResult) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(traceSessionsResultSize + 256)
	sessionsAt, sessionsN := 0, len(x.Sessions)
	if sessionsN > 0 {
		var blob []byte
		for i := range x.Sessions {
			enc, err := x.Sessions[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		sessionsAt = b.WriteBytes(blob)
	}
	ob := b.StartObject(traceSessionsResultSize)
	if sessionsN > 0 {
		ob.SetList(traceSessionsResultSessionsAt, sessionsAt, sessionsN)
	}
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads TraceSessionsResult out of the buffer that arrived.
func (x *TraceSessionsResult) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("TraceSessionsResult: %w", err)
	}
	o := m.Root()
	if l := o.List(traceSessionsResultSessionsAt); l.Len() > 0 {
		rows := make([]seccheck.SessionConfig, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.Sessions = rows
	}
	return nil
}

// ---- Usage -------------------------------------------------------------

const (
	usageContainerIDAt = 0
	usageCPUAt         = 8
	usageSize          = 16
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*Usage)(nil)

// MarshalZAP writes Usage from constant offsets.
func (x *Usage) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(usageSize + 256)
	ob := b.StartObject(usageSize)
	ob.SetText(usageContainerIDAt, string(x.ContainerID))
	ob.SetUint64(usageCPUAt, uint64(x.CPU))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads Usage out of the buffer that arrived.
func (x *Usage) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("Usage: %w", err)
	}
	o := m.Root()
	x.ContainerID = string(strings.Clone(o.Text(usageContainerIDAt)))
	x.CPU = uint64(o.Uint64(usageCPUAt))
	return nil
}

// ---- WaitFSRestoreArgs -------------------------------------------------

const (
	waitFSRestoreArgsCIDAt = 0
	waitFSRestoreArgsSize  = 8
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*WaitFSRestoreArgs)(nil)

// MarshalZAP writes WaitFSRestoreArgs from constant offsets.
func (x *WaitFSRestoreArgs) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(waitFSRestoreArgsSize + 256)
	ob := b.StartObject(waitFSRestoreArgsSize)
	ob.SetText(waitFSRestoreArgsCIDAt, string(x.CID))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads WaitFSRestoreArgs out of the buffer that arrived.
func (x *WaitFSRestoreArgs) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("WaitFSRestoreArgs: %w", err)
	}
	o := m.Root()
	x.CID = string(strings.Clone(o.Text(waitFSRestoreArgsCIDAt)))
	return nil
}

// ---- WaitPIDArgs -------------------------------------------------------

const (
	waitPIDArgsPIDAt = 0
	waitPIDArgsCIDAt = 8
	waitPIDArgsSize  = 16
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*WaitPIDArgs)(nil)

// MarshalZAP writes WaitPIDArgs from constant offsets.
func (x *WaitPIDArgs) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(waitPIDArgsSize + 256)
	ob := b.StartObject(waitPIDArgsSize)
	ob.SetInt32(waitPIDArgsPIDAt, int32(x.PID))
	ob.SetText(waitPIDArgsCIDAt, string(x.CID))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads WaitPIDArgs out of the buffer that arrived.
func (x *WaitPIDArgs) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("WaitPIDArgs: %w", err)
	}
	o := m.Root()
	x.PID = int32(o.Int32(waitPIDArgsPIDAt))
	x.CID = string(strings.Clone(o.Text(waitPIDArgsCIDAt)))
	return nil
}

// ---- XDPLink -----------------------------------------------------------

const (
	xDPLinkNameAt              = 0
	xDPLinkInterfaceIndexAt    = 8
	xDPLinkMTUAt               = 16
	xDPLinkAddressesAt         = 24
	xDPLinkRoutesAt            = 32
	xDPLinkTXChecksumOffloadAt = 40
	xDPLinkRXChecksumOffloadAt = 41
	xDPLinkLinkAddressAt       = 48
	xDPLinkQDiscAt             = 56
	xDPLinkTBFRateAt           = 64
	xDPLinkTBFBurstAt          = 72
	xDPLinkNeighborsAt         = 80
	xDPLinkGVisorGROAt         = 88
	xDPLinkBindAt              = 96
	xDPLinkNumChannelsAt       = 104
	xDPLinkSize                = 112
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*XDPLink)(nil)

// MarshalZAP writes XDPLink from constant offsets.
func (x *XDPLink) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(xDPLinkSize + 256)
	addressesAt, addressesN := 0, len(x.Addresses)
	if addressesN > 0 {
		var blob []byte
		for i := range x.Addresses {
			enc, err := x.Addresses[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		addressesAt = b.WriteBytes(blob)
	}
	routesAt, routesN := 0, len(x.Routes)
	if routesN > 0 {
		var blob []byte
		for i := range x.Routes {
			enc, err := x.Routes[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		routesAt = b.WriteBytes(blob)
	}
	neighborsAt, neighborsN := 0, len(x.Neighbors)
	if neighborsN > 0 {
		var blob []byte
		for i := range x.Neighbors {
			enc, err := x.Neighbors[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		neighborsAt = b.WriteBytes(blob)
	}
	ob := b.StartObject(xDPLinkSize)
	ob.SetText(xDPLinkNameAt, string(x.Name))
	ob.SetInt64(xDPLinkInterfaceIndexAt, int64(x.InterfaceIndex))
	ob.SetInt64(xDPLinkMTUAt, int64(x.MTU))
	ob.SetBool(xDPLinkTXChecksumOffloadAt, bool(x.TXChecksumOffload))
	ob.SetBool(xDPLinkRXChecksumOffloadAt, bool(x.RXChecksumOffload))
	ob.SetBytes(xDPLinkLinkAddressAt, []byte(x.LinkAddress))
	ob.SetInt64(xDPLinkQDiscAt, int64(x.QDisc))
	ob.SetUint64(xDPLinkTBFRateAt, uint64(x.TBFRate))
	ob.SetUint32(xDPLinkTBFBurstAt, uint32(x.TBFBurst))
	ob.SetBool(xDPLinkGVisorGROAt, bool(x.GVisorGRO))
	ob.SetInt64(xDPLinkBindAt, int64(x.Bind))
	ob.SetInt64(xDPLinkNumChannelsAt, int64(x.NumChannels))
	if addressesN > 0 {
		ob.SetList(xDPLinkAddressesAt, addressesAt, addressesN)
	}
	if routesN > 0 {
		ob.SetList(xDPLinkRoutesAt, routesAt, routesN)
	}
	if neighborsN > 0 {
		ob.SetList(xDPLinkNeighborsAt, neighborsAt, neighborsN)
	}
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads XDPLink out of the buffer that arrived.
func (x *XDPLink) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("XDPLink: %w", err)
	}
	o := m.Root()
	x.Name = string(strings.Clone(o.Text(xDPLinkNameAt)))
	x.InterfaceIndex = int(o.Int64(xDPLinkInterfaceIndexAt))
	x.MTU = int(o.Int64(xDPLinkMTUAt))
	if l := o.List(xDPLinkAddressesAt); l.Len() > 0 {
		rows := make([]IPWithPrefix, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.Addresses = rows
	}
	if l := o.List(xDPLinkRoutesAt); l.Len() > 0 {
		rows := make([]Route, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.Routes = rows
	}
	x.TXChecksumOffload = bool(o.Bool(xDPLinkTXChecksumOffloadAt))
	x.RXChecksumOffload = bool(o.Bool(xDPLinkRXChecksumOffloadAt))
	x.LinkAddress = net.HardwareAddr(append([]byte(nil), o.Bytes(xDPLinkLinkAddressAt)...))
	x.QDisc = config.QueueingDiscipline(o.Int64(xDPLinkQDiscAt))
	x.TBFRate = uint64(o.Uint64(xDPLinkTBFRateAt))
	x.TBFBurst = uint32(o.Uint32(xDPLinkTBFBurstAt))
	if l := o.List(xDPLinkNeighborsAt); l.Len() > 0 {
		rows := make([]Neighbor, l.Len())
		for i := range rows {
			if err := rows[i].UnmarshalZAP(l.BytesAt(i)); err != nil {
				return err
			}
		}
		x.Neighbors = rows
	}
	x.GVisorGRO = bool(o.Bool(xDPLinkGVisorGROAt))
	x.Bind = BindOpt(o.Int64(xDPLinkBindAt))
	x.NumChannels = int(o.Int64(xDPLinkNumChannelsAt))
	return nil
}