v1alpha1

type Affinity struct {
	NodeAffinity         *NodeAffinity         `json:"nodeAffinity,omitempty"`
	InstanceAntiAffinity *InstanceAntiAffinity `json:"instanceAntiAffinity,omitempty"`
}

type DaemonSet struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   DaemonSetSpec   `json:"spec,omitempty"`
	Status DaemonSetStatus `json:"status,omitempty"`
}

type DaemonSetList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []DaemonSet `json:"items"`
}

type DaemonSetSpec struct {
	// Selector selects all Instance that are managed by this daemon set.
	Selector *metav1.LabelSelector `json:"nodeSelector,omitempty"`

	// Template is the instance template.
	Template InstanceTemplate `json:"template"`
}

type DaemonSetStatus struct {
	CollisionCount *int32 `json:"collisionCount,omitempty"`
}

type IP struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   IPSpec   `json:"spec,omitempty"`
	Status IPStatus `json:"status,omitempty"`
}

type IPAddress struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec IPAddressSpec `json:"spec,omitempty"`
}

type IPAddressClaimRef struct {
	Group     string    `json:"group,omitempty"`
	Resource  string    `json:"resource,omitempty"`
	Namespace string    `json:"namespace,omitempty"`
	Name      string    `json:"name,omitempty"`
	UID       types.UID `json:"uid,omitempty"`
}

type IPAddressList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []IPAddress `json:"items"`
}

type IPAddressSpec struct {
	IP       net.IP            `json:"ip,omitempty"`
	ClaimRef IPAddressClaimRef `json:"claimRef,omitempty"`
}

type IPBlock struct {
	// CIDR is a string representing the ip block.
	CIDR net.IPPrefix `json:"cidr"`
	// Except is a slice of CIDRs that should not be included within the specified CIDR.
	// Values will be rejected if they are outside CIDR.
	Except []net.IPPrefix `json:"except,omitempty"`
}

type IPClaimRef struct {
	Group    string    `json:"group,omitempty"`
	Resource string    `json:"resource,omitempty"`
	Name     string    `json:"name,omitempty"`
	UID      types.UID `json:"uid,omitempty"`
}

type IPList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []IP `json:"items"`
}

type IPSpec struct {
	Type     IPType          `json:"type"`
	IPFamily corev1.IPFamily `json:"ipFamily,omitempty"`
	IP       net.IP          `json:"ip,omitempty"`
	ClaimRef *IPClaimRef     `json:"claimRef,omitempty"`
}

type IPStatus struct {
}

type IPType string

type Instance struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   InstanceSpec   `json:"spec,omitempty"`
	Status InstanceStatus `json:"status,omitempty"`
}

type InstanceAffinityTerm struct {
	// LabelSelector over a set of resources, in this case instances.
	LabelSelector *metav1.LabelSelector `json:"labelSelector,omitempty"`
	// TopologyKey indicates that this instance should be co-located (affinity) or not co-located (anti-affinity)
	// with the instances matching the labelSelector, where co-located is defined as running on a
	// node whose value of the label with key topologyKey matches that of any node on which any of the
	// selected instances is running.
	// Empty topologyKey is not allowed.
	TopologyKey string `json:"topologyKey"`
}

type InstanceAntiAffinity struct {
	// RequiredDuringSchedulingIgnoredDuringExecution specifies anti-affinity requirements at
	// scheduling time, that, if not met, will cause the instance not be scheduled onto the node.
	// When there are multiple elements, the lists of nodes corresponding to each
	// instanceAffinityTerm are intersected, i.e. all terms must be satisfied.
	RequiredDuringSchedulingIgnoredDuringExecution []InstanceAffinityTerm `json:"requiredDuringSchedulingIgnoredDuringExecution,omitempty"`
}

type InstanceList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Instance `json:"items"`
}

