github.com/kubearmor/cilium@v1.6.12/api/v1/health/models/status_response.go

// Code generated by go-swagger; DO NOT EDIT.

package models

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"encoding/json"
	"strconv"

	strfmt "github.com/go-openapi/strfmt"

	"github.com/go-openapi/errors"
	"github.com/go-openapi/swag"
	"github.com/go-openapi/validate"
)

// StatusResponse Health and status information of daemon
// swagger:model statusResponse
type StatusResponse struct {

	// cilium
	Cilium *StatusResponseCilium `json:"cilium,omitempty"`

	// cluster
	Cluster *StatusResponseCluster `json:"cluster,omitempty"`

	// container runtime
	ContainerRuntime *StatusResponseContainerRuntime `json:"container-runtime,omitempty"`

	// Collection of controller statuses
	Controllers []*StatusResponseControllersItems0 `json:"controllers"`

	// ipam
	IPAM *StatusResponseIPAM `json:"ipam,omitempty"`

	// kubernetes
	Kubernetes *StatusResponseKubernetes `json:"kubernetes,omitempty"`

	// kvstore
	Kvstore *StatusResponseKvstore `json:"kvstore,omitempty"`

	// node monitor
	NodeMonitor *StatusResponseNodeMonitor `json:"nodeMonitor,omitempty"`

	// proxy
	Proxy *StatusResponseProxy `json:"proxy,omitempty"`

	// List of stale information in the status
	Stale map[string]strfmt.DateTime `json:"stale,omitempty"`
}

// Validate validates this status response
func (m *StatusResponse) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateCilium(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateCluster(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateContainerRuntime(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateControllers(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateIPAM(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateKubernetes(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateKvstore(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateNodeMonitor(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateProxy(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateStale(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *StatusResponse) validateCilium(formats strfmt.Registry) error {

	if swag.IsZero(m.Cilium) { // not required
		return nil
	}

	if m.Cilium != nil {
		if err := m.Cilium.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("cilium")
			}
			return err
		}
	}

	return nil
}

func (m *StatusResponse) validateCluster(formats strfmt.Registry) error {

	if swag.IsZero(m.Cluster) { // not required
		return nil
	}

	if m.Cluster != nil {
		if err := m.Cluster.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("cluster")
			}
			return err
		}
	}

	return nil
}

func (m *StatusResponse) validateContainerRuntime(formats strfmt.Registry) error {

	if swag.IsZero(m.ContainerRuntime) { // not required
		return nil
	}

	if m.ContainerRuntime != nil {
		if err := m.ContainerRuntime.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("container-runtime")
			}
			return err
		}
	}

	return nil
}

func (m *StatusResponse) validateControllers(formats strfmt.Registry) error {

	if swag.IsZero(m.Controllers) { // not required
		return nil
	}

	for i := 0; i < len(m.Controllers); i++ {
		if swag.IsZero(m.Controllers[i]) { // not required
			continue
		}

		if m.Controllers[i] != nil {
			if err := m.Controllers[i].Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("controllers" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

func (m *StatusResponse) validateIPAM(formats strfmt.Registry) error {

	if swag.IsZero(m.IPAM) { // not required
		return nil
	}

	if m.IPAM != nil {
		if err := m.IPAM.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("ipam")
			}
			return err
		}
	}

	return nil
}

func (m *StatusResponse) validateKubernetes(formats strfmt.Registry) error {

	if swag.IsZero(m.Kubernetes) { // not required
		return nil
	}

	if m.Kubernetes != nil {
		if err := m.Kubernetes.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("kubernetes")
			}
			return err
		}
	}

	return nil
}

func (m *StatusResponse) validateKvstore(formats strfmt.Registry) error {

	if swag.IsZero(m.Kvstore) { // not required
		return nil
	}

	if m.Kvstore != nil {
		if err := m.Kvstore.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("kvstore")
			}
			return err
		}
	}

	return nil
}

func (m *StatusResponse) validateNodeMonitor(formats strfmt.Registry) error {

	if swag.IsZero(m.NodeMonitor) { // not required
		return nil
	}

	if m.NodeMonitor != nil {
		if err := m.NodeMonitor.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("nodeMonitor")
			}
			return err
		}
	}

	return nil
}

func (m *StatusResponse) validateProxy(formats strfmt.Registry) error {

	if swag.IsZero(m.Proxy) { // not required
		return nil
	}

	if m.Proxy != nil {
		if err := m.Proxy.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("proxy")
			}
			return err
		}
	}

	return nil
}

