types

type AuthConfig struct {
	Username string `json:"username,omitempty"`
	Password string `json:"password,omitempty"`
	Auth     string `json:"auth,omitempty"`
	// Email is an optional value associated with the username.
	// This field is deprecated and will be removed in a later
	// version of docker.
	Email         string `json:"email,omitempty"`
	ServerAddress string `json:"serveraddress,omitempty"`
	// IdentityToken is used to authenticate the user and get
	// an access token for the registry.
	IdentityToken string `json:"identitytoken,omitempty"`
	// RegistryToken is a bearer token to be sent to a registry
	RegistryToken string `json:"registrytoken,omitempty"`
}

type Cluster struct {
	Runtime
	Meta   Meta          `json:"meta"`
	Status ClusterStatus `json:"status"`
	Spec   ClusterSpec   `json:"spec"`
}

type ClusterCreateOptions struct {
	Description string `json:"description"`
}

type ClusterEvent struct {
	Data *Cluster
	// contains filtered or unexported fields
}

type ClusterList struct {
	Runtime
	Items []*Cluster
}

type ClusterMap struct {
	Runtime
	Items map[string]*Cluster
}

type ClusterResources struct {
	Containers int   `json:"containers"`
	Pods       int   `json:"pods"`
	Memory     int64 `json:"memory"`
	Cpu        int   `json:"cpu"`
	Storage    int64 `json:"storage"`
}

type ClusterSpec struct {
}

type ClusterStatus struct {
	Nodes     ClusterStatusNodes `json:"nodes"`
	Capacity  ClusterResources   `json:"capacity"`
	Allocated ClusterResources   `json:"allocated"`
	Deleted   bool               `json:"deleted"`
}

type ClusterStatusNodes struct {
	Total   int `json:"total"`
	Online  int `json:"online"`
	Offline int `json:"offline"`
}

type Config struct {
	Runtime
	Meta ConfigMeta `json:"meta" yaml:"meta"`
	Spec ConfigSpec `json:"spec" yaml:"spec"`
}

type ConfigEvent struct {
	Data *Config
	// contains filtered or unexported fields
}

type ConfigFile struct {
	Files map[string][]byte `json:"text"`
}

type ConfigList struct {
	Runtime
	Items []*Config
}

type ConfigManifest struct {
	Runtime
	State   string            `json:"state"`
	Type    string            `json:"kind"`
	Data    map[string]string `json:"data" yaml:"data"`
	Created time.Time         `json:"created"`
	Updated time.Time         `json:"updated"`
}

type ConfigMap struct {
	Runtime
	Items map[string]*Config
}

type ConfigMeta struct {
	Kind      string `json:"kind"`
	Namespace string `json:"namespace"`
	Meta      `yaml:",inline"`
}

type ConfigRemoveOptions struct {
	Force bool `json:"force"`
}

type ConfigSpec struct {
	Type string            `json:"type" yaml:"type"`
	Data map[string]string `json:"data" yaml:"data"`
}

type ConfigText struct {
	Text string `json:"text"`
}

type Container struct {
	// Container CID
	ID string `json:"id"`
	// Container Pod ID
	Pod string `json:"pod"`
	// Container Deployment ID
	Deployment string `json:"deployment"`
	// Container Namespace ID
	Namespace string `json:"namespace"`
	// Container envs
	Envs []string `json:"envs"`
	// Container binds
	Binds []string `json:"binds"`
	// Container name
	Name string `json:"name"`
	// Name information
	Image string `json:"image"`
	// Container current state
	State string `json:"state"`
	// ExitCode of the container
	ExitCode int `json:"exit_code"`
	// Container current state
	Status string `json:"status,omitempty"`
	// Container network settings
	Network NetworkSettings `json:"network"`
	// Container labels
	Labels map[string]string `json:"labels"`
	// Contaienr restart policy
	Restart struct {
		Policy string `json:"policy"`
		Retry  int    `json:"count"`
	} `json:"restart"`
	// Container created time
	Created time.Time `json:"created"`
	// Container started time
	Started time.Time `json:"started"`

	Exec SpecTemplateContainerExec `json:"exec"`
}

type ContainerDNSSpec struct {
	// List of DNS servers
	Server []string `json:"server"`
	// DNS server search options
	Search []string `json:"search"`
	// DNS server other options
	Options []string `json:"options"`
}

type ContainerLinkSpec struct {
	// Link name
	Link string `json:"link"`
	// Container alias
	Alias string `json:"alias"`
}

type ContainerManifest struct {
	// Template container id
	ID string `json:"id" yaml:"id"`
	// Template container name
	Name string `json:"name" yaml:"name"`
	// Labels list
	Labels map[string]string `json:"labels" yaml:"labels"`
	// Template container image
	Image string `json:"image" yaml:"image"`
	// Template container ports binding
	Ports SpecTemplateContainerPorts `json:"ports" yaml:"ports"`
	// Template container envs
	Envs []string `json:"env" yaml:"env"`
	// Template container resources
	Resources SpecTemplateContainerResources `json:"resources" yaml:"resources"`
	// Template container exec options
	Exec SpecTemplateContainerExec `json:"exec" yaml:"exec"`
	// Template container binds
	Binds []string `json:"volumes" yaml:"volumes"`
	// Template container security
	Security SpecTemplateContainerSecurity `json:"security" yaml:"security"`
	// Subnet container settings
	Network SpecTemplateContainerNetwork `json:"network" yaml:"network"`
	// Container DNS configuration
	DNS SpecTemplateContainerDNS `json:"dns" yaml:"dns"`
	// List of extra hosts
	ExtraHosts []string `json:"extra_hosts" yaml:"extra_hosts"`
	// Should docker publish all exposed port for the container
	PublishAllPorts bool `json:"publish" yaml:"publish"`
	// Links to another containers
	Links []SpecTemplateContainerLink `json:"links" yaml:"links"`
	// Restart Policy
	RestartPolicy SpecTemplateRestartPolicy `json:"restart" yaml:"restart"`
	// AutoRemove flag
	AutoRemove bool `json:"autoremove" yaml:"autoremove"`
}

type ContainerNetworkSpec struct {
	// Container hostname
	Hostname string `json:"hostname"`
	// Container host domain
	Domain string `json:"domain"`
	// Subnet ID to use
	Network string `json:"network"`
	// Subnet Mode to use
	Mode string `json:"mode"`
}

type ContainerPortSpec struct {
	// Container port to expose
	ContainerPort int `json:"container_port"`
	// Containers protocol allowed on exposed port
	Protocol string `json:"protocol"`
}

