v1

type AddressInfo struct {
	// Interface is a reference to the interface name against which to configure
	// the address.
	// +kubebuilder:validation:MaxLength=255
	// +kubebuilder:validation:Pattern=^[a-zA-Z0-9\-_\.]+$
	Interface string `json:"interface"`

	// Address defines the IPv4 or IPv6 address value.
	Address string `json:"address"`

	// Prefix defines the IP address network prefix length.
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:validation:Maximum=128
	Prefix int `json:"prefix"`
}

type AddressList []AddressInfo

type AllocationInfo struct {
	// Ranges defines the pools from which host addresses are allocated.   If
	// omitted addresses the entire network
	// address space is considered available.
	Ranges []AllocationRange `json:"ranges,omitempty"`

	// Type defines whether network addresses are allocated dynamically or
	// statically.
	// +kubebuilder:validation:Enum=static,dynamic
	Type string `json:"type"`

	// Order defines whether host address are allocation randomly or sequential
	// from the available pool or addresses.
	// +kubebuilder:validation:Enum=sequential,random
	// +optional
	Order *string `json:"order,omitempty"`
}

type AllocationRange struct {
	// Start defines the beginning of the address range (inclusively)
	Start string `json:"start"`

	// End defines the end of the address range (inclusively)
	End string `json:"end"`
}

type BMCredentials struct {
	// Password defines the attributes specific to password based
	// authentication.
	// +optional
	Password *BMPasswordInfo `json:"password,omitempty"`
}

type BMInfo struct {
	// Type defines the board management controller type.  This is left as
	// optional so that the address can be overridden on a per-host basis
	// without worrying about overwriting the type or credentials.
	// +kubebuilder:validation:Enum=none,bmc,dynamic,ipmi,redfish
	// +optional
	Type *string `json:"type,omitempty"`

	// Address defines the IP address or hostname of the board management
	// interface.  An address is specific to a host therefore this should only
	// be set if the profile is only going to be used to configure a single
	// host; otherwise it should be set as a per-host override.
	// +optional
	Address *string `json:"address,omitempty"`

	// Credentials defines the authentication credentials for the board
	// management interface.  This is left as optional so that the address can
	// be overridden on a per-host basis without worrying about overwriting the
	// type or credentials.
	// +optional
	Credentials *BMCredentials `json:"credentials,omitempty"`
}

type BMPasswordInfo struct {
	// Secret defines the name of the secret which contains the username and
	// password for the board management
	// controller.
	Secret string `json:"secret"`
}

type BondInfo struct {
	// CommonInterfaceInfo defines attributes common to all interface
	// types.
	CommonInterfaceInfo `json:",inline"`

	// Members defines the list of interfaces which, together, make up the Bond
	// interface.
	// +kubebuilder:validation:MaxLength=255
	// +kubebuilder:validation:Pattern=^[a-zA-Z0-9\-_\.]+$
	Members StringList `json:"members"`

	// Mode defines the Bond interface aggregation mode.
	// +kubebuilder:validation:Enum=balanced,active_standby,802.3ad
	Mode string `json:"mode"`

	// TransmitHashPolicy defines the transmit interface selection policy for
	// the Bond interface.  Only applicable for 802.3ad and balanced modes.
	// +kubebuilder:validation:Enum=layer2,layer2+3
	// +optional
	TransmitHashPolicy *string `json:"transmitHashPolicy,omitempty"`

	// PrimaryReselect defines the reselection policy for the Bond interface.
	// Only applicable for active_standby mode.
	// +kubebuilder:valiation:Enum=always,better,failure
	// +optional
	PrimaryReselect *string `json:"primaryReselect,omitempty"`
}

type BondList []BondInfo

type CertificateInfo struct {
	// Type represents the intended usage of the certificate
	// +kubebuilder:validation:Enum=ssl,ssl_ca,openstack,openstack_ca,docker_registry,tpm_mode
	Type string `json:"type"`

	// Secret is the name of a TLS secret containing the public certificate and
	// private key.  The secret must be of type kubernetes.io/tls and must
	// contain specific data attributes.  Specifically, all secrets must, at a
	// minimum contain the "tls.crt" key since all certificates will at least
	// require public certificate PEM data.  The remaining two keys "tls.key"
	// and "ca.crt" are optional depending on the certificate type. For the
	// "platform", "openstack", "tpm", and "docker" certificate types both the
	// "tls.crt" and "tls.key" certificates are needed while for the "*_ca"
	// version of those same certificate types only the "tls.crt" attribute is
	// required.  The "ca.crt" attribute is only required for the "platform" or
	// "tpm" certificate types, and only if the supplied public certificate is
	// signed by a non-standard root CA.
	Secret string `json:"secret"`

	// Signature is the serial number of the certificate prepended with its
	// type. This attribute is for internal use only, when making comparisons
	Signature string `json:"-"`
}

type CertificateList []CertificateInfo