type InstanceSpec struct {
	// Type specifies the InstanceType to deploy.
	Type InstanceType `json:"type"`

	// LoadBalancerType is the load balancer type this instance is for.
	LoadBalancerType LoadBalancerType `json:"loadBalancerType"`

	// NetworkRef references the network the instance is on.
	NetworkRef corev1.LocalObjectReference `json:"networkRef"`

	// IPs are the IPs of the instance.
	IPs []net.IP `json:"ips,omitempty"`

	// LoadBalancerPorts are the load balancer ports of this instance.
	LoadBalancerPorts []LoadBalancerPort `json:"loadBalancerPorts,omitempty"`

	// Affinity are affinity constraints.
	Affinity *Affinity `json:"affinity,omitempty"`

	// TopologySpreadConstraints describes how a group of instances ought to spread across topology
	// domains. Scheduler will schedule instances in a way which abides by the constraints.
	// All topologySpreadConstraints are ANDed.
	TopologySpreadConstraints []TopologySpreadConstraint `json:"topologySpreadConstraints,omitempty"`

	// NodeRef references the node hosting the load balancer instance.
	// Will be set by the scheduler if empty.
	NodeRef *corev1.LocalObjectReference `json:"nodeRef,omitempty"`
}

type InstanceStatus struct {
	IPs            []net.IP `json:"ips,omitempty"`
	CollisionCount *int32   `json:"collisionCount,omitempty"`
}

type InstanceTemplate struct {
	metav1.ObjectMeta `json:"metadata,omitempty"`
	Spec              InstanceSpec `json:"spec,omitempty"`
}

type InstanceType string

type LoadBalancer struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   LoadBalancerSpec   `json:"spec,omitempty"`
	Status LoadBalancerStatus `json:"status,omitempty"`
}

type LoadBalancerDestination struct {
	// IP is the target IP.
	IP net.IP `json:"ip"`
	// TargetRef is the target providing the destination.
	TargetRef *LoadBalancerTargetRef `json:"targetRef,omitempty"`
}

type LoadBalancerIP struct {
	// Name is the name of the load balancer IP.
	Name string `json:"name"`
	// IPFamily is the IP family of the IP. Has to match IP if specified. If unspecified and IP is specified,
	// will be defaulted by using the IP family of IP.
	// If only IPFamily is specified, a random IP of that family will be allocated if possible.
	IPFamily corev1.IPFamily `json:"ipFamily,omitempty"`
	// IP specifies a specific IP to allocate. If empty, a random IP will be allocated if possible.
	IP net.IP `json:"ip,omitempty"`
}

type LoadBalancerList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []LoadBalancer `json:"items"`
}

type LoadBalancerPort struct {
	// Protocol is the protocol the load balancer should allow.
	// If not specified, defaults to TCP.
	Protocol *corev1.Protocol `json:"protocol,omitempty"`
	// Port is the port to allow.
	Port int32 `json:"port"`
	// EndPort marks the end of the port range to allow.
	// If unspecified, only a single port, Port, will be allowed.
	EndPort *int32 `json:"endPort,omitempty"`
}

type LoadBalancerRouting struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Destinations []LoadBalancerDestination `json:"destinations,omitempty"`
}

type LoadBalancerRoutingList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []LoadBalancerRouting `json:"items"`
}

type LoadBalancerSpec struct {
	// Type specifies the type of load balancer.
	Type LoadBalancerType `json:"type"`

	// NetworkRef references the network the load balancer is part of.
	NetworkRef corev1.LocalObjectReference `json:"networkRef"`

	// IPs specifies the IPs of the load balancer.
	// +optional
	// +patchMergeKey=name
	// +patchStrategy=merge,retainKeys
	IPs []LoadBalancerIP `json:"ips,omitempty" patchStrategy:"merge,retainKeys" patchMergeKey:"name"`

	// Ports are the ports the load balancer should allow.
	// If empty, the load balancer allows all ports.
	Ports []LoadBalancerPort `json:"ports,omitempty"`

	// Selector selects all Instances matching the given labels
	Selector *metav1.LabelSelector `json:"selector,omitempty"`

	// Template is the instance template.
	Template InstanceTemplate `json:"template"`
}

type LoadBalancerStatus struct {
	// CollisionCount is used to construct names for IP addresses for the load balancer.
	CollisionCount *int32 `json:"collisionCount,omitempty"`
}

type LoadBalancerTargetRef struct {
	// UID is the UID of the target.
	UID types.UID `json:"uid"`
	// Name is the name of the target.
	Name string `json:"name"`
	// NodeRef references the node the destination network interface is on.
	NodeRef corev1.LocalObjectReference `json:"nodeRef"`
}

type LoadBalancerType string

type LocalUIDReference struct {
	// Name is the name of the referenced entity.
	Name string `json:"name"`
	// UID is the UID of the referenced entity.
	UID types.UID `json:"uid"`
}

type NATGateway struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   NATGatewaySpec   `json:"spec,omitempty"`
	Status NATGatewayStatus `json:"status,omitempty"`
}