type ContainerQuotaSpec struct {
	// Maximum memory allowed to use
	Memory int64 `json:"memory"`
	// CPU shares for container on one node
	CPUShares int64 `json:"cpu_shares"`
}

type ContainerRestartPolicySpec struct {
	// Restart policy name
	Name string `json:"name"`
	// Attempt to restart container
	Attempt int `json:"attempt"`
}

type ContainerSpec struct {
	ID string `json:"id"`
	// Container meta spec
	Meta ContainerSpecMeta `json:"meta"`
	// Name spec
	Image ImageSpec `json:"image"`
	// Subnet spec
	Network ContainerNetworkSpec `json:"network"`
	// Ports configuration
	Ports []ContainerPortSpec `json:"ports"`
	// Labels list
	Labels map[string]string `json:"labels"`
	// Environments list
	EnvVars []string `json:"environments"`
	// Container enrtypoint
	Entrypoint []string `json:"entrypoint"`
	// Container run command
	Command []string `json:"command"`
	// Container run command arguments
	Args []string `json:"args"`
	// Container DNS configuration
	DNS ContainerDNSSpec `json:"dns"`
	// Container resources quota
	Quota ContainerQuotaSpec `json:"quota"`
	// Container restart policy
	RestartPolicy ContainerRestartPolicySpec `json:"restart_policy"`
	// Container volumes mount
	Volumes []ContainerVolumeSpec `json:"volumes"`
	// Links to another containers
	Links []ContainerLinkSpec `json:"links"`
	// Container in privileged mode
	Privileged bool `json:"privileged"`
	// PWD where the commands will be run
	Workdir string `json:"workdir"`
	// List of extra hosts
	ExtraHosts []string `json:"extra_hosts"`
	// Should docker publish all exposed port for the container
	PublishAllPorts bool `json:"publish_all_ports"`
}

type ContainerSpecMeta struct {
	Meta
	// Service id
	Service string `json:"service"`
	// Service spec id
	Spec string `json:"spec"`
}

type ContainerStatusInfo struct {
	// Container ID on host
	ID string `json:"cid"`
	// Name ID
	Image string `json:"image"`
	// Container current state
	State string `json:"state"`
	// Container current state
	Status string `json:"status"`
	// Container ports mapping
	Ports map[string][]ContainerStatusInfoPort `json:"ports"`
	// Container created time
	Created time.Time `json:"created"`
	// Container updated time
	Updated time.Time `json:"updated"`
}

type ContainerStatusInfoPort struct {
	HostIP   string `json:"host_ip"`
	HostPort string `json:"host_port"`
}

type ContainerVolumeSpec struct {
	// Volume name
	Volume string `json:"volume"`
	// Container mount path
	MountPath string `json:"mount_path"`
}

type Deployment struct {
	Runtime
	// Deployment Meta
	Meta DeploymentMeta `json:"meta"`
	// Deployment status
	Status DeploymentStatus `json:"status"`
	// Deployment spec
	Spec DeploymentSpec `json:"spec"`
}

type DeploymentEvent struct {
	Data *Deployment
	// contains filtered or unexported fields
}

type DeploymentList struct {
	Runtime
	Items []*Deployment
}

type DeploymentMap struct {
	Runtime
	Items map[string]*Deployment
}

type DeploymentMeta struct {
	Meta
	// Version
	Version int `json:"version"`
	// Namespace id
	Namespace string `json:"namespace"`
	// Service id
	Service string `json:"service"`
	// Endpoint
	Endpoint string `json:"endpoint"`
	// Self Link
	Status string `json:"status"`
}

type DeploymentOptions struct {
	Replicas int `json:"replicas"`
}

type DeploymentReplicas struct {
	Total     int `json:"total"`
	Provision int `json:"provision"`
	Pulling   int `json:"pulling"`
	Created   int `json:"created"`
	Started   int `json:"started"`
	Stopped   int `json:"stopped"`
	Errored   int `json:"errored"`
}

type DeploymentSpec struct {
	Replicas int          `json:"replicas"`
	State    SpecState    `json:"state"`
	Selector SpecSelector `json:"selector"`
	Template SpecTemplate `json:"template"`
}

type DeploymentStatus struct {
	State   string `json:"state"`
	Message string `json:"message"`
}

type DeploymentUpdateOptions struct {
	// Number of replicas
	Replicas *int
	// Deployment status for update
	Status *struct {
		State   string
		Message string
	}
}

type Discovery struct {
	Runtime
	Meta   DiscoveryMeta   `json:"meta"`
	Status DiscoveryStatus `json:"status"`
	Spec   DiscoverySpec   `json:"spec"`
}

type DiscoveryEvent struct {
	Data *Discovery
	// contains filtered or unexported fields
}

type DiscoveryInfo struct {
	Version      string `json:"version"`
	Hostname     string `json:"hostname"`
	Architecture string `json:"architecture"`

	OSName string `json:"os_name"`
	OSType string `json:"os_type"`

	// RewriteIP - need to set true if you want to use an external ip
	ExternalIP string `json:"external_ip"`
	InternalIP string `json:"internal_ip"`
}

type DiscoveryList struct {
	Runtime
	Items []*Discovery
}

type DiscoveryManifest struct {
	Meta    DiscoveryManifestMeta      `json:"meta"`
	Network map[string]*SubnetManifest `json:"network"`
}

type DiscoveryManifestMeta struct {
	Initial bool `json:"initial"`
}

type DiscoveryMap struct {
	Runtime
	Items map[string]*Discovery
}

type DiscoveryMeta struct {
	Meta
	Node string `json:"node"`
}

type DiscoverySpec struct {
}

type DiscoveryStatus struct {
	IP     string `json:"ip"`
	Port   uint16 `json:"port"`
	Ready  bool   `json:"ready"`
	Online bool   `json:"online"`
}

type DiscoveryStatusEvent struct {
	Data *DiscoveryStatus
	// contains filtered or unexported fields
}

type Endpoint struct {
	Runtime
	Meta   EndpointMeta   `json:"meta"`
	Status EndpointStatus `json:"status"`
	Spec   EndpointSpec   `json:"spec"`
}

type EndpointCreateOptions struct {
	IP            string            `json:"ip"`
	Domain        string            `json:"domain"`
	Ports         map[uint16]string `json:"ports"`
	RouteStrategy string            `json:"route_strategy"`
	Policy        string            `json:"policy"`
	BindStrategy  string            `json:"bind_strategy"`
}

type EndpointEvent struct {
	Data *Endpoint
	// contains filtered or unexported fields
}