func (m *StatusResponse) validateStale(formats strfmt.Registry) error {

	if swag.IsZero(m.Stale) { // not required
		return nil
	}

	for k := range m.Stale {

		if err := validate.FormatOf("stale"+"."+k, "body", "date-time", m.Stale[k].String(), formats); err != nil {
			return err
		}

	}

	return nil
}

// MarshalBinary interface implementation
func (m *StatusResponse) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *StatusResponse) UnmarshalBinary(b []byte) error {
	var res StatusResponse
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// StatusResponseCilium Status of an individual component
// swagger:model StatusResponseCilium
type StatusResponseCilium struct {

	// Human readable status/error/warning message
	Msg string `json:"msg,omitempty"`

	// State the component is in
	// Enum: [Ok Warning Failure Disabled]
	State string `json:"state,omitempty"`
}

// Validate validates this status response cilium
func (m *StatusResponseCilium) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateState(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

var statusResponseCiliumTypeStatePropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["Ok","Warning","Failure","Disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		statusResponseCiliumTypeStatePropEnum = append(statusResponseCiliumTypeStatePropEnum, v)
	}
}

const (

	// StatusResponseCiliumStateOk captures enum value "Ok"
	StatusResponseCiliumStateOk string = "Ok"

	// StatusResponseCiliumStateWarning captures enum value "Warning"
	StatusResponseCiliumStateWarning string = "Warning"

	// StatusResponseCiliumStateFailure captures enum value "Failure"
	StatusResponseCiliumStateFailure string = "Failure"

	// StatusResponseCiliumStateDisabled captures enum value "Disabled"
	StatusResponseCiliumStateDisabled string = "Disabled"
)

// prop value enum
func (m *StatusResponseCilium) validateStateEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, statusResponseCiliumTypeStatePropEnum); err != nil {
		return err
	}
	return nil
}

func (m *StatusResponseCilium) validateState(formats strfmt.Registry) error {

	if swag.IsZero(m.State) { // not required
		return nil
	}

	// value enum
	if err := m.validateStateEnum("cilium"+"."+"state", "body", m.State); err != nil {
		return err
	}

	return nil
}

// MarshalBinary interface implementation
func (m *StatusResponseCilium) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *StatusResponseCilium) UnmarshalBinary(b []byte) error {
	var res StatusResponseCilium
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// StatusResponseCluster Status of cluster
// swagger:model StatusResponseCluster
type StatusResponseCluster struct {

	// cilium health
	CiliumHealth *StatusResponseClusterCiliumHealth `json:"ciliumHealth,omitempty"`

	// List of known nodes
	Nodes []*StatusResponseClusterNodesItems0 `json:"nodes"`

	// Name of local node (if available)
	Self string `json:"self,omitempty"`
}

// Validate validates this status response cluster
func (m *StatusResponseCluster) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateCiliumHealth(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateNodes(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *StatusResponseCluster) validateCiliumHealth(formats strfmt.Registry) error {

	if swag.IsZero(m.CiliumHealth) { // not required
		return nil
	}

	if m.CiliumHealth != nil {
		if err := m.CiliumHealth.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("cluster" + "." + "ciliumHealth")
			}
			return err
		}
	}

	return nil
}