type NATGatewayAutoscaler struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   NATGatewayAutoscalerSpec   `json:"spec,omitempty"`
	Status NATGatewayAutoscalerStatus `json:"status,omitempty"`
}

type NATGatewayAutoscalerList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []NATGatewayAutoscaler `json:"items"`
}

type NATGatewayAutoscalerSpec struct {
	// NATGatewayRef points to the target NATGateway to scale.
	NATGatewayRef corev1.LocalObjectReference `json:"natGatewayRef"`

	// MinPublicIPs is the minimum number of public IPs to allocate for a NAT Gateway.
	MinPublicIPs *int32 `json:"minPublicIPs,omitempty"`
	// MaxPublicIPs is the maximum number of public IPs to allocate for a NAT Gateway.
	MaxPublicIPs *int32 `json:"maxPublicIPs,omitempty"`
}

type NATGatewayAutoscalerStatus struct {
}

type NATGatewayIP struct {
	// Name is the semantic name of the NAT gateway IP.
	Name string `json:"name"`
	// IP specifies a specific IP to allocate. If empty, a random IP will be allocated if possible.
	IP net.IP `json:"ip,omitempty"`
}

type NATGatewayList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []NATGateway `json:"items"`
}

type NATGatewaySpec struct {
	// IPFamily is the IP family of the NAT gateway.
	IPFamily corev1.IPFamily `json:"ipFamily"`

	// NetworkRef references the network the NAT gateway is part of.
	NetworkRef corev1.LocalObjectReference `json:"networkRef"`

	// IPs specifies the IPs of the NAT gateway.
	// +optional
	// +patchMergeKey=name
	// +patchStrategy=merge,retainKeys
	IPs []NATGatewayIP `json:"ips,omitempty" patchStrategy:"merge,retainKeys" patchMergeKey:"name"`

	// PortsPerNetworkInterface specifies how many ports to allocate per network interface.
	PortsPerNetworkInterface int32 `json:"portsPerNetworkInterface"`
}

type NATGatewayStatus struct {
	// UsedNATIPs is the number of NAT IPs in-use.
	UsedNATIPs int64 `json:"usedNATIPs,omitempty"`
	// RequestedNATIPs is the number of requested NAT IPs.
	RequestedNATIPs int64 `json:"requestedNATIPs,omitempty"`
}

type NATIP struct {
	// IP is the IP to NAT.
	IP net.IP `json:"ip"`
	// Sections are the sections of the NATIP.
	Sections []NATIPSection `json:"sections,omitempty"`
}

type NATIPSection struct {
	// IP is the source IP.
	IP net.IP `json:"ip"`
	// Port is the start port of the section.
	Port int32 `json:"port"`
	// EndPort is the end port of the section
	EndPort int32 `json:"endPort"`
	// TargetRef references the entity having the IP.
	TargetRef *NATTableIPTargetRef `json:"targetRef,omitempty"`
}

type NATTable struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// IPs specifies how to NAT the IPs for the NAT gateway.
	IPs []NATIP `json:"ips,omitempty"`
}

type NATTableIPTargetRef struct {
	// UID is the UID of the target.
	UID types.UID `json:"uid"`
	// Name is the name of the target.
	Name string `json:"name"`
	// NodeRef references the node the destination network interface is on.
	NodeRef corev1.LocalObjectReference `json:"nodeRef"`
}

type NATTableList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []NATTable `json:"items"`
}

type Network struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   NetworkSpec   `json:"spec,omitempty"`
	Status NetworkStatus `json:"status,omitempty"`
}

type NetworkID struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec NetworkIDSpec `json:"spec,omitempty"`
}

type NetworkIDClaimRef struct {
	Group     string    `json:"group,omitempty"`
	Resource  string    `json:"resource,omitempty"`
	Namespace string    `json:"namespace,omitempty"`
	Name      string    `json:"name,omitempty"`
	UID       types.UID `json:"uid,omitempty"`
}

type NetworkIDList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []NetworkID `json:"items"`
}

type NetworkIDSpec struct {
	ClaimRef NetworkIDClaimRef `json:"claimRef"`
}

type NetworkInterface struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   NetworkInterfaceSpec   `json:"spec,omitempty"`
	Status NetworkInterfaceStatus `json:"status,omitempty"`
}

type NetworkInterfaceList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []NetworkInterface `json:"items"`
}