type EndpointList struct {
	Runtime
	Items []*Endpoint
}

type EndpointManifest struct {
	Runtime
	EndpointSpec `json:",inline"`
	Upstreams    []string `json:"upstreams"`
}

type EndpointManifestEvent struct {
	Data *EndpointManifest
	// contains filtered or unexported fields
}

type EndpointManifestList struct {
	Runtime
	Items []*EndpointManifest
}

type EndpointManifestMap struct {
	Runtime
	Items map[string]*EndpointManifest
}

type EndpointMap struct {
	Runtime
	Items map[string]*Endpoint
}

type EndpointMeta struct {
	Meta
	// Namespace name
	Namespace string `json:"namespace"`
}

type EndpointSpec struct {
	// Endpoint state
	State     string               `json:"state"`
	External  bool                 `json:"external"`
	IP        string               `json:"ip"`
	Domain    string               `json:"domain"`
	PortMap   map[uint16]string    `json:"port_map"`
	Strategy  EndpointSpecStrategy `json:"strategy"`
	Policy    string               `json:"policy"`
	Upstreams []string             `json:"upstreams"`
}

type EndpointSpecStrategy struct {
	Route string `json:"route"`
	Bind  string `json:"bind"`
}

type EndpointState struct {
	EndpointSpec
}

type EndpointStatus struct {
	State string          `json:"state"`
	Ready map[string]bool `json:"ready"`
}

type EndpointUpdateOptions struct {
	IP            *string           `json:"ip"`
	Ports         map[uint16]string `json:"ports"`
	RouteStrategy string            `json:"route_strategy"`
	Policy        string            `json:"policy"`
	BindStrategy  string            `json:"bind_strategy"`
}

type EndpointUpstream struct {
	Host string `json:"host"`
	Port int    `json:"port"`
}

type Event struct {
	Data interface{}
	// contains filtered or unexported fields
}

type Image struct {
	Meta   ImageMeta
	Status ImageStatus
	Spec   ImageSpec
}

type ImageContainer struct {
	Ports []string
	Envs  []string
	Exec  SpecTemplateContainerExec
}

type ImageManifest struct {
	Name   string `json:"name" yaml:"name"`
	Tag    string `json:"tag" yaml:"tag"`
	Auth   string `json:"auth" yaml:"auth"`
	Policy string `json:"policy" yaml:"policy"`
}

type ImageMeta struct {
	ID     string   `json:"id"`
	Digest string   `json:"digest"`
	Name   string   `json:"name"`
	Tags   []string `json:"tags"`
}

type ImageSpec struct {
	// Name full name
	Name string `json:"name"`
	// Secret name for pulling
	Secret string `json:"auth"`
}

type ImageStatus struct {
	State       string         `json:"state"`
	Size        int64          `json:"size"`
	VirtualSize int64          `json:"virtual_size"`
	Container   ImageContainer `json:"container"`
}

type Ingress struct {
	Runtime
	Meta   IngressMeta   `json:"meta"`
	Status IngressStatus `json:"status"`
	Spec   IngressSpec   `json:"spec"`
}

type IngressEvent struct {
	Data *Ingress
	// contains filtered or unexported fields
}

type IngressInfo struct {
	Type         string `json:"type"`
	Version      string `json:"version"`
	Hostname     string `json:"hostname"`
	Architecture string `json:"architecture"`

	OSName string `json:"os_name"`
	OSType string `json:"os_type"`

	// RewriteIP - need to set true if you want to use an external ip
	ExternalIP string `json:"external_ip"`
	InternalIP string `json:"internal_ip"`
}

type IngressList struct {
	Runtime
	Items []*Ingress
}

type IngressManifest struct {
	Meta      IngressManifestMeta          `json:"meta"`
	Resolvers map[string]*ResolverManifest `json:"resolvers"`
	Routes    map[string]*RouteManifest    `json:"routes"`
	Endpoints map[string]*EndpointManifest `json:"endpoints"`
	Network   map[string]*SubnetManifest   `json:"network"`
}

type IngressManifestMeta struct {
	Initial bool `json:"initial"`
}

type IngressMap struct {
	Runtime
	Items map[string]*Ingress
}

type IngressMeta struct {
	Meta
	Node string `json:"node"`
}

type IngressSpec struct {
}

type IngressStatus struct {
	Ready  bool `json:"ready"`
	Online bool `json:"online"`
}

type IngressStatusEvent struct {
	Data *IngressStatus
	// contains filtered or unexported fields
}

type Meta struct {
	// Meta name
	Name string `json:"name,omitempty",yaml:"name,omitempty"`
	// Meta description
	Description string `json:"description",yaml:"description"`
	// Meta self link
	SelfLink string `json:"self_link",yaml:"self_link"`
	// Meta labels
	Labels map[string]string `json:"labels",yaml:"labels"`
	// Meta created time
	Created time.Time `json:"created",yaml:"created"`
	// Meta updated time
	Updated time.Time `json:"updated",yaml:"updated"`
}

type MetaCreateOptions struct {
	Name        string            `json:"name",yaml:"name"`
	Description string            `json:"description",yaml:"description"`
	Labels      map[string]string `json:"labels",yaml:"labels"`
}

type MetaUpdateOptions struct {
	Description *string           `json:"description",yaml:"description"`
	Labels      map[string]string `json:"labels",yaml:"labels"`
}

type Namespace struct {
	Meta   NamespaceMeta   `json:"meta"`
	Status NamespaceStatus `json:"status"`
	Spec   NamespaceSpec   `json:"spec"`
}

type NamespaceCreateOptions struct {
	Name        string                     `json:"name"`
	Description string                     `json:"description"`
	Domain      *string                    `json:"domain"`
	Resources   *NamespaceResourcesOptions `json:"resources"`
}

type NamespaceDomain struct {
	Internal string `json:"internal"`
	External string `json:"external"`
}

type NamespaceEnv struct {
	Name  string `json:"name"`
	Value string `json:"value"`
}

type NamespaceEnvs []NamespaceEnv

type NamespaceEvent struct {
	Data *Namespace
	// contains filtered or unexported fields
}

type NamespaceList struct {
	Runtime
	Items []*Namespace
}

type NamespaceMap struct {
	Runtime
	Items map[string]*Namespace
}

type NamespaceMeta struct {
	Meta     `yaml:",inline"`
	Endpoint string `json:"endpoint"`
	Type     string `json:"type"`
}

type NamespaceRemoveOptions struct {
	Force bool `json:"force"`
}

type NamespaceResourcesOptions struct {
	Request *ResourceRequestItemOption `json:"request"`
	Limits  *ResourceRequestItemOption `json:"limits"`
}