type CommonInterfaceInfo struct {
	// Name defines the name of the interface to be configured.
	// +kubebuilder:validation:MaxLength=255
	// +kubebuilder:validation:Pattern=^[a-zA-Z0-9\-_\.]+$
	Name string `json:"name"`

	// Class defines the intended usage of this interface by the system.
	// +kubebuilder:validation:Enum=platform,data,pci-sriov,pci-passthrough,none
	Class string `json:"class"`

	// MTU defines the maximum transmit unit for this interface.
	// +kubebuilder:validation:Minimum=576
	// +kubebuilder:validation:Maximum=9216
	// +optional
	MTU *int `json:"mtu,omitempty"`

	// PlatformNetworks defines the list of platform networks to be configured
	// against this interface.
	// +kubebuilder:validation:MaxLength=255
	// +kubebuilder:validation:Pattern=^[a-zA-Z0-9\-_]+$
	// +optional
	PlatformNetworks *StringList `json:"platformNetworks,omitempty"`

	// DataNetworks defines the list of data networks to be configured against
	// this interface.
	// +kubebuilder:validation:MaxLength=255
	// +kubebuilder:validation:Pattern=^[a-zA-Z0-9\-_]+$
	// +optional
	DataNetworks *StringList `json:"dataNetworks,omitempty"`

	// PTPRole defines the ptp role as master, slave, or none
	// +kubebuilder:validation:Enum=master,slave,none
	PTPRole *string `json:"ptpRole,omitempty"`
}

type ControllerFileSystemInfo struct {
	// Name defines the system defined name of the filesystem resource.
	Name string `json:"name"`

	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:validation:ExclusiveMinimum=false
	Size int `json:"size"`
}

type ControllerFileSystemList []ControllerFileSystemInfo

type DRBDConfiguration struct {
	// LinkUtilization defines the maximum link utilisation percentage during
	// sync activities.
	// +kubebuilder:validation:Minimum=20
	// +kubebuilder:validation:Maximum=100
	// +kubebuilder:validation:ExclusiveMinimum=false
	// +kubebuilder:validation:ExclusiveMaximum=false
	LinkUtilization int `json:"linkUtilization"`
}

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

	Spec   DataNetworkSpec   `json:"spec,omitempty"`
	Status DataNetworkStatus `json:"status,omitempty"`
}

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

type DataNetworkSpec struct {
	// Type defines the encapsulation method used for the data network.
	// +kubebuilder:validation:Enum=flat,vlan,vxlan
	Type string `json:"type"`

	// Description defines a user define description which explains the purpose
	// of the data network.
	// +optional
	Description *string `json:"description,omitempty"`

	// MTU defines the maximum transmit unit for any virtual network derived
	// from this data network.
	// +kubebuilder:validation:Minimum=576
	// +kubebuilder:validation:Maximum=9216
	// +optional
	MTU *int `json:"mtu,omitempty"`

	// VxLan defines VxLAN specific attributes for the data network.
	// +optional
	VxLAN *VxLANInfo `json:"vxlan,omitempty"`
}

type DataNetworkStatus struct {
	// ID defines the system assigned unique identifier.  This will only exist
	// once this resource has been provisioned into the system.
	// +optional
	ID *string `json:"id,omitempty"`

	// Reconciled defines whether the host has been successfully reconciled
	// at least once.  If further changes are made they will be ignored by the
	// reconciler.
	Reconciled bool `json:"reconciled"`

	// Defines whether the resource has been provisioned on the target system.
	InSync bool `json:"inSync"`
}

type ErrMissingSystemResource struct {
	// contains filtered or unexported fields
}

type EthernetInfo struct {
	// CommonInterfaceInfo defines attributes common to all interface
	// types.
	CommonInterfaceInfo `json:",inline"`

	// VFCount defines the number of SRIOV VF interfaces to be allocated.  Only
	// applicable if the interface class is set to "pci-sriov".
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:validation:Maximum=128
	// +optional
	VFCount *int `json:"vfCount,omitempty"`

	// VFDriver defines the device driver to be associated with each individual
	// SRIOV VF interface allocated.  Only applicable if the interface class is
	// set to "pci-sriov".
	VFDriver *string `json:"vfDriver,omitempty"`

	// Port defines the attributes identifying the underlying port which defines
	// this Ethernet interface.
	Port EthernetPortInfo `json:"port"`

	// Lower defines the interface name over which this ethernet interface is to be
	// configured.
	// +kubebuilder:validation:Pattern=^[a-zA-Z0-9\-_\.]+$
	Lower string `json:"lower,omitempty"`
}

type EthernetList []EthernetInfo

type EthernetPortInfo struct {
	// SystemName defines the device name of the Ethernet port.
	// +kubebuilder:validation:MaxLength=255
	// +kubebuilder:validation:Pattern=^[a-zA-Z0-9\-_]+$
	Name string `json:"name"`
}

type FileSystemInfo struct {
	// Name defines the system defined name of the filesystem resource.  Each
	// filesystem name may only be applicable to a subset of host personalities.
	// Refer to StarlingX documentation for more information.
	// +kubebuilder:validation:Enum=backup,docker,scratch,kubelet
	Name string `json:"name"`

	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:validation:ExclusiveMinimum=false
	Size int `json:"size"`
}

type FileSystemList []FileSystemInfo

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

	Spec   HostSpec   `json:"spec,omitempty"`
	Status HostStatus `json:"status,omitempty"`
}

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

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

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

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