func (m *StatusResponseCluster) validateNodes(formats strfmt.Registry) error {

	if swag.IsZero(m.Nodes) { // not required
		return nil
	}

	for i := 0; i < len(m.Nodes); i++ {
		if swag.IsZero(m.Nodes[i]) { // not required
			continue
		}

		if m.Nodes[i] != nil {
			if err := m.Nodes[i].Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("cluster" + "." + "nodes" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

// MarshalBinary interface implementation
func (m *StatusResponseCluster) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *StatusResponseCluster) UnmarshalBinary(b []byte) error {
	var res StatusResponseCluster
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// StatusResponseClusterCiliumHealth Status of an individual component
// swagger:model StatusResponseClusterCiliumHealth
type StatusResponseClusterCiliumHealth struct {

	// Human readable status/error/warning message
	Msg string `json:"msg,omitempty"`

	// State the component is in
	// Enum: [Ok Warning Failure Disabled]
	State string `json:"state,omitempty"`
}

// Validate validates this status response cluster cilium health
func (m *StatusResponseClusterCiliumHealth) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateState(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

var statusResponseClusterCiliumHealthTypeStatePropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["Ok","Warning","Failure","Disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		statusResponseClusterCiliumHealthTypeStatePropEnum = append(statusResponseClusterCiliumHealthTypeStatePropEnum, v)
	}
}

const (

	// StatusResponseClusterCiliumHealthStateOk captures enum value "Ok"
	StatusResponseClusterCiliumHealthStateOk string = "Ok"

	// StatusResponseClusterCiliumHealthStateWarning captures enum value "Warning"
	StatusResponseClusterCiliumHealthStateWarning string = "Warning"

	// StatusResponseClusterCiliumHealthStateFailure captures enum value "Failure"
	StatusResponseClusterCiliumHealthStateFailure string = "Failure"

	// StatusResponseClusterCiliumHealthStateDisabled captures enum value "Disabled"
	StatusResponseClusterCiliumHealthStateDisabled string = "Disabled"
)

// prop value enum
func (m *StatusResponseClusterCiliumHealth) validateStateEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, statusResponseClusterCiliumHealthTypeStatePropEnum); err != nil {
		return err
	}
	return nil
}

func (m *StatusResponseClusterCiliumHealth) validateState(formats strfmt.Registry) error {

	if swag.IsZero(m.State) { // not required
		return nil
	}

	// value enum
	if err := m.validateStateEnum("cluster"+"."+"ciliumHealth"+"."+"state", "body", m.State); err != nil {
		return err
	}

	return nil
}

// MarshalBinary interface implementation
func (m *StatusResponseClusterCiliumHealth) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *StatusResponseClusterCiliumHealth) UnmarshalBinary(b []byte) error {
	var res StatusResponseClusterCiliumHealth
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// StatusResponseClusterNodesItems0 Known node in the cluster
// swagger:model StatusResponseClusterNodesItems0
type StatusResponseClusterNodesItems0 struct {

	// health endpoint address
	HealthEndpointAddress *StatusResponseClusterNodesItems0HealthEndpointAddress `json:"health-endpoint-address,omitempty"`

	// Name of the node including the cluster association. This is typically
	// <clustername>/<hostname>.
	//
	Name string `json:"name,omitempty"`

	// primary address
	PrimaryAddress *StatusResponseClusterNodesItems0PrimaryAddress `json:"primary-address,omitempty"`

	// Alternative addresses assigned to the node
	SecondaryAddresses []*StatusResponseClusterNodesItems0SecondaryAddressesItems0 `json:"secondary-addresses"`
}

// Validate validates this status response cluster nodes items0
func (m *StatusResponseClusterNodesItems0) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateHealthEndpointAddress(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validatePrimaryAddress(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSecondaryAddresses(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *StatusResponseClusterNodesItems0) validateHealthEndpointAddress(formats strfmt.Registry) error {

	if swag.IsZero(m.HealthEndpointAddress) { // not required
		return nil
	}

	if m.HealthEndpointAddress != nil {
		if err := m.HealthEndpointAddress.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("health-endpoint-address")
			}
			return err
		}
	}

	return nil
}

func (m *StatusResponseClusterNodesItems0) validatePrimaryAddress(formats strfmt.Registry) error {

	if swag.IsZero(m.PrimaryAddress) { // not required
		return nil
	}

	if m.PrimaryAddress != nil {
		if err := m.PrimaryAddress.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("primary-address")
			}
			return err
		}
	}

	return nil
}