type NamespaceSpec struct {
	Resources ResourceRequest `json:"resources"`
	Env       NamespaceEnvs   `json:"env"`
	Domain    NamespaceDomain `json:"domain"`
}

type NamespaceStatus struct {
	Resources NamespaceStatusResources `json:"resources"`
}

type NamespaceStatusResources struct {
	Allocated ResourceRequestItem `json:"usage"`
}

type NamespaceUpdateOptions struct {
	Description *string                    `json:"description"`
	Domain      *string                    `json:"domain"`
	Resources   *NamespaceResourcesOptions `json:"resources"`
}

type Network struct {
	Runtime
	Meta   Meta          `json:"meta"`
	Status NetworkStatus `json:"status"`
	Spec   NetworkSpec   `json:"spec"`
}

type NetworkEvent struct {
	Data *Network
	// contains filtered or unexported fields
}

type NetworkInterface struct {
	Index int    `json:"index"`
	Name  string `json:"name"`
	Addr  string `json:"addr"`
	HAddr string `json:"HAddr"`
}

type NetworkSettings struct {
	// Container gatway ip address
	Gateway string `json:"gateway"`
	// Container ip address
	IPAddress string `json:"ip"`
	// Container ports mapping
	Ports []*SpecTemplateContainerPort `json:"ports"`
}

type NetworkSpec struct {
}

type NetworkState struct {
	SubnetSpec
}

type NetworkStatus struct {
	State string `json:"state"`
}

type Node struct {
	Runtime
	Meta   NodeMeta   `json:"meta"`
	Status NodeStatus `json:"status"`
	Spec   NodeSpec   `json:"spec"`
}

type NodeCreateMetaOptions struct {
	MetaCreateOptions
	Subnet   string `json:"subnet"`
	Token    string `json:"token"`
	Region   string `json:"region"`
	Provider string `json:"provider"`
}

type NodeCreateOptions struct {
	Meta     NodeCreateMetaOptions `json:"meta", yaml:"meta"`
	Info     NodeInfo              `json:"info", yaml:"info"`
	Status   NodeStatus            `json:"status", yaml:"status"`
	Security NodeSecurity          `json:"security", yaml:"security"`
}

type NodeEvent struct {
	Data *Node
	// contains filtered or unexported fields
}

type NodeInfo struct {
	Version      string `json:"version"`
	Hostname     string `json:"hostname"`
	Architecture string `json:"architecture"`

	OSName string `json:"os_name"`
	OSType string `json:"os_type"`

	// RewriteIP - need to set true if you want to use an external ip
	ExternalIP string `json:"external_ip"`
	InternalIP string `json:"internal_ip"`
	CIDR       string `json:"cidr"`
}

type NodeList struct {
	Runtime
	Items []*Node
}

type NodeManifest struct {
	Meta      NodeManifestMeta             `json:"meta"`
	Resolvers map[string]*ResolverManifest `json:"resolvers"`
	Secrets   map[string]*SecretManifest   `json:"secrets"`
	Configs   map[string]*ConfigManifest   `json:"configs"`
	Endpoints map[string]*EndpointManifest `json:"endpoint"`
	Network   map[string]*SubnetManifest   `json:"network"`
	Pods      map[string]*PodManifest      `json:"pods"`
	Volumes   map[string]*VolumeManifest   `json:"volumes"`
}

type NodeManifestMeta struct {
	Initial bool `json:"initial"`
}

type NodeMap struct {
	Runtime
	Items map[string]*Node
}

type NodeMeta struct {
	Meta
	NodeInfo
	Subnet  string `json:"subnet"`
	Cluster string `json:"cluster"`
}

type NodeMode struct {
	Ingress bool `json:"ingress"`
}

type NodeResources struct {
	// Node total containers
	Containers int `json:"containers"`
	// Node total pods
	Pods int `json:"pods"`
	// Node total memory
	Memory int64 `json:"memory"`
	// Node total cpu
	Cpu int `json:"cpu"`
	// Node storage
	Storage int64 `json:"storage"`
}

type NodeRole struct {
	Router  NodeRoleRouter `json:"router"`
	Builder bool           `json:"builder"`
}

type NodeRoleRouter struct {
	ExternalIP string `json:"external_ip"`
	Enabled    bool   `json:"enabled"`
}

type NodeSSL struct {
	CA   []byte `json:"ca"`
	Cert []byte `json:"cert"`
	Key  []byte `json:"key"`
}

type NodeSecurity struct {
	TLS bool     `json:"tls"`
	SSL *NodeSSL `json:"ssl"`
}

type NodeSpec struct {
	Security NodeSecurity `json:"security"`
}

type NodeStatus struct {
	// state
	State NodeStatusState `json:"state"`
	// node status online
	Online bool `json:"online"`
	// Node Capacity
	Capacity NodeResources `json:"capacity"`
	// Node Allocated
	Allocated NodeResources `json:"allocated"`
}

type NodeStatusEvent struct {
	Data *NodeStatus
	// contains filtered or unexported fields
}

type NodeStatusInterfaceState struct {
	Type    string `json:"type"`
	Version string `json:"version"`
	State   string `json:"state"`
	Message string `json:"message"`
}

type NodeStatusState struct {
	CRI NodeStatusInterfaceState `json:"cri"`
	CNI NodeStatusInterfaceState `json:"cni"`
	CPI NodeStatusInterfaceState `json:"cpi"`
	CSI NodeStatusInterfaceState `json:"csi"`
}

type NodeTask struct {
	Cancel context.CancelFunc
}

type NodeUpdateInfoOptions struct {
	Hostname     *string `json:"hostname"`
	Architecture *string `json:"architecture"`
	OSName       *string `json:"os_name"`
	OSType       *string `json:"os_type"`
	ExternalIP   *string `json:"external_ip"`
	InternalIP   *string `json:"internal_ip"`
	CIDR         *string `json:"cidr"`
}

type NodeUpdateMetaOptions struct {
	MetaUpdateOptions
	NodeUpdateInfoOptions
}

type Notification struct {
	ID            string
	UserID        string
	ComponentType string
	ComponentID   string
	Service       string
	Channel       string
	Level1        int64
	Level2        int64
	Level3        int64
	Active        bool
}

type NotificationList []*Notification

type NotificationMap map[string]*Notification

type NotifyChannel struct {
	ID   string
	Name string
	Type string
}

type NotifyGroup struct {
	ID   string
	Name string
	Type string
}