type HostProfileSpec struct {
	// Base defines the name of another HostProfile from which to inherit
	// attributes.  HostProfiles can be structured in a hierarchy so that many
	// HostProfiles can inherit generic attributes from a parent HostProfile.
	// This hierarchy can be defined in multiple layers; with lower layers
	// overriding attributes set in higher layers.
	//
	// At configuration time, before a Host is configured, the hierarchy of
	// HostProfile resources is flattened to produce a single composite profile
	// that represents the final attributes as they are overridden down the
	// HostProfile hierarchy.
	//
	// Once the HostProfile hierarchy is flattened to a composite profile.  The
	// Deployment Manager will further refine the profile to create a final
	// HostProfile which serves as the final configuration for the Host
	// resource.  To create the final HostProfile, the Deployment Manages merges
	// the composite profile with the initial default host attributes, and then
	// merges the individual host overrides into that result.  The process
	// can be illustrated as follows:
	//
	//
	//         Host Defaults      +---------------------+
	//            |                                      \
	//            |                                       \
	//         Base Profile        +                       \
	//            |                 \                       \
	//           ...                  + Composite Profile ----+  Final Profile
	//            |                 /                        /
	//      Personality Profile(s) +                        /
	//            |                                        /
	//            |                                       /
	//           Host                                    /
	//            |                                     /
	//            |                                    /
	//         Host Overrides       +-----------------+
	//
	//
	// Merging two HostProfileSpec resources consists of merging the attributes
	// of a higher precedence profile into the attributes of a lower precedences
	// profile.  The rules for merging attributes are as follows.
	//
	//   1) A nil pointer is always overwritten by a non-nil pointer.
	//
	//   2) Two non-nil pointers are merged together according to the underlying
	//      type.
	//
	//   2a) If the type pointed to is a primitive type (e.g., int, bool,
	//       string, etc) then the higher precedence value is used).
	//
	//   2b) If the type pointed to is a structure then this same merge
	//       procedure is repeated recursively on each field of the structure
	//       with these same rules applying to each field.
	//
	//   2c) If the type pointed to is a slice/array then rule (3) is used.
	//
	//   2d) If the type pointed to is a map then higher precedence value is
	//       used and the entire map is overwritten.
	//
	//   3) Two slices are merged together using the following sub-rules.
	//
	//   3a) If the elements of slices define the KeyEqual() method then an
	//       attempt is made to try to merge equivalent element using this same
	//       merge strategy.  Elements from the higher precedence list that do
	//       not have an equivalent in the lower precedence list are appended to
	//       the list.  Elements appearing in the lower precedence list but not
	//       in the higher precedence list are kept intact.
	//
	//   3b) If the elements of the slices do not define the KeyEqual() method
	//       then they are simply concatenated together.
	//
	//   3c) An empty slice is handled as a special case that deletes the
	//       contents of the lower precedence slice.  Do not confuse an empty
	//       slice with a nil slice pointer.
	//
	// +optional
	Base *string `json:"base,omitempty"`

	// ProfileBaseAttributes defines the node level base attributes.  They are
	// grouped together to take advantage of the code generated DeepEqual
	// method to facilitate comparisons.
	ProfileBaseAttributes `json:",inline"`

	// BoardManagement defines the attributes specific to the board management
	// controller configuration.
	// +optional
	BoardManagement *BMInfo `json:"boardManagement,omitempty"`

	// Processors defines the core allocations for each function across all NUMA
	// sockets/nodes.
	Processors ProcessorNodeList `json:"processors,omitempty"`

	// Memory defines the memory allocations for each function across all NUMA
	// sockets/nodes.
	Memory MemoryNodeList `json:"memory,omitempty"`

	// Storage defines the storage attributes for the host
	// +optional
	Storage *ProfileStorageInfo `json:"storage,omitempty"`

	// Interfaces defines the list of interfaces to be configured against this
	// host.
	// +optional
	Interfaces *InterfaceInfo `json:"interfaces,omitempty"`

	// Addresses defines the list of addresses to be configured against this
	// host.  Addresses are specific to a single host therefore they should only
	// be specified if this profile is only going to be used to configure a
	// single
	// host.
	Addresses AddressList `json:"addresses,omitempty"`

	// Routes defines the list of routes to be configured against this host.
	// Routes require that the target interface be configured with a suitable
	// address (e.g., one that allows reachability to next hop device(s))
	// therefore the host must be configured with valid addresses or configured
	// to for automatic address assignment from a platform network.
	Routes RouteList `json:"routes,omitempty"`
}