func (m *StatusResponseClusterNodesItems0) validateSecondaryAddresses(formats strfmt.Registry) error {

	if swag.IsZero(m.SecondaryAddresses) { // not required
		return nil
	}

	for i := 0; i < len(m.SecondaryAddresses); i++ {
		if swag.IsZero(m.SecondaryAddresses[i]) { // not required
			continue
		}

		if m.SecondaryAddresses[i] != nil {
			if err := m.SecondaryAddresses[i].Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("secondary-addresses" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

// MarshalBinary interface implementation
func (m *StatusResponseClusterNodesItems0) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *StatusResponseClusterNodesItems0) UnmarshalBinary(b []byte) error {
	var res StatusResponseClusterNodesItems0
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// StatusResponseClusterNodesItems0HealthEndpointAddress Addressing information of a node for all address families
// swagger:model StatusResponseClusterNodesItems0HealthEndpointAddress
type StatusResponseClusterNodesItems0HealthEndpointAddress struct {

	// ipv4
	IPV4 *StatusResponseClusterNodesItems0HealthEndpointAddressIPV4 `json:"ipv4,omitempty"`

	// ipv6
	IPV6 *StatusResponseClusterNodesItems0HealthEndpointAddressIPV6 `json:"ipv6,omitempty"`
}

// Validate validates this status response cluster nodes items0 health endpoint address
func (m *StatusResponseClusterNodesItems0HealthEndpointAddress) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateIPV4(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateIPV6(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *StatusResponseClusterNodesItems0HealthEndpointAddress) validateIPV4(formats strfmt.Registry) error {

	if swag.IsZero(m.IPV4) { // not required
		return nil
	}

	if m.IPV4 != nil {
		if err := m.IPV4.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("health-endpoint-address" + "." + "ipv4")
			}
			return err
		}
	}

	return nil
}

func (m *StatusResponseClusterNodesItems0HealthEndpointAddress) validateIPV6(formats strfmt.Registry) error {

	if swag.IsZero(m.IPV6) { // not required
		return nil
	}

	if m.IPV6 != nil {
		if err := m.IPV6.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("health-endpoint-address" + "." + "ipv6")
			}
			return err
		}
	}

	return nil
}

// MarshalBinary interface implementation
func (m *StatusResponseClusterNodesItems0HealthEndpointAddress) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *StatusResponseClusterNodesItems0HealthEndpointAddress) UnmarshalBinary(b []byte) error {
	var res StatusResponseClusterNodesItems0HealthEndpointAddress
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// StatusResponseClusterNodesItems0HealthEndpointAddressIPV4 Addressing information
// swagger:model StatusResponseClusterNodesItems0HealthEndpointAddressIPV4
type StatusResponseClusterNodesItems0HealthEndpointAddressIPV4 struct {

	// Node address type, one of HostName, ExternalIP or InternalIP
	AddressType string `json:"address-type,omitempty"`

	// Address pool to be used for local endpoints
	AllocRange string `json:"alloc-range,omitempty"`

	// True if address family is enabled
	Enabled bool `json:"enabled,omitempty"`

	// IP address of node
	IP string `json:"ip,omitempty"`
}

// Validate validates this status response cluster nodes items0 health endpoint address IP v4
func (m *StatusResponseClusterNodesItems0HealthEndpointAddressIPV4) Validate(formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *StatusResponseClusterNodesItems0HealthEndpointAddressIPV4) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *StatusResponseClusterNodesItems0HealthEndpointAddressIPV4) UnmarshalBinary(b []byte) error {
	var res StatusResponseClusterNodesItems0HealthEndpointAddressIPV4
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// StatusResponseClusterNodesItems0HealthEndpointAddressIPV6 Addressing information
// swagger:model StatusResponseClusterNodesItems0HealthEndpointAddressIPV6
type StatusResponseClusterNodesItems0HealthEndpointAddressIPV6 struct {

	// Node address type, one of HostName, ExternalIP or InternalIP
	AddressType string `json:"address-type,omitempty"`

	// Address pool to be used for local endpoints
	AllocRange string `json:"alloc-range,omitempty"`

	// True if address family is enabled
	Enabled bool `json:"enabled,omitempty"`

	// IP address of node
	IP string `json:"ip,omitempty"`
}

// Validate validates this status response cluster nodes items0 health endpoint address IP v6
func (m *StatusResponseClusterNodesItems0HealthEndpointAddressIPV6) Validate(formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *StatusResponseClusterNodesItems0HealthEndpointAddressIPV6) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *StatusResponseClusterNodesItems0HealthEndpointAddressIPV6) UnmarshalBinary(b []byte) error {
	var res StatusResponseClusterNodesItems0HealthEndpointAddressIPV6
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// StatusResponseClusterNodesItems0PrimaryAddress Addressing information of a node for all address families
// swagger:model StatusResponseClusterNodesItems0PrimaryAddress
type StatusResponseClusterNodesItems0PrimaryAddress struct {

	// ipv4
	IPV4 *StatusResponseClusterNodesItems0PrimaryAddressIPV4 `json:"ipv4,omitempty"`

	// ipv6
	IPV6 *StatusResponseClusterNodesItems0PrimaryAddressIPV6 `json:"ipv6,omitempty"`
}

// Validate validates this status response cluster nodes items0 primary address
func (m *StatusResponseClusterNodesItems0PrimaryAddress) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateIPV4(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateIPV6(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *StatusResponseClusterNodesItems0PrimaryAddress) validateIPV4(formats strfmt.Registry) error {

	if swag.IsZero(m.IPV4) { // not required
		return nil
	}

	if m.IPV4 != nil {
		if err := m.IPV4.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("primary-address" + "." + "ipv4")
			}
			return err
		}
	}

	return nil
}