type Pod struct {
	Runtime
	// Pod Meta
	Meta PodMeta `json:"meta" yaml:"meta"`
	// Pod Spec
	Spec PodSpec `json:"spec" yaml:"spec"`
	// Containers status info
	Status PodStatus `json:"status" yaml:"status"`
}

type PodContainer struct {
	// Pod container ID
	ID string `json:"id" yaml:"id"`
	// Pod ID
	Pod string `json:"pod" yaml:"pod"`
	// Pod container name
	Name string `json:"name" yaml:"name"`
	// Pod container exec
	Exec SpecTemplateContainerExec `json:"exec" yaml:"exec"`
	// Pod container state
	State PodContainerState `json:"state" yaml:"state"`
	// Pod container ready
	Ready bool `json:"ready" yaml:"ready"`
	// Pod container restart count
	Restart struct {
		Policy  string `json:"policy"`
		Attempt int    `json:"count"`
	} `json:"restart" yaml:"restart"`
	// Pod container image meta
	Image PodContainerImage `json:"image" yaml:"image"`
	// Pod container envs
	Envs []string `json:"-"`
	// Pod container binds
	Binds []string `json:"-"`
	// Pod container ports
	Ports []*SpecTemplateContainerPort `json:"ports"`
}

type PodContainerImage struct {
	// Pod container image ID
	ID string `json:"id" yaml:"id"`
	// Pod container image name
	Name string `json:"name" yaml:"name"`
}

type PodContainerState struct {
	// Container restart state
	Restarted PodContainerStateRestarted `json:"restarted" yaml:"restarted"`
	// Container create state
	Created PodContainerStateCreated `json:"created" yaml:"created"`

	// Container started state
	Started PodContainerStateStarted `json:"started" yaml:"started"`

	// Container stopped state
	Stopped PodContainerStateStopped `json:"stopped" yaml:"stopped"`

	// Container error state
	Error PodContainerStateError `json:"error" yaml:"error"`
}

type PodContainerStateCreated struct {
	Created time.Time `json:"created" yaml:"created"`
}

type PodContainerStateError struct {
	Error   bool                  `json:"error" yaml:"error"`
	Message string                `json:"message" yaml:"message"`
	Exit    PodContainerStateExit `json:"exit" yaml:"exit"`
}

type PodContainerStateExit struct {
	Code      int       `json:"code" yaml:"code"`
	Timestamp time.Time `json:"timestamp" yaml:"timestamp"`
}

type PodContainerStateRestarted struct {
	Count     int       `json:"count" yaml:"count"`
	Restarted time.Time `json:"restarted" yaml:"restarted"`
}

type PodContainerStateStarted struct {
	Started   bool      `json:"started" yaml:"started"`
	Timestamp time.Time `json:"timestamp" yaml:"timestamp"`
}

type PodContainerStateStopped struct {
	Stopped bool                  `json:"stopped" yaml:"stopped"`
	Exit    PodContainerStateExit `json:"exit" yaml:"exit"`
}

type PodEvent struct {
	Data *Pod
	// contains filtered or unexported fields
}

type PodList struct {
	Runtime
	Items []*Pod
}

type PodManifest PodSpec

type PodManifestEvent struct {
	Node string
	Data *PodManifest
	// contains filtered or unexported fields
}

type PodManifestList struct {
	Runtime
	Items []*PodManifest
}

type PodManifestMap struct {
	Runtime
	Items map[string]*PodManifest
}

type PodMap struct {
	Runtime
	Items map[string]*Pod
}

type PodMeta struct {
	Meta `yaml:",inline"`
	// Pod SelfLink
	SelfLink string `json:"self_link" yaml:"self_link"`
	// Pod deployment
	Deployment string `json:"deployment" yaml:"deployment"`
	// Pod service
	Service string `json:"service" yaml:"service"`
	// Pod service id
	Namespace string `json:"namespace" yaml:"namespace"`
	// Pod node hostname
	Node string `json:"node" yaml:"node"`
	// Pod status
	Status string `json:"status" yaml:"status"`
	// Endpoint
	Endpoint string `json:"endpoint" yaml:"endpoint"`
}

type PodNetwork struct {
	// Pod host IP
	HostIP string `json:"host_ip" yaml:"host_ip"`
	// Pod IP
	PodIP string `json:"pod_ip" yaml:"pod_ip"`
}

type PodSpec struct {
	Local    bool         `json:"local,omitempty"`
	State    SpecState    `json:"state"`
	Selector SpecSelector `json:"selector"`
	Template SpecTemplate `json:"template" yaml:"template"`
}

type PodStatus struct {
	// Pod type
	Local bool `json:"local" yaml:"local"`
	// Pod state
	State string `json:"state" yaml:"state"`
	// Pod status
	Status string `json:"status" yaml:"status"`
	// Pod state
	Running bool `json:"running" yaml:"state"`
	// Pod state message
	Message string `json:"message" yaml:"message"`
	// Pod steps
	Steps PodSteps `json:"steps" yaml:"steps"`
	// Pod network
	Network PodNetwork `json:"network" yaml:"network"`
	// Pod containers
	Containers map[string]*PodContainer `json:"containers" yaml:"containers"`
	// Pod volumes
	Volumes map[string]*VolumeClaim `json:"volumes" yaml:"volumes"`
}

type PodStep struct {
	// Pod step ready
	Ready bool `json:"ready" yaml:"ready"`
	// Pod step timestamp
	Timestamp time.Time `json:"timestamp" yaml:"timestamp"`
}

type PodSteps map[string]PodStep

type Port struct {
	// HostIP is the host IP Address
	HostIP string `json:"host_ip"`
	// HostPort is the host port number
	HostPort string `json:"host_port"`
}

type Process struct {
	Runtime
	// Process Meta
	Meta ProcessMeta `json:"meta"`
	// Process status
	Status ProcessStatus `json:"status"`
}

type ProcessMeta struct {
	// Include default Meta struct
	Meta `json:"id" `

	ID string `json:"id" `

	// Process PID
	PID int `json:"pid" `

	// Process Master state
	Lead bool `json:"lead" `
	// Process Slave state
	Slave bool `json:"slave" `

	// Process registered type
	Kind string `json:"kind" `
	// Process registered hostname
	Hostname string `json:"hostname" `
}

type ProcessStatus struct{}

type ResolverManifest struct {
	IP   string `json:"ip"`
	Port uint16 `json:"port"`
}

type ResourceRequest struct {
	Request ResourceRequestItem `json:"request"`
	Limits  ResourceRequestItem `json:"limits"`
}

type ResourceRequestItem struct {
	RAM     string `json:"ram"`
	CPU     string `json:"cpu"`
	Storage string `json:"storage"`
}