type HostSpec struct {
	// Profile defines the name of the HostProfile to use as a configuration
	// template for the host.  A host may point to a single HostProfile resource
	// or may point to a chain or hierarchy of HostProfile resources.  At
	// configuration time the Deployment Manager will flatten the Host
	// attributes defined in the hierarchy of HostProfiles and produce a final
	// composite profile that represents the intended configuration state of
	// an individual Host resources.  This composite profile also include any
	// individual host specific attributes defined in the "overrides" attribute
	// defined below.
	Profile string `json:"profile"`

	// Match defines the attributes used to match a system host resource to a
	// host CR definition.
	// +optional
	Match *MatchInfo `json:"match,omitempty"`

	// Overrides defines a set of HostProfile attributes that must be overridden
	// from the base HostProfile before configuring the host.  The schema for
	// this field is intentionally a copy of the full HostProfileSpec schema
	// so that any HostProfile attribute can be overridden on a per-host basis.
	//
	// For example, it may be necessary to define IP addresses that are unique
	// to each host, or to override storage device paths if the installed
	// devices does not align completely with the HostProfile pointed to by the
	// "profile" attribute.
	// +optional
	Overrides *HostProfileSpec `json:"overrides,omitempty"`
}

type HostStatus struct {
	// ID defines the system assigned unique identifier.  This will only exist
	// once this resource has been provisioned into the system.
	ID *string `json:"id,omitempty"`

	// AdministrativeState is the last known administrative state of the host.
	AdministrativeState *string `json:"administrativeState,omitempty"`

	// OperationalStatus is the last known operational status of the host.
	OperationalStatus *string `json:"operationalStatus,omitempty"`

	// AvailabilityStatus is the last known availability status of the host.
	AvailabilityStatus *string `json:"availabilityStatus,omitempty"`

	// InSync defines whether the desired state matches the operational state.
	InSync bool `json:"inSync"`

	// Reconciled defines whether the host has been successfully reconciled
	// at least once.  If further changes are made they will be ignored by the
	// reconciler.
	Reconciled bool `json:"reconciled"`

	// Defaults defines the configuration attributed collected before applying
	// any user configuration values.
	Defaults *string `json:"defaults,omitempty"`
}

type InterfaceInfo struct {
	// Ethernet defines the list of ethernet interfaces to be configured on a
	// host.
	Ethernet EthernetList `json:"ethernet,omitempty" patchStrategy:"merge" patchMergeKey:"name"`

	// VLAN defines the list of VLAN interfaces to be configured on a host.
	VLAN VLANList `json:"vlan,omitempty"`

	// Bond defines the list of Bond interfaces to be configured on a host.
	Bond BondList `json:"bond,omitempty"`

	// VF defines the list of SR-IOV VF interfaces to be configured on a host.
	VF VFList `json:"vf,omitempty"`
}

type JournalInfo struct {
	// Location defines	the OSD device path to be used as the Journal OSD for
	// this logical device.
	// +kubebuilder:validation:MaxLength=255
	Location string `json:"location"`

	// Size defines the size of the OSD journal in gibibytes.
	// +kubebuilder:validation:Minimum=1
	Size int `json:"size"`
}

type LicenseInfo struct {
	// Secret is the name of a TLS secret containing the license file contents.
	// It must refer to a Opaque Kubernetes Secret.
	Secret string `json:"secret"`
}

type MatchBMInfo struct {
	// Address defines the board management IP address.
	Address *string `json:"address,omitempty"`

	// Type defines the board management type
	// +kubebuilder:validation:Enum=none,bmc,dynamic,ipmi,redfish
	// +optional
	Type *string `json:"type,omitempty"`
}

type MatchDMIInfo struct {
	// SerialNumber defines the board serial number as stored in the DMI block.
	// +kubebuilder:validation:MaxLength=255
	// +optional
	SerialNumber *string `json:"serialNumber,omitempty"`

	// AssetTag defines the board asset tag as stored in the DMI block.
	// +kubebuilder:validation:MaxLength=255
	// +optional
	AssetTag *string `json:"assetTag,omitempty"`
}

type MatchInfo struct {
	// BootMAC defines the MAC address that a host used to perform the initial
	// software installation.
	// +kubebuilder:validation:Pattern=^([0-9a-fA-Z]{2}[:-]){5}([0-9a-fA-Z]{2})$
	// +optional
	BootMAC *string `json:"bootMAC,omitempty"`

	// BoardManagement defines the board management attributes that can be used
	// to match a system host resource to a system CR definition.
	// NOTE:  Not yet supported.
	// +optional
	BoardManagement *MatchBMInfo `json:"boardManagement,omitempty"`

	// DMI defines the Desktop Management Interface attributes that can be used
	// to match a system host resource to a system CR definition.
	// NOTE:  Not yet supported.
	// +optional
	DMI *MatchDMIInfo `json:"dmi,omitempty"`
}

type MemoryFunctionInfo struct {
	// Function defines the function for which to allocate a number of cores.
	// +kubebuilder:validation:Enum=platform,vm,vswitch
	Function string `json:"function"`

	// PageSize defines the size of individual memory pages to be allocated to
	// a specific function.  For platform
	// allocations the 4KB page size is the only valid choice.
	// +kubebuilder:validation:Enum=4KB,2MB,1GB
	PageSize string `json:"pageSize"`

	// PageCount defines the number of pages to allocate to a specific function.
	PageCount int `json:"pageCount"`
}

type MemoryFunctionList []MemoryFunctionInfo

type MemoryNodeInfo struct {
	// Node defines the NUMA node number for which to allocate a number of
	// functions.
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:validation:Maximum=7
	Node int `json:"node"`

	// Functions defines a list of function specific allocations for the given
	// NUMA socket/node.
	Functions MemoryFunctionList `json:"functions"`
}