type NetworkInterfaceNAT struct {
	// IPFamily is the IP family of the handling NAT gateway.
	IPFamily corev1.IPFamily `json:"ipFamily"`
	// ClaimRef references the NAT claim handling the network interface's NAT.
	ClaimRef NetworkInterfaceNATClaimRef `json:"claimRef"`
}

type NetworkInterfaceNATClaimRef struct {
	// Name is the name of the claiming NAT gateway.
	Name string `json:"name"`
	// UID is the uid of the claiming NAT gateway.
	UID types.UID `json:"uid"`
}

type NetworkInterfacePublicIP struct {
	// Name is the semantic name of the network interface public IP.
	Name string `json:"name"`
	// IPFamily is the IP family of the IP. Has to match IP if specified. If unspecified and IP is specified,
	// will be defaulted by using the IP family of IP.
	// If only IPFamily is specified, a random IP of that family will be allocated if possible.
	IPFamily corev1.IPFamily `json:"ipFamily,omitempty"`
	// IP specifies a specific IP to allocate. If empty, a random ephemeral IP will be allocated.
	IP net.IP `json:"ip,omitempty"`
}

type NetworkInterfaceSpec struct {
	// NodeRef is the node the network interface is hosted on.
	NodeRef corev1.LocalObjectReference `json:"nodeRef"`

	// NetworkRef references the network that the network interface is in.
	NetworkRef corev1.LocalObjectReference `json:"networkRef"`

	// IPs are the internal IPs of the network interface.
	IPs []net.IP `json:"ips,omitempty"`

	// Prefixes are additional prefixes to route to the network interface.
	Prefixes []net.IPPrefix `json:"prefixes,omitempty"`

	// NATs specify the NAT of the network interface IP family.
	// Can only be set if there is no matching IP family in PublicIPs.
	NATs []NetworkInterfaceNAT `json:"natGateways,omitempty"`

	// Hostname is the hostname which should be announced by the network interface.
	Hostname string `json:"hostname,omitempty"`

	// PublicIPs are the public IPs the network interface should have.
	// +optional
	// +patchMergeKey=name
	// +patchStrategy=merge,retainKeys
	PublicIPs []NetworkInterfacePublicIP `json:"publicIPs,omitempty" patchStrategy:"merge,retainKeys" patchMergeKey:"name"`
}

type NetworkInterfaceState string

type NetworkInterfaceStatus struct {
	// State is the state of the network interface.
	State NetworkInterfaceState `json:"state,omitempty"`
	// PCIAddress is the PCI address of the network interface.
	PCIAddress *PCIAddress `json:"pciAddress,omitempty"`
	// TAPDevice is the TAP device of the network interface.
	TAPDevice *TAPDevice `json:"tapDevice,omitempty"`
	// Prefixes are the prefixes of the network interface.
	Prefixes []net.IPPrefix `json:"prefixes,omitempty"`
	// PublicIPs are the public IPs of the network interface.
	PublicIPs []net.IP `json:"publicIPs,omitempty"`
	// NATIPs are the NAT IPs of the network interface.
	NATIPs []net.IP `json:"natIPs,omitempty"`
}

type NetworkList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Network `json:"items"`
}

type NetworkPeering struct {
	// Name is the semantical name of the network peering.
	Name string `json:"name"`
	// ID is the ID of the network to peer with.
	ID string `json:"id"`
	// Prefixes is a list of prefixes that we want only to be exposed
	// to the peered network, if no prefixes are specified no filtering will be done.
	Prefixes []PeeringPrefix `json:"prefixes,omitempty"`
}

type NetworkPeeringState string

type NetworkPeeringStatus struct {
	// ID is the ID of network
	ID int32 `json:"id"`
	// State represents the network peering state
	State NetworkPeeringState `json:"state,omitempty"`
}

type NetworkPolicy struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec NetworkPolicySpec `json:"spec,omitempty"`
}

type NetworkPolicyEgressRule struct {
	// Ports specifies the list of destination ports that can be called with
	// this rule. Each item in this list is combined using a logical OR. Empty matches all ports.
	// As soon as a single item is present, only these ports are allowed.
	Ports []NetworkPolicyPort `json:"ports,omitempty"`
	// To specifies the list of destinations which the selected network interfaces should be
	// able to send traffic to. Fields are combined using a logical OR. Empty matches all destinations.
	// As soon as a single item is present, only these peers are allowed.
	To []NetworkPolicyPeer `json:"to,omitempty"`
}