type ResourceRequestItemOption struct {
	RAM     *string `json:"ram"`
	CPU     *string `json:"cpu"`
	Storage *string `json:"storage"`
}

type Route struct {
	Runtime
	Meta   RouteMeta   `json:"meta" yaml:"meta"`
	Status RouteStatus `json:"status" yaml:"status"`
	Spec   RouteSpec   `json:"spec" yaml:"spec"`
}

type RouteEvent struct {
	Data *Route
	// contains filtered or unexported fields
}

type RouteList struct {
	Runtime
	Items []*Route
}

type RouteManifest struct {
	State    string      `json:"state"`
	Domain   string      `json:"domain"`
	Port     uint16      `json:"port"`
	Endpoint string      `json:"endpoint"`
	Rules    []RouteRule `json:"rules"`
}

type RouteManifestEvent struct {
	Ingress string
	Data    *RouteManifest
	// contains filtered or unexported fields
}

type RouteManifestList struct {
	Runtime
	Items []*RouteManifest
}

type RouteManifestMap struct {
	Runtime
	Items map[string]*RouteManifest
}

type RouteMap struct {
	Runtime
	Items map[string]*Route
}

type RouteMeta struct {
	Meta      `yaml:",inline"`
	Namespace string `json:"namespace" yaml:"namespace"`
	Ingress   string `json:"ingress" yaml:"ingress"`
}

type RouteRule struct {
	Service  string `json:"service" yaml:"service"`
	Path     string `json:"path" yaml:"path"`
	Endpoint string `json:"endpoint" yaml:"endpoint"`
	Port     int    `json:"port" yaml:"port"`
}

type RouteSelector struct {
	Ingress string            `json:"ingress" yaml:"ingress"`
	Label   map[string]string `json:"label" yaml:"label"`
}

type RouteSpec struct {
	Selector RouteSelector `json:"selector" yaml:"selector"`
	State    string        `json:"state" yaml:"state"`
	Domain   string        `json:"domain" yaml:"domain"`
	Port     uint16        `json:"port" yaml:"port"`
	Rules    []RouteRule   `json:"rules" yaml:"rules"`
	Updated  time.Time     `json:"updated"`
}

type RouteStatus struct {
	State   string `json:"state" yaml:"state"`
	Message string `json:"message" yaml:"message"`
}

type Runtime struct {
	System RuntimeSystem `json:"-"`
}

type RuntimeSystem struct {
	Revision int64  `json:"-"`
	Key      string `json:"-"`
}

type Secret struct {
	Runtime
	Meta SecretMeta `json:"meta" yaml:"meta"`
	Spec SecretSpec `json:"spec" yaml:"yaml"`
}

type SecretAuthData struct {
	Username string `json:"username"`
	Password string `json:"password"`
}

type SecretCreateOptions struct {
	Name string
	Kind string
	Data map[string][]byte
}

type SecretEvent struct {
	Data *Secret
	// contains filtered or unexported fields
}

type SecretFile struct {
	Files map[string][]byte `json:"text"`
}

type SecretList struct {
	Runtime
	Items []*Secret
}

type SecretManifest struct {
	Runtime
	State   string    `json:"state"`
	Type    string    `json:"type"`
	Created time.Time `json:"created"`
	Updated time.Time `json:"updated"`
}

type SecretManifestEvent struct {
	Data *SecretManifest
	// contains filtered or unexported fields
}

type SecretManifestList struct {
	Runtime
	Items []*SecretManifest
}

type SecretManifestMap struct {
	Runtime
	Items map[string]*SecretManifest
}

type SecretMap struct {
	Runtime
	Items map[string]*Secret
}

type SecretMeta struct {
	Meta      `yaml:",inline"`
	Namespace string `json:"namespace" yaml:"namespace"`
}

type SecretRemoveOptions struct {
	Force bool `json:"force"`
}

type SecretSpec struct {
	Type string            `json:"type"`
	Data map[string][]byte `json:"data" yaml:"data"`
}

type SecretText struct {
	Text string `json:"text"`
}

type SecretUpdateOptions struct {
	Kind string
	Data map[string][]byte
}

type Service struct {
	Runtime
	Meta   ServiceMeta   `json:"meta"`
	Status ServiceStatus `json:"status"`
	Spec   ServiceSpec   `json:"spec"`
}

type ServiceEndpoint struct {
	Name string `json:"name"`
	Main bool   `json:"main"`
}

type ServiceEnvFromOption struct {
	Name string `json:"name"`
	Key  string `json:"key"`
}

type ServiceEnvOption struct {
	Name  string               `json:"name"`
	Value string               `json:"value"`
	From  ServiceEnvFromOption `json:"from"`
}

type ServiceEvent struct {
	Data *Service
	// contains filtered or unexported fields
}

type ServiceImageSpec struct {
	Name   *string `json:"image"`
	Secret *string `json:"secret"`
}

type ServiceList struct {
	Runtime
	Items []*Service
}

type ServiceManifest struct {
	Meta ServiceMeta `json:"meta"`
}

type ServiceMap struct {
	Runtime
	Items map[string]*Service
}

type ServiceMeta struct {
	Meta
	Namespace string `json:"namespace"`
	SelfLink  string `json:"self_link"`
	Endpoint  string `json:"endpoint"`
	IP        string `json:"ip"`
}

type ServiceOptionsSpec struct {
	Replicas   *int                `json:"replicas"`
	Memory     *int64              `json:"memory,omitempty"`
	Entrypoint *string             `json:"entrypoint,omitempty"`
	Command    *string             `json:"command,omitempty"`
	EnvVars    *[]ServiceEnvOption `json:"env,omitempty"`
	Ports      map[uint16]string   `json:"ports,omitempty"`
}

type ServiceRemoveOptions struct {
	Force bool `json:"force"`
}

type ServiceReplicas struct {
	Total     int `json:"total"`
	Provision int `json:"provision"`
	Created   int `json:"created"`
	Started   int `json:"started"`
	Stopped   int `json:"stopped"`
	Errored   int `json:"errored"`
}

type ServiceSpec struct {
	Replicas int          `json:"replicas" yaml:"replicas"`
	State    SpecState    `json:"state" yaml:"state"`
	Network  SpecNetwork  `json:"network" yaml:"network" `
	Strategy SpecStrategy `json:"strategy" yaml:"strategy"`
	Selector SpecSelector `json:"selector" yaml:"selector"`
	Template SpecTemplate `json:"template" yaml:"template"`
}