type MemoryNodeList []MemoryNodeInfo

type MonitorInfo struct {
	// Size represents the storage allocated to the monitor in gibibytes
	// +kubebuilder:validation:Minimum=20
	// +kubebuilder:validation:Maximum=40
	// +optional
	Size *int `json:"size,omitempty"`
}

type OSDInfo struct {
	// Function defines the function to be assigned to the OSD device.
	// +kubebuilder:validation:Enum=osd,journal
	Function string `json:"function"`

	// Path defines the disk device path to use as backing for the OSD device.
	// +kubebuilder:validation:MaxLength=4095
	// +kubebuilder:validation:Pattern=^/dev/.+$
	Path string `json:"path"`

	// ClusterName defines the storage cluster to which the OSD device should
	// be assigned.  By default this is the "ceph_cluster".
	// +kubebuilder:validation:MaxLength=255
	// +optional
	ClusterName *string `json:"cluster,omitempty"`

	// Journal defines another OSD device to be used as the journal for this
	// OSD device.
	// +optional
	Journal *JournalInfo `json:"journal,omitempty"`
}

type OSDList []OSDInfo

type PTPInfo struct {
	// Mode defines the precision time protocol mode of the system.
	// +kubebuilder:validation:Enum=hardware,software,legacy
	// +optional
	Mode *string `json:"mode,omitempty"`

	// Transport defines the network transport protocol used to implement the
	// precision time protocol.
	// +kubebuilder:validation:Enum=l2,udp
	// +optional
	Transport *string `json:"transport,omitempty"`

	// Mechanism defines the high level messaging architecture used to implement
	// the precision time procotol.
	// +kubebuilder:validation:Enum=p2p,e2e
	// +optional
	Mechanism *string `json:"mechanism,omitempty"`
}

type PageSize string

type PhysicalVolumeInfo struct {
	// Type defines the type of physical volume.
	// +kubebuilder:validation:Enum=disk,partition
	Type string `json:"type"`

	// Path defines the device path backing the physical volume.  If 'Type' is
	// set as disk then this attribute refers to the absolute path of a disk
	// device.  If 'Type' is set as partition then it refers to the device path
	// of the disk onto which this partition will be created.
	// +kubebuilder:validation:MaxLength=255
	Path string `json:"path"`

	// Size defines the size of the disk partition in gibibytes.  This should be
	// omitted if the path refers to a disk.
	// +kubebuilder:validation:Minimum=1
	// +optional
	Size *int `json:"size,omitempty"`
}

type PhysicalVolumeList []PhysicalVolumeInfo

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

	Spec   PlatformNetworkSpec   `json:"spec,omitempty"`
	Status PlatformNetworkStatus `json:"status,omitempty"`
}

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

type PlatformNetworkSpec struct {
	// Type defines the intended usage of the network
	// +kubebuilder:validation:Enum=mgmt,pxeboot,infra,oam,multicast,system-controller,cluster-host,cluster-pod,cluster-service,storage,other
	Type string `json:"type"`

	// Subnet defines the IPv4 or IPv6 network address for the network
	Subnet string `json:"subnet"`

	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:validation:Maximum=128
	Prefix int `json:"prefix"`

	// Gateway defines the nexthop gateway IP address if applicable
	// +optional
	Gateway *string `json:"gateway,omitempty"`

	// Allocation defines the allocation scheme details for the network
	Allocation AllocationInfo `json:"allocation"`
}

type PlatformNetworkStatus struct {
	// ID defines the system assigned unique identifier.  This will only exist
	// once this resource has been provisioned into the system.
	// +optional
	ID *string `json:"id,omitempty"`

	// PoolUUID defines the system assigned unique identifier that is represents
	// the networks underlying address pool resource.  This will only exist
	// once this resource has been provisioned into the system.
	// +optional
	PoolUUID *string `json:"poolUUID,omitempty"`

	// Reconciled defines whether the network has been successfully reconciled
	// at least once.  If further changes are made they will be ignored by the
	// reconciler.
	Reconciled bool `json:"reconciled"`

	// Defines whether the resource has been provisioned on the target system.
	InSync bool `json:"inSync"`
}

type ProcessorFunctionInfo struct {
	// Function defines the function for which to allocate a number of cores.
	// +kubebuilder:validation:Enum=platform,shared,vswitch,application-isolated,application
	Function string `json:"function"`

	// Count defines the number of cores to allocate to a specific function.
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:validation:Maximum=64
	Count int `json:"count"`
}

type ProcessorFunctionList []ProcessorFunctionInfo

type ProcessorInfo struct {
	// Node defines the NUMA node number for which to allocate a number of
	// functions.
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:validation:Maximum=7
	Node int `json:"node"`

	// Functions defines a list of function specific allocations for the given
	// NUMA socket/node.
	Functions ProcessorFunctionList `json:"functions"`
}

type ProcessorNodeList []ProcessorInfo