func (m *StatusResponseClusterNodesItems0PrimaryAddress) validateIPV6(formats strfmt.Registry) error {

	if swag.IsZero(m.IPV6) { // not required
		return nil
	}

	if m.IPV6 != nil {
		if err := m.IPV6.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("primary-address" + "." + "ipv6")
			}
			return err
		}
	}

	return nil
}

// MarshalBinary interface implementation
func (m *StatusResponseClusterNodesItems0PrimaryAddress) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *StatusResponseClusterNodesItems0PrimaryAddress) UnmarshalBinary(b []byte) error {
	var res StatusResponseClusterNodesItems0PrimaryAddress
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// StatusResponseClusterNodesItems0PrimaryAddressIPV4 Addressing information
// swagger:model StatusResponseClusterNodesItems0PrimaryAddressIPV4
type StatusResponseClusterNodesItems0PrimaryAddressIPV4 struct {

	// Node address type, one of HostName, ExternalIP or InternalIP
	AddressType string `json:"address-type,omitempty"`

	// Address pool to be used for local endpoints
	AllocRange string `json:"alloc-range,omitempty"`

	// True if address family is enabled
	Enabled bool `json:"enabled,omitempty"`

	// IP address of node
	IP string `json:"ip,omitempty"`
}

// Validate validates this status response cluster nodes items0 primary address IP v4
func (m *StatusResponseClusterNodesItems0PrimaryAddressIPV4) Validate(formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *StatusResponseClusterNodesItems0PrimaryAddressIPV4) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *StatusResponseClusterNodesItems0PrimaryAddressIPV4) UnmarshalBinary(b []byte) error {
	var res StatusResponseClusterNodesItems0PrimaryAddressIPV4
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// StatusResponseClusterNodesItems0PrimaryAddressIPV6 Addressing information
// swagger:model StatusResponseClusterNodesItems0PrimaryAddressIPV6
type StatusResponseClusterNodesItems0PrimaryAddressIPV6 struct {

	// Node address type, one of HostName, ExternalIP or InternalIP
	AddressType string `json:"address-type,omitempty"`

	// Address pool to be used for local endpoints
	AllocRange string `json:"alloc-range,omitempty"`

	// True if address family is enabled
	Enabled bool `json:"enabled,omitempty"`

	// IP address of node
	IP string `json:"ip,omitempty"`
}

// Validate validates this status response cluster nodes items0 primary address IP v6
func (m *StatusResponseClusterNodesItems0PrimaryAddressIPV6) Validate(formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *StatusResponseClusterNodesItems0PrimaryAddressIPV6) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *StatusResponseClusterNodesItems0PrimaryAddressIPV6) UnmarshalBinary(b []byte) error {
	var res StatusResponseClusterNodesItems0PrimaryAddressIPV6
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// StatusResponseClusterNodesItems0SecondaryAddressesItems0 Addressing information
// swagger:model StatusResponseClusterNodesItems0SecondaryAddressesItems0
type StatusResponseClusterNodesItems0SecondaryAddressesItems0 struct {

	// Node address type, one of HostName, ExternalIP or InternalIP
	AddressType string `json:"address-type,omitempty"`

	// Address pool to be used for local endpoints
	AllocRange string `json:"alloc-range,omitempty"`

	// True if address family is enabled
	Enabled bool `json:"enabled,omitempty"`

	// IP address of node
	IP string `json:"ip,omitempty"`
}

// Validate validates this status response cluster nodes items0 secondary addresses items0
func (m *StatusResponseClusterNodesItems0SecondaryAddressesItems0) Validate(formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *StatusResponseClusterNodesItems0SecondaryAddressesItems0) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *StatusResponseClusterNodesItems0SecondaryAddressesItems0) UnmarshalBinary(b []byte) error {
	var res StatusResponseClusterNodesItems0SecondaryAddressesItems0
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// StatusResponseContainerRuntime Status of an individual component
// swagger:model StatusResponseContainerRuntime
type StatusResponseContainerRuntime struct {

	// Human readable status/error/warning message
	Msg string `json:"msg,omitempty"`

	// State the component is in
	// Enum: [Ok Warning Failure Disabled]
	State string `json:"state,omitempty"`
}

// Validate validates this status response container runtime
func (m *StatusResponseContainerRuntime) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateState(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

var statusResponseContainerRuntimeTypeStatePropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["Ok","Warning","Failure","Disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		statusResponseContainerRuntimeTypeStatePropEnum = append(statusResponseContainerRuntimeTypeStatePropEnum, v)
	}
}

const (

	// StatusResponseContainerRuntimeStateOk captures enum value "Ok"
	StatusResponseContainerRuntimeStateOk string = "Ok"

	// StatusResponseContainerRuntimeStateWarning captures enum value "Warning"
	StatusResponseContainerRuntimeStateWarning string = "Warning"

	// StatusResponseContainerRuntimeStateFailure captures enum value "Failure"
	StatusResponseContainerRuntimeStateFailure string = "Failure"

	// StatusResponseContainerRuntimeStateDisabled captures enum value "Disabled"
	StatusResponseContainerRuntimeStateDisabled string = "Disabled"
)

// prop value enum
func (m *StatusResponseContainerRuntime) validateStateEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, statusResponseContainerRuntimeTypeStatePropEnum); err != nil {
		return err
	}
	return nil
}