type NetworkPolicyIngressRule struct {
	// From specifies the list of sources which should be able to send traffic to the
	// selected network interfaces. Fields are combined using a logical OR. Empty matches all sources.
	// As soon as a single item is present, only these peers are allowed.
	From []NetworkPolicyPeer `json:"from,omitempty"`
	// Ports specifies the list of ports which should be made accessible for
	// this rule. Each item in this list is combined using a logical OR. Empty matches all ports.
	// As soon as a single item is present, only these ports are allowed.
	Ports []NetworkPolicyPort `json:"ports,omitempty"`
}

type NetworkPolicyList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []NetworkPolicy `json:"items"`
}

type NetworkPolicyPeer struct {
	// ObjectSelector selects peers with the given kind matching the label selector.
	// Exclusive with other peer specifiers.
	ObjectSelector *ObjectSelector `json:"objectSelector,omitempty"`
	// IPBlock specifies the ip block from or to which network traffic may come.
	IPBlock *IPBlock `json:"ipBlock,omitempty"`
}

type NetworkPolicyPort struct {
	// Protocol (TCP, UDP, or SCTP) which traffic must match. If not specified, this
	// field defaults to TCP.
	Protocol *corev1.Protocol `json:"protocol,omitempty"`

	// The port on the given protocol. If this field is not provided, this matches
	// all port names and numbers.
	// If present, only traffic on the specified protocol AND port will be matched.
	Port int32 `json:"port,omitempty"`

	// EndPort indicates that the range of ports from Port to EndPort, inclusive,
	// should be allowed by the policy. This field cannot be defined if the port field
	// is not defined. The endPort must be equal or greater than port.
	EndPort *int32 `json:"endPort,omitempty" protobuf:"bytes,3,opt,name=endPort"`
}

type NetworkPolicyRule struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// NetworkRef is the network to which network policy is applied.
	NetworkRef LocalUIDReference `json:"networkRef"`
	// Targets are the targets of the network policy.
	Targets []TargetNetworkInterface `json:"targets,omitempty"`
	// Priority is an optional field that specifies the order in which the policy is applied.
	Priority *int32 `json:"priority,omitempty"`
	// IngressRules are the ingress rules.
	IngressRules []Rule `json:"ingressRule,omitempty"`
	// EgressRules are the egress rules.
	EgressRules []Rule `json:"egressRule,omitempty"`
}

type NetworkPolicyRuleList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []NetworkPolicyRule `json:"items"`
}

type NetworkPolicySpec struct {
	// NetworkRef is the network to regulate using this policy.
	NetworkRef corev1.LocalObjectReference `json:"networkRef"`
	// NetworkInterfaceSelector selects the network interfaces that are subject to this policy.
	NetworkInterfaceSelector metav1.LabelSelector `json:"networkInterfaceSelector"`
	// Priority is an optional field that specifies the order in which the policy is applied.
	// Policies with higher "order" are applied after those with lower
	// order.  If the order is omitted, it may be considered to be "infinite" - i.e. the
	// policy will be applied last.  Policies with identical order will be applied in
	// alphanumerical order based on the Policy "Name".
	Priority *int32 `json:"priority,omitempty"`
	// Ingress specifies rules for ingress traffic.
	Ingress []NetworkPolicyIngressRule `json:"ingress,omitempty"`
	// Egress specifies rules for egress traffic.
	Egress []NetworkPolicyEgressRule `json:"egress,omitempty"`
	// PolicyTypes specifies the types of policies this network policy contains.
	PolicyTypes []PolicyType `json:"policyTypes,omitempty"`
}

type NetworkSpec struct {
	// ID is the ID of the network.
	ID string `json:"id,omitempty"`
	// Peerings are the network peerings with this network
	Peerings []NetworkPeering `json:"peerings,omitempty"`
}

type NetworkState string

type NetworkStatus struct {
	// Peerings contains the states of the network peerings for the network.
	Peerings map[string][]NetworkPeeringStatus `json:"peerings,omitempty"`
}

type Node struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   NodeSpec   `json:"spec,omitempty"`
	Status NodeStatus `json:"status,omitempty"`
}

type NodeAffinity struct {
	RequiredDuringSchedulingIgnoredDuringExecution *NodeSelector `json:"requiredDuringSchedulingIgnoredDuringExecution,omitempty"`
}