type ProfileBaseAttributes struct {
	// Personality defines the role to be assigned to the host
	// +kubebuilder:validation:Enum=controller,worker,storage,controller-worker
	// +optional
	Personality *string `json:"personality,omitempty"`

	// AdministrativeState defines the desired administrative state of the host
	// +kubebuilder:validation:Enum=locked,unlocked
	// +optional
	AdministrativeState *string `json:"administrativeState,omitempty"`

	// SubFunctionList defines the set of subfunctions to be provisioned on the
	// node at time of initial provisioning.
	// +kubebuilder:validation:Enum=controller,worker,storage,lowlatency
	// +optional
	SubFunctions StringList `json:"subfunctions,omitempty"`

	// Location defines the physical location of the host in the data centre.
	// +optional
	Location *string `json:"location,omitempty"`

	// Labels defines the set of labels to be applied to the kubernetes node
	// resources that is running on this host.
	Labels map[string]string `json:"labels,omitempty"`

	// InstallOutput defines the install output method.  The graphical mode is
	// only suitable when the console attribute is set to a graphical terminal.
	// The text mode can be used with both serial and graphical console
	// configurations.
	// +kubebuilder:validation:Enum=text,graphical
	// +optional
	InstallOutput *string `json:"installOutput,omitempty"`

	// Console defines the installation output device.
	// +kubebuilder:validation:Pattern=^(|tty[0-9]+|ttyS[0-9]+(,\d+([a-zA-Z0-9]+)?)?|ttyUSB[0-9]+(,\d+([a-zA-Z0-9]+))?|lp[0-9]+)$
	// +optional
	Console *string `json:"console,omitempty"`

	// BootDevice defines the absolute device path of the device to be used for
	// installation.
	// +kubebuilder:validation:Pattern=^/dev/.+$
	// +kubebuilder:validation:MaxLength=4095
	// +optional
	BootDevice *string `json:"bootDevice,omitempty"`

	// PowerOn defines the initial power state of the node if static
	// provisioning is being used.
	// +optional
	PowerOn *bool `json:"powerOn,omitempty"`

	// ProvisioningMode defines whether a host is provisioned dynamically when
	// it appears in system host inventory or whether it is provisioned
	// statically and powered up explicitly.  Statically provisioned hosts
	// require that the user supply a boot MAC address, board management IP
	// address, and a management IP address if the management network is
	// configured for static address assignment.
	// +kubebuilder:validation:Enum=static,dynamic
	// +optional
	ProvisioningMode *string `json:"provisioningMode,omitempty"`

	// BootMAC defines the MAC address that a host uses to perform the initial
	// software installation.  This is only applicable for statically
	// provisioned hosts and should be set on each hosts via the overrides
	// attributes.
	// +kubebuilder:validation:Pattern=^([0-9a-fA-Z]{2}[:-]){5}([0-9a-fA-Z]{2})$
	// +optional
	BootMAC *string `json:"bootMAC,omitempty"`

	// RootDevice defines the absolute device path of the device to be used as
	// the root file system.
	// +kubebuilder:validation:Pattern=^/dev/.+$
	// +kubebuilder:validation:MaxLength=4095
	// +optional
	RootDevice *string `json:"rootDevice,omitempty"`

	// ClockSynchronization defines the clock synchronization source of the host
	// resource.
	// +kubebuilder:validation:Enum=ntp,ptp
	// +optional
	ClockSynchronization *string `json:"clockSynchronization,omitempty"`
}

type ProfileStorageInfo struct {
	// Monitor defines whether a Ceph storage monitor should be enabled on a
	// node.
	// +optional
	Monitor *MonitorInfo `json:"monitor,omitempty"`

	// OSDs defines the list of OSD devices to be created on the host.  This is
	// only applicable to storage related nodes.
	// +optional
	OSDs *OSDList `json:"osds,omitempty"`

	// VolumeGroups defines the list of volume groups to be created on the host.
	// +optional
	VolumeGroups *VolumeGroupList `json:"volumeGroups,omitempty"`

	// FileSystems defines the list of file systems to be defined on the host.
	// +optional
	FileSystems *FileSystemList `json:"filesystems,omitempty"`
}

type RouteInfo struct {
	// Interface is a reference to the interface name against which to configure
	// the route.
	// +kubebuilder:validation:MaxLength=255
	// +kubebuilder:validation:Pattern=^[a-zA-Z0-9\-_\.]+$
	Interface string `json:"interface"`

	// Subnet defines the destination network address subnet.
	Network string `json:"subnet"`

	// Prefix defines the destination network address prefix length.
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:validation:Maximum=128
	Prefix int `json:"prefix"`

	// Gateway defines the next hop gateway IP address.
	Gateway string `json:"gateway"`

	// Metric defines the route preference metric for this route.
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:validation:Maximum=255
	// +optional
	Metric *int `json:"metric,omitempty"`
}

type RouteList []RouteInfo