func (m *StatusResponseContainerRuntime) validateState(formats strfmt.Registry) error {

	if swag.IsZero(m.State) { // not required
		return nil
	}

	// value enum
	if err := m.validateStateEnum("container-runtime"+"."+"state", "body", m.State); err != nil {
		return err
	}

	return nil
}

// MarshalBinary interface implementation
func (m *StatusResponseContainerRuntime) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *StatusResponseContainerRuntime) UnmarshalBinary(b []byte) error {
	var res StatusResponseContainerRuntime
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// StatusResponseControllersItems0 Status of a controller
// swagger:model StatusResponseControllersItems0
type StatusResponseControllersItems0 struct {

	// configuration
	Configuration *StatusResponseControllersItems0Configuration `json:"configuration,omitempty"`

	// Name of controller
	Name string `json:"name,omitempty"`

	// status
	Status *StatusResponseControllersItems0Status `json:"status,omitempty"`

	// UUID of controller
	// Format: uuid
	UUID strfmt.UUID `json:"uuid,omitempty"`
}

// Validate validates this status response controllers items0
func (m *StatusResponseControllersItems0) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateConfiguration(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateStatus(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateUUID(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *StatusResponseControllersItems0) validateConfiguration(formats strfmt.Registry) error {

	if swag.IsZero(m.Configuration) { // not required
		return nil
	}

	if m.Configuration != nil {
		if err := m.Configuration.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("configuration")
			}
			return err
		}
	}

	return nil
}

func (m *StatusResponseControllersItems0) validateStatus(formats strfmt.Registry) error {

	if swag.IsZero(m.Status) { // not required
		return nil
	}

	if m.Status != nil {
		if err := m.Status.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("status")
			}
			return err
		}
	}

	return nil
}

func (m *StatusResponseControllersItems0) validateUUID(formats strfmt.Registry) error {

	if swag.IsZero(m.UUID) { // not required
		return nil
	}

	if err := validate.FormatOf("uuid", "body", "uuid", m.UUID.String(), formats); err != nil {
		return err
	}

	return nil
}