type NodeList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Node `json:"items"`
}

type NodeSelector struct {
	// Required. A list of node selector terms. The terms are ORed.
	NodeSelectorTerms []NodeSelectorTerm `json:"nodeSelectorTerms"`
}

type NodeSelectorOperator string

type NodeSelectorRequirement struct {
	// Key is the key the selector applies to.
	Key string `json:"key"`
	// Operator represents the key's relationship to the values.
	// Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
	Operator NodeSelectorOperator `json:"operator"`
	// Values are the values to relate the key to via the operator.
	Values []string `json:"values,omitempty"`
}

type NodeSelectorTerm struct {
	// MatchExpressions matches nodes by the label selector requirements.
	MatchExpressions []NodeSelectorRequirement `json:"matchExpressions,omitempty"`
	// MatchFields matches the nodes by their fields.
	MatchFields []NodeSelectorRequirement `json:"matchFields,omitempty"`
}

type NodeSpec struct {
}

type NodeStatus struct {
}

type ObjectIP struct {
	// IPFamily is the IPFamily of the prefix.
	// If unset but Prefix is set, this can be inferred.
	IPFamily corev1.IPFamily `json:"ipFamily,omitempty"`
	// Prefix is the prefix of the IP.
	Prefix net.IPPrefix `json:"prefix,omitempty"`
}

type ObjectSelector struct {
	// Kind is the kind of object to select.
	Kind string `json:"kind"`
	// LabelSelector is the label selector to select objects of the specified Kind by.
	metav1.LabelSelector `json:",inline"`
}

type PCIAddress struct {
	Domain   string `json:"domain,omitempty"`
	Bus      string `json:"bus,omitempty"`
	Slot     string `json:"slot,omitempty"`
	Function string `json:"function,omitempty"`
}

type PeeringPrefix struct {
	// Name is the semantical name of the peering prefixes
	Name string `json:"name"`
	// CIDR to be exposed to the peered network
	Prefix *net.IPPrefix `json:"prefix,omitempty"`
}

type PolicyType string

type Rule struct {
	// CIDRBlock specifies the CIDR block from which network traffic may come or go.
	CIDRBlock []IPBlock `json:"ipBlock,omitempty"`
	// ObjectIPs are the object IPs the rule applies to.
	ObjectIPs []ObjectIP `json:"ips,omitempty"`
	// NetworkPolicyPorts are the protocol type and ports.
	NetworkPolicyPorts []NetworkPolicyPort `json:"networkPolicyPorts,omitempty"`
}

type TAPDevice struct {
	// Name is the name of the TAP device.
	Name string `json:"name,omitempty"`
}

type TargetNetworkInterface struct {
	// IP is the IP address of the target network interface.
	IP net.IP `json:"ip"`
	// TargetRef is the target providing the destination.
	TargetRef *LocalUIDReference `json:"targetRef,omitempty"`
}

type TopologySpreadConstraint struct {
	// MaxSkew describes the degree to which instances may be unevenly distributed.
	// When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference
	// between the number of matching instances in the target topology and the global minimum.
	// The global minimum is the minimum number of matching instances in an eligible domain
	// or zero if the number of eligible domains is less than MinDomains.
	MaxSkew int32 `json:"maxSkew"`
	// TopologyKey is the key of node labels. Nodes that have a label with this key
	// and identical values are considered to be in the same topology.
	// We consider each <key, value> as a "bucket", and try to put balanced number
	// of instances into each bucket.
	// We define a domain as a particular instance of a topology.
	// Also, we define an eligible domain as a domain whose nodes meet the requirements of
	// nodeAffinityPolicy and nodeTaintsPolicy.
	TopologyKey string `json:"topologyKey"`
	// WhenUnsatisfiable indicates how to deal with a instance if it doesn't satisfy
	// the spread constraint.
	// - DoNotSchedule (default) tells the scheduler not to schedule it.
	// - ScheduleAnyway tells the scheduler to schedule the instance in any location,
	//   but giving higher precedence to topologies that would help reduce the
	//   skew.
	WhenUnsatisfiable UnsatisfiableConstraintAction `json:"whenUnsatisfiable"`
	// LabelSelector is used to find matching instances.
	// Instances that match this label selector are counted to determine the number of instances
	// in their corresponding topology domain.
	LabelSelector *metav1.LabelSelector `json:"labelSelector,omitempty"`
}

type UnsatisfiableConstraintAction string