type ServiceParameterInfo struct {
	// Service identifies the service for this service parameter
	// +kubebuilder:validation:Pattern=^[a-zA-Z0-9\-_]+$
	// +kubebuilder:validation:MaxLength=16
	Service string `json:"service"`

	// Section identifies the section for this service parameter
	// +kubebuilder:validation:Pattern=^[a-zA-Z0-9\-_]+$
	// +kubebuilder:validation:MaxLength=128
	Section string `json:"section"`

	// ParamName identifies the name for this service parameter
	// +kubebuilder:validation:MaxLength=255
	ParamName string `json:"paramname"`

	// ParamValue identifies the value for this service parameter
	// +kubebuilder:validation:MaxLength=4096
	ParamValue string `json:"paramvalue"`

	// Personality identifies the personality for this service parameter
	// +kubebuilder:validation:MaxLength=255
	// +optional
	Personality *string `json:"personality,omitempty"`

	// Resource identifies the resource for this service parameter
	// +kubebuilder:validation:MaxLength=255
	// +optional
	Resource *string `json:"resource,omitempty"`
}

type ServiceParameterList []ServiceParameterInfo

type StorageBackend struct {
	// SystemName uniquely identifies the storage backend instance.
	// +kubebuilder:validation:Pattern=^[a-zA-Z0-9\-_]+$
	// +kubebuilder:validation:MaxLength=255
	Name string `json:"name"`

	// Type specifies the storage backend type.
	// +kubebuilder:validation:Enum=file,lvm,ceph
	Type string `json:"type"`

	// Services is a list of services to enable for this backend instance.  Each
	// backend type supports a limited set
	// of services.  Refer to customer documentation for more information.
	// +kubebuilder:validation:Enum=cinder,glance,nova,swift,rbd-provisioner
	Services []string `json:"services,omitempty"`

	// ReplicationFactor is the number of storage hosts required in each
	// replication group for storage redundancy.
	// This attribute is only applicable for Ceph storage backends.
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:validation:Maximum=3
	// +kubebuilder:validation:ExclusiveMinimum=false
	// +kubebuilder:validation:ExclusiveMaximum=false
	// +optional
	ReplicationFactor *int `json:"replicationFactor,omitempty"`

	// PartitionSize is the controller disk partition size to be allocated for
	// the Ceph monitor - in gigabytes.
	// This attribute is only applicable for Ceph storage backends.
	// +kubebuilder:validation:Minimum=20
	// +kubebuilder:validation:ExclusiveMinimum=false
	// +optional
	PartitionSize *int `json:"partitionSize,omitempty"`

	// Network is the network type associated with this backend.
	// At the momemnt it is used only for ceph backend.
	// +kubebuilder:validation:Enum=mgmt,cluster-host
	// +optional
	Network *string `json:"network,omitempty"`
}

type StorageBackendList []StorageBackend

type StringList []string

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

	Spec   SystemSpec   `json:"spec,omitempty"`
	Status SystemStatus `json:"status,omitempty"`
}

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

type SystemSpec struct {
	// Description is a free form string describing the intended purpose of the
	// system.
	// +optional
	Description *string `json:"description,omitempty"`

	// Location is a short description of the system's physical location.
	// +kubebuilder:validation:Pattern=^[a-zA-Z0-9\-_\. ]+$
	// +kubebuilder:validation:MaxLength=255
	// +optional
	Location *string `json:"location,omitempty"`

	// Latitude is the latitude geolocation coordinate of the system's physical
	// location.
	// +kubebuilder:validation:Pattern=^[a-zA-Z0-9\-_\. ]+$
	// +kubebuilder:validation:MaxLength=30
	// +optional
	Latitude *string `json:"latitude,omitempty"`

	// Longitude is the longitude geolocation coordinate of the system's physical
	// location.
	// +kubebuilder:validation:Pattern=^[a-zA-Z0-9\-_\. ]+$
	// +kubebuilder:validation:MaxLength=30
	// +optional
	Longitude *string `json:"longitude,omitempty"`

	// Contact is a method to reach the person responsible for the system.  For
	// example it could be an email address,
	// phone number, or physical address.
	// +kubebuilder:validation:Pattern=^[a-zA-Z0-9@\-_\. ]+$
	// +kubebuilder:validation:MaxLength=255
	// +optional
	Contact *string `json:"contact,omitempty"`

	// Nameservers is an array of Domain SystemName servers.  Each server can be
	// specified as either an IPv4 or IPv6
	// address.
	// +optional
	DNSServers *StringList `json:"dnsServers,omitempty"`

	// NTPServers is an array of Network Time Protocol servers.  Each server can
	// be specified as either an IPv4 or IPv6
	// address, or a FQDN hostname.
	// +optional
	NTPServers *StringList `json:"ntpServers,omitempty"`

	// PTP defines the Precision Time Protocol configuration for the system.
	PTP *PTPInfo `json:"ptp,omitempty"`

	// Certificates is a list of references to certificates that must be
	// installed.
	// +optional
	Certificates *CertificateList `json:"certificates,omitempty"`

	// License is a reference to a license file that must be installed.
	// +optional
	License *LicenseInfo `json:"license,omitempty"`

	// ServiceParameters is a list of service parameters
	// +optional
	ServiceParameters *ServiceParameterList `json:"serviceParameters,omitempty"`

	// Storage is a set of storage specific attributes to be configured for the
	// system.
	// +optional
	Storage *SystemStorageInfo `json:"storage,omitempty"`

	// VSwitchType is the desired vswitch implementation to be configured. This
	// is intentionally left unvalidated to avoid issues with proprietary
	// vswitch implementation.
	// +optional
	VSwitchType *string `json:"vswitchType,omitempty"`
}