// MarshalBinary interface implementation
func (m *StatusResponseControllersItems0) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *StatusResponseControllersItems0) UnmarshalBinary(b []byte) error {
	var res StatusResponseControllersItems0
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// StatusResponseControllersItems0Configuration Configuration of controller
// swagger:model StatusResponseControllersItems0Configuration
type StatusResponseControllersItems0Configuration struct {

	// Retry on error
	ErrorRetry bool `json:"error-retry,omitempty"`

	// Base error retry back-off time
	// Format: duration
	ErrorRetryBase strfmt.Duration `json:"error-retry-base,omitempty"`

	// Regular synchronization interval
	// Format: duration
	Interval strfmt.Duration `json:"interval,omitempty"`
}

// Validate validates this status response controllers items0 configuration
func (m *StatusResponseControllersItems0Configuration) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateErrorRetryBase(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateInterval(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *StatusResponseControllersItems0Configuration) validateErrorRetryBase(formats strfmt.Registry) error {

	if swag.IsZero(m.ErrorRetryBase) { // not required
		return nil
	}

	if err := validate.FormatOf("configuration"+"."+"error-retry-base", "body", "duration", m.ErrorRetryBase.String(), formats); err != nil {
		return err
	}

	return nil
}

func (m *StatusResponseControllersItems0Configuration) validateInterval(formats strfmt.Registry) error {

	if swag.IsZero(m.Interval) { // not required
		return nil
	}

	if err := validate.FormatOf("configuration"+"."+"interval", "body", "duration", m.Interval.String(), formats); err != nil {
		return err
	}

	return nil
}

// MarshalBinary interface implementation
func (m *StatusResponseControllersItems0Configuration) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *StatusResponseControllersItems0Configuration) UnmarshalBinary(b []byte) error {
	var res StatusResponseControllersItems0Configuration
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// StatusResponseControllersItems0Status Current status of controller
// swagger:model StatusResponseControllersItems0Status
type StatusResponseControllersItems0Status struct {

	// Number of consecutive errors since last success
	ConsecutiveFailureCount int64 `json:"consecutive-failure-count,omitempty"`

	// Total number of failed runs
	FailureCount int64 `json:"failure-count,omitempty"`

	// Error message of last failed run
	LastFailureMsg string `json:"last-failure-msg,omitempty"`

	// Timestamp of last error
	// Format: date-time
	LastFailureTimestamp strfmt.DateTime `json:"last-failure-timestamp,omitempty"`

	// Timestamp of last success
	// Format: date-time
	LastSuccessTimestamp strfmt.DateTime `json:"last-success-timestamp,omitempty"`

	// Total number of successful runs
	SuccessCount int64 `json:"success-count,omitempty"`
}

// Validate validates this status response controllers items0 status
func (m *StatusResponseControllersItems0Status) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateLastFailureTimestamp(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateLastSuccessTimestamp(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *StatusResponseControllersItems0Status) validateLastFailureTimestamp(formats strfmt.Registry) error {

	if swag.IsZero(m.LastFailureTimestamp) { // not required
		return nil
	}

	if err := validate.FormatOf("status"+"."+"last-failure-timestamp", "body", "date-time", m.LastFailureTimestamp.String(), formats); err != nil {
		return err
	}

	return nil
}

func (m *StatusResponseControllersItems0Status) validateLastSuccessTimestamp(formats strfmt.Registry) error {

	if swag.IsZero(m.LastSuccessTimestamp) { // not required
		return nil
	}

	if err := validate.FormatOf("status"+"."+"last-success-timestamp", "body", "date-time", m.LastSuccessTimestamp.String(), formats); err != nil {
		return err
	}

	return nil
}

// MarshalBinary interface implementation
func (m *StatusResponseControllersItems0Status) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *StatusResponseControllersItems0Status) UnmarshalBinary(b []byte) error {
	var res StatusResponseControllersItems0Status
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// StatusResponseIPAM Status of IP address management
// swagger:model StatusResponseIPAM
type StatusResponseIPAM struct {

	// Map of allocated IPs
	//
	Allocations map[string]string `json:"allocations,omitempty"`

	// ipv4
	IPV4 []string `json:"ipv4"`

	// ipv6
	IPV6 []string `json:"ipv6"`

	// status
	Status string `json:"status,omitempty"`
}

// Validate validates this status response IP a m
func (m *StatusResponseIPAM) Validate(formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *StatusResponseIPAM) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *StatusResponseIPAM) UnmarshalBinary(b []byte) error {
	var res StatusResponseIPAM
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// StatusResponseKubernetes Status of Kubernetes integration
// swagger:model StatusResponseKubernetes
type StatusResponseKubernetes struct {

	// k8s api versions
	K8sAPIVersions []string `json:"k8s-api-versions"`

	// Human readable status/error/warning message
	Msg string `json:"msg,omitempty"`

	// State the component is in
	// Enum: [Ok Warning Failure Disabled]
	State string `json:"state,omitempty"`
}

// Validate validates this status response kubernetes
func (m *StatusResponseKubernetes) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateState(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

var statusResponseKubernetesTypeStatePropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["Ok","Warning","Failure","Disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		statusResponseKubernetesTypeStatePropEnum = append(statusResponseKubernetesTypeStatePropEnum, v)
	}
}

const (

	// StatusResponseKubernetesStateOk captures enum value "Ok"
	StatusResponseKubernetesStateOk string = "Ok"

	// StatusResponseKubernetesStateWarning captures enum value "Warning"
	StatusResponseKubernetesStateWarning string = "Warning"

	// StatusResponseKubernetesStateFailure captures enum value "Failure"
	StatusResponseKubernetesStateFailure string = "Failure"

	// StatusResponseKubernetesStateDisabled captures enum value "Disabled"
	StatusResponseKubernetesStateDisabled string = "Disabled"
)

// prop value enum
func (m *StatusResponseKubernetes) validateStateEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, statusResponseKubernetesTypeStatePropEnum); err != nil {
		return err
	}
	return nil
}

func (m *StatusResponseKubernetes) validateState(formats strfmt.Registry) error {

	if swag.IsZero(m.State) { // not required
		return nil
	}

	// value enum
	if err := m.validateStateEnum("kubernetes"+"."+"state", "body", m.State); err != nil {
		return err
	}

	return nil
}

// MarshalBinary interface implementation
func (m *StatusResponseKubernetes) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *StatusResponseKubernetes) UnmarshalBinary(b []byte) error {
	var res StatusResponseKubernetes
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// StatusResponseKvstore Status of an individual component
// swagger:model StatusResponseKvstore
type StatusResponseKvstore struct {

	// Human readable status/error/warning message
	Msg string `json:"msg,omitempty"`

	// State the component is in
	// Enum: [Ok Warning Failure Disabled]
	State string `json:"state,omitempty"`
}

// Validate validates this status response kvstore
func (m *StatusResponseKvstore) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateState(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

var statusResponseKvstoreTypeStatePropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["Ok","Warning","Failure","Disabled"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		statusResponseKvstoreTypeStatePropEnum = append(statusResponseKvstoreTypeStatePropEnum, v)
	}
}

const (

	// StatusResponseKvstoreStateOk captures enum value "Ok"
	StatusResponseKvstoreStateOk string = "Ok"

	// StatusResponseKvstoreStateWarning captures enum value "Warning"
	StatusResponseKvstoreStateWarning string = "Warning"

	// StatusResponseKvstoreStateFailure captures enum value "Failure"
	StatusResponseKvstoreStateFailure string = "Failure"

	// StatusResponseKvstoreStateDisabled captures enum value "Disabled"
	StatusResponseKvstoreStateDisabled string = "Disabled"
)

// prop value enum
func (m *StatusResponseKvstore) validateStateEnum(path, location string, value string) error {
	if err := validate.Enum(path, location, value, statusResponseKvstoreTypeStatePropEnum); err != nil {
		return err
	}
	return nil
}

func (m *StatusResponseKvstore) validateState(formats strfmt.Registry) error {

	if swag.IsZero(m.State) { // not required
		return nil
	}

	// value enum
	if err := m.validateStateEnum("kvstore"+"."+"state", "body", m.State); err != nil {
		return err
	}

	return nil
}

// MarshalBinary interface implementation
func (m *StatusResponseKvstore) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *StatusResponseKvstore) UnmarshalBinary(b []byte) error {
	var res StatusResponseKvstore
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// StatusResponseNodeMonitor Status of the node monitor
// swagger:model StatusResponseNodeMonitor
type StatusResponseNodeMonitor struct {

	// Number of CPUs to listen on for events.
	Cpus int64 `json:"cpus,omitempty"`

	// Number of samples lost by perf.
	Lost int64 `json:"lost,omitempty"`

	// Number of pages used for the perf ring buffer.
	Npages int64 `json:"npages,omitempty"`

	// Pages size used for the perf ring buffer.
	Pagesize int64 `json:"pagesize,omitempty"`

	// Number of unknown samples.
	Unknown int64 `json:"unknown,omitempty"`
}

// Validate validates this status response node monitor
func (m *StatusResponseNodeMonitor) Validate(formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *StatusResponseNodeMonitor) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *StatusResponseNodeMonitor) UnmarshalBinary(b []byte) error {
	var res StatusResponseNodeMonitor
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// StatusResponseProxy Status of proxy
// swagger:model StatusResponseProxy
type StatusResponseProxy struct {

	// IP address that the proxy listens on
	IP string `json:"ip,omitempty"`

	// Port range used for proxying
	PortRange string `json:"port-range,omitempty"`
}

// Validate validates this status response proxy
func (m *StatusResponseProxy) Validate(formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *StatusResponseProxy) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *StatusResponseProxy) UnmarshalBinary(b []byte) error {
	var res StatusResponseProxy
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}