type ServiceSpecStrategy struct {
	Type           string                            `json:"type"` // Rolling
	RollingOptions ServiceSpecStrategyRollingOptions `json:"rollingOptions"`
	Resources      ServiceSpecStrategyResources      `json:"resources"`
	Deadline       int                               `json:"deadline"`
}

type ServiceSpecStrategyResources struct{}

type ServiceSpecStrategyRollingOptions struct {
	PeriodUpdate   int `json:"period_update"`
	Interval       int `json:"interval"`
	Timeout        int `json:"timeout"`
	MaxUnavailable int `json:"max_unavailable"`
	MaxSurge       int `json:"max_surge"`
}

type ServiceStatus struct {
	State   string               `json:"state"`
	Message string               `json:"message"`
	Network ServiceStatusNetwork `json:"network"`
}

type ServiceStatusNetwork struct {
	IP string `json:"ip"`
}

type SpecBuildImage struct {
	Tags           []string
	NoCache        bool
	Memory         int64
	Dockerfile     string
	SuppressOutput bool
	AuthConfigs    map[string]AuthConfig
	Context        io.Reader
	ExtraHosts     []string // List of extra hosts
}

type SpecNetwork struct {
	IP       string               `json:"ip"`
	Ports    map[uint16]string    `json:"ports"`
	Strategy EndpointSpecStrategy `json:"strategy"`
	Policy   string               `json:"policy"`
	// Spec updated time
	Updated time.Time `json:"updated"`
}

type SpecSelector struct {
	Labels map[string]string `json:"labels"`

	Node string `json:"node"`
	// Spec updated time
	Updated time.Time `json:"updated"`
}

type SpecState struct {
	Destroy     bool `json:"destroy"`
	Maintenance bool `json:"maintenance"`
}

type SpecStrategy struct {
	Type           string                     `json:"type"` // Rolling
	RollingOptions SpecStrategyRollingOptions `json:"rollingOptions"`
	Resources      SpecStrategyResources      `json:"resources"`
	Deadline       int                        `json:"deadline"`
	// Spec updated time
	Updated time.Time `json:"updated"`
}

type SpecStrategyResources struct {
}

type SpecStrategyRollingOptions struct {
	PeriodUpdate   int `json:"period_update"`
	Interval       int `json:"interval"`
	Timeout        int `json:"timeout"`
	MaxUnavailable int `json:"max_unavailable"`
	MaxSurge       int `json:"max_surge"`
}

type SpecTemplate struct {
	// Template spec for volume
	Volumes SpecTemplateVolumeList `json:"volumes" yaml:"volumes"`
	// Template main container
	Containers SpecTemplateContainers `json:"containers" yaml:"containers"`
	// Termination period
	Termination int `json:"termination" yaml:"termination"`
	// Spec updated time
	Updated time.Time `json:"updated" yaml:"updated"`
}

type SpecTemplateConfigVolume struct {
	// Secret name to mount
	Name string `json:"name"`
	// Config file binding
	Binds []SpecTemplateConfigVolumeBind `json:"binds"`
}

type SpecTemplateConfigVolumeBind struct {
	// Config key
	Key string `json:"key"`
	// File to create
	File string `json:"file"`
}

type SpecTemplateContainer struct {
	// Template container id
	ID string `json:"id" yaml:"id"`
	// Template container name
	Name string `json:"name" yaml:"name"`
	// Template container role
	Role string `json:"role" yaml:"role"`
	// Automatically remove container when it exits
	AutoRemove bool `json:"autoremove" yaml:"autoremove"`
	// Labels list
	Labels map[string]string `json:"labels" yaml:"labels"`
	// Template container image
	Image SpecTemplateContainerImage `json:"image" yaml:"image"`
	// Template container ports binding
	Ports SpecTemplateContainerPorts `json:"ports" yaml:"ports"`
	// Template container envs
	EnvVars SpecTemplateContainerEnvs `json:"env" yaml:"env"`
	// Template container resources
	Resources SpecTemplateContainerResources `json:"resources" yaml:"resources"`
	// Template container exec options
	Exec SpecTemplateContainerExec `json:"exec" yaml:"exec"`
	// Template container volumes
	Volumes SpecTemplateContainerVolumes `json:"volumes" yaml:"volumes"`
	// Template container probes
	Probes SpecTemplateContainerProbes `json:"probes" yaml:"probes"`
	// Template container security
	Security SpecTemplateContainerSecurity `json:"security" yaml:"security"`
	// Subnet container settings
	Network SpecTemplateContainerNetwork `json:"network" yaml:"network"`
	// Container DNS configuration
	DNS SpecTemplateContainerDNS `json:"dns" yaml:"dns"`
	// List of extra hosts
	ExtraHosts []string `json:"extra_hosts" yaml:"extra_hosts"`
	// Should docker publish all exposed port for the container
	PublishAllPorts bool `json:"publish" yaml:"publish"`
	// Links to another containers
	Links []SpecTemplateContainerLink `json:"links" yaml:"links"`
	// Restart Policy
	RestartPolicy SpecTemplateRestartPolicy `json:"restart" yaml:"restart"`
}

type SpecTemplateContainerDNS struct {
	// List of DNS servers
	Server []string `json:"server"`
	// DNS server search options
	Search []string `json:"search"`
	// DNS server other options
	Options []string `json:"options"`
}

type SpecTemplateContainerEnv struct {
	Name   string                         `json:"name"`
	Value  string                         `json:"value,omitempty"`
	Secret SpecTemplateContainerEnvSecret `json:"secret,omitempty"`
	Config SpecTemplateContainerEnvConfig `json:"config,omitempty"`
}

type SpecTemplateContainerEnvConfig struct {
	Name string `json:"name"`
	Key  string `json:"key"`
}

type SpecTemplateContainerEnvSecret struct {
	Name string `json:"name"`
	Key  string `json:"key"`
}

type SpecTemplateContainerEnvs []*SpecTemplateContainerEnv

type SpecTemplateContainerExec struct {
	Command []string `json:"command"`
	// Container enrtypoint
	Entrypoint []string `json:"entrypoint"`
	// Container run workdir option
	Workdir string `json:"workdir"`
	// Container run command arguments
	Args []string `json:"args"`
}

type SpecTemplateContainerImage struct {
	Name   string `json:"name" yaml:"name"`
	Secret string `json:"secret" yaml:"secret"`
	Policy string `json:"policy" yaml:"policy"`
}

type SpecTemplateContainerLink struct {
	// Link name
	Link string `json:"link"`
	// Container alias
	Alias string `json:"alias"`
}