type SystemStatus struct {
	// ID defines the unique identifier assigned by the system.
	ID string `json:"id"`

	// SystemType defines the current system type reported by the system API.
	SystemType string `json:"systemType"`

	// SystemMode defines the current system mode reported by the system API.
	SystemMode string `json:"systemMode"`

	// SoftwareVersion defines the current software version reported by the
	// system API.
	SoftwareVersion string `json:"softwareVersion"`

	// Defines whether the resource has been provisioned on the target system.
	InSync bool `json:"inSync"`

	// Reconciled defines whether the System has been successfully reconciled
	// at least once.  If further changes are made they will be ignored by the
	// reconciler.
	Reconciled bool `json:"reconciled"`

	// Defaults defines the configuration attributed collected before applying
	// any user configuration values.
	// +optional
	Defaults *string `json:"defaults,omitempty"`
}

type SystemStorageInfo struct {
	// Backends is a set of backend storage methods to be configured.  Only
	Backends *StorageBackendList `json:"backends,omitempty"`

	// DRBD defines the set of DRBD configuration attributes for the system.
	DRBD *DRBDConfiguration `json:"drbd,omitempty"`

	// Filesystems defines the set of controller file system definitions.
	FileSystems *ControllerFileSystemList `json:"filesystems,omitempty"`
}

type VFInfo struct {
	// CommonInterfaceInfo defines attributes common to all interface
	// types.
	CommonInterfaceInfo `json:",inline"`

	// Lower defines the interface name over which this VF interface is to be
	// configured.
	// +kubebuilder:validation:Pattern=^[a-zA-Z0-9\-_\.]+$
	Lower string `json:"lower"`

	// VFCount defines the number of SRIOV virtual functions for this VF interface.
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:validation:Maximum=256
	VFCount int `json:"vfCount"`

	// VFDriver defines the device driver to be associated with each individual
	// SRIOV VF interface allocated.  Only applicable if the interface class is
	// set to "pci-sriov".
	VFDriver *string `json:"vfDriver,omitempty"`

	// MaxTxRate defines the maximum tx rate of SRIOV VF
	// interfaces. Only applicable if the interface class is set to
	// "pci-sriov" and interface type is set to "vf".
	MaxTxRate *int `json:"maxTxRate,omitempty"`
}

type VFList []VFInfo

type VLANInfo struct {
	// CommonInterfaceInfo defines attributes common to all interface
	// types.
	CommonInterfaceInfo `json:",inline"`

	// Lower defines the interface name over which this VLAN interface is to be
	// configured.
	// +kubebuilder:validation:Pattern=^[a-zA-Z0-9\-_\.]+$
	Lower string `json:"lower"`

	// VID defines the VLAN ID value to be assigned to this VLAN interface.
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:validation:Maximum=4095
	VID int `json:"vid"`
}

type VLANList []VLANInfo

type VolumeGroupInfo struct {
	// SystemName defines the name of the logical volume group
	// +kubebuilder:validation:MaxLength=255
	// +kubebuilder:validation:Pattern=^[a-zA-Z0-9\-_]+$
	Name string `json:"name"`

	// ConcurrentDiskOperations defines the number of concurrent disk operations
	// permitted.
	// +kubebuilder:validation:Minimum=1
	// +optional
	ConcurrentDiskOperations *int `json:"concurrentDiskOperations,omitempty"`

	// LVMType defines the provisioning type for volumes defines with 'Type'
	// set to 'lvm'.
	// +kubebuilder:validation:Enum=thin,thick
	// +optional
	LVMType *string `json:"lvmType,omitempty"`

	// PhysicalVolumes defines the list of volumes to be created on the host.
	PhysicalVolumes PhysicalVolumeList `json:"physicalVolumes"`
}

type VolumeGroupList []VolumeGroupInfo

type VxLANInfo struct {
	// MulticastGroup defines the multicast IP address to be used for the data
	// network.
	// +optional
	MulticastGroup *string `json:"multicastGroup,omitempty"`

	// UDPPortNumber defines the UDP protocol number to be used for the data
	// network.  The IANA or Legacy port
	// number values can be used.
	// +kubebuilder:validation:Enum=4789,8472
	UDPPortNumber *int `json:"udpPortNumber,omitempty"`

	// TTL defines the time-to-live value to assign to the data network.
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:validation:Maximum=255
	// +optional
	TTL *int `json:"ttl,omitempty"`

	// EndpointMode defines the endpoint port learning mode for the data network
	// network.  The dynamic mode allows the virtual network to use multicast
	// addressing when transmitting a packet to an unknown endpoint to
	// dynamically discover that node's VTEP IP address.   The static mode
	// requires that all VTEP IP addresses be programmed into the virtual switch
	// in advance and any packets destined to an unknown endpoint are dropped.
	// +kubebuilder:validation:Enum=static,dynamic
	// +optional
	EndpointMode *string `json:"endpointMode,omitempty"`
}