type SpecTemplateContainerNetwork struct {
	// Container hostname
	Hostname string `json:"hostname"`
	// Container host domain
	Domain string `json:"domain"`
	// Subnet ID to use
	Network string `json:"network"`
	// Subnet Mode to use
	Mode string `json:"mode"`
}

type SpecTemplateContainerPort struct {
	// Container port
	ContainerPort uint16 `json:"container_port"`
	// Host port
	HostPort uint16 `json:"host_port"`
	// Host port
	HostIP string `json:"host_port"`
	// Binding protocol
	Protocol string `json:"protocol"`
}

type SpecTemplateContainerPorts []*SpecTemplateContainerPort

type SpecTemplateContainerProbe struct {
	// Exec command to check container liveness
	Exec struct {
		Command []string `json:"command"`
	} `json:"exec"`

	Socket struct {
		Protocol string `json:"protocol"`
		Port     int    `json:"port"`
	} `json:"socket"`

	InitialDelaySeconds int `json:"initial_delay"`
	TimeoutSeconds      int `json:"timeout_seconds"`
	PeriodSeconds       int `json:"period_seconds"`
	ThresholdSuccess    int `json:"threshold_success"`
	ThresholdFailure    int `json:"threshold_failure"`
}

type SpecTemplateContainerProbes struct {
	LiveProbe SpecTemplateContainerProbe `json:"live_probe"`
	ReadProbe SpecTemplateContainerProbe `json:"read_probe"`
}

type SpecTemplateContainerResource struct {
	// CPU resource option
	CPU int64 `json:"cpu"`
	// RAM resource option
	RAM int64 `json:"ram"`
}

type SpecTemplateContainerResources struct {
	// Limit resources
	Limits SpecTemplateContainerResource `json:"limits"`
	// Request resources
	Request SpecTemplateContainerResource `json:"quota"`
}

type SpecTemplateContainerSecurity struct {
	// Start container in priveleged mode
	Privileged bool `json:"privileged"`
	// Add linux security options
	LinuxOptions SpecTemplateContainerSecurityLinuxOptions `json:"linux_options"`
	// Run container as particular user
	User int `json:"user"`
}

type SpecTemplateContainerSecurityLinuxOptions struct {
	Level string `json:"level"`
}

type SpecTemplateContainerVolume struct {
	// Volume name
	Name string `json:"name"`
	// Volume mount mode
	Mode string `json:"mode"`
	// Volume mount path
	Path string `json:"path"`
}

type SpecTemplateContainerVolumes []*SpecTemplateContainerVolume

type SpecTemplateContainers []*SpecTemplateContainer

type SpecTemplateRestartPolicy struct {
	// Restart policy name
	Policy string `json:"policy" yaml:"policy"`
	// Attempt period
	Attempt int `json:"attempt" yaml:"attempt"`
}

type SpecTemplateSecretVolume struct {
	// Secret name to mount
	Name string `json:"name"`
	// Secret file key
	Binds []SpecTemplateSecretVolumeBind `json:"binds"`
}

type SpecTemplateSecretVolumeBind struct {
	Key  string `json:"key"`
	File string `json:"file"`
}

type SpecTemplateVolume struct {
	// Template volume name
	Name string `json:"name"`
	// Template volume name
	Type string `json:"type"`
	// Template volume from persistent volume
	Volume SpecTemplateVolumeClaim `json:"volume,omitempty"`
	// Template volume from secret type
	Secret SpecTemplateSecretVolume `json:"secret,omitempty"`
	// Template volume from config type
	Config SpecTemplateConfigVolume `json:"config,omitempty"`
}

type SpecTemplateVolumeClaim struct {
	// Persistent volume name to mount
	Name string `json:"name"`
	// Persistent Volume Subpath
	Subpath string `json:"subpath"`
}

type SpecTemplateVolumeList []*SpecTemplateVolume

type SpecTemplateVolumeMap map[string]*SpecTemplateVolume

type SpecTemplateVolumeMounts struct {
	// Template volume mounts name
	Name string `json:"name"`
}

type SpecTrigger struct {
}

type SpecTriggers []SpecTrigger

type SpecVolumeCapacity struct {
	// Limit resources
	Storage int64 `json:"storage"`
}

type SpecVolumeResource struct {
	// Size resource option
	Size int64 `json:"size"`
}

type Subnet struct {
	Runtime
	Meta   SubnetMeta   `json:"meta"`
	Status SubnetStatus `json:"status"`
	Spec   SubnetSpec   `json:"spec"`
}

type SubnetEvent struct {
	Data *Subnet
	// contains filtered or unexported fields
}

type SubnetManifest struct {
	Runtime
	SubnetSpec
}

type SubnetManifestEvent struct {
	Data *SubnetManifest
	// contains filtered or unexported fields
}

type SubnetManifestList struct {
	Runtime
	Items []*SubnetManifest
}

type SubnetManifestMap struct {
	Runtime
	Items map[string]*SubnetManifest
}

type SubnetMeta struct {
	Meta
	Node string `json:"node"`
}

type SubnetSpec struct {
	// Subnet state
	State string `json:"state"`
	// Node network type
	Type string `json:"type"`
	// Node Subnet subnet info
	CIDR string `json:"cidr"`
	// Node Subnet interface
	IFace NetworkInterface `json:"iface"`
	// Node Public IP
	Addr string `json:"addr"`
	// Node Internal IP
	IP string `json:"ip"`
}

type SubnetStatus struct {
	State string `json:"state"`
}

type Volume struct {
	Runtime
	// Volume meta
	Meta VolumeMeta `json:"meta" yaml:"meta"`
	// Volume spec
	Spec VolumeSpec `json:"spec" yaml:"spec"`
	// Volume status
	Status VolumeStatus `json:"status" yaml:"status"`
}

type VolumeClaim struct {
	// Pod name
	Name string `json:"name" yaml:"name"`
	// Pod volume name
	Volume string `json:"volume" yaml:"volume"`
	// Pod volume Path
	Path string `json:"path" yaml:"path"`
}

type VolumeCreateOptions struct {
}

type VolumeEvent struct {
	Data *Volume
	// contains filtered or unexported fields
}

type VolumeList struct {
	Runtime
	Items []*Volume
}

type VolumeManifest VolumeSpec

type VolumeManifestEvent struct {
	Node string
	Data *VolumeManifest
	// contains filtered or unexported fields
}

type VolumeManifestList struct {
	Runtime
	Items []*VolumeManifest
}

type VolumeManifestMap struct {
	Runtime
	Items map[string]*VolumeManifest
}

type VolumeMap struct {
	Runtime
	Items map[string]*Volume
}