models

package
v0.0.0-...-ac479d4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 20, 2024 License: Apache-2.0 Imports: 11 Imported by: 2

Documentation

Overview

custom.go file has custom models for assisted-service that are not auto-generated via the swagger.yaml file due to the need for custom validation or fields

Index

Constants

View Source 
const (

	// ClusterCPUArchitectureX8664 captures enum value "x86_64"
	ClusterCPUArchitectureX8664 string = "x86_64"

	// ClusterCPUArchitectureAarch64 captures enum value "aarch64"
	ClusterCPUArchitectureAarch64 string = "aarch64"

	// ClusterCPUArchitectureArm64 captures enum value "arm64"
	ClusterCPUArchitectureArm64 string = "arm64"

	// ClusterCPUArchitecturePpc64le captures enum value "ppc64le"
	ClusterCPUArchitecturePpc64le string = "ppc64le"

	// ClusterCPUArchitectureS390x captures enum value "s390x"
	ClusterCPUArchitectureS390x string = "s390x"

	// ClusterCPUArchitectureMulti captures enum value "multi"
	ClusterCPUArchitectureMulti string = "multi"
)
View Source 
const (

	// ClusterHighAvailabilityModeFull captures enum value "Full"
	ClusterHighAvailabilityModeFull string = "Full"

	// ClusterHighAvailabilityModeNone captures enum value "None"
	ClusterHighAvailabilityModeNone string = "None"
)
View Source 
const (

	// ClusterHyperthreadingMasters captures enum value "masters"
	ClusterHyperthreadingMasters string = "masters"

	// ClusterHyperthreadingWorkers captures enum value "workers"
	ClusterHyperthreadingWorkers string = "workers"

	// ClusterHyperthreadingAll captures enum value "all"
	ClusterHyperthreadingAll string = "all"

	// ClusterHyperthreadingNone captures enum value "none"
	ClusterHyperthreadingNone string = "none"
)
View Source 
const (

	// ClusterKindCluster captures enum value "Cluster"
	ClusterKindCluster string = "Cluster"

	// ClusterKindAddHostsCluster captures enum value "AddHostsCluster"
	ClusterKindAddHostsCluster string = "AddHostsCluster"
)
View Source 
const (

	// ClusterNetworkTypeOpenShiftSDN captures enum value "OpenShiftSDN"
	ClusterNetworkTypeOpenShiftSDN string = "OpenShiftSDN"

	// ClusterNetworkTypeOVNKubernetes captures enum value "OVNKubernetes"
	ClusterNetworkTypeOVNKubernetes string = "OVNKubernetes"
)
View Source 
const (

	// ClusterStatusInsufficient captures enum value "insufficient"
	ClusterStatusInsufficient string = "insufficient"

	// ClusterStatusReady captures enum value "ready"
	ClusterStatusReady string = "ready"

	// ClusterStatusError captures enum value "error"
	ClusterStatusError string = "error"

	// ClusterStatusPreparingForInstallation captures enum value "preparing-for-installation"
	ClusterStatusPreparingForInstallation string = "preparing-for-installation"

	// ClusterStatusPendingForInput captures enum value "pending-for-input"
	ClusterStatusPendingForInput string = "pending-for-input"

	// ClusterStatusInstalling captures enum value "installing"
	ClusterStatusInstalling string = "installing"

	// ClusterStatusFinalizing captures enum value "finalizing"
	ClusterStatusFinalizing string = "finalizing"

	// ClusterStatusInstalled captures enum value "installed"
	ClusterStatusInstalled string = "installed"

	// ClusterStatusAddingHosts captures enum value "adding-hosts"
	ClusterStatusAddingHosts string = "adding-hosts"

	// ClusterStatusCancelled captures enum value "cancelled"
	ClusterStatusCancelled string = "cancelled"

	// ClusterStatusInstallingPendingUserAction captures enum value "installing-pending-user-action"
	ClusterStatusInstallingPendingUserAction string = "installing-pending-user-action"
)
View Source 
const (

	// ClusterCreateParamsCPUArchitectureX8664 captures enum value "x86_64"
	ClusterCreateParamsCPUArchitectureX8664 string = "x86_64"

	// ClusterCreateParamsCPUArchitectureAarch64 captures enum value "aarch64"
	ClusterCreateParamsCPUArchitectureAarch64 string = "aarch64"

	// ClusterCreateParamsCPUArchitectureArm64 captures enum value "arm64"
	ClusterCreateParamsCPUArchitectureArm64 string = "arm64"

	// ClusterCreateParamsCPUArchitecturePpc64le captures enum value "ppc64le"
	ClusterCreateParamsCPUArchitecturePpc64le string = "ppc64le"

	// ClusterCreateParamsCPUArchitectureS390x captures enum value "s390x"
	ClusterCreateParamsCPUArchitectureS390x string = "s390x"

	// ClusterCreateParamsCPUArchitectureMulti captures enum value "multi"
	ClusterCreateParamsCPUArchitectureMulti string = "multi"
)
View Source 
const (

	// ClusterCreateParamsHighAvailabilityModeFull captures enum value "Full"
	ClusterCreateParamsHighAvailabilityModeFull string = "Full"

	// ClusterCreateParamsHighAvailabilityModeNone captures enum value "None"
	ClusterCreateParamsHighAvailabilityModeNone string = "None"
)
View Source 
const (

	// ClusterCreateParamsHyperthreadingMasters captures enum value "masters"
	ClusterCreateParamsHyperthreadingMasters string = "masters"

	// ClusterCreateParamsHyperthreadingWorkers captures enum value "workers"
	ClusterCreateParamsHyperthreadingWorkers string = "workers"

	// ClusterCreateParamsHyperthreadingNone captures enum value "none"
	ClusterCreateParamsHyperthreadingNone string = "none"

	// ClusterCreateParamsHyperthreadingAll captures enum value "all"
	ClusterCreateParamsHyperthreadingAll string = "all"
)
View Source 
const (

	// ClusterCreateParamsNetworkTypeOpenShiftSDN captures enum value "OpenShiftSDN"
	ClusterCreateParamsNetworkTypeOpenShiftSDN string = "OpenShiftSDN"

	// ClusterCreateParamsNetworkTypeOVNKubernetes captures enum value "OVNKubernetes"
	ClusterCreateParamsNetworkTypeOVNKubernetes string = "OVNKubernetes"
)
View Source 
const (

	// CreateManifestParamsFolderManifests captures enum value "manifests"
	CreateManifestParamsFolderManifests string = "manifests"

	// CreateManifestParamsFolderOpenshift captures enum value "openshift"
	CreateManifestParamsFolderOpenshift string = "openshift"
)
View Source 
const (

	// DiskEncryptionEnableOnNone captures enum value "none"
	DiskEncryptionEnableOnNone string = "none"

	// DiskEncryptionEnableOnAll captures enum value "all"
	DiskEncryptionEnableOnAll string = "all"

	// DiskEncryptionEnableOnMasters captures enum value "masters"
	DiskEncryptionEnableOnMasters string = "masters"

	// DiskEncryptionEnableOnWorkers captures enum value "workers"
	DiskEncryptionEnableOnWorkers string = "workers"
)
View Source 
const (

	// DiskEncryptionModeTpmv2 captures enum value "tpmv2"
	DiskEncryptionModeTpmv2 string = "tpmv2"

	// DiskEncryptionModeTang captures enum value "tang"
	DiskEncryptionModeTang string = "tang"
)
View Source 
const (

	// EventCategoryUser captures enum value "user"
	EventCategoryUser string = "user"

	// EventCategoryMetrics captures enum value "metrics"
	EventCategoryMetrics string = "metrics"
)
View Source 
const (

	// EventSeverityInfo captures enum value "info"
	EventSeverityInfo string = "info"

	// EventSeverityWarning captures enum value "warning"
	EventSeverityWarning string = "warning"

	// EventSeverityError captures enum value "error"
	EventSeverityError string = "error"

	// EventSeverityCritical captures enum value "critical"
	EventSeverityCritical string = "critical"
)
View Source 
const (

	// HostKindHost captures enum value "Host"
	HostKindHost string = "Host"

	// HostKindAddToExistingClusterHost captures enum value "AddToExistingClusterHost"
	HostKindAddToExistingClusterHost string = "AddToExistingClusterHost"
)
View Source 
const (

	// HostMediaStatusConnected captures enum value "connected"
	HostMediaStatusConnected string = "connected"

	// HostMediaStatusDisconnected captures enum value "disconnected"
	HostMediaStatusDisconnected string = "disconnected"
)
View Source 
const (

	// HostStatusDiscovering captures enum value "discovering"
	HostStatusDiscovering string = "discovering"

	// HostStatusKnown captures enum value "known"
	HostStatusKnown string = "known"

	// HostStatusDisconnected captures enum value "disconnected"
	HostStatusDisconnected string = "disconnected"

	// HostStatusInsufficient captures enum value "insufficient"
	HostStatusInsufficient string = "insufficient"

	// HostStatusDisabled captures enum value "disabled"
	HostStatusDisabled string = "disabled"

	// HostStatusPreparingForInstallation captures enum value "preparing-for-installation"
	HostStatusPreparingForInstallation string = "preparing-for-installation"

	// HostStatusPreparingFailed captures enum value "preparing-failed"
	HostStatusPreparingFailed string = "preparing-failed"

	// HostStatusPreparingSuccessful captures enum value "preparing-successful"
	HostStatusPreparingSuccessful string = "preparing-successful"

	// HostStatusPendingForInput captures enum value "pending-for-input"
	HostStatusPendingForInput string = "pending-for-input"

	// HostStatusInstalling captures enum value "installing"
	HostStatusInstalling string = "installing"

	// HostStatusInstallingInProgress captures enum value "installing-in-progress"
	HostStatusInstallingInProgress string = "installing-in-progress"

	// HostStatusInstallingPendingUserAction captures enum value "installing-pending-user-action"
	HostStatusInstallingPendingUserAction string = "installing-pending-user-action"

	// HostStatusResettingPendingUserAction captures enum value "resetting-pending-user-action"
	HostStatusResettingPendingUserAction string = "resetting-pending-user-action"

	// HostStatusInstalled captures enum value "installed"
	HostStatusInstalled string = "installed"

	// HostStatusError captures enum value "error"
	HostStatusError string = "error"

	// HostStatusResetting captures enum value "resetting"
	HostStatusResetting string = "resetting"

	// HostStatusAddedToExistingCluster captures enum value "added-to-existing-cluster"
	HostStatusAddedToExistingCluster string = "added-to-existing-cluster"

	// HostStatusCancelled captures enum value "cancelled"
	HostStatusCancelled string = "cancelled"

	// HostStatusBinding captures enum value "binding"
	HostStatusBinding string = "binding"

	// HostStatusUnbinding captures enum value "unbinding"
	HostStatusUnbinding string = "unbinding"

	// HostStatusUnbindingPendingUserAction captures enum value "unbinding-pending-user-action"
	HostStatusUnbindingPendingUserAction string = "unbinding-pending-user-action"

	// HostStatusKnownUnbound captures enum value "known-unbound"
	HostStatusKnownUnbound string = "known-unbound"

	// HostStatusDisconnectedUnbound captures enum value "disconnected-unbound"
	HostStatusDisconnectedUnbound string = "disconnected-unbound"

	// HostStatusInsufficientUnbound captures enum value "insufficient-unbound"
	HostStatusInsufficientUnbound string = "insufficient-unbound"

	// HostStatusDisabledUnbound captures enum value "disabled-unbound"
	HostStatusDisabledUnbound string = "disabled-unbound"

	// HostStatusDiscoveringUnbound captures enum value "discovering-unbound"
	HostStatusDiscoveringUnbound string = "discovering-unbound"

	// HostStatusReclaiming captures enum value "reclaiming"
	HostStatusReclaiming string = "reclaiming"

	// HostStatusReclaimingRebooting captures enum value "reclaiming-rebooting"
	HostStatusReclaimingRebooting string = "reclaiming-rebooting"
)
View Source 
const (

	// HostUpdateParamsHostRoleAutoAssign captures enum value "auto-assign"
	HostUpdateParamsHostRoleAutoAssign string = "auto-assign"

	// HostUpdateParamsHostRoleMaster captures enum value "master"
	HostUpdateParamsHostRoleMaster string = "master"

	// HostUpdateParamsHostRoleWorker captures enum value "worker"
	HostUpdateParamsHostRoleWorker string = "worker"
)
View Source 
const (

	// InfraEnvCPUArchitectureX8664 captures enum value "x86_64"
	InfraEnvCPUArchitectureX8664 string = "x86_64"

	// InfraEnvCPUArchitectureAarch64 captures enum value "aarch64"
	InfraEnvCPUArchitectureAarch64 string = "aarch64"

	// InfraEnvCPUArchitectureArm64 captures enum value "arm64"
	InfraEnvCPUArchitectureArm64 string = "arm64"

	// InfraEnvCPUArchitecturePpc64le captures enum value "ppc64le"
	InfraEnvCPUArchitecturePpc64le string = "ppc64le"

	// InfraEnvCPUArchitectureS390x captures enum value "s390x"
	InfraEnvCPUArchitectureS390x string = "s390x"
)
View Source 
const (

	// InfraEnvCreateParamsCPUArchitectureX8664 captures enum value "x86_64"
	InfraEnvCreateParamsCPUArchitectureX8664 string = "x86_64"

	// InfraEnvCreateParamsCPUArchitectureAarch64 captures enum value "aarch64"
	InfraEnvCreateParamsCPUArchitectureAarch64 string = "aarch64"

	// InfraEnvCreateParamsCPUArchitectureArm64 captures enum value "arm64"
	InfraEnvCreateParamsCPUArchitectureArm64 string = "arm64"

	// InfraEnvCreateParamsCPUArchitecturePpc64le captures enum value "ppc64le"
	InfraEnvCreateParamsCPUArchitecturePpc64le string = "ppc64le"

	// InfraEnvCreateParamsCPUArchitectureS390x captures enum value "s390x"
	InfraEnvCreateParamsCPUArchitectureS390x string = "s390x"
)
View Source 
const (

	// InstallCmdRequestHighAvailabilityModeFull captures enum value "Full"
	InstallCmdRequestHighAvailabilityModeFull string = "Full"

	// InstallCmdRequestHighAvailabilityModeNone captures enum value "None"
	InstallCmdRequestHighAvailabilityModeNone string = "None"
)
View Source 
const (

	// InventoryTpmVersionNone captures enum value "none"
	InventoryTpmVersionNone string = "none"

	// InventoryTpmVersionNr12 captures enum value "1.2"
	InventoryTpmVersionNr12 string = "1.2"

	// InventoryTpmVersionNr20 captures enum value "2.0"
	InventoryTpmVersionNr20 string = "2.0"
)
View Source 
const (

	// KernelArgumentOperationAppend captures enum value "append"
	KernelArgumentOperationAppend string = "append"

	// KernelArgumentOperationReplace captures enum value "replace"
	KernelArgumentOperationReplace string = "replace"

	// KernelArgumentOperationDelete captures enum value "delete"
	KernelArgumentOperationDelete string = "delete"
)
View Source 
const (

	// LastInstallationPreparationStatusNotStarted captures enum value "not_started"
	LastInstallationPreparationStatusNotStarted string = "not_started"

	// LastInstallationPreparationStatusFailed captures enum value "failed"
	LastInstallationPreparationStatusFailed string = "failed"

	// LastInstallationPreparationStatusSuccess captures enum value "success"
	LastInstallationPreparationStatusSuccess string = "success"
)
View Source 
const (

	// ManifestFolderManifests captures enum value "manifests"
	ManifestFolderManifests string = "manifests"

	// ManifestFolderOpenshift captures enum value "openshift"
	ManifestFolderOpenshift string = "openshift"
)
View Source 
const (

	// ManifestManifestSourceUser captures enum value "user"
	ManifestManifestSourceUser string = "user"

	// ManifestManifestSourceSystem captures enum value "system"
	ManifestManifestSourceSystem string = "system"
)
View Source 
const (

	// OpenshiftVersionSupportLevelBeta captures enum value "beta"
	OpenshiftVersionSupportLevelBeta string = "beta"

	// OpenshiftVersionSupportLevelProduction captures enum value "production"
	OpenshiftVersionSupportLevelProduction string = "production"

	// OpenshiftVersionSupportLevelMaintenance captures enum value "maintenance"
	OpenshiftVersionSupportLevelMaintenance string = "maintenance"

	// OpenshiftVersionSupportLevelEndOfLife captures enum value "end-of-life"
	OpenshiftVersionSupportLevelEndOfLife string = "end-of-life"
)
View Source 
const (

	// OperatorPropertyDataTypeBoolean captures enum value "boolean"
	OperatorPropertyDataTypeBoolean string = "boolean"

	// OperatorPropertyDataTypeString captures enum value "string"
	OperatorPropertyDataTypeString string = "string"

	// OperatorPropertyDataTypeInteger captures enum value "integer"
	OperatorPropertyDataTypeInteger string = "integer"

	// OperatorPropertyDataTypeFloat captures enum value "float"
	OperatorPropertyDataTypeFloat string = "float"
)
View Source 
const (

	// OsImageCPUArchitectureX8664 captures enum value "x86_64"
	OsImageCPUArchitectureX8664 string = "x86_64"

	// OsImageCPUArchitectureAarch64 captures enum value "aarch64"
	OsImageCPUArchitectureAarch64 string = "aarch64"

	// OsImageCPUArchitectureArm64 captures enum value "arm64"
	OsImageCPUArchitectureArm64 string = "arm64"

	// OsImageCPUArchitecturePpc64le captures enum value "ppc64le"
	OsImageCPUArchitecturePpc64le string = "ppc64le"

	// OsImageCPUArchitectureS390x captures enum value "s390x"
	OsImageCPUArchitectureS390x string = "s390x"
)
View Source 
const (

	// PlatformExternalCloudControllerManagerEmpty captures enum value ""
	PlatformExternalCloudControllerManagerEmpty string = ""

	// PlatformExternalCloudControllerManagerExternal captures enum value "External"
	PlatformExternalCloudControllerManagerExternal string = "External"
)
View Source 
const (

	// ReleaseImageCPUArchitectureX8664 captures enum value "x86_64"
	ReleaseImageCPUArchitectureX8664 string = "x86_64"

	// ReleaseImageCPUArchitectureAarch64 captures enum value "aarch64"
	ReleaseImageCPUArchitectureAarch64 string = "aarch64"

	// ReleaseImageCPUArchitectureArm64 captures enum value "arm64"
	ReleaseImageCPUArchitectureArm64 string = "arm64"

	// ReleaseImageCPUArchitecturePpc64le captures enum value "ppc64le"
	ReleaseImageCPUArchitecturePpc64le string = "ppc64le"

	// ReleaseImageCPUArchitectureS390x captures enum value "s390x"
	ReleaseImageCPUArchitectureS390x string = "s390x"

	// ReleaseImageCPUArchitectureMulti captures enum value "multi"
	ReleaseImageCPUArchitectureMulti string = "multi"
)
View Source 
const (

	// ReleaseImageSupportLevelBeta captures enum value "beta"
	ReleaseImageSupportLevelBeta string = "beta"

	// ReleaseImageSupportLevelProduction captures enum value "production"
	ReleaseImageSupportLevelProduction string = "production"

	// ReleaseImageSupportLevelMaintenance captures enum value "maintenance"
	ReleaseImageSupportLevelMaintenance string = "maintenance"

	// ReleaseImageSupportLevelEndOfLife captures enum value "end-of-life"
	ReleaseImageSupportLevelEndOfLife string = "end-of-life"
)
View Source 
const (

	// StepsPostStepActionExit captures enum value "exit"
	StepsPostStepActionExit string = "exit"

	// StepsPostStepActionContinue captures enum value "continue"
	StepsPostStepActionContinue string = "continue"
)
View Source 
const (

	// UpdateManifestParamsFolderManifests captures enum value "manifests"
	UpdateManifestParamsFolderManifests string = "manifests"

	// UpdateManifestParamsFolderOpenshift captures enum value "openshift"
	UpdateManifestParamsFolderOpenshift string = "openshift"
)
View Source 
const (

	// UpdateManifestParamsUpdatedFolderManifests captures enum value "manifests"
	UpdateManifestParamsUpdatedFolderManifests string = "manifests"

	// UpdateManifestParamsUpdatedFolderOpenshift captures enum value "openshift"
	UpdateManifestParamsUpdatedFolderOpenshift string = "openshift"
)
View Source 
const (

	// UpgradeChannelCPUArchitectureX8664 captures enum value "x86_64"
	UpgradeChannelCPUArchitectureX8664 string = "x86_64"

	// UpgradeChannelCPUArchitectureAarch64 captures enum value "aarch64"
	UpgradeChannelCPUArchitectureAarch64 string = "aarch64"

	// UpgradeChannelCPUArchitectureArm64 captures enum value "arm64"
	UpgradeChannelCPUArchitectureArm64 string = "arm64"

	// UpgradeChannelCPUArchitecturePpc64le captures enum value "ppc64le"
	UpgradeChannelCPUArchitecturePpc64le string = "ppc64le"

	// UpgradeChannelCPUArchitectureS390x captures enum value "s390x"
	UpgradeChannelCPUArchitectureS390x string = "s390x"

	// UpgradeChannelCPUArchitectureMulti captures enum value "multi"
	UpgradeChannelCPUArchitectureMulti string = "multi"
)
View Source 
const (

	// V2ClusterUpdateParamsHyperthreadingMasters captures enum value "masters"
	V2ClusterUpdateParamsHyperthreadingMasters string = "masters"

	// V2ClusterUpdateParamsHyperthreadingWorkers captures enum value "workers"
	V2ClusterUpdateParamsHyperthreadingWorkers string = "workers"

	// V2ClusterUpdateParamsHyperthreadingAll captures enum value "all"
	V2ClusterUpdateParamsHyperthreadingAll string = "all"

	// V2ClusterUpdateParamsHyperthreadingNone captures enum value "none"
	V2ClusterUpdateParamsHyperthreadingNone string = "none"
)
View Source 
const (

	// V2ClusterUpdateParamsNetworkTypeOpenShiftSDN captures enum value "OpenShiftSDN"
	V2ClusterUpdateParamsNetworkTypeOpenShiftSDN string = "OpenShiftSDN"

	// V2ClusterUpdateParamsNetworkTypeOVNKubernetes captures enum value "OVNKubernetes"
	V2ClusterUpdateParamsNetworkTypeOVNKubernetes string = "OVNKubernetes"
)
View Source 
const (

	// ErrorKindError captures enum value "Error"
	ErrorKindError string = "Error"
)
View Source 
const (

	// InfraEnvKindInfraEnv captures enum value "InfraEnv"
	InfraEnvKindInfraEnv string = "InfraEnv"
)
View Source 
const (

	// ManagedDomainProviderRoute53 captures enum value "route53"
	ManagedDomainProviderRoute53 string = "route53"
)

Variables

This section is empty.

Functions

This section is empty.

Types

type APIVip 

type APIVip struct {

	// The cluster that this VIP is associated with.
	// Format: uuid
	ClusterID strfmt.UUID `json:"cluster_id,omitempty" gorm:"primaryKey"`

	// The IP address.
	IP IP `json:"ip,omitempty" gorm:"primaryKey"`

	// API VIP verification result.
	Verification *VipVerification `json:"verification,omitempty"`
}

APIVip The virtual IP used to reach the OpenShift cluster's API.

swagger:model api_vip

func (*APIVip) ContextValidate 

func (m *APIVip) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this api vip based on the context it is used

func (*APIVip) MarshalBinary 

func (m *APIVip) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*APIVip) UnmarshalBinary 

func (m *APIVip) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*APIVip) Validate 

func (m *APIVip) Validate(formats strfmt.Registry) error

Validate validates this api vip

type APIVipConnectivityAdditionalRequestHeader 

type APIVipConnectivityAdditionalRequestHeader struct {

	// Value of the header's key when making a request
	Key string `json:"key,omitempty"`

	// The value corresponding to the header key
	Value string `json:"value,omitempty"`
}

APIVipConnectivityAdditionalRequestHeader api vip connectivity additional request header

swagger:model api_vip_connectivity_additional_request_header

func (*APIVipConnectivityAdditionalRequestHeader) ContextValidate 

func (m *APIVipConnectivityAdditionalRequestHeader) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this api vip connectivity additional request header based on context it is used

func (*APIVipConnectivityAdditionalRequestHeader) MarshalBinary 

func (m *APIVipConnectivityAdditionalRequestHeader) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*APIVipConnectivityAdditionalRequestHeader) UnmarshalBinary 

func (m *APIVipConnectivityAdditionalRequestHeader) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*APIVipConnectivityAdditionalRequestHeader) Validate 

func (m *APIVipConnectivityAdditionalRequestHeader) Validate(formats strfmt.Registry) error

Validate validates this api vip connectivity additional request header

type APIVipConnectivityRequest 

type APIVipConnectivityRequest struct {

	// A CA certficate to be used when contacting the URL via https.
	CaCertificate *string `json:"ca_certificate,omitempty"`

	// A string which will be used as Authorization Bearer token to fetch the ignition from ignition_endpoint_url (DEPRECATED use request_headers to pass this token).
	IgnitionEndpointToken *string `json:"ignition_endpoint_token,omitempty"`

	// Additional request headers to include when fetching the ignition from ignition_endpoint_url.
	RequestHeaders []*APIVipConnectivityAdditionalRequestHeader `json:"request_headers,omitempty"`

	// URL address of the API.
	// Required: true
	URL *string `json:"url"`

	// Whether to verify if the API VIP belongs to one of the interfaces (DEPRECATED).
	VerifyCidr bool `json:"verify_cidr,omitempty"`
}

APIVipConnectivityRequest api vip connectivity request

swagger:model api_vip_connectivity_request

func (*APIVipConnectivityRequest) ContextValidate 

func (m *APIVipConnectivityRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this api vip connectivity request based on the context it is used

func (*APIVipConnectivityRequest) MarshalBinary 

func (m *APIVipConnectivityRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*APIVipConnectivityRequest) UnmarshalBinary 

func (m *APIVipConnectivityRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*APIVipConnectivityRequest) Validate 

func (m *APIVipConnectivityRequest) Validate(formats strfmt.Registry) error

Validate validates this api vip connectivity request

type APIVipConnectivityResponse 

type APIVipConnectivityResponse struct {

	// The error that occurred while downloading the worker ignition file, ignored when is_success is true
	DownloadError string `json:"download_error,omitempty"`

	// Ignition file fetched from the target cluster's API machine config server.
	// This ignition file may be incomplete as almost all files / systemd units are removed from it by the agent in order to save space.
	Ignition string `json:"ignition,omitempty"`

	// Whether the agent was able to download the ignition or not
	IsSuccess bool `json:"is_success,omitempty"`

	// This parameter mirrors the url parameter of the corresponding api_vip_connectivity_request
	URL string `json:"url,omitempty"`
}

APIVipConnectivityResponse The response from the day-2 agent's attempt to download the worker ignition file from the API machine config server of the target cluster. Note - the name "API VIP connectivity" is old and misleading and is preserved for backwards compatibility.

swagger:model api_vip_connectivity_response

func (*APIVipConnectivityResponse) ContextValidate 

func (m *APIVipConnectivityResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this api vip connectivity response based on context it is used

func (*APIVipConnectivityResponse) MarshalBinary 

func (m *APIVipConnectivityResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*APIVipConnectivityResponse) UnmarshalBinary 

func (m *APIVipConnectivityResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*APIVipConnectivityResponse) Validate 

func (m *APIVipConnectivityResponse) Validate(formats strfmt.Registry) error

Validate validates this api vip connectivity response

type ArchitectureSupportLevelID 

type ArchitectureSupportLevelID string

ArchitectureSupportLevelID architecture support level id

swagger:model architecture-support-level-id 

const (

	// ArchitectureSupportLevelIDX8664ARCHITECTURE captures enum value "X86_64_ARCHITECTURE"
	ArchitectureSupportLevelIDX8664ARCHITECTURE ArchitectureSupportLevelID = "X86_64_ARCHITECTURE"

	// ArchitectureSupportLevelIDARM64ARCHITECTURE captures enum value "ARM64_ARCHITECTURE"
	ArchitectureSupportLevelIDARM64ARCHITECTURE ArchitectureSupportLevelID = "ARM64_ARCHITECTURE"

	// ArchitectureSupportLevelIDPPC64LEARCHITECTURE captures enum value "PPC64LE_ARCHITECTURE"
	ArchitectureSupportLevelIDPPC64LEARCHITECTURE ArchitectureSupportLevelID = "PPC64LE_ARCHITECTURE"

	// ArchitectureSupportLevelIDS390XARCHITECTURE captures enum value "S390X_ARCHITECTURE"
	ArchitectureSupportLevelIDS390XARCHITECTURE ArchitectureSupportLevelID = "S390X_ARCHITECTURE"

	// ArchitectureSupportLevelIDMULTIARCHRELEASEIMAGE captures enum value "MULTIARCH_RELEASE_IMAGE"
	ArchitectureSupportLevelIDMULTIARCHRELEASEIMAGE ArchitectureSupportLevelID = "MULTIARCH_RELEASE_IMAGE"
)

func NewArchitectureSupportLevelID 

func NewArchitectureSupportLevelID(value ArchitectureSupportLevelID) *ArchitectureSupportLevelID

func (ArchitectureSupportLevelID) ContextValidate 

func (m ArchitectureSupportLevelID) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this architecture support level id based on context it is used

func (ArchitectureSupportLevelID) Pointer 

func (m ArchitectureSupportLevelID) Pointer() *ArchitectureSupportLevelID

Pointer returns a pointer to a freshly-allocated ArchitectureSupportLevelID.

func (ArchitectureSupportLevelID) Validate 

func (m ArchitectureSupportLevelID) Validate(formats strfmt.Registry) error

Validate validates this architecture support level id

type BindHostParams 

type BindHostParams struct {

	// cluster id
	// Required: true
	// Format: uuid
	ClusterID *strfmt.UUID `json:"cluster_id"`
}

BindHostParams bind host params

swagger:model bind-host-params

func (*BindHostParams) ContextValidate 

func (m *BindHostParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this bind host params based on context it is used

func (*BindHostParams) MarshalBinary 

func (m *BindHostParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*BindHostParams) UnmarshalBinary 

func (m *BindHostParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*BindHostParams) Validate 

func (m *BindHostParams) Validate(formats strfmt.Registry) error

Validate validates this bind host params

type Boot 

type Boot struct {

	// command line
	CommandLine string `json:"command_line,omitempty"`

	// current boot mode
	CurrentBootMode string `json:"current_boot_mode,omitempty"`

	// pxe interface
	PxeInterface string `json:"pxe_interface,omitempty"`
}

Boot boot

swagger:model boot

func (*Boot) ContextValidate 

func (m *Boot) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this boot based on context it is used

func (*Boot) MarshalBinary 

func (m *Boot) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Boot) UnmarshalBinary 

func (m *Boot) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Boot) Validate 

func (m *Boot) Validate(formats strfmt.Registry) error

Validate validates this boot

type CPU 

type CPU struct {

	// architecture
	Architecture string `json:"architecture,omitempty"`

	// count
	Count int64 `json:"count,omitempty"`

	// flags
	Flags []string `json:"flags"`

	// frequency
	Frequency float64 `json:"frequency,omitempty"`

	// model name
	ModelName string `json:"model_name,omitempty"`
}

CPU cpu

swagger:model cpu

func (*CPU) ContextValidate 

func (m *CPU) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this cpu based on context it is used

func (*CPU) MarshalBinary 

func (m *CPU) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*CPU) UnmarshalBinary 

func (m *CPU) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*CPU) Validate 

func (m *CPU) Validate(formats strfmt.Registry) error

Validate validates this cpu

type Cluster 

type Cluster struct {

	// A comma-separated list of NTP sources (name or IP) going to be added to all the hosts.
	AdditionalNtpSource string `json:"additional_ntp_source,omitempty"`

	// Unique identifier of the AMS subscription in OCM.
	// Format: uuid
	AmsSubscriptionID strfmt.UUID `json:"ams_subscription_id,omitempty"`

	// The domain name used to reach the OpenShift cluster API.
	APIVipDNSName *string `json:"api_vip_dns_name,omitempty"`

	// The virtual IPs used to reach the OpenShift cluster's API. Enter one IP address for single-stack clusters, or up to two for dual-stack clusters (at most one IP address per IP stack used). The order of stacks should be the same as order of subnets in Cluster Networks, Service Networks, and Machine Networks.
	APIVips []*APIVip `json:"api_vips" gorm:"foreignkey:ClusterID;references:ID"`

	// Base domain of the cluster. All DNS records must be sub-domains of this base and include the cluster name.
	BaseDNSDomain string `json:"base_dns_domain,omitempty"`

	// IP address block from which Pod IPs are allocated. This block must not overlap with existing physical networks. These IP addresses are used for the Pod network, and if you need to access the Pods from an external network, configure load balancers and routers to manage the traffic.
	// Pattern: ^(?:(?:(?:[0-9]{1,3}\.){3}[0-9]{1,3}\/(?:(?:[0-9])|(?:[1-2][0-9])|(?:3[0-2])))|(?:(?:[0-9a-fA-F]*:[0-9a-fA-F]*){2,})/(?:(?:[0-9])|(?:[1-9][0-9])|(?:1[0-1][0-9])|(?:12[0-8])))$
	ClusterNetworkCidr string `json:"cluster_network_cidr,omitempty"`

	// The subnet prefix length to assign to each individual node. For example, if clusterNetworkHostPrefix is set to 23, then each node is assigned a /23 subnet out of the given cidr (clusterNetworkCIDR), which allows for 510 (2^(32 - 23) - 2) pod IPs addresses. If you are required to provide access to nodes from an external network, configure load balancers and routers to manage the traffic.
	// Maximum: 128
	// Minimum: 1
	ClusterNetworkHostPrefix int64 `json:"cluster_network_host_prefix,omitempty"`

	// Cluster networks that are associated with this cluster.
	ClusterNetworks []*ClusterNetwork `json:"cluster_networks" gorm:"foreignkey:ClusterID;references:ID"`

	// Json formatted string containing the majority groups for connectivity checks.
	ConnectivityMajorityGroups string `json:"connectivity_majority_groups,omitempty" gorm:"type:text"`

	// controller logs collected at
	// Format: date-time
	ControllerLogsCollectedAt strfmt.DateTime `json:"controller_logs_collected_at,omitempty" gorm:"type:timestamp with time zone"`

	// controller logs started at
	// Format: date-time
	ControllerLogsStartedAt strfmt.DateTime `json:"controller_logs_started_at,omitempty" gorm:"type:timestamp with time zone"`

	// The CPU architecture of the image (x86_64/arm64/etc).
	// Enum: [x86_64 aarch64 arm64 ppc64le s390x multi]
	CPUArchitecture string `json:"cpu_architecture,omitempty"`

	// The time that this cluster was created.
	// Format: date-time
	CreatedAt timeext.Time `json:"created_at,omitempty" gorm:"type:timestamp with time zone"`

	// swagger:ignore
	DeletedAt gorm.DeletedAt `json:"deleted_at,omitempty" gorm:"type:timestamp with time zone;index"`

	// Information regarding hosts' installation disks encryption.
	DiskEncryption *DiskEncryption `json:"disk_encryption,omitempty" gorm:"embedded;embeddedPrefix:disk_encryption_"`

	// email domain
	EmailDomain string `json:"email_domain,omitempty"`

	// hosts associated to this cluster that are not in 'disabled' state.
	EnabledHostCount int64 `json:"enabled_host_count,omitempty" gorm:"-"`

	// JSON-formatted string containing the usage information by feature name
	FeatureUsage string `json:"feature_usage,omitempty" gorm:"type:text"`

	// Guaranteed availability of the installed cluster. 'Full' installs a Highly-Available cluster
	// over multiple master nodes whereas 'None' installs a full cluster over one node.
	//
	// Enum: [Full None]
	HighAvailabilityMode *string `json:"high_availability_mode,omitempty"`

	// List of host networks to be filled during query.
	HostNetworks []*HostNetwork `json:"host_networks" gorm:"-"`

	// Hosts that are associated with this cluster.
	Hosts []*Host `json:"hosts" gorm:"foreignkey:ClusterID;references:ID"`

	// Self link.
	// Required: true
	Href *string `json:"href"`

	// A proxy URL to use for creating HTTP connections outside the cluster.
	// http://\<username\>:\<pswd\>@\<ip\>:\<port\>
	//
	HTTPProxy string `json:"http_proxy,omitempty"`

	// A proxy URL to use for creating HTTPS connections outside the cluster.
	// http://\<username\>:\<pswd\>@\<ip\>:\<port\>
	//
	HTTPSProxy string `json:"https_proxy,omitempty" gorm:"column:https_proxy"`

	// Enable/disable hyperthreading on master nodes, worker nodes, or all nodes
	// Enum: [masters workers all none]
	Hyperthreading string `json:"hyperthreading,omitempty"`

	// Unique identifier of the object.
	// Required: true
	// Format: uuid
	ID *strfmt.UUID `json:"id" gorm:"primaryKey"`

	// Explicit ignition endpoint overrides the default ignition endpoint.
	IgnitionEndpoint *IgnitionEndpoint `json:"ignition_endpoint,omitempty" gorm:"embedded;embeddedPrefix:ignition_endpoint_"`

	// Json formatted string containing a list of cluster validations to be ignored. May also contain a list with a single string "all" to ignore all cluster validations. Some validations cannot be ignored.
	IgnoredClusterValidations string `json:"ignored_cluster_validations,omitempty" gorm:"type:text"`

	// Json formatted string containing a list of host validations to be ignored. May also contain a list with a single string "all" to ignore all host validations. Some validations cannot be ignored.
	IgnoredHostValidations string `json:"ignored_host_validations,omitempty" gorm:"type:text"`

	// image info
	// Required: true
	ImageInfo *ImageInfo `json:"image_info" gorm:"embedded;embeddedPrefix:image_"`

	// Indicates whether this cluster is an imported day-2 cluster or a
	// regular cluster. Clusters are considered imported when they are
	// created via the ../clusters/import endpoint. Day-2 clusters converted
	// from day-1 clusters by kube-api controllers or the
	// ../clusters/<cluster_id>/actions/allow-add-hosts endpoint are not
	// considered imported. Imported clusters usually lack a lot of
	// information and are filled with default values that don't necessarily
	// reflect the actual cluster they represent
	Imported *bool `json:"imported,omitempty"`

	// The virtual IPs used for cluster ingress traffic. Enter one IP address for single-stack clusters, or up to two for dual-stack clusters (at most one IP address per IP stack used). The order of stacks should be the same as order of subnets in Cluster Networks, Service Networks, and Machine Networks.
	IngressVips []*IngressVip `json:"ingress_vips" gorm:"foreignkey:ClusterID;references:ID"`

	// The time that this cluster completed installation.
	// Format: date-time
	InstallCompletedAt strfmt.DateTime `json:"install_completed_at,omitempty" gorm:"type:timestamp with time zone"`

	// JSON-formatted string containing the user overrides for the install-config.yaml file.
	// Example: {\"networking\":{\"networkType\": \"OVNKubernetes\"},\"fips\":true}
	InstallConfigOverrides string `json:"install_config_overrides,omitempty" gorm:"type:text"`

	// The time that this cluster started installation.
	// Format: date-time
	InstallStartedAt strfmt.DateTime `json:"install_started_at,omitempty" gorm:"type:timestamp with time zone"`

	// Json formatted string containing ip collisions detected in the cluster.
	IPCollisions string `json:"ip_collisions,omitempty" gorm:"type:text"`

	// Indicates the type of this object. Will be 'Cluster' if this is a complete object,
	// 'AddHostsCluster' for cluster that add hosts to existing OCP cluster,
	//
	// Required: true
	// Enum: [Cluster AddHostsCluster]
	Kind *string `json:"kind"`

	// last installation preparation
	LastInstallationPreparation LastInstallationPreparation `json:"last-installation-preparation,omitempty" gorm:"embedded;embeddedPrefix:last_installation_preparation_"`

	// The progress of log collection or empty if logs are not applicable
	LogsInfo LogsState `json:"logs_info,omitempty" gorm:"type:varchar(2048)"`

	// A CIDR that all hosts belonging to the cluster should have an interfaces with IP address that belongs to this CIDR. The api_vip belongs to this CIDR.
	// Pattern: ^(?:(?:(?:[0-9]{1,3}\.){3}[0-9]{1,3}\/(?:(?:[0-9])|(?:[1-2][0-9])|(?:3[0-2])))|(?:(?:[0-9a-fA-F]*:[0-9a-fA-F]*){2,})/(?:(?:[0-9])|(?:[1-9][0-9])|(?:1[0-1][0-9])|(?:12[0-8])))$
	MachineNetworkCidr string `json:"machine_network_cidr,omitempty"`

	// Machine networks that are associated with this cluster.
	MachineNetworks []*MachineNetwork `json:"machine_networks" gorm:"foreignkey:ClusterID;references:ID"`

	// Operators that are associated with this cluster.
	MonitoredOperators []*MonitoredOperator `json:"monitored_operators" gorm:"foreignkey:ClusterID;references:ID"`

	// Name of the OpenShift cluster.
	Name string `json:"name,omitempty"`

	// The desired network type used.
	// Enum: [OpenShiftSDN OVNKubernetes]
	NetworkType *string `json:"network_type,omitempty"`

	// A comma-separated list of destination domain names, domains, IP addresses, or other network CIDRs to exclude from proxying.
	NoProxy string `json:"no_proxy,omitempty"`

	// OpenShift release image URI.
	OcpReleaseImage string `json:"ocp_release_image,omitempty"`

	// Cluster ID on OCP system.
	// Format: uuid
	OpenshiftClusterID strfmt.UUID `json:"openshift_cluster_id,omitempty"`

	// Version of the OpenShift cluster.
	OpenshiftVersion string `json:"openshift_version,omitempty"`

	// org id
	OrgID string `json:"org_id,omitempty"`

	// Indication if organization soft timeouts is enabled for the cluster.
	OrgSoftTimeoutsEnabled bool `json:"org_soft_timeouts_enabled,omitempty"`

	// platform
	Platform *Platform `json:"platform,omitempty" gorm:"embedded;embeddedPrefix:platform_"`

	// Installation progress percentages of the cluster.
	Progress *ClusterProgressInfo `json:"progress,omitempty" gorm:"embedded;embeddedPrefix:progress_"`

	// True if the pull secret has been added to the cluster.
	PullSecretSet bool `json:"pull_secret_set,omitempty"`

	// hosts associated to this cluster that are in 'known' state.
	ReadyHostCount int64 `json:"ready_host_count,omitempty" gorm:"-"`

	// Schedule workloads on masters
	SchedulableMasters *bool `json:"schedulable_masters,omitempty"`

	// Indicates if schedule workloads on masters will be enabled regardless the value of 'schedulable_masters' property.
	// Set to 'true' when not enough hosts are associated with this cluster to disable the scheduling on masters.
	//
	SchedulableMastersForcedTrue *bool `json:"schedulable_masters_forced_true,omitempty"`

	// The IP address pool to use for service IP addresses. You can enter only one IP address pool. If you need to access the services from an external network, configure load balancers and routers to manage the traffic.
	// Pattern: ^(?:(?:(?:[0-9]{1,3}\.){3}[0-9]{1,3}\/(?:(?:[0-9])|(?:[1-2][0-9])|(?:3[0-2])))|(?:(?:[0-9a-fA-F]*:[0-9a-fA-F]*){2,})/(?:(?:[0-9])|(?:[1-9][0-9])|(?:1[0-1][0-9])|(?:12[0-8])))$
	ServiceNetworkCidr string `json:"service_network_cidr,omitempty"`

	// Service networks that are associated with this cluster.
	ServiceNetworks []*ServiceNetwork `json:"service_networks" gorm:"foreignkey:ClusterID;references:ID"`

	// SSH public key for debugging OpenShift nodes.
	SSHPublicKey string `json:"ssh_public_key,omitempty"`

	// Status of the OpenShift cluster.
	// Required: true
	// Enum: [insufficient ready error preparing-for-installation pending-for-input installing finalizing installed adding-hosts cancelled installing-pending-user-action]
	Status *string `json:"status"`

	// Additional information pertaining to the status of the OpenShift cluster.
	// Required: true
	StatusInfo *string `json:"status_info" gorm:"type:varchar(2048)"`

	// The last time that the cluster status was updated.
	// Format: date-time
	StatusUpdatedAt strfmt.DateTime `json:"status_updated_at,omitempty" gorm:"type:timestamp with time zone"`

	// A comma-separated list of tags that are associated to the cluster.
	Tags string `json:"tags,omitempty"`

	// All hosts associated to this cluster.
	TotalHostCount int64 `json:"total_host_count,omitempty" gorm:"-"`

	// The last time that this cluster was updated.
	// Format: date-time
	UpdatedAt timeext.Time `json:"updated_at,omitempty" gorm:"type:timestamp with time zone"`

	// (DEPRECATED) Indicate if the networking is managed by the user.
	UserManagedNetworking *bool `json:"user_managed_networking,omitempty"`

	// user name
	UserName string `json:"user_name,omitempty"`

	// JSON-formatted string containing the validation results for each validation id grouped by category (network, hosts-data, etc.)
	ValidationsInfo string `json:"validations_info,omitempty" gorm:"type:text"`

	// Indicate if virtual IP DHCP allocation mode is enabled.
	VipDhcpAllocation *bool `json:"vip_dhcp_allocation,omitempty"`
}

Cluster cluster

swagger:model cluster

func (*Cluster) ContextValidate 

func (m *Cluster) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this cluster based on the context it is used

func (*Cluster) MarshalBinary 

func (m *Cluster) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Cluster) UnmarshalBinary 

func (m *Cluster) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Cluster) Validate 

func (m *Cluster) Validate(formats strfmt.Registry) error

Validate validates this cluster

type ClusterCreateParams 

type ClusterCreateParams struct {

	// A comma-separated list of NTP sources (name or IP) going to be added to all the hosts.
	AdditionalNtpSource *string `json:"additional_ntp_source,omitempty"`

	// The virtual IPs used to reach the OpenShift cluster's API. Enter one IP address for single-stack clusters, or up to two for dual-stack clusters (at most one IP address per IP stack used). The order of stacks should be the same as order of subnets in Cluster Networks, Service Networks, and Machine Networks.
	APIVips []*APIVip `json:"api_vips"`

	// Base domain of the cluster. All DNS records must be sub-domains of this base and include the cluster name.
	BaseDNSDomain string `json:"base_dns_domain,omitempty"`

	// IP address block from which Pod IPs are allocated. This block must not overlap with existing physical networks. These IP addresses are used for the Pod network, and if you need to access the Pods from an external network, configure load balancers and routers to manage the traffic.
	// Pattern: ^(?:(?:(?:[0-9]{1,3}\.){3}[0-9]{1,3}\/(?:(?:[0-9])|(?:[1-2][0-9])|(?:3[0-2])))|(?:(?:[0-9a-fA-F]*:[0-9a-fA-F]*){2,})/(?:(?:[0-9])|(?:[1-9][0-9])|(?:1[0-1][0-9])|(?:12[0-8])))$
	ClusterNetworkCidr *string `json:"cluster_network_cidr,omitempty"`

	// The subnet prefix length to assign to each individual node. For example, if clusterNetworkHostPrefix is set to 23, then each node is assigned a /23 subnet out of the given cidr (clusterNetworkCIDR), which allows for 510 (2^(32 - 23) - 2) pod IPs addresses. If you are required to provide access to nodes from an external network, configure load balancers and routers to manage the traffic.
	// Maximum: 128
	// Minimum: 1
	ClusterNetworkHostPrefix int64 `json:"cluster_network_host_prefix,omitempty"`

	// Cluster networks that are associated with this cluster.
	ClusterNetworks []*ClusterNetwork `json:"cluster_networks"`

	// The CPU architecture of the image (x86_64/arm64/etc).
	// Enum: [x86_64 aarch64 arm64 ppc64le s390x multi]
	CPUArchitecture string `json:"cpu_architecture,omitempty"`

	// Installation disks encryption mode and host roles to be applied.
	DiskEncryption *DiskEncryption `json:"disk_encryption,omitempty" gorm:"embedded;embeddedPrefix:disk_encryption_"`

	// Guaranteed availability of the installed cluster. 'Full' installs a Highly-Available cluster
	// over multiple master nodes whereas 'None' installs a full cluster over one node.
	//
	// Enum: [Full None]
	HighAvailabilityMode *string `json:"high_availability_mode,omitempty"`

	// A proxy URL to use for creating HTTP connections outside the cluster.
	// http://\<username\>:\<pswd\>@\<ip\>:\<port\>
	//
	HTTPProxy *string `json:"http_proxy,omitempty"`

	// A proxy URL to use for creating HTTPS connections outside the cluster.
	// http://\<username\>:\<pswd\>@\<ip\>:\<port\>
	//
	HTTPSProxy *string `json:"https_proxy,omitempty"`

	// Enable/disable hyperthreading on master nodes, worker nodes, or all nodes.
	// Enum: [masters workers none all]
	Hyperthreading *string `json:"hyperthreading,omitempty"`

	// Explicit ignition endpoint overrides the default ignition endpoint.
	IgnitionEndpoint *IgnitionEndpoint `json:"ignition_endpoint,omitempty" gorm:"embedded;embeddedPrefix:ignition_endpoint_"`

	// The virtual IPs used for cluster ingress traffic. Enter one IP address for single-stack clusters, or up to two for dual-stack clusters (at most one IP address per IP stack used). The order of stacks should be the same as order of subnets in Cluster Networks, Service Networks, and Machine Networks.
	IngressVips []*IngressVip `json:"ingress_vips"`

	// Machine networks that are associated with this cluster.
	MachineNetworks []*MachineNetwork `json:"machine_networks"`

	// Name of the OpenShift cluster.
	// Required: true
	// Max Length: 54
	// Min Length: 1
	Name *string `json:"name"`

	// The desired network type used.
	// Enum: [OpenShiftSDN OVNKubernetes]
	NetworkType *string `json:"network_type,omitempty"`

	// An "*" or a comma-separated list of destination domain names, domains, IP addresses, or other network CIDRs to exclude from proxying.
	NoProxy *string `json:"no_proxy,omitempty"`

	// OpenShift release image URI.
	OcpReleaseImage string `json:"ocp_release_image,omitempty"`

	// List of OLM operators to be installed.
	OlmOperators []*OperatorCreateParams `json:"olm_operators"`

	// Version of the OpenShift cluster.
	// Required: true
	OpenshiftVersion *string `json:"openshift_version"`

	// platform
	Platform *Platform `json:"platform,omitempty" gorm:"embedded;embeddedPrefix:platform_"`

	// The pull secret obtained from Red Hat OpenShift Cluster Manager at console.redhat.com/openshift/install/pull-secret.
	// Required: true
	PullSecret *string `json:"pull_secret"`

	// Schedule workloads on masters
	SchedulableMasters *bool `json:"schedulable_masters,omitempty"`

	// The IP address pool to use for service IP addresses. You can enter only one IP address pool. If you need to access the services from an external network, configure load balancers and routers to manage the traffic.
	// Pattern: ^(?:(?:(?:[0-9]{1,3}\.){3}[0-9]{1,3}\/(?:(?:[0-9])|(?:[1-2][0-9])|(?:3[0-2])))|(?:(?:[0-9a-fA-F]*:[0-9a-fA-F]*){2,})/(?:(?:[0-9])|(?:[1-9][0-9])|(?:1[0-1][0-9])|(?:12[0-8])))$
	ServiceNetworkCidr *string `json:"service_network_cidr,omitempty"`

	// Service networks that are associated with this cluster.
	ServiceNetworks []*ServiceNetwork `json:"service_networks"`

	// SSH public key for debugging OpenShift nodes.
	SSHPublicKey string `json:"ssh_public_key,omitempty"`

	// A comma-separated list of tags that are associated to the cluster.
	Tags *string `json:"tags,omitempty"`

	// (DEPRECATED) Indicate if the networking is managed by the user.
	UserManagedNetworking *bool `json:"user_managed_networking,omitempty"`

	// Indicate if virtual IP DHCP allocation mode is enabled.
	VipDhcpAllocation *bool `json:"vip_dhcp_allocation,omitempty"`
}

ClusterCreateParams cluster create params

swagger:model cluster-create-params

func (*ClusterCreateParams) ContextValidate 

func (m *ClusterCreateParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this cluster create params based on the context it is used

func (*ClusterCreateParams) MarshalBinary 

func (m *ClusterCreateParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ClusterCreateParams) UnmarshalBinary 

func (m *ClusterCreateParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ClusterCreateParams) Validate 

func (m *ClusterCreateParams) Validate(formats strfmt.Registry) error

Validate validates this cluster create params

type ClusterDefaultConfig 

type ClusterDefaultConfig struct {

	// cluster network cidr
	// Pattern: ^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)[\/]([1-9]|[1-2][0-9]|3[0-2]?)$
	ClusterNetworkCidr string `json:"cluster_network_cidr,omitempty"`

	// cluster network host prefix
	// Maximum: 32
	// Minimum: 1
	ClusterNetworkHostPrefix int64 `json:"cluster_network_host_prefix,omitempty"`

	// cluster networks dualstack
	ClusterNetworksDualstack []*ClusterNetwork `json:"cluster_networks_dualstack"`

	// cluster networks ipv4
	ClusterNetworksIPV4 []*ClusterNetwork `json:"cluster_networks_ipv4"`

	// This provides a list of forbidden hostnames. If this list is empty or not present, this implies that the UI should fall back to a hard coded list.
	ForbiddenHostnames []string `json:"forbidden_hostnames"`

	// inactive deletion hours
	InactiveDeletionHours int64 `json:"inactive_deletion_hours,omitempty"`

	// ntp source
	NtpSource string `json:"ntp_source"`

	// service network cidr
	// Pattern: ^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)[\/]([1-9]|[1-2][0-9]|3[0-2]?)$
	ServiceNetworkCidr string `json:"service_network_cidr,omitempty"`

	// service networks dualstack
	ServiceNetworksDualstack []*ServiceNetwork `json:"service_networks_dualstack"`

	// service networks ipv4
	ServiceNetworksIPV4 []*ServiceNetwork `json:"service_networks_ipv4"`
}

ClusterDefaultConfig cluster default config

swagger:model cluster_default_config

func (*ClusterDefaultConfig) ContextValidate 

func (m *ClusterDefaultConfig) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this cluster default config based on the context it is used

func (*ClusterDefaultConfig) MarshalBinary 

func (m *ClusterDefaultConfig) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ClusterDefaultConfig) UnmarshalBinary 

func (m *ClusterDefaultConfig) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ClusterDefaultConfig) Validate 

func (m *ClusterDefaultConfig) Validate(formats strfmt.Registry) error

Validate validates this cluster default config

type ClusterFinalizingProgress 

type ClusterFinalizingProgress struct {

	// finalizing stage
	FinalizingStage FinalizingStage `json:"finalizing_stage,omitempty"`
}

ClusterFinalizingProgress cluster finalizing progress

swagger:model cluster-finalizing-progress

func (*ClusterFinalizingProgress) ContextValidate 

func (m *ClusterFinalizingProgress) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this cluster finalizing progress based on the context it is used

func (*ClusterFinalizingProgress) MarshalBinary 

func (m *ClusterFinalizingProgress) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ClusterFinalizingProgress) UnmarshalBinary 

func (m *ClusterFinalizingProgress) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ClusterFinalizingProgress) Validate 

func (m *ClusterFinalizingProgress) Validate(formats strfmt.Registry) error

Validate validates this cluster finalizing progress

type ClusterHostRequirements 

type ClusterHostRequirements struct {

	// Unique identifier of the host the requirements relate to.
	// Format: uuid
	HostID strfmt.UUID `json:"host_id,omitempty"`

	// Host requirements for the OCP installation
	Ocp *ClusterHostRequirementsDetails `json:"ocp,omitempty"`

	// Host requirements related to requested operators
	Operators []*OperatorHostRequirements `json:"operators"`

	// Total host requirements for the cluster configuration
	Total *ClusterHostRequirementsDetails `json:"total,omitempty"`
}

ClusterHostRequirements cluster host requirements

swagger:model cluster-host-requirements

func (*ClusterHostRequirements) ContextValidate 

func (m *ClusterHostRequirements) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this cluster host requirements based on the context it is used

func (*ClusterHostRequirements) MarshalBinary 

func (m *ClusterHostRequirements) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ClusterHostRequirements) UnmarshalBinary 

func (m *ClusterHostRequirements) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ClusterHostRequirements) Validate 

func (m *ClusterHostRequirements) Validate(formats strfmt.Registry) error

Validate validates this cluster host requirements

type ClusterHostRequirementsDetails 

type ClusterHostRequirementsDetails struct {

	// Required number of CPU cores
	CPUCores int64 `json:"cpu_cores,omitempty"`

	// Required disk size in GB
	DiskSizeGb int64 `json:"disk_size_gb,omitempty"`

	// Required installation disk speed in ms
	InstallationDiskSpeedThresholdMs int64 `json:"installation_disk_speed_threshold_ms,omitempty"`

	// Maximum network average latency (RTT) at L3 for role.
	NetworkLatencyThresholdMs *float64 `json:"network_latency_threshold_ms,omitempty"`

	// Maximum packet loss allowed at L3 for role.
	PacketLossPercentage *float64 `json:"packet_loss_percentage,omitempty"`

	// Required number of RAM in MiB
	RAMMib int64 `json:"ram_mib,omitempty"`

	// Whether TPM module should be enabled in host's BIOS.
	TpmEnabledInBios bool `json:"tpm_enabled_in_bios,omitempty"`
}

ClusterHostRequirementsDetails cluster host requirements details

swagger:model cluster-host-requirements-details

func (*ClusterHostRequirementsDetails) ContextValidate 

func (m *ClusterHostRequirementsDetails) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this cluster host requirements details based on context it is used

func (*ClusterHostRequirementsDetails) MarshalBinary 

func (m *ClusterHostRequirementsDetails) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ClusterHostRequirementsDetails) UnmarshalBinary 

func (m *ClusterHostRequirementsDetails) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ClusterHostRequirementsDetails) Validate 

func (m *ClusterHostRequirementsDetails) Validate(formats strfmt.Registry) error

Validate validates this cluster host requirements details

type ClusterHostRequirementsList 

type ClusterHostRequirementsList []*ClusterHostRequirements

ClusterHostRequirementsList cluster host requirements list

swagger:model cluster-host-requirements-list

func (ClusterHostRequirementsList) ContextValidate 

func (m ClusterHostRequirementsList) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this cluster host requirements list based on the context it is used

func (ClusterHostRequirementsList) Validate 

func (m ClusterHostRequirementsList) Validate(formats strfmt.Registry) error

Validate validates this cluster host requirements list

type ClusterList 

type ClusterList []*Cluster

ClusterList cluster list

swagger:model cluster-list

func (ClusterList) ContextValidate 

func (m ClusterList) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this cluster list based on the context it is used

func (ClusterList) Validate 

func (m ClusterList) Validate(formats strfmt.Registry) error

Validate validates this cluster list

type ClusterNetwork 

type ClusterNetwork struct {

	// The IP block address pool.
	Cidr Subnet `json:"cidr,omitempty" gorm:"primaryKey"`

	// The cluster that this network is associated with.
	// Format: uuid
	ClusterID strfmt.UUID `json:"cluster_id,omitempty" gorm:"primaryKey"`

	// The subnet prefix length to assign to each individual node. For example if is set to 23, then each node is assigned a /23 subnet out of the given CIDR, which allows for 510 (2^(32 - 23) - 2) pod IPs addresses.
	// Maximum: 128
	// Minimum: 1
	HostPrefix int64 `json:"host_prefix,omitempty"`
}

ClusterNetwork A network from which Pod IPs are allocated. This block must not overlap with existing physical networks. These IP addresses are used for the Pod network, and if you need to access the Pods from an external network, configure load balancers and routers to manage the traffic.

swagger:model cluster_network

func (*ClusterNetwork) ContextValidate 

func (m *ClusterNetwork) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this cluster network based on the context it is used

func (*ClusterNetwork) MarshalBinary 

func (m *ClusterNetwork) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ClusterNetwork) UnmarshalBinary 

func (m *ClusterNetwork) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ClusterNetwork) Validate 

func (m *ClusterNetwork) Validate(formats strfmt.Registry) error

Validate validates this cluster network

type ClusterProgressInfo 

type ClusterProgressInfo struct {

	// finalizing stage
	FinalizingStage FinalizingStage `json:"finalizing_stage,omitempty"`

	// finalizing stage percentage
	FinalizingStagePercentage int64 `json:"finalizing_stage_percentage,omitempty"`

	// finalizing stage started at
	// Format: date-time
	FinalizingStageStartedAt strfmt.DateTime `json:"finalizing_stage_started_at,omitempty" gorm:"type:timestamp with time zone"`

	// finalizing stage timed out
	FinalizingStageTimedOut bool `json:"finalizing_stage_timed_out,omitempty"`

	// installing stage percentage
	InstallingStagePercentage int64 `json:"installing_stage_percentage,omitempty"`

	// preparing for installation stage percentage
	PreparingForInstallationStagePercentage int64 `json:"preparing_for_installation_stage_percentage,omitempty"`

	// total percentage
	TotalPercentage int64 `json:"total_percentage,omitempty"`
}

ClusterProgressInfo cluster progress info

swagger:model cluster-progress-info

func (*ClusterProgressInfo) ContextValidate 

func (m *ClusterProgressInfo) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this cluster progress info based on the context it is used

func (*ClusterProgressInfo) MarshalBinary 

func (m *ClusterProgressInfo) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ClusterProgressInfo) UnmarshalBinary 

func (m *ClusterProgressInfo) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ClusterProgressInfo) Validate 

func (m *ClusterProgressInfo) Validate(formats strfmt.Registry) error

Validate validates this cluster progress info

type ClusterValidationID 

type ClusterValidationID string

ClusterValidationID cluster validation id

swagger:model cluster-validation-id 

const (

	// ClusterValidationIDMachineCidrDefined captures enum value "machine-cidr-defined"
	ClusterValidationIDMachineCidrDefined ClusterValidationID = "machine-cidr-defined"

	// ClusterValidationIDClusterCidrDefined captures enum value "cluster-cidr-defined"
	ClusterValidationIDClusterCidrDefined ClusterValidationID = "cluster-cidr-defined"

	// ClusterValidationIDServiceCidrDefined captures enum value "service-cidr-defined"
	ClusterValidationIDServiceCidrDefined ClusterValidationID = "service-cidr-defined"

	// ClusterValidationIDNoCidrsOverlapping captures enum value "no-cidrs-overlapping"
	ClusterValidationIDNoCidrsOverlapping ClusterValidationID = "no-cidrs-overlapping"

	// ClusterValidationIDNetworksSameAddressFamilies captures enum value "networks-same-address-families"
	ClusterValidationIDNetworksSameAddressFamilies ClusterValidationID = "networks-same-address-families"

	// ClusterValidationIDNetworkPrefixValid captures enum value "network-prefix-valid"
	ClusterValidationIDNetworkPrefixValid ClusterValidationID = "network-prefix-valid"

	// ClusterValidationIDMachineCidrEqualsToCalculatedCidr captures enum value "machine-cidr-equals-to-calculated-cidr"
	ClusterValidationIDMachineCidrEqualsToCalculatedCidr ClusterValidationID = "machine-cidr-equals-to-calculated-cidr"

	// ClusterValidationIDAPIVipsDefined captures enum value "api-vips-defined"
	ClusterValidationIDAPIVipsDefined ClusterValidationID = "api-vips-defined"

	// ClusterValidationIDAPIVipsValid captures enum value "api-vips-valid"
	ClusterValidationIDAPIVipsValid ClusterValidationID = "api-vips-valid"

	// ClusterValidationIDIngressVipsDefined captures enum value "ingress-vips-defined"
	ClusterValidationIDIngressVipsDefined ClusterValidationID = "ingress-vips-defined"

	// ClusterValidationIDIngressVipsValid captures enum value "ingress-vips-valid"
	ClusterValidationIDIngressVipsValid ClusterValidationID = "ingress-vips-valid"

	// ClusterValidationIDAllHostsAreReadyToInstall captures enum value "all-hosts-are-ready-to-install"
	ClusterValidationIDAllHostsAreReadyToInstall ClusterValidationID = "all-hosts-are-ready-to-install"

	// ClusterValidationIDSufficientMastersCount captures enum value "sufficient-masters-count"
	ClusterValidationIDSufficientMastersCount ClusterValidationID = "sufficient-masters-count"

	// ClusterValidationIDDNSDomainDefined captures enum value "dns-domain-defined"
	ClusterValidationIDDNSDomainDefined ClusterValidationID = "dns-domain-defined"

	// ClusterValidationIDPullSecretSet captures enum value "pull-secret-set"
	ClusterValidationIDPullSecretSet ClusterValidationID = "pull-secret-set"

	// ClusterValidationIDNtpServerConfigured captures enum value "ntp-server-configured"
	ClusterValidationIDNtpServerConfigured ClusterValidationID = "ntp-server-configured"

	// ClusterValidationIDLsoRequirementsSatisfied captures enum value "lso-requirements-satisfied"
	ClusterValidationIDLsoRequirementsSatisfied ClusterValidationID = "lso-requirements-satisfied"

	// ClusterValidationIDOcsRequirementsSatisfied captures enum value "ocs-requirements-satisfied"
	ClusterValidationIDOcsRequirementsSatisfied ClusterValidationID = "ocs-requirements-satisfied"

	// ClusterValidationIDOdfRequirementsSatisfied captures enum value "odf-requirements-satisfied"
	ClusterValidationIDOdfRequirementsSatisfied ClusterValidationID = "odf-requirements-satisfied"

	// ClusterValidationIDCnvRequirementsSatisfied captures enum value "cnv-requirements-satisfied"
	ClusterValidationIDCnvRequirementsSatisfied ClusterValidationID = "cnv-requirements-satisfied"

	// ClusterValidationIDLvmRequirementsSatisfied captures enum value "lvm-requirements-satisfied"
	ClusterValidationIDLvmRequirementsSatisfied ClusterValidationID = "lvm-requirements-satisfied"

	// ClusterValidationIDMceRequirementsSatisfied captures enum value "mce-requirements-satisfied"
	ClusterValidationIDMceRequirementsSatisfied ClusterValidationID = "mce-requirements-satisfied"

	// ClusterValidationIDNetworkTypeValid captures enum value "network-type-valid"
	ClusterValidationIDNetworkTypeValid ClusterValidationID = "network-type-valid"

	// ClusterValidationIDPlatformRequirementsSatisfied captures enum value "platform-requirements-satisfied"
	ClusterValidationIDPlatformRequirementsSatisfied ClusterValidationID = "platform-requirements-satisfied"
)

func NewClusterValidationID 

func NewClusterValidationID(value ClusterValidationID) *ClusterValidationID

func (ClusterValidationID) ContextValidate 

func (m ClusterValidationID) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this cluster validation id based on context it is used

func (ClusterValidationID) Pointer 

func (m ClusterValidationID) Pointer() *ClusterValidationID

Pointer returns a pointer to a freshly-allocated ClusterValidationID.

func (ClusterValidationID) Validate 

func (m ClusterValidationID) Validate(formats strfmt.Registry) error

Validate validates this cluster validation id

type CompletionParams 

type CompletionParams struct {

	// additional data from the cluster
	Data map[string]interface{} `json:"data,omitempty"`

	// error info
	ErrorInfo string `json:"error_info,omitempty"`

	// is success
	// Required: true
	IsSuccess *bool `json:"is_success"`
}

CompletionParams completion params

swagger:model completion-params

func (*CompletionParams) ContextValidate 

func (m *CompletionParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this completion params based on context it is used

func (*CompletionParams) MarshalBinary 

func (m *CompletionParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*CompletionParams) UnmarshalBinary 

func (m *CompletionParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*CompletionParams) Validate 

func (m *CompletionParams) Validate(formats strfmt.Registry) error

Validate validates this completion params

type ConnectivityCheckHost 

type ConnectivityCheckHost struct {

	// host id
	// Format: uuid
	HostID strfmt.UUID `json:"host_id,omitempty"`

	// nics
	Nics []*ConnectivityCheckNic `json:"nics"`
}

ConnectivityCheckHost connectivity check host

swagger:model connectivity-check-host

func (*ConnectivityCheckHost) ContextValidate 

func (m *ConnectivityCheckHost) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this connectivity check host based on the context it is used

func (*ConnectivityCheckHost) MarshalBinary 

func (m *ConnectivityCheckHost) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ConnectivityCheckHost) UnmarshalBinary 

func (m *ConnectivityCheckHost) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ConnectivityCheckHost) Validate 

func (m *ConnectivityCheckHost) Validate(formats strfmt.Registry) error

Validate validates this connectivity check host

type ConnectivityCheckNic 

type ConnectivityCheckNic struct {

	// ip addresses
	IPAddresses []string `json:"ip_addresses"`

	// mac
	// Format: mac
	Mac strfmt.MAC `json:"mac,omitempty"`

	// name
	Name string `json:"name,omitempty"`
}

ConnectivityCheckNic connectivity check nic

swagger:model connectivity-check-nic

func (*ConnectivityCheckNic) ContextValidate 

func (m *ConnectivityCheckNic) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this connectivity check nic based on context it is used

func (*ConnectivityCheckNic) MarshalBinary 

func (m *ConnectivityCheckNic) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ConnectivityCheckNic) UnmarshalBinary 

func (m *ConnectivityCheckNic) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ConnectivityCheckNic) Validate 

func (m *ConnectivityCheckNic) Validate(formats strfmt.Registry) error

Validate validates this connectivity check nic

type ConnectivityCheckParams 

type ConnectivityCheckParams []*ConnectivityCheckHost

ConnectivityCheckParams connectivity check params

swagger:model connectivity-check-params

func (ConnectivityCheckParams) ContextValidate 

func (m ConnectivityCheckParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this connectivity check params based on the context it is used

func (ConnectivityCheckParams) Validate 

func (m ConnectivityCheckParams) Validate(formats strfmt.Registry) error

Validate validates this connectivity check params

type ConnectivityRemoteHost 

type ConnectivityRemoteHost struct {

	// host id
	// Format: uuid
	HostID strfmt.UUID `json:"host_id,omitempty"`

	// l2 connectivity
	L2Connectivity []*L2Connectivity `json:"l2_connectivity"`

	// l3 connectivity
	L3Connectivity []*L3Connectivity `json:"l3_connectivity"`
}

ConnectivityRemoteHost connectivity remote host

swagger:model connectivity-remote-host

func (*ConnectivityRemoteHost) ContextValidate 

func (m *ConnectivityRemoteHost) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this connectivity remote host based on the context it is used

func (*ConnectivityRemoteHost) MarshalBinary 

func (m *ConnectivityRemoteHost) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ConnectivityRemoteHost) UnmarshalBinary 

func (m *ConnectivityRemoteHost) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ConnectivityRemoteHost) Validate 

func (m *ConnectivityRemoteHost) Validate(formats strfmt.Registry) error

Validate validates this connectivity remote host

type ConnectivityReport 

type ConnectivityReport struct {

	// remote hosts
	RemoteHosts []*ConnectivityRemoteHost `json:"remote_hosts"`
}

ConnectivityReport connectivity report

swagger:model connectivity-report

func (*ConnectivityReport) ContextValidate 

func (m *ConnectivityReport) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this connectivity report based on the context it is used

func (*ConnectivityReport) MarshalBinary 

func (m *ConnectivityReport) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ConnectivityReport) UnmarshalBinary 

func (m *ConnectivityReport) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ConnectivityReport) Validate 

func (m *ConnectivityReport) Validate(formats strfmt.Registry) error

Validate validates this connectivity report

type ContainerImageAvailability 

type ContainerImageAvailability struct {

	// The rate of size/time in seconds MBps.
	DownloadRate float64 `json:"download_rate,omitempty"`

	// A fully qualified image name (FQIN).
	Name string `json:"name,omitempty"`

	// result
	Result ContainerImageAvailabilityResult `json:"result,omitempty"`

	// Size of the image in bytes.
	SizeBytes float64 `json:"size_bytes,omitempty"`

	// Seconds it took to pull the image.
	Time float64 `json:"time,omitempty"`
}

ContainerImageAvailability container image availability

swagger:model container_image_availability

func (*ContainerImageAvailability) ContextValidate 

func (m *ContainerImageAvailability) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this container image availability based on the context it is used

func (*ContainerImageAvailability) MarshalBinary 

func (m *ContainerImageAvailability) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ContainerImageAvailability) UnmarshalBinary 

func (m *ContainerImageAvailability) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ContainerImageAvailability) Validate 

func (m *ContainerImageAvailability) Validate(formats strfmt.Registry) error

Validate validates this container image availability

type ContainerImageAvailabilityRequest 

type ContainerImageAvailabilityRequest struct {

	// List of image names to be checked.
	// Required: true
	Images []string `json:"images"`

	// Positive number represents a timeout in seconds for a pull operation.
	Timeout int64 `json:"timeout,omitempty"`
}

ContainerImageAvailabilityRequest container image availability request

swagger:model container_image_availability_request

func (*ContainerImageAvailabilityRequest) ContextValidate 

func (m *ContainerImageAvailabilityRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this container image availability request based on context it is used

func (*ContainerImageAvailabilityRequest) MarshalBinary 

func (m *ContainerImageAvailabilityRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ContainerImageAvailabilityRequest) UnmarshalBinary 

func (m *ContainerImageAvailabilityRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ContainerImageAvailabilityRequest) Validate 

func (m *ContainerImageAvailabilityRequest) Validate(formats strfmt.Registry) error

Validate validates this container image availability request

type ContainerImageAvailabilityResponse 

type ContainerImageAvailabilityResponse struct {

	// List of images that were checked.
	// Required: true
	Images []*ContainerImageAvailability `json:"images"`
}

ContainerImageAvailabilityResponse container image availability response

swagger:model container_image_availability_response

func (*ContainerImageAvailabilityResponse) ContextValidate 

func (m *ContainerImageAvailabilityResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this container image availability response based on the context it is used

func (*ContainerImageAvailabilityResponse) MarshalBinary 

func (m *ContainerImageAvailabilityResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ContainerImageAvailabilityResponse) UnmarshalBinary 

func (m *ContainerImageAvailabilityResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ContainerImageAvailabilityResponse) Validate 

func (m *ContainerImageAvailabilityResponse) Validate(formats strfmt.Registry) error

Validate validates this container image availability response

type ContainerImageAvailabilityResult 

type ContainerImageAvailabilityResult string

ContainerImageAvailabilityResult Image availability result.

swagger:model container_image_availability_result 

const (

	// ContainerImageAvailabilityResultSuccess captures enum value "success"
	ContainerImageAvailabilityResultSuccess ContainerImageAvailabilityResult = "success"

	// ContainerImageAvailabilityResultFailure captures enum value "failure"
	ContainerImageAvailabilityResultFailure ContainerImageAvailabilityResult = "failure"
)

func NewContainerImageAvailabilityResult 

func NewContainerImageAvailabilityResult(value ContainerImageAvailabilityResult) *ContainerImageAvailabilityResult

func (ContainerImageAvailabilityResult) ContextValidate 

func (m ContainerImageAvailabilityResult) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this container image availability result based on context it is used

func (ContainerImageAvailabilityResult) Pointer 

func (m ContainerImageAvailabilityResult) Pointer() *ContainerImageAvailabilityResult

Pointer returns a pointer to a freshly-allocated ContainerImageAvailabilityResult.

func (ContainerImageAvailabilityResult) Validate 

func (m ContainerImageAvailabilityResult) Validate(formats strfmt.Registry) error

Validate validates this container image availability result

type CreateManifestParams 

type CreateManifestParams struct {

	// base64 encoded manifest content.
	// Required: true
	Content *string `json:"content"`

	// The name of the manifest to customize the installed OCP cluster.
	// Required: true
	// Pattern: ^[^\/]*\.(json|ya?ml(\.patch_?[a-zA-Z0-9_]*)?)$
	FileName *string `json:"file_name"`

	// The folder that contains the files. Manifests can be placed in 'manifests' or 'openshift' directories.
	// Enum: [manifests openshift]
	Folder *string `json:"folder,omitempty"`
}

CreateManifestParams create manifest params

swagger:model create-manifest-params

func (*CreateManifestParams) ContextValidate 

func (m *CreateManifestParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this create manifest params based on context it is used

func (*CreateManifestParams) MarshalBinary 

func (m *CreateManifestParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*CreateManifestParams) UnmarshalBinary 

func (m *CreateManifestParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*CreateManifestParams) Validate 

func (m *CreateManifestParams) Validate(formats strfmt.Registry) error

Validate validates this create manifest params

type Credentials 

type Credentials struct {

	// console url
	ConsoleURL string `json:"console_url,omitempty"`

	// password
	Password string `json:"password,omitempty"`

	// username
	Username string `json:"username,omitempty"`
}

Credentials credentials

swagger:model credentials

func (*Credentials) ContextValidate 

func (m *Credentials) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this credentials based on context it is used

func (*Credentials) MarshalBinary 

func (m *Credentials) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Credentials) UnmarshalBinary 

func (m *Credentials) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Credentials) Validate 

func (m *Credentials) Validate(formats strfmt.Registry) error

Validate validates this credentials

type DhcpAllocationRequest 

type DhcpAllocationRequest struct {

	// Contents of lease file to be used for API virtual IP.
	APIVipLease string `json:"api_vip_lease,omitempty"`

	// MAC address for the API virtual IP.
	// Required: true
	// Format: mac
	APIVipMac *strfmt.MAC `json:"api_vip_mac"`

	// Contents of lease file to be used for for Ingress virtual IP.
	IngressVipLease string `json:"ingress_vip_lease,omitempty"`

	// MAC address for the Ingress virtual IP.
	// Required: true
	// Format: mac
	IngressVipMac *strfmt.MAC `json:"ingress_vip_mac"`

	// The network interface (NIC) to run the DHCP requests on.
	// Required: true
	Interface *string `json:"interface"`
}

DhcpAllocationRequest dhcp allocation request

swagger:model dhcp_allocation_request

func (*DhcpAllocationRequest) ContextValidate 

func (m *DhcpAllocationRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this dhcp allocation request based on context it is used

func (*DhcpAllocationRequest) MarshalBinary 

func (m *DhcpAllocationRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DhcpAllocationRequest) UnmarshalBinary 

func (m *DhcpAllocationRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DhcpAllocationRequest) Validate 

func (m *DhcpAllocationRequest) Validate(formats strfmt.Registry) error

Validate validates this dhcp allocation request

type DhcpAllocationResponse 

type DhcpAllocationResponse struct {

	// The IPv4 address that was allocated by DHCP for the API virtual IP.
	// Required: true
	// Format: ipv4
	APIVipAddress *strfmt.IPv4 `json:"api_vip_address"`

	// Contents of last acquired lease for API virtual IP.
	APIVipLease string `json:"api_vip_lease,omitempty"`

	// The IPv4 address that was allocated by DHCP for the Ingress virtual IP.
	// Required: true
	// Format: ipv4
	IngressVipAddress *strfmt.IPv4 `json:"ingress_vip_address"`

	// Contents of last acquired lease for Ingress virtual IP.
	IngressVipLease string `json:"ingress_vip_lease,omitempty"`
}

DhcpAllocationResponse dhcp allocation response

swagger:model dhcp_allocation_response

func (*DhcpAllocationResponse) ContextValidate 

func (m *DhcpAllocationResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this dhcp allocation response based on context it is used

func (*DhcpAllocationResponse) MarshalBinary 

func (m *DhcpAllocationResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DhcpAllocationResponse) UnmarshalBinary 

func (m *DhcpAllocationResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DhcpAllocationResponse) Validate 

func (m *DhcpAllocationResponse) Validate(formats strfmt.Registry) error

Validate validates this dhcp allocation response

type Disk 

type Disk struct {

	// bootable
	Bootable bool `json:"bootable,omitempty"`

	// by-id is the World Wide Number of the device which guaranteed to be unique for every storage device
	ByID string `json:"by_id,omitempty"`

	// by-path is the shortest physical path to the device
	ByPath string `json:"by_path,omitempty"`

	// drive type
	DriveType DriveType `json:"drive_type,omitempty"`

	// has uuid
	HasUUID bool `json:"has_uuid,omitempty"`

	// hctl
	Hctl string `json:"hctl,omitempty"`

	// A comma-separated list of disk names that this disk belongs to
	Holders string `json:"holders,omitempty"`

	// Determine the disk's unique identifier which is the by-id field if it exists and fallback to the by-path field otherwise
	ID string `json:"id,omitempty"`

	// installation eligibility
	InstallationEligibility DiskInstallationEligibility `json:"installation_eligibility,omitempty"`

	// io perf
	IoPerf *IoPerf `json:"io_perf,omitempty"`

	// Whether the disk appears to be an installation media or not
	IsInstallationMedia bool `json:"is_installation_media,omitempty"`

	// iscsi
	Iscsi *Iscsi `json:"iscsi,omitempty"`

	// model
	Model string `json:"model,omitempty"`

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

	// partition types
	PartitionTypes string `json:"partitionTypes,omitempty"`

	// path
	Path string `json:"path,omitempty"`

	// removable
	Removable bool `json:"removable,omitempty"`

	// serial
	Serial string `json:"serial,omitempty"`

	// size bytes
	SizeBytes int64 `json:"size_bytes,omitempty"`

	// smart
	Smart string `json:"smart,omitempty"`

	// vendor
	Vendor string `json:"vendor,omitempty"`

	// wwn
	Wwn string `json:"wwn,omitempty"`
}

Disk disk

swagger:model disk

func (*Disk) ContextValidate 

func (m *Disk) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this disk based on the context it is used

func (*Disk) MarshalBinary 

func (m *Disk) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Disk) UnmarshalBinary 

func (m *Disk) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Disk) Validate 

func (m *Disk) Validate(formats strfmt.Registry) error

Validate validates this disk

type DiskConfigParams 

type DiskConfigParams struct {

	// id
	// Required: true
	ID *string `json:"id"`

	// role
	Role DiskRole `json:"role,omitempty"`
}

DiskConfigParams disk config params

swagger:model disk-config-params

func (*DiskConfigParams) ContextValidate 

func (m *DiskConfigParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this disk config params based on the context it is used

func (*DiskConfigParams) MarshalBinary 

func (m *DiskConfigParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DiskConfigParams) UnmarshalBinary 

func (m *DiskConfigParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DiskConfigParams) Validate 

func (m *DiskConfigParams) Validate(formats strfmt.Registry) error

Validate validates this disk config params

type DiskEncryption 

type DiskEncryption struct {

	// Enable/disable disk encryption on master nodes, worker nodes, or all nodes.
	// Enum: [none all masters workers]
	EnableOn *string `json:"enable_on,omitempty"`

	// The disk encryption mode to use.
	// Enum: [tpmv2 tang]
	Mode *string `json:"mode,omitempty"`

	// JSON-formatted string containing additional information regarding tang's configuration
	// Example: [{\"url\":\"http://tang.example.com:7500\",\"thumbprint\":\"PLjNyRdGw03zlRoGjQYMahSZGu9\"}, {\"url\":\"http://tang.example.com:7501\",\"thumbprint\":\"PLjNyRdGw03zlRoGjQYMahSZGu8\"}]
	TangServers string `json:"tang_servers,omitempty" gorm:"type:text"`
}

DiskEncryption disk encryption

swagger:model disk-encryption

func (*DiskEncryption) ContextValidate 

func (m *DiskEncryption) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this disk encryption based on context it is used

func (*DiskEncryption) MarshalBinary 

func (m *DiskEncryption) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DiskEncryption) UnmarshalBinary 

func (m *DiskEncryption) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DiskEncryption) Validate 

func (m *DiskEncryption) Validate(formats strfmt.Registry) error

Validate validates this disk encryption

type DiskInfo 

type DiskInfo struct {

	// disk speed
	DiskSpeed *DiskSpeed `json:"disk_speed,omitempty"`

	// id
	// Format: uuid
	ID strfmt.UUID `json:"id,omitempty"`

	// path
	Path string `json:"path,omitempty"`
}

DiskInfo disk info

swagger:model disk_info

func (*DiskInfo) ContextValidate 

func (m *DiskInfo) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this disk info based on the context it is used

func (*DiskInfo) MarshalBinary 

func (m *DiskInfo) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DiskInfo) UnmarshalBinary 

func (m *DiskInfo) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DiskInfo) Validate 

func (m *DiskInfo) Validate(formats strfmt.Registry) error

Validate validates this disk info

type DiskInstallationEligibility 

type DiskInstallationEligibility struct {

	// Whether the disk is eligible for installation or not.
	Eligible bool `json:"eligible,omitempty"`

	// Reasons for why this disk is not eligible for installation.
	NotEligibleReasons []string `json:"not_eligible_reasons"`
}

DiskInstallationEligibility disk installation eligibility

swagger:model DiskInstallationEligibility

func (*DiskInstallationEligibility) ContextValidate 

func (m *DiskInstallationEligibility) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this disk installation eligibility based on context it is used

func (*DiskInstallationEligibility) MarshalBinary 

func (m *DiskInstallationEligibility) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DiskInstallationEligibility) UnmarshalBinary 

func (m *DiskInstallationEligibility) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DiskInstallationEligibility) Validate 

func (m *DiskInstallationEligibility) Validate(formats strfmt.Registry) error

Validate validates this disk installation eligibility

type DiskRole 

type DiskRole string

DiskRole disk role

swagger:model disk-role 

const (

	// DiskRoleNone captures enum value "none"
	DiskRoleNone DiskRole = "none"

	// DiskRoleInstall captures enum value "install"
	DiskRoleInstall DiskRole = "install"
)

func NewDiskRole 

func NewDiskRole(value DiskRole) *DiskRole

func (DiskRole) ContextValidate 

func (m DiskRole) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this disk role based on context it is used

func (DiskRole) Pointer 

func (m DiskRole) Pointer() *DiskRole

Pointer returns a pointer to a freshly-allocated DiskRole.

func (DiskRole) Validate 

func (m DiskRole) Validate(formats strfmt.Registry) error

Validate validates this disk role

type DiskSkipFormattingParams 

type DiskSkipFormattingParams struct {

	// The ID of the disk that is being added to or removed from the host's skip_formatting_disks list
	// Required: true
	DiskID *string `json:"disk_id"`

	// True if you wish to add the disk to the skip_formatting_disks list, false if you wish to remove it
	// Required: true
	SkipFormatting *bool `json:"skip_formatting"`
}

DiskSkipFormattingParams Allows an addition or removal of a host disk from the host's skip_formatting_disks list

swagger:model disk-skip-formatting-params

func (*DiskSkipFormattingParams) ContextValidate 

func (m *DiskSkipFormattingParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this disk skip formatting params based on context it is used

func (*DiskSkipFormattingParams) MarshalBinary 

func (m *DiskSkipFormattingParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DiskSkipFormattingParams) UnmarshalBinary 

func (m *DiskSkipFormattingParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DiskSkipFormattingParams) Validate 

func (m *DiskSkipFormattingParams) Validate(formats strfmt.Registry) error

Validate validates this disk skip formatting params

type DiskSpeed 

type DiskSpeed struct {

	// exit code
	ExitCode int64 `json:"exit_code,omitempty"`

	// speed ms
	SpeedMs int64 `json:"speed_ms,omitempty"`

	// tested
	Tested bool `json:"tested,omitempty"`
}

DiskSpeed disk speed

swagger:model disk_speed

func (*DiskSpeed) ContextValidate 

func (m *DiskSpeed) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this disk speed based on context it is used

func (*DiskSpeed) MarshalBinary 

func (m *DiskSpeed) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DiskSpeed) UnmarshalBinary 

func (m *DiskSpeed) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DiskSpeed) Validate 

func (m *DiskSpeed) Validate(formats strfmt.Registry) error

Validate validates this disk speed

type DiskSpeedCheckRequest 

type DiskSpeedCheckRequest struct {

	// --filename argument for fio (expects a file or a block device path).
	// Required: true
	Path *string `json:"path"`
}

DiskSpeedCheckRequest disk speed check request

swagger:model disk_speed_check_request

func (*DiskSpeedCheckRequest) ContextValidate 

func (m *DiskSpeedCheckRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this disk speed check request based on context it is used

func (*DiskSpeedCheckRequest) MarshalBinary 

func (m *DiskSpeedCheckRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DiskSpeedCheckRequest) UnmarshalBinary 

func (m *DiskSpeedCheckRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DiskSpeedCheckRequest) Validate 

func (m *DiskSpeedCheckRequest) Validate(formats strfmt.Registry) error

Validate validates this disk speed check request

type DiskSpeedCheckResponse 

type DiskSpeedCheckResponse struct {

	// The 99th percentile of fdatasync durations in milliseconds.
	IoSyncDuration int64 `json:"io_sync_duration,omitempty"`

	// The device path.
	Path string `json:"path,omitempty"`
}

DiskSpeedCheckResponse disk speed check response

swagger:model disk_speed_check_response

func (*DiskSpeedCheckResponse) ContextValidate 

func (m *DiskSpeedCheckResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this disk speed check response based on context it is used

func (*DiskSpeedCheckResponse) MarshalBinary 

func (m *DiskSpeedCheckResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DiskSpeedCheckResponse) UnmarshalBinary 

func (m *DiskSpeedCheckResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DiskSpeedCheckResponse) Validate 

func (m *DiskSpeedCheckResponse) Validate(formats strfmt.Registry) error

Validate validates this disk speed check response

type DomainResolutionRequest 

type DomainResolutionRequest struct {

	// domains
	// Required: true
	Domains []DomainResolutionRequestDomain `json:"domains"`
}

DomainResolutionRequest domain resolution request

swagger:model domain_resolution_request

func (*DomainResolutionRequest) ContextValidate 

func (m *DomainResolutionRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this domain resolution request based on context it is used

func (*DomainResolutionRequest) MarshalBinary 

func (m *DomainResolutionRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DomainResolutionRequest) UnmarshalBinary 

func (m *DomainResolutionRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DomainResolutionRequest) Validate 

func (m *DomainResolutionRequest) Validate(formats strfmt.Registry) error

Validate validates this domain resolution request

type DomainResolutionRequestDomain 

type DomainResolutionRequestDomain struct {

	// The domain name that should be resolved
	// Required: true
	DomainName *string `json:"domain_name"`
}

DomainResolutionRequestDomain is a struct to hold the domain resolution request domain

func (*DomainResolutionRequestDomain) ContextValidate 

func (m *DomainResolutionRequestDomain) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this domain resolution request domain based on context it is used

func (*DomainResolutionRequestDomain) MarshalBinary 

func (m *DomainResolutionRequestDomain) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DomainResolutionRequestDomain) UnmarshalBinary 

func (m *DomainResolutionRequestDomain) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DomainResolutionRequestDomain) Validate 

func (m *DomainResolutionRequestDomain) Validate(formats strfmt.Registry) error

Validate is a function required for interfaces derived from swagger models and it validates this domain resolution request domain

type DomainResolutionResponse 

type DomainResolutionResponse struct {

	// resolutions
	// Required: true
	Resolutions []*DomainResolutionResponseDomain `json:"resolutions"`
}

DomainResolutionResponse domain resolution response

swagger:model domain_resolution_response

func (*DomainResolutionResponse) ContextValidate 

func (m *DomainResolutionResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this domain resolution response based on the context it is used

func (*DomainResolutionResponse) MarshalBinary 

func (m *DomainResolutionResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DomainResolutionResponse) UnmarshalBinary 

func (m *DomainResolutionResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DomainResolutionResponse) Validate 

func (m *DomainResolutionResponse) Validate(formats strfmt.Registry) error

Validate validates this domain resolution response

type DomainResolutionResponseDomain 

type DomainResolutionResponseDomain struct {

	// The cnames that were resolved for the domain, empty if none
	Cnames []string `json:"cnames"`

	// The domain that was resolved
	// Required: true
	DomainName *string `json:"domain_name"`

	// The IPv4 addresses of the domain, empty if none
	IPV4Addresses []strfmt.IPv4 `json:"ipv4_addresses"`

	// The IPv6 addresses of the domain, empty if none
	IPV6Addresses []strfmt.IPv6 `json:"ipv6_addresses"`
}

DomainResolutionResponseDomain domain resolution response domain

swagger:model DomainResolutionResponseDomain

func (*DomainResolutionResponseDomain) ContextValidate 

func (m *DomainResolutionResponseDomain) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this domain resolution response domain based on context it is used

func (*DomainResolutionResponseDomain) MarshalBinary 

func (m *DomainResolutionResponseDomain) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DomainResolutionResponseDomain) UnmarshalBinary 

func (m *DomainResolutionResponseDomain) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DomainResolutionResponseDomain) Validate 

func (m *DomainResolutionResponseDomain) Validate(formats strfmt.Registry) error

Validate validates this domain resolution response domain

type DownloadBootArtifactsRequest 

type DownloadBootArtifactsRequest struct {

	// The base directory on the host that contains the /boot folder. The host will download boot
	// artifacts into a folder in this directory.
	// Required: true
	HostFsMountDir *string `json:"host_fs_mount_dir"`

	// URL address to download the initrd.
	// Required: true
	InitrdURL *string `json:"initrd_url"`

	// URL address to download the kernel.
	// Required: true
	KernelURL *string `json:"kernel_url"`

	// URL address to download the rootfs.
	// Required: true
	RootfsURL *string `json:"rootfs_url"`
}

DownloadBootArtifactsRequest Information sent to the agent for downloading artifacts to boot a host into discovery.

swagger:model download_boot_artifacts_request

func (*DownloadBootArtifactsRequest) ContextValidate 

func (m *DownloadBootArtifactsRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this download boot artifacts request based on context it is used

func (*DownloadBootArtifactsRequest) MarshalBinary 

func (m *DownloadBootArtifactsRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DownloadBootArtifactsRequest) UnmarshalBinary 

func (m *DownloadBootArtifactsRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DownloadBootArtifactsRequest) Validate 

func (m *DownloadBootArtifactsRequest) Validate(formats strfmt.Registry) error

Validate validates this download boot artifacts request

type DriveType 

type DriveType string

DriveType drive type

swagger:model drive_type 

const (

	// DriveTypeUnknown captures enum value "Unknown"
	DriveTypeUnknown DriveType = "Unknown"

	// DriveTypeHDD captures enum value "HDD"
	DriveTypeHDD DriveType = "HDD"

	// DriveTypeFDD captures enum value "FDD"
	DriveTypeFDD DriveType = "FDD"

	// DriveTypeODD captures enum value "ODD"
	DriveTypeODD DriveType = "ODD"

	// DriveTypeSSD captures enum value "SSD"
	DriveTypeSSD DriveType = "SSD"

	// DriveTypeVirtual captures enum value "virtual"
	DriveTypeVirtual DriveType = "virtual"

	// DriveTypeMultipath captures enum value "Multipath"
	DriveTypeMultipath DriveType = "Multipath"

	// DriveTypeISCSI captures enum value "iSCSI"
	DriveTypeISCSI DriveType = "iSCSI"

	// DriveTypeFC captures enum value "FC"
	DriveTypeFC DriveType = "FC"

	// DriveTypeLVM captures enum value "LVM"
	DriveTypeLVM DriveType = "LVM"

	// DriveTypeRAID captures enum value "RAID"
	DriveTypeRAID DriveType = "RAID"

	// DriveTypeECKD captures enum value "ECKD"
	DriveTypeECKD DriveType = "ECKD"

	// DriveTypeECKDESE captures enum value "ECKD (ESE)"
	DriveTypeECKDESE DriveType = "ECKD (ESE)"

	// DriveTypeFBA captures enum value "FBA"
	DriveTypeFBA DriveType = "FBA"
)

func NewDriveType 

func NewDriveType(value DriveType) *DriveType

func (DriveType) ContextValidate 

func (m DriveType) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this drive type based on context it is used

func (DriveType) Pointer 

func (m DriveType) Pointer() *DriveType

Pointer returns a pointer to a freshly-allocated DriveType.

func (DriveType) Validate 

func (m DriveType) Validate(formats strfmt.Registry) error

Validate validates this drive type

type Error 

type Error struct {

	// Globally unique code of the error, composed of the unique identifier of the API and the numeric identifier of the error. For example, if the numeric identifier of the error is 93 and the identifier of the API is assisted_install then the code will be ASSISTED-INSTALL-93.
	// Required: true
	Code *string `json:"code"`

	// Self link.
	// Required: true
	Href *string `json:"href"`

	// Numeric identifier of the error.
	// Required: true
	// Maximum: 504
	// Minimum: 400
	ID *int32 `json:"id"`

	// Indicates the type of this object. Will always be 'Error'.
	// Required: true
	// Enum: [Error]
	Kind *string `json:"kind"`

	// Human-readable description of the error.
	// Required: true
	Reason *string `json:"reason"`
}

Error error

swagger:model error

func (*Error) ContextValidate 

func (m *Error) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this error based on context it is used

func (*Error) MarshalBinary 

func (m *Error) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Error) UnmarshalBinary 

func (m *Error) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Error) Validate 

func (m *Error) Validate(formats strfmt.Registry) error

Validate validates this error

type Event 

type Event struct {

	// category
	// Enum: [user metrics]
	Category string `json:"category,omitempty" gorm:"default:'user'"`

	// Unique identifier of the cluster this event relates to.
	// Format: uuid
	ClusterID *strfmt.UUID `json:"cluster_id,omitempty" gorm:"index"`

	// event time
	// Required: true
	// Format: date-time
	EventTime *strfmt.DateTime `json:"event_time" gorm:"type:timestamp with time zone"`

	// Unique identifier of the host this event relates to.
	// Format: uuid
	HostID *strfmt.UUID `json:"host_id,omitempty" gorm:"index"`

	// Unique identifier of the infra-env this event relates to.
	// Format: uuid
	InfraEnvID *strfmt.UUID `json:"infra_env_id,omitempty" gorm:"index"`

	// message
	// Required: true
	Message *string `json:"message" gorm:"type:varchar(4096)"`

	// Event Name.
	Name string `json:"name,omitempty"`

	// Additional properties for the event in JSON format.
	Props string `json:"props,omitempty" gorm:"type:text"`

	// Unique identifier of the request that caused this event to occur.
	// Format: uuid
	RequestID strfmt.UUID `json:"request_id,omitempty"`

	// severity
	// Required: true
	// Enum: [info warning error critical]
	Severity *string `json:"severity"`
}

Event event

swagger:model event

func (*Event) ContextValidate 

func (m *Event) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this event based on context it is used

func (*Event) MarshalBinary 

func (m *Event) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Event) UnmarshalBinary 

func (m *Event) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Event) Validate 

func (m *Event) Validate(formats strfmt.Registry) error

Validate validates this event

type EventList 

type EventList []*Event

EventList event list

swagger:model event-list

func (EventList) ContextValidate 

func (m EventList) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this event list based on the context it is used

func (EventList) Validate 

func (m EventList) Validate(formats strfmt.Registry) error

Validate validates this event list

type FeatureSupportLevelID 

type FeatureSupportLevelID string

FeatureSupportLevelID feature support level id

swagger:model feature-support-level-id 

const (

	// FeatureSupportLevelIDSNO captures enum value "SNO"
	FeatureSupportLevelIDSNO FeatureSupportLevelID = "SNO"

	// FeatureSupportLevelIDVIPAUTOALLOC captures enum value "VIP_AUTO_ALLOC"
	FeatureSupportLevelIDVIPAUTOALLOC FeatureSupportLevelID = "VIP_AUTO_ALLOC"

	// FeatureSupportLevelIDCUSTOMMANIFEST captures enum value "CUSTOM_MANIFEST"
	FeatureSupportLevelIDCUSTOMMANIFEST FeatureSupportLevelID = "CUSTOM_MANIFEST"

	// FeatureSupportLevelIDSINGLENODEEXPANSION captures enum value "SINGLE_NODE_EXPANSION"
	FeatureSupportLevelIDSINGLENODEEXPANSION FeatureSupportLevelID = "SINGLE_NODE_EXPANSION"

	// FeatureSupportLevelIDLVM captures enum value "LVM"
	FeatureSupportLevelIDLVM FeatureSupportLevelID = "LVM"

	// FeatureSupportLevelIDODF captures enum value "ODF"
	FeatureSupportLevelIDODF FeatureSupportLevelID = "ODF"

	// FeatureSupportLevelIDLSO captures enum value "LSO"
	FeatureSupportLevelIDLSO FeatureSupportLevelID = "LSO"

	// FeatureSupportLevelIDCNV captures enum value "CNV"
	FeatureSupportLevelIDCNV FeatureSupportLevelID = "CNV"

	// FeatureSupportLevelIDMCE captures enum value "MCE"
	FeatureSupportLevelIDMCE FeatureSupportLevelID = "MCE"

	// FeatureSupportLevelIDNUTANIXINTEGRATION captures enum value "NUTANIX_INTEGRATION"
	FeatureSupportLevelIDNUTANIXINTEGRATION FeatureSupportLevelID = "NUTANIX_INTEGRATION"

	// FeatureSupportLevelIDBAREMETALPLATFORM captures enum value "BAREMETAL_PLATFORM"
	FeatureSupportLevelIDBAREMETALPLATFORM FeatureSupportLevelID = "BAREMETAL_PLATFORM"

	// FeatureSupportLevelIDNONEPLATFORM captures enum value "NONE_PLATFORM"
	FeatureSupportLevelIDNONEPLATFORM FeatureSupportLevelID = "NONE_PLATFORM"

	// FeatureSupportLevelIDVSPHEREINTEGRATION captures enum value "VSPHERE_INTEGRATION"
	FeatureSupportLevelIDVSPHEREINTEGRATION FeatureSupportLevelID = "VSPHERE_INTEGRATION"

	// FeatureSupportLevelIDDUALSTACKVIPS captures enum value "DUAL_STACK_VIPS"
	FeatureSupportLevelIDDUALSTACKVIPS FeatureSupportLevelID = "DUAL_STACK_VIPS"

	// FeatureSupportLevelIDCLUSTERMANAGEDNETWORKING captures enum value "CLUSTER_MANAGED_NETWORKING"
	FeatureSupportLevelIDCLUSTERMANAGEDNETWORKING FeatureSupportLevelID = "CLUSTER_MANAGED_NETWORKING"

	// FeatureSupportLevelIDUSERMANAGEDNETWORKING captures enum value "USER_MANAGED_NETWORKING"
	FeatureSupportLevelIDUSERMANAGEDNETWORKING FeatureSupportLevelID = "USER_MANAGED_NETWORKING"

	// FeatureSupportLevelIDMINIMALISO captures enum value "MINIMAL_ISO"
	FeatureSupportLevelIDMINIMALISO FeatureSupportLevelID = "MINIMAL_ISO"

	// FeatureSupportLevelIDFULLISO captures enum value "FULL_ISO"
	FeatureSupportLevelIDFULLISO FeatureSupportLevelID = "FULL_ISO"

	// FeatureSupportLevelIDEXTERNALPLATFORMOCI captures enum value "EXTERNAL_PLATFORM_OCI"
	FeatureSupportLevelIDEXTERNALPLATFORMOCI FeatureSupportLevelID = "EXTERNAL_PLATFORM_OCI"

	// FeatureSupportLevelIDDUALSTACK captures enum value "DUAL_STACK"
	FeatureSupportLevelIDDUALSTACK FeatureSupportLevelID = "DUAL_STACK"

	// FeatureSupportLevelIDPLATFORMMANAGEDNETWORKING captures enum value "PLATFORM_MANAGED_NETWORKING"
	FeatureSupportLevelIDPLATFORMMANAGEDNETWORKING FeatureSupportLevelID = "PLATFORM_MANAGED_NETWORKING"

	// FeatureSupportLevelIDSKIPMCOREBOOT captures enum value "SKIP_MCO_REBOOT"
	FeatureSupportLevelIDSKIPMCOREBOOT FeatureSupportLevelID = "SKIP_MCO_REBOOT"

	// FeatureSupportLevelIDEXTERNALPLATFORM captures enum value "EXTERNAL_PLATFORM"
	FeatureSupportLevelIDEXTERNALPLATFORM FeatureSupportLevelID = "EXTERNAL_PLATFORM"

	// FeatureSupportLevelIDOVNNETWORKTYPE captures enum value "OVN_NETWORK_TYPE"
	FeatureSupportLevelIDOVNNETWORKTYPE FeatureSupportLevelID = "OVN_NETWORK_TYPE"

	// FeatureSupportLevelIDSDNNETWORKTYPE captures enum value "SDN_NETWORK_TYPE"
	FeatureSupportLevelIDSDNNETWORKTYPE FeatureSupportLevelID = "SDN_NETWORK_TYPE"
)

func NewFeatureSupportLevelID 

func NewFeatureSupportLevelID(value FeatureSupportLevelID) *FeatureSupportLevelID

func (FeatureSupportLevelID) ContextValidate 

func (m FeatureSupportLevelID) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this feature support level id based on context it is used

func (FeatureSupportLevelID) Pointer 

func (m FeatureSupportLevelID) Pointer() *FeatureSupportLevelID

Pointer returns a pointer to a freshly-allocated FeatureSupportLevelID.

func (FeatureSupportLevelID) Validate 

func (m FeatureSupportLevelID) Validate(formats strfmt.Registry) error

Validate validates this feature support level id

type FinalizingStage 

type FinalizingStage string

FinalizingStage Cluster finalizing stage managed by controller

swagger:model finalizing-stage 

const (

	// FinalizingStageWaitingForClusterOperators captures enum value "Waiting for cluster operators"
	FinalizingStageWaitingForClusterOperators FinalizingStage = "Waiting for cluster operators"

	// FinalizingStageAddingRouterCa captures enum value "Adding router ca"
	FinalizingStageAddingRouterCa FinalizingStage = "Adding router ca"

	// FinalizingStageApplyingOlmManifests captures enum value "Applying olm manifests"
	FinalizingStageApplyingOlmManifests FinalizingStage = "Applying olm manifests"

	// FinalizingStageWaitingForOlmOperatorsCsvInitialization captures enum value "Waiting for olm operators csv initialization"
	FinalizingStageWaitingForOlmOperatorsCsvInitialization FinalizingStage = "Waiting for olm operators csv initialization"

	// FinalizingStageWaitingForOlmOperatorsCsv captures enum value "Waiting for olm operators csv"
	FinalizingStageWaitingForOlmOperatorsCsv FinalizingStage = "Waiting for olm operators csv"

	// FinalizingStageDone captures enum value "Done"
	FinalizingStageDone FinalizingStage = "Done"
)

func NewFinalizingStage 

func NewFinalizingStage(value FinalizingStage) *FinalizingStage

func (FinalizingStage) ContextValidate 

func (m FinalizingStage) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this finalizing stage based on context it is used

func (FinalizingStage) Pointer 

func (m FinalizingStage) Pointer() *FinalizingStage

Pointer returns a pointer to a freshly-allocated FinalizingStage.

func (FinalizingStage) Validate 

func (m FinalizingStage) Validate(formats strfmt.Registry) error

Validate validates this finalizing stage

type FreeAddressesList 

type FreeAddressesList []strfmt.IPv4

FreeAddressesList free addresses list

swagger:model free-addresses-list

func (FreeAddressesList) ContextValidate 

func (m FreeAddressesList) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this free addresses list based on context it is used

func (FreeAddressesList) Validate 

func (m FreeAddressesList) Validate(formats strfmt.Registry) error

Validate validates this free addresses list

type FreeAddressesRequest 

type FreeAddressesRequest []string

FreeAddressesRequest free addresses request

swagger:model free_addresses_request

func (FreeAddressesRequest) ContextValidate 

func (m FreeAddressesRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this free addresses request based on context it is used

func (FreeAddressesRequest) Validate 

func (m FreeAddressesRequest) Validate(formats strfmt.Registry) error

Validate validates this free addresses request

type FreeNetworkAddresses 

type FreeNetworkAddresses struct {

	// free addresses
	FreeAddresses []strfmt.IPv4 `json:"free_addresses"`

	// network
	// Pattern: ^([0-9]{1,3}\.){3}[0-9]{1,3}\/[0-9]|[1-2][0-9]|3[0-2]?$
	Network string `json:"network,omitempty"`
}

FreeNetworkAddresses free network addresses

swagger:model free_network_addresses

func (*FreeNetworkAddresses) ContextValidate 

func (m *FreeNetworkAddresses) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this free network addresses based on context it is used

func (*FreeNetworkAddresses) MarshalBinary 

func (m *FreeNetworkAddresses) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*FreeNetworkAddresses) UnmarshalBinary 

func (m *FreeNetworkAddresses) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*FreeNetworkAddresses) Validate 

func (m *FreeNetworkAddresses) Validate(formats strfmt.Registry) error

Validate validates this free network addresses

type FreeNetworksAddresses 

type FreeNetworksAddresses []*FreeNetworkAddresses

FreeNetworksAddresses free networks addresses

swagger:model free_networks_addresses

func (FreeNetworksAddresses) ContextValidate 

func (m FreeNetworksAddresses) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this free networks addresses based on the context it is used

func (FreeNetworksAddresses) Validate 

func (m FreeNetworksAddresses) Validate(formats strfmt.Registry) error

Validate validates this free networks addresses

type Gpu 

type Gpu struct {

	// Device address (for example "0000:00:02.0")
	Address string `json:"address,omitempty"`

	// ID of the device (for example "3ea0")
	DeviceID string `json:"device_id,omitempty"`

	// Product name of the device (for example "UHD Graphics 620 (Whiskey Lake)")
	Name string `json:"name,omitempty"`

	// The name of the device vendor (for example "Intel Corporation")
	Vendor string `json:"vendor,omitempty"`

	// ID of the vendor (for example "8086")
	VendorID string `json:"vendor_id,omitempty"`
}

Gpu gpu

swagger:model gpu

func (*Gpu) ContextValidate 

func (m *Gpu) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this gpu based on context it is used

func (*Gpu) MarshalBinary 

func (m *Gpu) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Gpu) UnmarshalBinary 

func (m *Gpu) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Gpu) Validate 

func (m *Gpu) Validate(formats strfmt.Registry) error

Validate validates this gpu

type Host 

type Host struct {

	// Contains a serialized api_vip_connectivity_response
	APIVipConnectivity string `json:"api_vip_connectivity,omitempty" gorm:"type:text"`

	// bootstrap
	Bootstrap bool `json:"bootstrap,omitempty"`

	// The last time the host's agent communicated with the service.
	// Format: date-time
	CheckedInAt strfmt.DateTime `json:"checked_in_at,omitempty" gorm:"type:timestamp with time zone"`

	// The cluster that this host is associated with.
	// Format: uuid
	ClusterID *strfmt.UUID `json:"cluster_id,omitempty" gorm:"foreignkey:Cluster"`

	// Indicate that connection to assisted service was timed out when soft timeout is enabled.
	ConnectionTimedOut bool `json:"connection_timed_out,omitempty"`

	// connectivity
	Connectivity string `json:"connectivity,omitempty" gorm:"type:text"`

	// created at
	// Format: date-time
	CreatedAt timeext.Time `json:"created_at,omitempty" gorm:"type:timestamp with time zone"`

	// swagger:ignore
	DeletedAt gorm.DeletedAt `json:"deleted_at,omitempty" gorm:"type:timestamp with time zone;index"`

	// discovery agent version
	DiscoveryAgentVersion string `json:"discovery_agent_version,omitempty"`

	// Additional information about disks, formatted as JSON.
	DisksInfo string `json:"disks_info,omitempty" gorm:"type:text"`

	// A comma-separated list of disks that will be formatted once
	// installation begins, unless otherwise set to be skipped by
	// skip_formatting_disks. This means that this list also includes disks
	// that appear in skip_formatting_disks. This property is managed by the
	// service and cannot be modified by the user.
	DisksToBeFormatted string `json:"disks_to_be_formatted,omitempty" gorm:"type:text"`

	// The domain name resolution result.
	DomainNameResolutions string `json:"domain_name_resolutions,omitempty" gorm:"type:text"`

	// free addresses
	FreeAddresses string `json:"free_addresses,omitempty" gorm:"type:text"`

	// Self link.
	// Required: true
	Href *string `json:"href"`

	// Unique identifier of the object.
	// Required: true
	// Format: uuid
	ID *strfmt.UUID `json:"id" gorm:"primaryKey"`

	// Json formatted string containing the user overrides for the host's pointer ignition
	// Example: {\"ignition\": {\"version\": \"3.1.0\"}, \"storage\": {\"files\": [{\"path\": \"/tmp/example\", \"contents\": {\"source\": \"data:text/plain;base64,aGVscGltdHJhcHBlZGluYXN3YWdnZXJzcGVj\"}}]}}
	IgnitionConfigOverrides string `json:"ignition_config_overrides,omitempty" gorm:"type:text"`

	// True if the token to fetch the ignition from ignition_endpoint_url is set.
	IgnitionEndpointTokenSet bool `json:"ignition_endpoint_token_set,omitempty"`

	// Array of image statuses.
	ImagesStatus string `json:"images_status,omitempty" gorm:"type:text"`

	// The infra-env that this host is associated with.
	// Format: uuid
	InfraEnvID strfmt.UUID `json:"infra_env_id,omitempty" gorm:"primaryKey;foreignkey:InfraEnvID"`

	// Contains the inventory disk id to install on.
	InstallationDiskID string `json:"installation_disk_id,omitempty"`

	// Contains the inventory disk path, This field is replaced by installation_disk_id field and used for backward compatability with the old UI.
	// Example: /dev/sda
	InstallationDiskPath string `json:"installation_disk_path,omitempty"`

	// installer args
	InstallerArgs string `json:"installer_args,omitempty"`

	// Installer version.
	InstallerVersion string `json:"installer_version,omitempty"`

	// inventory
	Inventory string `json:"inventory,omitempty" gorm:"type:text"`

	// Indicates the type of this object. Will be 'Host' if this is a complete object or 'HostLink' if it is just a link, or
	// 'AddToExistingClusterHost' for host being added to existing OCP cluster, or
	//
	// Required: true
	// Enum: [Host AddToExistingClusterHost]
	Kind *string `json:"kind"`

	// logs collected at
	// Format: date-time
	LogsCollectedAt strfmt.DateTime `json:"logs_collected_at,omitempty" gorm:"type:timestamp with time zone"`

	// The progress of log collection or empty if logs are not applicable
	LogsInfo LogsState `json:"logs_info,omitempty" gorm:"type:varchar(2048)"`

	// logs started at
	// Format: date-time
	LogsStartedAt strfmt.DateTime `json:"logs_started_at,omitempty" gorm:"type:timestamp with time zone"`

	// machine config pool name
	MachineConfigPoolName string `json:"machine_config_pool_name,omitempty"`

	// media status
	// Enum: [connected disconnected]
	MediaStatus *string `json:"media_status,omitempty"`

	// Json containing node's labels.
	NodeLabels string `json:"node_labels,omitempty" gorm:"type:text"`

	// The configured NTP sources on the host.
	NtpSources string `json:"ntp_sources,omitempty" gorm:"type:text"`

	// progress
	Progress *HostProgressInfo `json:"progress,omitempty" gorm:"embedded;embeddedPrefix:progress_"`

	// progress stages
	ProgressStages []HostStage `json:"progress_stages" gorm:"-"`

	// The last time the host's agent tried to register in the service.
	// Format: date-time
	RegisteredAt strfmt.DateTime `json:"registered_at,omitempty" gorm:"type:timestamp with time zone"`

	// requested hostname
	RequestedHostname string `json:"requested_hostname,omitempty"`

	// role
	Role HostRole `json:"role,omitempty"`

	// A comma-seperated list of host disks that the service will avoid
	// formatting.
	SkipFormattingDisks string `json:"skip_formatting_disks,omitempty" gorm:"type:text"`

	// Time at which the current progress stage started.
	// Format: date-time
	StageStartedAt strfmt.DateTime `json:"stage_started_at,omitempty" gorm:"type:timestamp with time zone"`

	// Time at which the current progress stage was last updated.
	// Format: date-time
	StageUpdatedAt strfmt.DateTime `json:"stage_updated_at,omitempty" gorm:"type:timestamp with time zone"`

	// status
	// Required: true
	// Enum: [discovering known disconnected insufficient disabled preparing-for-installation preparing-failed preparing-successful pending-for-input installing installing-in-progress installing-pending-user-action resetting-pending-user-action installed error resetting added-to-existing-cluster cancelled binding unbinding unbinding-pending-user-action known-unbound disconnected-unbound insufficient-unbound disabled-unbound discovering-unbound reclaiming reclaiming-rebooting]
	Status *string `json:"status"`

	// status info
	// Required: true
	StatusInfo *string `json:"status_info" gorm:"type:varchar(2048)"`

	// The last time that the host status was updated.
	// Format: date-time
	StatusUpdatedAt strfmt.DateTime `json:"status_updated_at,omitempty" gorm:"type:timestamp with time zone"`

	// suggested role
	SuggestedRole HostRole `json:"suggested_role,omitempty"`

	// tang connectivity
	TangConnectivity string `json:"tang_connectivity,omitempty" gorm:"type:text"`

	// The time on the host as seconds since the Unix epoch.
	Timestamp int64 `json:"timestamp,omitempty"`

	// updated at
	// Format: date-time
	UpdatedAt timeext.Time `json:"updated_at,omitempty" gorm:"type:timestamp with time zone"`

	// user name
	UserName string `json:"user_name,omitempty"`

	// JSON-formatted string containing the validation results for each validation id grouped by category (network, hardware, etc.)
	ValidationsInfo string `json:"validations_info,omitempty" gorm:"type:text"`
}

Host host

swagger:model host

func (*Host) ContextValidate 

func (m *Host) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this host based on the context it is used

func (*Host) MarshalBinary 

func (m *Host) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Host) UnmarshalBinary 

func (m *Host) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Host) Validate 

func (m *Host) Validate(formats strfmt.Registry) error

Validate validates this host

type HostCreateParams 

type HostCreateParams struct {

	// discovery agent version
	DiscoveryAgentVersion string `json:"discovery_agent_version,omitempty"`

	// host id
	// Required: true
	// Format: uuid
	HostID *strfmt.UUID `json:"host_id"`
}

HostCreateParams host create params

swagger:model host-create-params

func (*HostCreateParams) ContextValidate 

func (m *HostCreateParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this host create params based on context it is used

func (*HostCreateParams) MarshalBinary 

func (m *HostCreateParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HostCreateParams) UnmarshalBinary 

func (m *HostCreateParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HostCreateParams) Validate 

func (m *HostCreateParams) Validate(formats strfmt.Registry) error

Validate validates this host create params

type HostIgnitionParams 

type HostIgnitionParams struct {

	// config
	Config string `json:"config,omitempty"`
}

HostIgnitionParams host ignition params

swagger:model host-ignition-params

func (*HostIgnitionParams) ContextValidate 

func (m *HostIgnitionParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this host ignition params based on context it is used

func (*HostIgnitionParams) MarshalBinary 

func (m *HostIgnitionParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HostIgnitionParams) UnmarshalBinary 

func (m *HostIgnitionParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HostIgnitionParams) Validate 

func (m *HostIgnitionParams) Validate(formats strfmt.Registry) error

Validate validates this host ignition params

type HostList 

type HostList []*Host

HostList host list

swagger:model host-list

func (HostList) ContextValidate 

func (m HostList) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this host list based on the context it is used

func (HostList) Validate 

func (m HostList) Validate(formats strfmt.Registry) error

Validate validates this host list

type HostNetwork 

type HostNetwork struct {

	// cidr
	Cidr string `json:"cidr,omitempty"`

	// host ids
	HostIds []strfmt.UUID `json:"host_ids"`
}

HostNetwork host network

swagger:model host_network

func (*HostNetwork) ContextValidate 

func (m *HostNetwork) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this host network based on context it is used

func (*HostNetwork) MarshalBinary 

func (m *HostNetwork) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HostNetwork) UnmarshalBinary 

func (m *HostNetwork) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HostNetwork) Validate 

func (m *HostNetwork) Validate(formats strfmt.Registry) error

Validate validates this host network

type HostProgress 

type HostProgress struct {

	// current stage
	CurrentStage HostStage `json:"current_stage,omitempty"`

	// progress info
	ProgressInfo string `json:"progress_info,omitempty" gorm:"type:varchar(2048)"`
}

HostProgress host progress

swagger:model host-progress

func (*HostProgress) ContextValidate 

func (m *HostProgress) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this host progress based on the context it is used

func (*HostProgress) MarshalBinary 

func (m *HostProgress) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HostProgress) UnmarshalBinary 

func (m *HostProgress) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HostProgress) Validate 

func (m *HostProgress) Validate(formats strfmt.Registry) error

Validate validates this host progress

type HostProgressInfo 

type HostProgressInfo struct {

	// current stage
	CurrentStage HostStage `json:"current_stage,omitempty"`

	// installation percentage
	InstallationPercentage int64 `json:"installation_percentage,omitempty"`

	// progress info
	ProgressInfo string `json:"progress_info,omitempty" gorm:"type:varchar(2048)"`

	// Time at which the current progress stage started.
	// Format: date-time
	StageStartedAt strfmt.DateTime `json:"stage_started_at,omitempty" gorm:"type:timestamp with time zone"`

	// Indicate of the current stage has been timed out.
	StageTimedOut bool `json:"stage_timed_out,omitempty"`

	// Time at which the current progress stage was last updated.
	// Format: date-time
	StageUpdatedAt strfmt.DateTime `json:"stage_updated_at,omitempty" gorm:"type:timestamp with time zone"`
}

HostProgressInfo host progress info

swagger:model host-progress-info

func (*HostProgressInfo) ContextValidate 

func (m *HostProgressInfo) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this host progress info based on the context it is used

func (*HostProgressInfo) MarshalBinary 

func (m *HostProgressInfo) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HostProgressInfo) UnmarshalBinary 

func (m *HostProgressInfo) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HostProgressInfo) Validate 

func (m *HostProgressInfo) Validate(formats strfmt.Registry) error

Validate validates this host progress info

type HostRegistrationResponse 

type HostRegistrationResponse struct {
	Host

	// next step runner command
	NextStepRunnerCommand *HostRegistrationResponseAO1NextStepRunnerCommand `json:"next_step_runner_command,omitempty"`
}

HostRegistrationResponse host registration response

swagger:model host_registration_response

func (*HostRegistrationResponse) ContextValidate 

func (m *HostRegistrationResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this host registration response based on the context it is used

func (*HostRegistrationResponse) MarshalBinary 

func (m *HostRegistrationResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (HostRegistrationResponse) MarshalJSON 

func (m HostRegistrationResponse) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object to a JSON structure

func (*HostRegistrationResponse) UnmarshalBinary 

func (m *HostRegistrationResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HostRegistrationResponse) UnmarshalJSON 

func (m *HostRegistrationResponse) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object from a JSON structure

func (*HostRegistrationResponse) Validate 

func (m *HostRegistrationResponse) Validate(formats strfmt.Registry) error

Validate validates this host registration response

type HostRegistrationResponseAO1NextStepRunnerCommand 

type HostRegistrationResponseAO1NextStepRunnerCommand struct {

	// args
	Args []string `json:"args"`

	// command
	Command string `json:"command,omitempty"`

	// How long in seconds to wait before retrying registration if the command fails
	RetrySeconds int64 `json:"retry_seconds,omitempty"`
}

HostRegistrationResponseAO1NextStepRunnerCommand Command for starting the next step runner

swagger:model HostRegistrationResponseAO1NextStepRunnerCommand

func (*HostRegistrationResponseAO1NextStepRunnerCommand) ContextValidate 

func (m *HostRegistrationResponseAO1NextStepRunnerCommand) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this host registration response a o1 next step runner command based on context it is used

func (*HostRegistrationResponseAO1NextStepRunnerCommand) MarshalBinary 

func (m *HostRegistrationResponseAO1NextStepRunnerCommand) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HostRegistrationResponseAO1NextStepRunnerCommand) UnmarshalBinary 

func (m *HostRegistrationResponseAO1NextStepRunnerCommand) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HostRegistrationResponseAO1NextStepRunnerCommand) Validate 

func (m *HostRegistrationResponseAO1NextStepRunnerCommand) Validate(formats strfmt.Registry) error

Validate validates this host registration response a o1 next step runner command

type HostRole 

type HostRole string

HostRole host role

swagger:model host-role 

const (

	// HostRoleAutoAssign captures enum value "auto-assign"
	HostRoleAutoAssign HostRole = "auto-assign"

	// HostRoleMaster captures enum value "master"
	HostRoleMaster HostRole = "master"

	// HostRoleWorker captures enum value "worker"
	HostRoleWorker HostRole = "worker"

	// HostRoleBootstrap captures enum value "bootstrap"
	HostRoleBootstrap HostRole = "bootstrap"
)

func NewHostRole 

func NewHostRole(value HostRole) *HostRole

func (HostRole) ContextValidate 

func (m HostRole) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this host role based on context it is used

func (HostRole) Pointer 

func (m HostRole) Pointer() *HostRole

Pointer returns a pointer to a freshly-allocated HostRole.

func (HostRole) Validate 

func (m HostRole) Validate(formats strfmt.Registry) error

Validate validates this host role

type HostRoleUpdateParams 

type HostRoleUpdateParams string

HostRoleUpdateParams host role update params

swagger:model host-role-update-params 

const (

	// HostRoleUpdateParamsAutoAssign captures enum value "auto-assign"
	HostRoleUpdateParamsAutoAssign HostRoleUpdateParams = "auto-assign"

	// HostRoleUpdateParamsMaster captures enum value "master"
	HostRoleUpdateParamsMaster HostRoleUpdateParams = "master"

	// HostRoleUpdateParamsWorker captures enum value "worker"
	HostRoleUpdateParamsWorker HostRoleUpdateParams = "worker"
)

func NewHostRoleUpdateParams 

func NewHostRoleUpdateParams(value HostRoleUpdateParams) *HostRoleUpdateParams

func (HostRoleUpdateParams) ContextValidate 

func (m HostRoleUpdateParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this host role update params based on context it is used

func (HostRoleUpdateParams) Pointer 

func (m HostRoleUpdateParams) Pointer() *HostRoleUpdateParams

Pointer returns a pointer to a freshly-allocated HostRoleUpdateParams.

func (HostRoleUpdateParams) Validate 

func (m HostRoleUpdateParams) Validate(formats strfmt.Registry) error

Validate validates this host role update params

type HostStage 

type HostStage string

HostStage host stage

swagger:model host-stage 

const (

	// HostStageStartingInstallation captures enum value "Starting installation"
	HostStageStartingInstallation HostStage = "Starting installation"

	// HostStageWaitingForControlPlane captures enum value "Waiting for control plane"
	HostStageWaitingForControlPlane HostStage = "Waiting for control plane"

	// HostStageWaitingForBootkube captures enum value "Waiting for bootkube"
	HostStageWaitingForBootkube HostStage = "Waiting for bootkube"

	// HostStageWaitingForController captures enum value "Waiting for controller"
	HostStageWaitingForController HostStage = "Waiting for controller"

	// HostStageInstalling captures enum value "Installing"
	HostStageInstalling HostStage = "Installing"

	// HostStageWritingImageToDisk captures enum value "Writing image to disk"
	HostStageWritingImageToDisk HostStage = "Writing image to disk"

	// HostStageRebooting captures enum value "Rebooting"
	HostStageRebooting HostStage = "Rebooting"

	// HostStageWaitingForIgnition captures enum value "Waiting for ignition"
	HostStageWaitingForIgnition HostStage = "Waiting for ignition"

	// HostStageConfiguring captures enum value "Configuring"
	HostStageConfiguring HostStage = "Configuring"

	// HostStageJoined captures enum value "Joined"
	HostStageJoined HostStage = "Joined"

	// HostStageDone captures enum value "Done"
	HostStageDone HostStage = "Done"

	// HostStageFailed captures enum value "Failed"
	HostStageFailed HostStage = "Failed"
)

func NewHostStage 

func NewHostStage(value HostStage) *HostStage

func (HostStage) ContextValidate 

func (m HostStage) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this host stage based on context it is used

func (HostStage) Pointer 

func (m HostStage) Pointer() *HostStage

Pointer returns a pointer to a freshly-allocated HostStage.

func (HostStage) Validate 

func (m HostStage) Validate(formats strfmt.Registry) error

Validate validates this host stage

type HostStaticNetworkConfig 

type HostStaticNetworkConfig struct {

	// mapping of host macs to logical interfaces used in the network yaml
	MacInterfaceMap MacInterfaceMap `json:"mac_interface_map,omitempty"`

	// yaml string that can be processed by nmstate
	NetworkYaml string `json:"network_yaml,omitempty"`
}

HostStaticNetworkConfig host static network config

swagger:model host_static_network_config

func (*HostStaticNetworkConfig) ContextValidate 

func (m *HostStaticNetworkConfig) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this host static network config based on the context it is used

func (*HostStaticNetworkConfig) MarshalBinary 

func (m *HostStaticNetworkConfig) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HostStaticNetworkConfig) UnmarshalBinary 

func (m *HostStaticNetworkConfig) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HostStaticNetworkConfig) Validate 

func (m *HostStaticNetworkConfig) Validate(formats strfmt.Registry) error

Validate validates this host static network config

type HostTypeHardwareRequirements 

type HostTypeHardwareRequirements struct {

	// Host requirements that cannot be quantified at the time of calculation. Descriptions or formulas of requiements
	Qualitative []string `json:"qualitative"`

	// Host requirements that can be quantified
	Quantitative *ClusterHostRequirementsDetails `json:"quantitative,omitempty"`
}

HostTypeHardwareRequirements host type hardware requirements

swagger:model host-type-hardware-requirements

func (*HostTypeHardwareRequirements) ContextValidate 

func (m *HostTypeHardwareRequirements) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this host type hardware requirements based on the context it is used

func (*HostTypeHardwareRequirements) MarshalBinary 

func (m *HostTypeHardwareRequirements) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HostTypeHardwareRequirements) UnmarshalBinary 

func (m *HostTypeHardwareRequirements) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HostTypeHardwareRequirements) Validate 

func (m *HostTypeHardwareRequirements) Validate(formats strfmt.Registry) error

Validate validates this host type hardware requirements

type HostTypeHardwareRequirementsWrapper 

type HostTypeHardwareRequirementsWrapper struct {

	// Requirements towards a master node
	Master *HostTypeHardwareRequirements `json:"master,omitempty"`

	// Requirements towards a worker node
	Worker *HostTypeHardwareRequirements `json:"worker,omitempty"`
}

HostTypeHardwareRequirementsWrapper host type hardware requirements wrapper

swagger:model host-type-hardware-requirements-wrapper

func (*HostTypeHardwareRequirementsWrapper) ContextValidate 

func (m *HostTypeHardwareRequirementsWrapper) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this host type hardware requirements wrapper based on the context it is used

func (*HostTypeHardwareRequirementsWrapper) MarshalBinary 

func (m *HostTypeHardwareRequirementsWrapper) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HostTypeHardwareRequirementsWrapper) UnmarshalBinary 

func (m *HostTypeHardwareRequirementsWrapper) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HostTypeHardwareRequirementsWrapper) Validate 

func (m *HostTypeHardwareRequirementsWrapper) Validate(formats strfmt.Registry) error

Validate validates this host type hardware requirements wrapper

type HostUpdateParams 

type HostUpdateParams struct {

	// disks selected config
	DisksSelectedConfig []*DiskConfigParams `json:"disks_selected_config"`

	// Allows changing the host's skip_formatting_disks parameter
	DisksSkipFormatting []*DiskSkipFormattingParams `json:"disks_skip_formatting"`

	// host name
	HostName *string `json:"host_name,omitempty"`

	// host role
	// Enum: [auto-assign master worker]
	HostRole *string `json:"host_role,omitempty"`

	// JSON-formatted string of additional HTTP headers when fetching the ignition.
	IgnitionEndpointHTTPHeaders []*IgnitionEndpointHTTPHeadersParams `json:"ignition_endpoint_http_headers"`

	// A string which will be used as Authorization Bearer token to fetch the ignition from ignition_endpoint_url.
	IgnitionEndpointToken *string `json:"ignition_endpoint_token,omitempty"`

	// machine config pool name
	MachineConfigPoolName *string `json:"machine_config_pool_name,omitempty"`

	// Labels to be added to the corresponding node.
	NodeLabels []*NodeLabelParams `json:"node_labels"`
}

HostUpdateParams host update params

swagger:model host-update-params

func (*HostUpdateParams) ContextValidate 

func (m *HostUpdateParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this host update params based on the context it is used

func (*HostUpdateParams) MarshalBinary 

func (m *HostUpdateParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HostUpdateParams) UnmarshalBinary 

func (m *HostUpdateParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HostUpdateParams) Validate 

func (m *HostUpdateParams) Validate(formats strfmt.Registry) error

Validate validates this host update params

type HostValidationID 

type HostValidationID string

HostValidationID host validation id

swagger:model host-validation-id 

const (

	// HostValidationIDConnected captures enum value "connected"
	HostValidationIDConnected HostValidationID = "connected"

	// HostValidationIDMediaConnected captures enum value "media-connected"
	HostValidationIDMediaConnected HostValidationID = "media-connected"

	// HostValidationIDHasInventory captures enum value "has-inventory"
	HostValidationIDHasInventory HostValidationID = "has-inventory"

	// HostValidationIDHasMinCPUCores captures enum value "has-min-cpu-cores"
	HostValidationIDHasMinCPUCores HostValidationID = "has-min-cpu-cores"

	// HostValidationIDHasMinValidDisks captures enum value "has-min-valid-disks"
	HostValidationIDHasMinValidDisks HostValidationID = "has-min-valid-disks"

	// HostValidationIDHasMinMemory captures enum value "has-min-memory"
	HostValidationIDHasMinMemory HostValidationID = "has-min-memory"

	// HostValidationIDMachineCidrDefined captures enum value "machine-cidr-defined"
	HostValidationIDMachineCidrDefined HostValidationID = "machine-cidr-defined"

	// HostValidationIDHasCPUCoresForRole captures enum value "has-cpu-cores-for-role"
	HostValidationIDHasCPUCoresForRole HostValidationID = "has-cpu-cores-for-role"

	// HostValidationIDHasMemoryForRole captures enum value "has-memory-for-role"
	HostValidationIDHasMemoryForRole HostValidationID = "has-memory-for-role"

	// HostValidationIDHostnameUnique captures enum value "hostname-unique"
	HostValidationIDHostnameUnique HostValidationID = "hostname-unique"

	// HostValidationIDHostnameValid captures enum value "hostname-valid"
	HostValidationIDHostnameValid HostValidationID = "hostname-valid"

	// HostValidationIDBelongsToMachineCidr captures enum value "belongs-to-machine-cidr"
	HostValidationIDBelongsToMachineCidr HostValidationID = "belongs-to-machine-cidr"

	// HostValidationIDIgnitionDownloadable captures enum value "ignition-downloadable"
	HostValidationIDIgnitionDownloadable HostValidationID = "ignition-downloadable"

	// HostValidationIDBelongsToMajorityGroup captures enum value "belongs-to-majority-group"
	HostValidationIDBelongsToMajorityGroup HostValidationID = "belongs-to-majority-group"

	// HostValidationIDValidPlatformNetworkSettings captures enum value "valid-platform-network-settings"
	HostValidationIDValidPlatformNetworkSettings HostValidationID = "valid-platform-network-settings"

	// HostValidationIDNtpSynced captures enum value "ntp-synced"
	HostValidationIDNtpSynced HostValidationID = "ntp-synced"

	// HostValidationIDTimeSyncedBetweenHostAndService captures enum value "time-synced-between-host-and-service"
	HostValidationIDTimeSyncedBetweenHostAndService HostValidationID = "time-synced-between-host-and-service"

	// HostValidationIDContainerImagesAvailable captures enum value "container-images-available"
	HostValidationIDContainerImagesAvailable HostValidationID = "container-images-available"

	// HostValidationIDLsoRequirementsSatisfied captures enum value "lso-requirements-satisfied"
	HostValidationIDLsoRequirementsSatisfied HostValidationID = "lso-requirements-satisfied"

	// HostValidationIDOcsRequirementsSatisfied captures enum value "ocs-requirements-satisfied"
	HostValidationIDOcsRequirementsSatisfied HostValidationID = "ocs-requirements-satisfied"

	// HostValidationIDOdfRequirementsSatisfied captures enum value "odf-requirements-satisfied"
	HostValidationIDOdfRequirementsSatisfied HostValidationID = "odf-requirements-satisfied"

	// HostValidationIDLvmRequirementsSatisfied captures enum value "lvm-requirements-satisfied"
	HostValidationIDLvmRequirementsSatisfied HostValidationID = "lvm-requirements-satisfied"

	// HostValidationIDMceRequirementsSatisfied captures enum value "mce-requirements-satisfied"
	HostValidationIDMceRequirementsSatisfied HostValidationID = "mce-requirements-satisfied"

	// HostValidationIDSufficientInstallationDiskSpeed captures enum value "sufficient-installation-disk-speed"
	HostValidationIDSufficientInstallationDiskSpeed HostValidationID = "sufficient-installation-disk-speed"

	// HostValidationIDCnvRequirementsSatisfied captures enum value "cnv-requirements-satisfied"
	HostValidationIDCnvRequirementsSatisfied HostValidationID = "cnv-requirements-satisfied"

	// HostValidationIDSufficientNetworkLatencyRequirementForRole captures enum value "sufficient-network-latency-requirement-for-role"
	HostValidationIDSufficientNetworkLatencyRequirementForRole HostValidationID = "sufficient-network-latency-requirement-for-role"

	// HostValidationIDSufficientPacketLossRequirementForRole captures enum value "sufficient-packet-loss-requirement-for-role"
	HostValidationIDSufficientPacketLossRequirementForRole HostValidationID = "sufficient-packet-loss-requirement-for-role"

	// HostValidationIDHasDefaultRoute captures enum value "has-default-route"
	HostValidationIDHasDefaultRoute HostValidationID = "has-default-route"

	// HostValidationIDAPIDomainNameResolvedCorrectly captures enum value "api-domain-name-resolved-correctly"
	HostValidationIDAPIDomainNameResolvedCorrectly HostValidationID = "api-domain-name-resolved-correctly"

	// HostValidationIDAPIIntDomainNameResolvedCorrectly captures enum value "api-int-domain-name-resolved-correctly"
	HostValidationIDAPIIntDomainNameResolvedCorrectly HostValidationID = "api-int-domain-name-resolved-correctly"

	// HostValidationIDAppsDomainNameResolvedCorrectly captures enum value "apps-domain-name-resolved-correctly"
	HostValidationIDAppsDomainNameResolvedCorrectly HostValidationID = "apps-domain-name-resolved-correctly"

	// HostValidationIDReleaseDomainNameResolvedCorrectly captures enum value "release-domain-name-resolved-correctly"
	HostValidationIDReleaseDomainNameResolvedCorrectly HostValidationID = "release-domain-name-resolved-correctly"

	// HostValidationIDCompatibleWithClusterPlatform captures enum value "compatible-with-cluster-platform"
	HostValidationIDCompatibleWithClusterPlatform HostValidationID = "compatible-with-cluster-platform"

	// HostValidationIDDNSWildcardNotConfigured captures enum value "dns-wildcard-not-configured"
	HostValidationIDDNSWildcardNotConfigured HostValidationID = "dns-wildcard-not-configured"

	// HostValidationIDDiskEncryptionRequirementsSatisfied captures enum value "disk-encryption-requirements-satisfied"
	HostValidationIDDiskEncryptionRequirementsSatisfied HostValidationID = "disk-encryption-requirements-satisfied"

	// HostValidationIDNonOverlappingSubnets captures enum value "non-overlapping-subnets"
	HostValidationIDNonOverlappingSubnets HostValidationID = "non-overlapping-subnets"

	// HostValidationIDVsphereDiskUUIDEnabled captures enum value "vsphere-disk-uuid-enabled"
	HostValidationIDVsphereDiskUUIDEnabled HostValidationID = "vsphere-disk-uuid-enabled"

	// HostValidationIDCompatibleAgent captures enum value "compatible-agent"
	HostValidationIDCompatibleAgent HostValidationID = "compatible-agent"

	// HostValidationIDNoSkipInstallationDisk captures enum value "no-skip-installation-disk"
	HostValidationIDNoSkipInstallationDisk HostValidationID = "no-skip-installation-disk"

	// HostValidationIDNoSkipMissingDisk captures enum value "no-skip-missing-disk"
	HostValidationIDNoSkipMissingDisk HostValidationID = "no-skip-missing-disk"

	// HostValidationIDNoIPCollisionsInNetwork captures enum value "no-ip-collisions-in-network"
	HostValidationIDNoIPCollisionsInNetwork HostValidationID = "no-ip-collisions-in-network"
)

func NewHostValidationID 

func NewHostValidationID(value HostValidationID) *HostValidationID

func (HostValidationID) ContextValidate 

func (m HostValidationID) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this host validation id based on context it is used

func (HostValidationID) Pointer 

func (m HostValidationID) Pointer() *HostValidationID

Pointer returns a pointer to a freshly-allocated HostValidationID.

func (HostValidationID) Validate 

func (m HostValidationID) Validate(formats strfmt.Registry) error

Validate validates this host validation id

type IP 

type IP string

IP ip

swagger:model ip

func (IP) ContextValidate 

func (m IP) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this ip based on context it is used

func (IP) Validate 

func (m IP) Validate(formats strfmt.Registry) error

Validate validates this ip

type IgnitionEndpoint 

type IgnitionEndpoint struct {

	// base64 encoded CA certficate to be used when contacting the URL via https.
	CaCertificate *string `json:"ca_certificate,omitempty"`

	// The URL for the ignition endpoint.
	URL *string `json:"url,omitempty"`
}

IgnitionEndpoint Explicit ignition endpoint overrides the default ignition endpoint.

swagger:model ignition-endpoint

func (*IgnitionEndpoint) ContextValidate 

func (m *IgnitionEndpoint) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this ignition endpoint based on context it is used

func (*IgnitionEndpoint) MarshalBinary 

func (m *IgnitionEndpoint) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*IgnitionEndpoint) UnmarshalBinary 

func (m *IgnitionEndpoint) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*IgnitionEndpoint) Validate 

func (m *IgnitionEndpoint) Validate(formats strfmt.Registry) error

Validate validates this ignition endpoint

type IgnitionEndpointHTTPHeadersParams 

type IgnitionEndpointHTTPHeadersParams struct {

	// The key for the http header's key-value pair.
	// Required: true
	Key *string `json:"key"`

	// The value for the http header's key-value pair.
	// Required: true
	Value *string `json:"value"`
}

IgnitionEndpointHTTPHeadersParams ignition endpoint http headers params

swagger:model ignition-endpoint-http-headers-params

func (*IgnitionEndpointHTTPHeadersParams) ContextValidate 

func (m *IgnitionEndpointHTTPHeadersParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this ignition endpoint http headers params based on context it is used

func (*IgnitionEndpointHTTPHeadersParams) MarshalBinary 

func (m *IgnitionEndpointHTTPHeadersParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*IgnitionEndpointHTTPHeadersParams) UnmarshalBinary 

func (m *IgnitionEndpointHTTPHeadersParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*IgnitionEndpointHTTPHeadersParams) Validate 

func (m *IgnitionEndpointHTTPHeadersParams) Validate(formats strfmt.Registry) error

Validate validates this ignition endpoint http headers params

type IgnoredValidations 

type IgnoredValidations struct {

	// JSON-formatted list of cluster validation IDs that will be ignored for all hosts that belong to this cluster. It may also contain a list with a single string "all" to ignore all cluster validations. Some validations cannot be ignored.
	ClusterValidationIds string `json:"cluster-validation-ids,omitempty"`

	// JSON-formatted list of host validation IDs that will be ignored for all hosts that belong to this cluster. It may also contain a list with a single string "all" to ignore all host validations. Some validations cannot be ignored.
	HostValidationIds string `json:"host-validation-ids,omitempty"`
}

IgnoredValidations ignored validations

swagger:model ignored-validations

func (*IgnoredValidations) ContextValidate 

func (m *IgnoredValidations) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this ignored validations based on context it is used

func (*IgnoredValidations) MarshalBinary 

func (m *IgnoredValidations) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*IgnoredValidations) UnmarshalBinary 

func (m *IgnoredValidations) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*IgnoredValidations) Validate 

func (m *IgnoredValidations) Validate(formats strfmt.Registry) error

Validate validates this ignored validations

type ImageCreateParams 

type ImageCreateParams struct {

	// Type of image that should be generated.
	ImageType ImageType `json:"image_type,omitempty"`

	// SSH public key for debugging the installation.
	SSHPublicKey string `json:"ssh_public_key,omitempty"`

	// static network config
	StaticNetworkConfig []*HostStaticNetworkConfig `json:"static_network_config"`
}

ImageCreateParams image create params

swagger:model image-create-params

func (*ImageCreateParams) ContextValidate 

func (m *ImageCreateParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this image create params based on the context it is used

func (*ImageCreateParams) MarshalBinary 

func (m *ImageCreateParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ImageCreateParams) UnmarshalBinary 

func (m *ImageCreateParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ImageCreateParams) Validate 

func (m *ImageCreateParams) Validate(formats strfmt.Registry) error

Validate validates this image create params

type ImageInfo 

type ImageInfo struct {

	// created at
	// Format: date-time
	CreatedAt timeext.Time `json:"created_at,omitempty" gorm:"type:timestamp with time zone"`

	// download url
	DownloadURL string `json:"download_url,omitempty"`

	// expires at
	// Format: date-time
	ExpiresAt strfmt.DateTime `json:"expires_at,omitempty" gorm:"type:timestamp with time zone"`

	// Image generator version.
	GeneratorVersion string `json:"generator_version,omitempty"`

	// size bytes
	// Minimum: 0
	SizeBytes *int64 `json:"size_bytes,omitempty"`

	// SSH public key for debugging the installation.
	SSHPublicKey string `json:"ssh_public_key,omitempty"`

	// static network configuration string in the format expected by discovery ignition generation
	StaticNetworkConfig string `json:"static_network_config,omitempty"`

	// type
	Type ImageType `json:"type,omitempty"`
}

ImageInfo image info

swagger:model image_info

func (*ImageInfo) ContextValidate 

func (m *ImageInfo) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this image info based on the context it is used

func (*ImageInfo) MarshalBinary 

func (m *ImageInfo) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ImageInfo) UnmarshalBinary 

func (m *ImageInfo) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ImageInfo) Validate 

func (m *ImageInfo) Validate(formats strfmt.Registry) error

Validate validates this image info

type ImageType 

type ImageType string

ImageType image type

swagger:model image_type 

const (

	// ImageTypeFullIso captures enum value "full-iso"
	ImageTypeFullIso ImageType = "full-iso"

	// ImageTypeMinimalIso captures enum value "minimal-iso"
	ImageTypeMinimalIso ImageType = "minimal-iso"
)

func NewImageType 

func NewImageType(value ImageType) *ImageType

func (ImageType) ContextValidate 

func (m ImageType) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this image type based on context it is used

func (ImageType) Pointer 

func (m ImageType) Pointer() *ImageType

Pointer returns a pointer to a freshly-allocated ImageType.

func (ImageType) Validate 

func (m ImageType) Validate(formats strfmt.Registry) error

Validate validates this image type

type ImportClusterParams 

type ImportClusterParams struct {

	// The domain name used to reach the OpenShift cluster API.
	// Required: true
	APIVipDnsname *string `json:"api_vip_dnsname"`

	// OpenShift cluster name.
	// Required: true
	Name *string `json:"name"`

	// The id of the OCP cluster, that hosts will be added to
	// Required: true
	// Format: uuid
	OpenshiftClusterID *strfmt.UUID `json:"openshift_cluster_id"`

	// Version of the OpenShift cluster.
	OpenshiftVersion string `json:"openshift_version,omitempty"`
}

ImportClusterParams import cluster params

swagger:model import-cluster-params

func (*ImportClusterParams) ContextValidate 

func (m *ImportClusterParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this import cluster params based on context it is used

func (*ImportClusterParams) MarshalBinary 

func (m *ImportClusterParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ImportClusterParams) UnmarshalBinary 

func (m *ImportClusterParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ImportClusterParams) Validate 

func (m *ImportClusterParams) Validate(formats strfmt.Registry) error

Validate validates this import cluster params

type InfraEnv 

type InfraEnv struct {

	// A comma-separated list of NTP sources (name or IP) going to be added to all the hosts.
	AdditionalNtpSources string `json:"additional_ntp_sources,omitempty"`

	// PEM-encoded X.509 certificate bundle. Hosts discovered by this
	// infra-env will trust the certificates in this bundle. Clusters formed
	// from the hosts discovered by this infra-env will also trust the
	// certificates in this bundle.
	AdditionalTrustBundle string `json:"additional_trust_bundle,omitempty"`

	// If set, all hosts that register will be associated with the specified cluster.
	// Format: uuid
	ClusterID strfmt.UUID `json:"cluster_id,omitempty" gorm:"index"`

	// The CPU architecture of the image (x86_64/arm64/etc).
	// Enum: [x86_64 aarch64 arm64 ppc64le s390x]
	CPUArchitecture string `json:"cpu_architecture,omitempty"`

	// created at
	// Required: true
	// Format: date-time
	CreatedAt *timeext.Time `json:"created_at" gorm:"type:timestamp with time zone"`

	// download url
	DownloadURL string `json:"download_url,omitempty"`

	// email domain
	EmailDomain string `json:"email_domain,omitempty"`

	// expires at
	// Format: date-time
	ExpiresAt strfmt.DateTime `json:"expires_at,omitempty" gorm:"type:timestamp with time zone"`

	// Image generator version.
	GeneratorVersion string `json:"generator_version,omitempty"`

	// Self link.
	// Required: true
	Href *string `json:"href"`

	// Unique identifier of the object.
	// Required: true
	// Format: uuid
	ID *strfmt.UUID `json:"id" gorm:"primaryKey"`

	// Json formatted string containing the user overrides for the initial ignition config.
	IgnitionConfigOverride string `json:"ignition_config_override,omitempty"`

	// JSON formatted string array representing the discovery image kernel arguments.
	KernelArguments *string `json:"kernel_arguments,omitempty" gorm:"type:text"`

	// Indicates the type of this object.
	// Required: true
	// Enum: [InfraEnv]
	Kind *string `json:"kind"`

	// Name of the infra-env.
	// Required: true
	Name *string `json:"name"`

	// Version of the OpenShift cluster (used to infer the RHCOS version - temporary until generic logic implemented).
	OpenshiftVersion string `json:"openshift_version,omitempty"`

	// org id
	OrgID string `json:"org_id,omitempty"`

	// proxy
	Proxy *Proxy `json:"proxy,omitempty" gorm:"embedded;embeddedPrefix:proxy_"`

	// True if the pull secret has been added to the cluster.
	PullSecretSet bool `json:"pull_secret_set,omitempty"`

	// size bytes
	// Minimum: 0
	SizeBytes *int64 `json:"size_bytes,omitempty"`

	// SSH public key for debugging the installation.
	SSHAuthorizedKey string `json:"ssh_authorized_key,omitempty"`

	// static network configuration string in the format expected by discovery ignition generation.
	StaticNetworkConfig string `json:"static_network_config,omitempty"`

	// type
	// Required: true
	Type *ImageType `json:"type"`

	// The last time that this infra-env was updated.
	// Required: true
	// Format: date-time
	UpdatedAt *timeext.Time `json:"updated_at" gorm:"type:timestamp with time zone"`

	// user name
	UserName string `json:"user_name,omitempty"`
}

InfraEnv infra env

swagger:model infra-env

func (*InfraEnv) ContextValidate 

func (m *InfraEnv) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this infra env based on the context it is used

func (*InfraEnv) MarshalBinary 

func (m *InfraEnv) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*InfraEnv) UnmarshalBinary 

func (m *InfraEnv) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*InfraEnv) Validate 

func (m *InfraEnv) Validate(formats strfmt.Registry) error

Validate validates this infra env

type InfraEnvCreateParams 

type InfraEnvCreateParams struct {

	// A comma-separated list of NTP sources (name or IP) going to be added to all the hosts.
	AdditionalNtpSources *string `json:"additional_ntp_sources,omitempty"`

	// PEM-encoded X.509 certificate bundle. Hosts discovered by this
	// infra-env will trust the certificates in this bundle. Clusters formed
	// from the hosts discovered by this infra-env will also trust the
	// certificates in this bundle.
	// Max Length: 65535
	AdditionalTrustBundle string `json:"additional_trust_bundle,omitempty"`

	// If set, all hosts that register will be associated with the specified cluster.
	// Format: uuid
	ClusterID *strfmt.UUID `json:"cluster_id,omitempty"`

	// The CPU architecture of the image (x86_64/arm64/etc).
	// Enum: [x86_64 aarch64 arm64 ppc64le s390x]
	CPUArchitecture string `json:"cpu_architecture,omitempty"`

	// JSON formatted string containing the user overrides for the initial ignition config.
	IgnitionConfigOverride string `json:"ignition_config_override,omitempty"`

	// image type
	ImageType ImageType `json:"image_type,omitempty"`

	// kernel arguments
	KernelArguments KernelArguments `json:"kernel_arguments"`

	// Name of the infra-env.
	// Required: true
	Name *string `json:"name"`

	// Version of the OpenShift cluster (used to infer the RHCOS version - temporary until generic logic implemented).
	OpenshiftVersion string `json:"openshift_version,omitempty"`

	// proxy
	Proxy *Proxy `json:"proxy,omitempty" gorm:"embedded;embeddedPrefix:proxy_"`

	// The pull secret obtained from Red Hat OpenShift Cluster Manager at console.redhat.com/openshift/install/pull-secret.
	// Required: true
	PullSecret *string `json:"pull_secret"`

	// SSH public key for debugging the installation.
	SSHAuthorizedKey *string `json:"ssh_authorized_key,omitempty"`

	// static network config
	StaticNetworkConfig []*HostStaticNetworkConfig `json:"static_network_config"`
}

InfraEnvCreateParams infra env create params

swagger:model infra-env-create-params

func (*InfraEnvCreateParams) ContextValidate 

func (m *InfraEnvCreateParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this infra env create params based on the context it is used

func (*InfraEnvCreateParams) MarshalBinary 

func (m *InfraEnvCreateParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*InfraEnvCreateParams) UnmarshalBinary 

func (m *InfraEnvCreateParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*InfraEnvCreateParams) Validate 

func (m *InfraEnvCreateParams) Validate(formats strfmt.Registry) error

Validate validates this infra env create params

type InfraEnvList 

type InfraEnvList []*InfraEnv

InfraEnvList infra env list

swagger:model infra-env-list

func (InfraEnvList) ContextValidate 

func (m InfraEnvList) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this infra env list based on the context it is used

func (InfraEnvList) Validate 

func (m InfraEnvList) Validate(formats strfmt.Registry) error

Validate validates this infra env list

type InfraEnvUpdateParams 

type InfraEnvUpdateParams struct {

	// A comma-separated list of NTP sources (name or IP) going to be added to all the hosts.
	AdditionalNtpSources *string `json:"additional_ntp_sources,omitempty"`

	// Allows users to change the additional_trust_bundle infra-env field
	// Max Length: 65535
	AdditionalTrustBundle *string `json:"additional_trust_bundle,omitempty"`

	// JSON formatted string containing the user overrides for the initial ignition config.
	IgnitionConfigOverride string `json:"ignition_config_override,omitempty"`

	// image type
	ImageType ImageType `json:"image_type,omitempty"`

	// kernel arguments
	KernelArguments KernelArguments `json:"kernel_arguments"`

	// Version of the OS image
	OpenshiftVersion *string `json:"openshift_version,omitempty"`

	// proxy
	Proxy *Proxy `json:"proxy,omitempty" gorm:"embedded;embeddedPrefix:proxy_"`

	// The pull secret obtained from Red Hat OpenShift Cluster Manager at console.redhat.com/openshift/install/pull-secret.
	PullSecret string `json:"pull_secret,omitempty"`

	// SSH public key for debugging the installation.
	SSHAuthorizedKey *string `json:"ssh_authorized_key,omitempty"`

	// static network config
	StaticNetworkConfig []*HostStaticNetworkConfig `json:"static_network_config"`
}

InfraEnvUpdateParams infra env update params

swagger:model infra-env-update-params

func (*InfraEnvUpdateParams) ContextValidate 

func (m *InfraEnvUpdateParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this infra env update params based on the context it is used

func (*InfraEnvUpdateParams) MarshalBinary 

func (m *InfraEnvUpdateParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*InfraEnvUpdateParams) UnmarshalBinary 

func (m *InfraEnvUpdateParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*InfraEnvUpdateParams) Validate 

func (m *InfraEnvUpdateParams) Validate(formats strfmt.Registry) error

Validate validates this infra env update params

type InfraError 

type InfraError struct {

	// Numeric identifier of the error.
	// Required: true
	// Maximum: 403
	// Minimum: 401
	Code *int32 `json:"code"`

	// Human-readable description of the error.
	// Required: true
	Message *string `json:"message"`
}

InfraError infra error

swagger:model infra_error

func (*InfraError) ContextValidate 

func (m *InfraError) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this infra error based on context it is used

func (*InfraError) MarshalBinary 

func (m *InfraError) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*InfraError) UnmarshalBinary 

func (m *InfraError) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*InfraError) Validate 

func (m *InfraError) Validate(formats strfmt.Registry) error

Validate validates this infra error

type IngressCertParams 

type IngressCertParams string

IngressCertParams ingress cert params

swagger:model ingress-cert-params

func (IngressCertParams) ContextValidate 

func (m IngressCertParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this ingress cert params based on context it is used

func (IngressCertParams) Validate 

func (m IngressCertParams) Validate(formats strfmt.Registry) error

Validate validates this ingress cert params

type IngressVip 

type IngressVip struct {

	// The cluster that this VIP is associated with.
	// Format: uuid
	ClusterID strfmt.UUID `json:"cluster_id,omitempty" gorm:"primaryKey"`

	// The IP address.
	IP IP `json:"ip,omitempty" gorm:"primaryKey"`

	// Ingress VIP verification result.
	Verification *VipVerification `json:"verification,omitempty"`
}

IngressVip The virtual IP used for cluster ingress traffic.

swagger:model ingress_vip

func (*IngressVip) ContextValidate 

func (m *IngressVip) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this ingress vip based on the context it is used

func (*IngressVip) MarshalBinary 

func (m *IngressVip) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*IngressVip) UnmarshalBinary 

func (m *IngressVip) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*IngressVip) Validate 

func (m *IngressVip) Validate(formats strfmt.Registry) error

Validate validates this ingress vip

type InstallCmdRequest 

type InstallCmdRequest struct {

	// Boot device to write image on
	// Required: true
	BootDevice *string `json:"boot_device"`

	// Check CVO status if needed
	CheckCvo *bool `json:"check_cvo,omitempty"`

	// Cluster id
	// Required: true
	// Format: uuid
	ClusterID *strfmt.UUID `json:"cluster_id"`

	// Assisted installer controller image
	// Required: true
	// Pattern: ^(([a-zA-Z0-9\-\.]+)(:[0-9]+)?\/)?[a-z0-9\._\-\/@]+[?::a-zA-Z0-9_\-.]+$
	ControllerImage *string `json:"controller_image"`

	// List of disks to format
	DisksToFormat []string `json:"disks_to_format"`

	// If true, assisted service will attempt to skip MCO reboot
	EnableSkipMcoReboot bool `json:"enable_skip_mco_reboot,omitempty"`

	// Guaranteed availability of the installed cluster. 'Full' installs a Highly-Available cluster
	// over multiple master nodes whereas 'None' installs a full cluster over one node.
	//
	// Enum: [Full None]
	HighAvailabilityMode *string `json:"high_availability_mode,omitempty"`

	// Host id
	// Required: true
	// Format: uuid
	HostID *strfmt.UUID `json:"host_id"`

	// Infra env id
	// Required: true
	// Format: uuid
	InfraEnvID *strfmt.UUID `json:"infra_env_id"`

	// Core-os installer addtional args
	InstallerArgs string `json:"installer_args,omitempty"`

	// Assisted installer image
	// Required: true
	// Pattern: ^(([a-zA-Z0-9\-\.]+)(:[0-9]+)?\/)?[a-z0-9\._\-\/@]+[?::a-zA-Z0-9_\-.]+$
	InstallerImage *string `json:"installer_image"`

	// Machine config operator image
	// Pattern: ^(([a-zA-Z0-9\-\.]+)(:[0-9]+)?\/)?[a-z0-9\._\-\/@]+[?::a-zA-Z0-9_\-.]+$
	McoImage string `json:"mco_image,omitempty"`

	// Must-gather images to use
	MustGatherImage string `json:"must_gather_image,omitempty"`

	// If true, notify number of reboots by assisted controller
	NotifyNumReboots bool `json:"notify_num_reboots,omitempty"`

	// Version of the OpenShift cluster.
	OpenshiftVersion string `json:"openshift_version,omitempty"`

	// proxy
	Proxy *Proxy `json:"proxy,omitempty" gorm:"embedded;embeddedPrefix:proxy_"`

	// role
	// Required: true
	Role *HostRole `json:"role"`

	// List of service ips
	ServiceIps []string `json:"service_ips"`

	// Skip formatting installation disk
	SkipInstallationDiskCleanup bool `json:"skip_installation_disk_cleanup,omitempty"`
}

InstallCmdRequest install cmd request

swagger:model install_cmd_request

func (*InstallCmdRequest) ContextValidate 

func (m *InstallCmdRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this install cmd request based on the context it is used

func (*InstallCmdRequest) MarshalBinary 

func (m *InstallCmdRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*InstallCmdRequest) UnmarshalBinary 

func (m *InstallCmdRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*InstallCmdRequest) Validate 

func (m *InstallCmdRequest) Validate(formats strfmt.Registry) error

Validate validates this install cmd request

type InstallerArgsParams 

type InstallerArgsParams struct {

	// List of additional arguments passed to coreos-installer
	// Example: ["--append-karg","ip=192.0.2.2::192.0.2.254:255.255.255.0:core0.example.com:enp1s0:none","--save-partindex","1","-n"]
	Args []string `json:"args"`
}

InstallerArgsParams installer args params

swagger:model installer-args-params

func (*InstallerArgsParams) ContextValidate 

func (m *InstallerArgsParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this installer args params based on context it is used

func (*InstallerArgsParams) MarshalBinary 

func (m *InstallerArgsParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*InstallerArgsParams) UnmarshalBinary 

func (m *InstallerArgsParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*InstallerArgsParams) Validate 

func (m *InstallerArgsParams) Validate(formats strfmt.Registry) error

Validate validates this installer args params

type Interface 

type Interface struct {

	// biosdevname
	Biosdevname string `json:"biosdevname,omitempty"`

	// client id
	ClientID string `json:"client_id,omitempty"`

	// flags
	Flags []string `json:"flags"`

	// has carrier
	HasCarrier bool `json:"has_carrier,omitempty"`

	// ipv4 addresses
	IPV4Addresses []string `json:"ipv4_addresses"`

	// ipv6 addresses
	IPV6Addresses []string `json:"ipv6_addresses"`

	// mac address
	MacAddress string `json:"mac_address,omitempty"`

	// mtu
	Mtu int64 `json:"mtu,omitempty"`

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

	// product
	Product string `json:"product,omitempty"`

	// speed mbps
	SpeedMbps int64 `json:"speed_mbps,omitempty"`

	// type
	Type string `json:"type,omitempty"`

	// vendor
	Vendor string `json:"vendor,omitempty"`
}

Interface interface

swagger:model interface

func (*Interface) ContextValidate 

func (m *Interface) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this interface based on context it is used

func (*Interface) MarshalBinary 

func (m *Interface) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Interface) UnmarshalBinary 

func (m *Interface) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Interface) Validate 

func (m *Interface) Validate(formats strfmt.Registry) error

Validate validates this interface

type Inventory 

type Inventory struct {

	// bmc address
	BmcAddress string `json:"bmc_address,omitempty"`

	// bmc v6address
	BmcV6address string `json:"bmc_v6address,omitempty"`

	// boot
	Boot *Boot `json:"boot,omitempty"`

	// cpu
	CPU *CPU `json:"cpu,omitempty"`

	// disks
	Disks []*Disk `json:"disks"`

	// gpus
	Gpus []*Gpu `json:"gpus"`

	// hostname
	Hostname string `json:"hostname,omitempty"`

	// interfaces
	Interfaces []*Interface `json:"interfaces"`

	// memory
	Memory *Memory `json:"memory,omitempty"`

	// routes
	Routes []*Route `json:"routes"`

	// system vendor
	SystemVendor *SystemVendor `json:"system_vendor,omitempty"`

	// tpm version
	// Enum: [none 1.2 2.0]
	TpmVersion string `json:"tpm_version,omitempty"`
}

Inventory inventory

swagger:model inventory

func (*Inventory) ContextValidate 

func (m *Inventory) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this inventory based on the context it is used

func (*Inventory) MarshalBinary 

func (m *Inventory) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Inventory) UnmarshalBinary 

func (m *Inventory) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Inventory) Validate 

func (m *Inventory) Validate(formats strfmt.Registry) error

Validate validates this inventory

type IoPerf 

type IoPerf struct {

	// 99th percentile of fsync duration in milliseconds
	SyncDuration int64 `json:"sync_duration,omitempty"`
}

IoPerf io perf

swagger:model io_perf

func (*IoPerf) ContextValidate 

func (m *IoPerf) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this io perf based on context it is used

func (*IoPerf) MarshalBinary 

func (m *IoPerf) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*IoPerf) UnmarshalBinary 

func (m *IoPerf) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*IoPerf) Validate 

func (m *IoPerf) Validate(formats strfmt.Registry) error

Validate validates this io perf

type Iscsi 

type Iscsi struct {

	// Host IP address used to reach iSCSI target
	HostIPAddress string `json:"host_ip_address,omitempty"`
}

Iscsi iscsi

swagger:model iscsi

func (*Iscsi) ContextValidate 

func (m *Iscsi) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this iscsi based on context it is used

func (*Iscsi) MarshalBinary 

func (m *Iscsi) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Iscsi) UnmarshalBinary 

func (m *Iscsi) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Iscsi) Validate 

func (m *Iscsi) Validate(formats strfmt.Registry) error

Validate validates this iscsi

type KernelArgument 

type KernelArgument struct {

	// The operation to apply on the kernel argument.
	// Enum: [append replace delete]
	Operation string `json:"operation,omitempty"`

	// Kernel argument can have the form <parameter> or <parameter>=<value>. The following examples should
	// be supported:
	// rd.net.timeout.carrier=60
	// isolcpus=1,2,10-20,100-2000:2/25
	// quiet
	// The parsing by the command line parser in linux kernel is much looser and this pattern follows it.
	//
	// Pattern: ^(?:(?:[^ \t\n\r"]+)|(?:"[^"]*"))+$
	Value string `json:"value,omitempty"`
}

KernelArgument pair of [operation, argument] specifying the argument and what operation should be applied on it.

swagger:model kernel_argument

func (*KernelArgument) ContextValidate 

func (m *KernelArgument) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this kernel argument based on context it is used

func (*KernelArgument) MarshalBinary 

func (m *KernelArgument) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*KernelArgument) UnmarshalBinary 

func (m *KernelArgument) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*KernelArgument) Validate 

func (m *KernelArgument) Validate(formats strfmt.Registry) error

Validate validates this kernel argument

type KernelArguments 

type KernelArguments []*KernelArgument

KernelArguments List of kernel arugment objects that define the operations and values to be applied.

swagger:model kernel_arguments

func (KernelArguments) ContextValidate 

func (m KernelArguments) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this kernel arguments based on the context it is used

func (KernelArguments) Validate 

func (m KernelArguments) Validate(formats strfmt.Registry) error

Validate validates this kernel arguments

type L2Connectivity 

type L2Connectivity struct {

	// outgoing ip address
	OutgoingIPAddress string `json:"outgoing_ip_address,omitempty"`

	// outgoing nic
	OutgoingNic string `json:"outgoing_nic,omitempty"`

	// remote ip address
	RemoteIPAddress string `json:"remote_ip_address,omitempty"`

	// remote mac
	RemoteMac string `json:"remote_mac,omitempty"`

	// successful
	Successful bool `json:"successful,omitempty"`
}

L2Connectivity l2 connectivity

swagger:model l2-connectivity

func (*L2Connectivity) ContextValidate 

func (m *L2Connectivity) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this l2 connectivity based on context it is used

func (*L2Connectivity) MarshalBinary 

func (m *L2Connectivity) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*L2Connectivity) UnmarshalBinary 

func (m *L2Connectivity) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*L2Connectivity) Validate 

func (m *L2Connectivity) Validate(formats strfmt.Registry) error

Validate validates this l2 connectivity

type L3Connectivity 

type L3Connectivity struct {

	// Average round trip time in milliseconds.
	AverageRTTMs float64 `json:"average_rtt_ms,omitempty"`

	// outgoing nic
	OutgoingNic string `json:"outgoing_nic,omitempty"`

	// Percentage of packets lost during connectivity check.
	PacketLossPercentage float64 `json:"packet_loss_percentage,omitempty"`

	// remote ip address
	RemoteIPAddress string `json:"remote_ip_address,omitempty"`

	// successful
	Successful bool `json:"successful,omitempty"`
}

L3Connectivity l3 connectivity

swagger:model l3-connectivity

func (*L3Connectivity) ContextValidate 

func (m *L3Connectivity) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this l3 connectivity based on context it is used

func (*L3Connectivity) MarshalBinary 

func (m *L3Connectivity) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*L3Connectivity) UnmarshalBinary 

func (m *L3Connectivity) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*L3Connectivity) Validate 

func (m *L3Connectivity) Validate(formats strfmt.Registry) error

Validate validates this l3 connectivity

type LastInstallationPreparation 

type LastInstallationPreparation struct {

	// The reason for the preparation status if applicable
	Reason string `json:"reason,omitempty"`

	// The last installation preparation status
	// Enum: [not_started failed success]
	Status string `json:"status,omitempty"`
}

LastInstallationPreparation Gives the status of the last installation preparation (if any)

swagger:model last-installation-preparation

func (*LastInstallationPreparation) ContextValidate 

func (m *LastInstallationPreparation) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this last installation preparation based on context it is used

func (*LastInstallationPreparation) MarshalBinary 

func (m *LastInstallationPreparation) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*LastInstallationPreparation) UnmarshalBinary 

func (m *LastInstallationPreparation) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*LastInstallationPreparation) Validate 

func (m *LastInstallationPreparation) Validate(formats strfmt.Registry) error

Validate validates this last installation preparation

type ListManagedDomains 

type ListManagedDomains []*ManagedDomain

ListManagedDomains list managed domains

swagger:model list-managed-domains

func (ListManagedDomains) ContextValidate 

func (m ListManagedDomains) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this list managed domains based on the context it is used

func (ListManagedDomains) Validate 

func (m ListManagedDomains) Validate(formats strfmt.Registry) error

Validate validates this list managed domains

type ListManifests 

type ListManifests []*Manifest

ListManifests list manifests

swagger:model list-manifests

func (ListManifests) ContextValidate 

func (m ListManifests) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this list manifests based on the context it is used

func (ListManifests) Validate 

func (m ListManifests) Validate(formats strfmt.Registry) error

Validate validates this list manifests

type ListVersions 

type ListVersions struct {

	// release tag
	ReleaseTag string `json:"release_tag,omitempty"`

	// versions
	Versions Versions `json:"versions,omitempty"`
}

ListVersions list versions

swagger:model list-versions

func (*ListVersions) ContextValidate 

func (m *ListVersions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this list versions based on the context it is used

func (*ListVersions) MarshalBinary 

func (m *ListVersions) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ListVersions) UnmarshalBinary 

func (m *ListVersions) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ListVersions) Validate 

func (m *ListVersions) Validate(formats strfmt.Registry) error

Validate validates this list versions

type LogsGatherCmdRequest 

type LogsGatherCmdRequest struct {

	// Host is bootstrap or not
	// Required: true
	Bootstrap *bool `json:"bootstrap"`

	// Cluster id
	// Required: true
	// Format: uuid
	ClusterID *strfmt.UUID `json:"cluster_id"`

	// Host id
	// Required: true
	// Format: uuid
	HostID *strfmt.UUID `json:"host_id"`

	// Infra env id
	// Required: true
	// Format: uuid
	InfraEnvID *strfmt.UUID `json:"infra_env_id"`

	// Run installer gather logs
	// Required: true
	InstallerGather bool `json:"installer_gather"`

	// List of master ips
	MasterIps []string `json:"master_ips"`
}

LogsGatherCmdRequest logs gather cmd request

swagger:model logs_gather_cmd_request

func (*LogsGatherCmdRequest) ContextValidate 

func (m *LogsGatherCmdRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this logs gather cmd request based on context it is used

func (*LogsGatherCmdRequest) MarshalBinary 

func (m *LogsGatherCmdRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*LogsGatherCmdRequest) UnmarshalBinary 

func (m *LogsGatherCmdRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*LogsGatherCmdRequest) Validate 

func (m *LogsGatherCmdRequest) Validate(formats strfmt.Registry) error

Validate validates this logs gather cmd request

type LogsProgressParams 

type LogsProgressParams struct {

	// The state of collecting logs.
	// Required: true
	LogsState *LogsState `json:"logs_state" gorm:"type:varchar(2048)"`
}

LogsProgressParams logs progress params

swagger:model logs-progress-params

func (*LogsProgressParams) ContextValidate 

func (m *LogsProgressParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this logs progress params based on the context it is used

func (*LogsProgressParams) MarshalBinary 

func (m *LogsProgressParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*LogsProgressParams) UnmarshalBinary 

func (m *LogsProgressParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*LogsProgressParams) Validate 

func (m *LogsProgressParams) Validate(formats strfmt.Registry) error

Validate validates this logs progress params

type LogsState 

type LogsState string

LogsState logs state

swagger:model logs_state 

const (

	// LogsStateRequested captures enum value "requested"
	LogsStateRequested LogsState = "requested"

	// LogsStateCollecting captures enum value "collecting"
	LogsStateCollecting LogsState = "collecting"

	// LogsStateCompleted captures enum value "completed"
	LogsStateCompleted LogsState = "completed"

	// LogsStateTimeout captures enum value "timeout"
	LogsStateTimeout LogsState = "timeout"

	// LogsStateEmpty captures enum value ""
	LogsStateEmpty LogsState = ""
)

func NewLogsState 

func NewLogsState(value LogsState) *LogsState

func (LogsState) ContextValidate 

func (m LogsState) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this logs state based on context it is used

func (LogsState) Pointer 

func (m LogsState) Pointer() *LogsState

Pointer returns a pointer to a freshly-allocated LogsState.

func (LogsState) Validate 

func (m LogsState) Validate(formats strfmt.Registry) error

Validate validates this logs state

type LogsType 

type LogsType string

LogsType logs type

swagger:model logs_type 

const (

	// LogsTypeHost captures enum value "host"
	LogsTypeHost LogsType = "host"

	// LogsTypeController captures enum value "controller"
	LogsTypeController LogsType = "controller"

	// LogsTypeAll captures enum value "all"
	LogsTypeAll LogsType = "all"

	// LogsTypeEmpty captures enum value ""
	LogsTypeEmpty LogsType = ""
)

func NewLogsType 

func NewLogsType(value LogsType) *LogsType

func (LogsType) ContextValidate 

func (m LogsType) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this logs type based on context it is used

func (LogsType) Pointer 

func (m LogsType) Pointer() *LogsType

Pointer returns a pointer to a freshly-allocated LogsType.

func (LogsType) Validate 

func (m LogsType) Validate(formats strfmt.Registry) error

Validate validates this logs type

type MacInterfaceMap 

type MacInterfaceMap []*MacInterfaceMapItems0

MacInterfaceMap mac interface map

swagger:model mac_interface_map

func (MacInterfaceMap) ContextValidate 

func (m MacInterfaceMap) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this mac interface map based on the context it is used

func (MacInterfaceMap) Validate 

func (m MacInterfaceMap) Validate(formats strfmt.Registry) error

Validate validates this mac interface map

type MacInterfaceMapItems0 

type MacInterfaceMapItems0 struct {

	// nic name used in the yaml, which relates 1:1 to the mac address
	LogicalNicName string `json:"logical_nic_name,omitempty"`

	// mac address present on the host
	// Pattern: ^([0-9A-Fa-f]{2}[:]){5}([0-9A-Fa-f]{2})$
	MacAddress string `json:"mac_address,omitempty"`
}

MacInterfaceMapItems0 mac interface map items0

swagger:model MacInterfaceMapItems0

func (*MacInterfaceMapItems0) ContextValidate 

func (m *MacInterfaceMapItems0) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this mac interface map items0 based on context it is used

func (*MacInterfaceMapItems0) MarshalBinary 

func (m *MacInterfaceMapItems0) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*MacInterfaceMapItems0) UnmarshalBinary 

func (m *MacInterfaceMapItems0) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*MacInterfaceMapItems0) Validate 

func (m *MacInterfaceMapItems0) Validate(formats strfmt.Registry) error

Validate validates this mac interface map items0

type MachineNetwork 

type MachineNetwork struct {

	// The IP block address pool.
	Cidr Subnet `json:"cidr,omitempty" gorm:"primaryKey"`

	// The cluster that this network is associated with.
	// Format: uuid
	ClusterID strfmt.UUID `json:"cluster_id,omitempty" gorm:"primaryKey"`
}

MachineNetwork A network that all hosts belonging to the cluster should have an interface with IP address in. The VIPs (if exist) belong to this network.

swagger:model machine_network

func (*MachineNetwork) ContextValidate 

func (m *MachineNetwork) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this machine network based on the context it is used

func (*MachineNetwork) MarshalBinary 

func (m *MachineNetwork) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*MachineNetwork) UnmarshalBinary 

func (m *MachineNetwork) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*MachineNetwork) Validate 

func (m *MachineNetwork) Validate(formats strfmt.Registry) error

Validate validates this machine network

type ManagedDomain 

type ManagedDomain struct {

	// domain
	Domain string `json:"domain,omitempty"`

	// provider
	// Enum: [route53]
	Provider string `json:"provider,omitempty"`
}

ManagedDomain managed domain

swagger:model managed-domain

func (*ManagedDomain) ContextValidate 

func (m *ManagedDomain) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this managed domain based on context it is used

func (*ManagedDomain) MarshalBinary 

func (m *ManagedDomain) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ManagedDomain) UnmarshalBinary 

func (m *ManagedDomain) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ManagedDomain) Validate 

func (m *ManagedDomain) Validate(formats strfmt.Registry) error

Validate validates this managed domain

type Manifest 

type Manifest struct {

	// The file name prefaced by the folder that contains it.
	FileName string `json:"file_name,omitempty"`

	// The folder that contains the files. Manifests can be placed in 'manifests' or 'openshift' directories.
	// Enum: [manifests openshift]
	Folder string `json:"folder,omitempty"`

	// Describes whether manifest is sourced from a user or created by the system.
	// Enum: [user system]
	ManifestSource string `json:"manifest_source,omitempty"`
}

Manifest manifest

swagger:model manifest

func (*Manifest) ContextValidate 

func (m *Manifest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this manifest based on context it is used

func (*Manifest) MarshalBinary 

func (m *Manifest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Manifest) UnmarshalBinary 

func (m *Manifest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Manifest) Validate 

func (m *Manifest) Validate(formats strfmt.Registry) error

Validate validates this manifest

type Memory 

type Memory struct {

	// physical bytes
	PhysicalBytes int64 `json:"physical_bytes,omitempty"`

	// The method by which the physical memory was set
	PhysicalBytesMethod MemoryMethod `json:"physical_bytes_method,omitempty"`

	// usable bytes
	UsableBytes int64 `json:"usable_bytes,omitempty"`
}

Memory memory

swagger:model memory

func (*Memory) ContextValidate 

func (m *Memory) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this memory based on the context it is used

func (*Memory) MarshalBinary 

func (m *Memory) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Memory) UnmarshalBinary 

func (m *Memory) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Memory) Validate 

func (m *Memory) Validate(formats strfmt.Registry) error

Validate validates this memory

type MemoryMethod 

type MemoryMethod string

MemoryMethod memory method

swagger:model memory_method 

const (

	// MemoryMethodDmidecode captures enum value "dmidecode"
	MemoryMethodDmidecode MemoryMethod = "dmidecode"

	// MemoryMethodGhw captures enum value "ghw"
	MemoryMethodGhw MemoryMethod = "ghw"

	// MemoryMethodMeminfo captures enum value "meminfo"
	MemoryMethodMeminfo MemoryMethod = "meminfo"
)

func NewMemoryMethod 

func NewMemoryMethod(value MemoryMethod) *MemoryMethod

func (MemoryMethod) ContextValidate 

func (m MemoryMethod) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this memory method based on context it is used

func (MemoryMethod) Pointer 

func (m MemoryMethod) Pointer() *MemoryMethod

Pointer returns a pointer to a freshly-allocated MemoryMethod.

func (MemoryMethod) Validate 

func (m MemoryMethod) Validate(formats strfmt.Registry) error

Validate validates this memory method

type MonitoredOperator 

type MonitoredOperator struct {

	// The cluster that this operator is associated with.
	// Format: uuid
	ClusterID strfmt.UUID `json:"cluster_id,omitempty" gorm:"primaryKey"`

	// Unique name of the operator.
	Name string `json:"name,omitempty" gorm:"primaryKey"`

	// Namespace where to deploy an operator. Only some operators require a namespace.
	Namespace string `json:"namespace,omitempty"`

	// operator type
	OperatorType OperatorType `json:"operator_type,omitempty"`

	// Blob of operator-dependent parameters that are required for installation.
	Properties string `json:"properties,omitempty" gorm:"type:text"`

	// status
	Status OperatorStatus `json:"status,omitempty"`

	// Detailed information about the operator state.
	StatusInfo string `json:"status_info,omitempty"`

	// Time at which the operator was last updated.
	// Format: date-time
	StatusUpdatedAt strfmt.DateTime `json:"status_updated_at,omitempty" gorm:"type:timestamp with time zone"`

	// The name of the subscription of the operator.
	SubscriptionName string `json:"subscription_name,omitempty"`

	// Positive number represents a timeout in seconds for the operator to be available.
	TimeoutSeconds int64 `json:"timeout_seconds,omitempty"`

	// Operator version
	Version string `json:"version,omitempty"`
}

MonitoredOperator monitored operator

swagger:model monitored-operator

func (*MonitoredOperator) ContextValidate 

func (m *MonitoredOperator) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this monitored operator based on the context it is used

func (*MonitoredOperator) MarshalBinary 

func (m *MonitoredOperator) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*MonitoredOperator) UnmarshalBinary 

func (m *MonitoredOperator) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*MonitoredOperator) Validate 

func (m *MonitoredOperator) Validate(formats strfmt.Registry) error

Validate validates this monitored operator

type MonitoredOperatorsList 

type MonitoredOperatorsList []*MonitoredOperator

MonitoredOperatorsList monitored operators list

swagger:model monitored-operators-list

func (MonitoredOperatorsList) ContextValidate 

func (m MonitoredOperatorsList) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this monitored operators list based on the context it is used

func (MonitoredOperatorsList) Validate 

func (m MonitoredOperatorsList) Validate(formats strfmt.Registry) error

Validate validates this monitored operators list

type NextStepCmdRequest 

type NextStepCmdRequest struct {

	// Agent image version
	// Required: true
	// Pattern: ^(([a-zA-Z0-9\-\.]+)(:[0-9]+)?\/)?[a-z0-9\._\-\/@]+[?::a-zA-Z0-9_\-.]+$
	AgentVersion *string `json:"agent_version"`

	// Host id
	// Required: true
	// Format: uuid
	HostID *strfmt.UUID `json:"host_id"`

	// Infra env id
	// Required: true
	// Format: uuid
	InfraEnvID *strfmt.UUID `json:"infra_env_id"`
}

NextStepCmdRequest next step cmd request

swagger:model next_step_cmd_request

func (*NextStepCmdRequest) ContextValidate 

func (m *NextStepCmdRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this next step cmd request based on context it is used

func (*NextStepCmdRequest) MarshalBinary 

func (m *NextStepCmdRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NextStepCmdRequest) UnmarshalBinary 

func (m *NextStepCmdRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NextStepCmdRequest) Validate 

func (m *NextStepCmdRequest) Validate(formats strfmt.Registry) error

Validate validates this next step cmd request

type NodeLabelParams 

type NodeLabelParams struct {

	// The key for the label's key-value pair.
	// Required: true
	Key *string `json:"key"`

	// The value for the label's key-value pair.
	// Required: true
	Value *string `json:"value"`
}

NodeLabelParams node label params

swagger:model node-label-params

func (*NodeLabelParams) ContextValidate 

func (m *NodeLabelParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this node label params based on context it is used

func (*NodeLabelParams) MarshalBinary 

func (m *NodeLabelParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NodeLabelParams) UnmarshalBinary 

func (m *NodeLabelParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NodeLabelParams) Validate 

func (m *NodeLabelParams) Validate(formats strfmt.Registry) error

Validate validates this node label params

type NtpSource 

type NtpSource struct {

	// NTP source name or IP.
	SourceName string `json:"source_name,omitempty"`

	// Indication of state of an NTP source.
	SourceState SourceState `json:"source_state,omitempty"`
}

NtpSource ntp source

swagger:model ntp_source

func (*NtpSource) ContextValidate 

func (m *NtpSource) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this ntp source based on the context it is used

func (*NtpSource) MarshalBinary 

func (m *NtpSource) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NtpSource) UnmarshalBinary 

func (m *NtpSource) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NtpSource) Validate 

func (m *NtpSource) Validate(formats strfmt.Registry) error

Validate validates this ntp source

type NtpSynchronizationRequest 

type NtpSynchronizationRequest struct {

	// A comma-separated list of NTP sources (name or IP) going to be added to all the hosts.
	// Required: true
	NtpSource *string `json:"ntp_source"`
}

NtpSynchronizationRequest ntp synchronization request

swagger:model ntp_synchronization_request

func (*NtpSynchronizationRequest) ContextValidate 

func (m *NtpSynchronizationRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this ntp synchronization request based on context it is used

func (*NtpSynchronizationRequest) MarshalBinary 

func (m *NtpSynchronizationRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NtpSynchronizationRequest) UnmarshalBinary 

func (m *NtpSynchronizationRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NtpSynchronizationRequest) Validate 

func (m *NtpSynchronizationRequest) Validate(formats strfmt.Registry) error

Validate validates this ntp synchronization request

type NtpSynchronizationResponse 

type NtpSynchronizationResponse struct {

	// ntp sources
	NtpSources []*NtpSource `json:"ntp_sources"`
}

NtpSynchronizationResponse ntp synchronization response

swagger:model ntp_synchronization_response

func (*NtpSynchronizationResponse) ContextValidate 

func (m *NtpSynchronizationResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this ntp synchronization response based on the context it is used

func (*NtpSynchronizationResponse) MarshalBinary 

func (m *NtpSynchronizationResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NtpSynchronizationResponse) UnmarshalBinary 

func (m *NtpSynchronizationResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NtpSynchronizationResponse) Validate 

func (m *NtpSynchronizationResponse) Validate(formats strfmt.Registry) error

Validate validates this ntp synchronization response

type OpenshiftVersion 

type OpenshiftVersion struct {

	// Available CPU architectures.
	// Required: true
	CPUArchitectures []string `json:"cpu_architectures"`

	// Indication that the version is the recommended one.
	Default bool `json:"default,omitempty"`

	// Name of the version to be presented to the user.
	// Required: true
	DisplayName *string `json:"display_name"`

	// Level of support of the version.
	// Required: true
	// Enum: [beta production maintenance end-of-life]
	SupportLevel *string `json:"support_level"`
}

OpenshiftVersion openshift version

swagger:model openshift-version

func (*OpenshiftVersion) ContextValidate 

func (m *OpenshiftVersion) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this openshift version based on context it is used

func (*OpenshiftVersion) MarshalBinary 

func (m *OpenshiftVersion) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*OpenshiftVersion) UnmarshalBinary 

func (m *OpenshiftVersion) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*OpenshiftVersion) Validate 

func (m *OpenshiftVersion) Validate(formats strfmt.Registry) error

Validate validates this openshift version

type OpenshiftVersions 

type OpenshiftVersions map[string]OpenshiftVersion

OpenshiftVersions openshift versions

swagger:model openshift-versions

func (OpenshiftVersions) ContextValidate 

func (m OpenshiftVersions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this openshift versions based on the context it is used

func (OpenshiftVersions) Validate 

func (m OpenshiftVersions) Validate(formats strfmt.Registry) error

Validate validates this openshift versions

type OperatorCreateParams 

type OperatorCreateParams struct {

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

	// Blob of operator-dependent parameters that are required for installation.
	Properties string `json:"properties,omitempty" gorm:"type:text"`
}

OperatorCreateParams operator create params

swagger:model operator-create-params

func (*OperatorCreateParams) ContextValidate 

func (m *OperatorCreateParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this operator create params based on context it is used

func (*OperatorCreateParams) MarshalBinary 

func (m *OperatorCreateParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*OperatorCreateParams) UnmarshalBinary 

func (m *OperatorCreateParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*OperatorCreateParams) Validate 

func (m *OperatorCreateParams) Validate(formats strfmt.Registry) error

Validate validates this operator create params

type OperatorHardwareRequirements 

type OperatorHardwareRequirements struct {

	// List of other operator unique names that are required to be installed. Corresponds to name property of the monitored-operator, i.e. "lso", "cnv", etc.
	Dependencies []string `json:"dependencies"`

	// Unique name of the operator. Corresponds to name property of the monitored-operator, i.e. "lso", "cnv", etc.
	OperatorName string `json:"operator_name,omitempty"`

	// requirements
	Requirements *HostTypeHardwareRequirementsWrapper `json:"requirements,omitempty"`
}

OperatorHardwareRequirements operator hardware requirements

swagger:model operator-hardware-requirements

func (*OperatorHardwareRequirements) ContextValidate 

func (m *OperatorHardwareRequirements) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this operator hardware requirements based on the context it is used

func (*OperatorHardwareRequirements) MarshalBinary 

func (m *OperatorHardwareRequirements) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*OperatorHardwareRequirements) UnmarshalBinary 

func (m *OperatorHardwareRequirements) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*OperatorHardwareRequirements) Validate 

func (m *OperatorHardwareRequirements) Validate(formats strfmt.Registry) error

Validate validates this operator hardware requirements

type OperatorHostRequirements 

type OperatorHostRequirements struct {

	// Name of the operator
	OperatorName string `json:"operator_name,omitempty"`

	// Host requirements for the operator
	Requirements *ClusterHostRequirementsDetails `json:"requirements,omitempty"`
}

OperatorHostRequirements operator host requirements

swagger:model operator-host-requirements

func (*OperatorHostRequirements) ContextValidate 

func (m *OperatorHostRequirements) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this operator host requirements based on the context it is used

func (*OperatorHostRequirements) MarshalBinary 

func (m *OperatorHostRequirements) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*OperatorHostRequirements) UnmarshalBinary 

func (m *OperatorHostRequirements) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*OperatorHostRequirements) Validate 

func (m *OperatorHostRequirements) Validate(formats strfmt.Registry) error

Validate validates this operator host requirements

type OperatorMonitorReport 

type OperatorMonitorReport struct {

	// Unique name of the operator.
	Name string `json:"name,omitempty"`

	// status
	Status OperatorStatus `json:"status,omitempty"`

	// Detailed information about the operator state.
	StatusInfo string `json:"status_info,omitempty"`

	// operator version.
	Version string `json:"version,omitempty"`
}

OperatorMonitorReport operator monitor report

swagger:model operator-monitor-report

func (*OperatorMonitorReport) ContextValidate 

func (m *OperatorMonitorReport) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this operator monitor report based on the context it is used

func (*OperatorMonitorReport) MarshalBinary 

func (m *OperatorMonitorReport) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*OperatorMonitorReport) UnmarshalBinary 

func (m *OperatorMonitorReport) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*OperatorMonitorReport) Validate 

func (m *OperatorMonitorReport) Validate(formats strfmt.Registry) error

Validate validates this operator monitor report

type OperatorProperties 

type OperatorProperties []*OperatorProperty

OperatorProperties operator properties

swagger:model operator-properties

func (OperatorProperties) ContextValidate 

func (m OperatorProperties) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this operator properties based on the context it is used

func (OperatorProperties) Validate 

func (m OperatorProperties) Validate(formats strfmt.Registry) error

Validate validates this operator properties

type OperatorProperty 

type OperatorProperty struct {

	// Type of the property
	// Enum: [boolean string integer float]
	DataType string `json:"data_type,omitempty"`

	// Default value for the property
	DefaultValue string `json:"default_value,omitempty"`

	// Description of a property
	Description string `json:"description,omitempty"`

	// Indicates whether the property is reqired
	Mandatory bool `json:"mandatory,omitempty"`

	// Name of the property
	Name string `json:"name,omitempty"`

	// Values to select from
	Options []string `json:"options"`
}

OperatorProperty operator property

swagger:model operator-property

func (*OperatorProperty) ContextValidate 

func (m *OperatorProperty) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this operator property based on context it is used

func (*OperatorProperty) MarshalBinary 

func (m *OperatorProperty) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*OperatorProperty) UnmarshalBinary 

func (m *OperatorProperty) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*OperatorProperty) Validate 

func (m *OperatorProperty) Validate(formats strfmt.Registry) error

Validate validates this operator property

type OperatorStatus 

type OperatorStatus string

OperatorStatus Represents the operator state.

swagger:model operator-status 

const (

	// OperatorStatusFailed captures enum value "failed"
	OperatorStatusFailed OperatorStatus = "failed"

	// OperatorStatusProgressing captures enum value "progressing"
	OperatorStatusProgressing OperatorStatus = "progressing"

	// OperatorStatusAvailable captures enum value "available"
	OperatorStatusAvailable OperatorStatus = "available"
)

func NewOperatorStatus 

func NewOperatorStatus(value OperatorStatus) *OperatorStatus

func (OperatorStatus) ContextValidate 

func (m OperatorStatus) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this operator status based on context it is used

func (OperatorStatus) Pointer 

func (m OperatorStatus) Pointer() *OperatorStatus

Pointer returns a pointer to a freshly-allocated OperatorStatus.

func (OperatorStatus) Validate 

func (m OperatorStatus) Validate(formats strfmt.Registry) error

Validate validates this operator status

type OperatorType 

type OperatorType string

OperatorType Kind of operator. Different types are monitored by the service differently.

swagger:model operator-type 

const (

	// OperatorTypeBuiltin captures enum value "builtin"
	OperatorTypeBuiltin OperatorType = "builtin"

	// OperatorTypeOlm captures enum value "olm"
	OperatorTypeOlm OperatorType = "olm"
)

func NewOperatorType 

func NewOperatorType(value OperatorType) *OperatorType

func (OperatorType) ContextValidate 

func (m OperatorType) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this operator type based on context it is used

func (OperatorType) Pointer 

func (m OperatorType) Pointer() *OperatorType

Pointer returns a pointer to a freshly-allocated OperatorType.

func (OperatorType) Validate 

func (m OperatorType) Validate(formats strfmt.Registry) error

Validate validates this operator type

type OsImage 

type OsImage struct {

	// The CPU architecture of the image (x86_64/arm64/etc).
	// Required: true
	// Enum: [x86_64 aarch64 arm64 ppc64le s390x]
	CPUArchitecture *string `json:"cpu_architecture" gorm:"default:'x86_64'"`

	// Version of the operating system image
	// Example: 4.12
	// Required: true
	OpenshiftVersion *string `json:"openshift_version"`

	// The base OS image used for the discovery iso.
	// Required: true
	URL *string `json:"url"`

	// Build ID of the OS image.
	// Required: true
	Version *string `json:"version"`
}

OsImage os image

swagger:model os-image

func (*OsImage) ContextValidate 

func (m *OsImage) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this os image based on context it is used

func (*OsImage) MarshalBinary 

func (m *OsImage) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*OsImage) UnmarshalBinary 

func (m *OsImage) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*OsImage) Validate 

func (m *OsImage) Validate(formats strfmt.Registry) error

Validate validates this os image

type OsImages 

type OsImages []*OsImage

OsImages os images

swagger:model os-images

func (OsImages) ContextValidate 

func (m OsImages) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this os images based on the context it is used

func (OsImages) Validate 

func (m OsImages) Validate(formats strfmt.Registry) error

Validate validates this os images

type Platform 

type Platform struct {

	// external
	External *PlatformExternal `json:"external,omitempty" gorm:"embedded;embeddedPrefix:external_"`

	// type
	// Required: true
	Type *PlatformType `json:"type"`
}

Platform The configuration for the specific platform upon which to perform the installation.

swagger:model platform

func (*Platform) ContextValidate 

func (m *Platform) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this platform based on the context it is used

func (*Platform) MarshalBinary 

func (m *Platform) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Platform) UnmarshalBinary 

func (m *Platform) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Platform) Validate 

func (m *Platform) Validate(formats strfmt.Registry) error

Validate validates this platform

type PlatformExternal 

type PlatformExternal struct {

	// When set to external, this property will enable an external cloud provider.
	// Enum: [ External]
	CloudControllerManager *string `json:"cloud_controller_manager,omitempty"`

	// Holds the arbitrary string representing the infrastructure provider name.
	// Min Length: 1
	PlatformName *string `json:"platform_name,omitempty"`
}

PlatformExternal Configuration used when installing with an external platform type.

swagger:model platform_external

func (*PlatformExternal) ContextValidate 

func (m *PlatformExternal) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this platform external based on context it is used

func (*PlatformExternal) MarshalBinary 

func (m *PlatformExternal) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PlatformExternal) UnmarshalBinary 

func (m *PlatformExternal) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PlatformExternal) Validate 

func (m *PlatformExternal) Validate(formats strfmt.Registry) error

Validate validates this platform external

type PlatformType 

type PlatformType string

PlatformType platform type

swagger:model platform_type 

const (

	// PlatformTypeBaremetal captures enum value "baremetal"
	PlatformTypeBaremetal PlatformType = "baremetal"

	// PlatformTypeNutanix captures enum value "nutanix"
	PlatformTypeNutanix PlatformType = "nutanix"

	// PlatformTypeVsphere captures enum value "vsphere"
	PlatformTypeVsphere PlatformType = "vsphere"

	// PlatformTypeNone captures enum value "none"
	PlatformTypeNone PlatformType = "none"

	// PlatformTypeExternal captures enum value "external"
	PlatformTypeExternal PlatformType = "external"
)

func NewPlatformType 

func NewPlatformType(value PlatformType) *PlatformType

func (PlatformType) ContextValidate 

func (m PlatformType) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this platform type based on context it is used

func (PlatformType) Pointer 

func (m PlatformType) Pointer() *PlatformType

Pointer returns a pointer to a freshly-allocated PlatformType.

func (PlatformType) Validate 

func (m PlatformType) Validate(formats strfmt.Registry) error

Validate validates this platform type

type PreflightHardwareRequirements 

type PreflightHardwareRequirements struct {

	// Preflight OCP requirements
	Ocp *HostTypeHardwareRequirementsWrapper `json:"ocp,omitempty"`

	// Preflight operators hardware requirements
	Operators []*OperatorHardwareRequirements `json:"operators"`
}

PreflightHardwareRequirements preflight hardware requirements

swagger:model preflight-hardware-requirements

func (*PreflightHardwareRequirements) ContextValidate 

func (m *PreflightHardwareRequirements) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this preflight hardware requirements based on the context it is used

func (*PreflightHardwareRequirements) MarshalBinary 

func (m *PreflightHardwareRequirements) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PreflightHardwareRequirements) UnmarshalBinary 

func (m *PreflightHardwareRequirements) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PreflightHardwareRequirements) Validate 

func (m *PreflightHardwareRequirements) Validate(formats strfmt.Registry) error

Validate validates this preflight hardware requirements

type PresignedURL 

type PresignedURL struct {

	// Expiration time for the URL token.
	// Format: date-time
	ExpiresAt strfmt.DateTime `json:"expires_at,omitempty"`

	// Pre-signed URL for downloading the infra-env discovery image.
	// Required: true
	URL *string `json:"url"`
}

PresignedURL presigned url

swagger:model presigned-url

func (*PresignedURL) ContextValidate 

func (m *PresignedURL) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this presigned url based on context it is used

func (*PresignedURL) MarshalBinary 

func (m *PresignedURL) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PresignedURL) UnmarshalBinary 

func (m *PresignedURL) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PresignedURL) Validate 

func (m *PresignedURL) Validate(formats strfmt.Registry) error

Validate validates this presigned url

type Proxy 

type Proxy struct {

	// A proxy URL to use for creating HTTP connections outside the cluster.
	// http://\<username\>:\<pswd\>@\<ip\>:\<port\>
	//
	HTTPProxy *string `json:"http_proxy,omitempty"`

	// A proxy URL to use for creating HTTPS connections outside the cluster.
	// http://\<username\>:\<pswd\>@\<ip\>:\<port\>
	//
	HTTPSProxy *string `json:"https_proxy,omitempty" gorm:"column:https_proxy"`

	// An "*" or a comma-separated list of destination domain names, domains, IP addresses, or other network CIDRs to exclude from proxying.
	NoProxy *string `json:"no_proxy,omitempty"`
}

Proxy proxy

swagger:model proxy

func (*Proxy) ContextValidate 

func (m *Proxy) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this proxy based on context it is used

func (*Proxy) MarshalBinary 

func (m *Proxy) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Proxy) UnmarshalBinary 

func (m *Proxy) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Proxy) Validate 

func (m *Proxy) Validate(formats strfmt.Registry) error

Validate validates this proxy

type RebootForReclaimRequest 

type RebootForReclaimRequest struct {

	// The base directory on the host that contains the /boot folder. The host needs to
	// chroot into this directory in order to properly reboot.
	// Required: true
	HostFsMountDir *string `json:"host_fs_mount_dir"`
}

RebootForReclaimRequest Information sent to the agent for rebooting a host into discovery.

swagger:model reboot_for_reclaim_request

func (*RebootForReclaimRequest) ContextValidate 

func (m *RebootForReclaimRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this reboot for reclaim request based on context it is used

func (*RebootForReclaimRequest) MarshalBinary 

func (m *RebootForReclaimRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RebootForReclaimRequest) UnmarshalBinary 

func (m *RebootForReclaimRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RebootForReclaimRequest) Validate 

func (m *RebootForReclaimRequest) Validate(formats strfmt.Registry) error

Validate validates this reboot for reclaim request

type ReleaseChannel 

type ReleaseChannel string

ReleaseChannel Release channel.

swagger:model release-channel 

const (

	// ReleaseChannelCandidate captures enum value "candidate"
	ReleaseChannelCandidate ReleaseChannel = "candidate"

	// ReleaseChannelFast captures enum value "fast"
	ReleaseChannelFast ReleaseChannel = "fast"

	// ReleaseChannelStable captures enum value "stable"
	ReleaseChannelStable ReleaseChannel = "stable"

	// ReleaseChannelEus captures enum value "eus"
	ReleaseChannelEus ReleaseChannel = "eus"
)

func NewReleaseChannel 

func NewReleaseChannel(value ReleaseChannel) *ReleaseChannel

func (ReleaseChannel) ContextValidate 

func (m ReleaseChannel) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this release channel based on context it is used

func (ReleaseChannel) Pointer 

func (m ReleaseChannel) Pointer() *ReleaseChannel

Pointer returns a pointer to a freshly-allocated ReleaseChannel.

func (ReleaseChannel) Validate 

func (m ReleaseChannel) Validate(formats strfmt.Registry) error

Validate validates this release channel

type ReleaseImage 

type ReleaseImage struct {

	// (DEPRECATED) The CPU architecture of the image (x86_64/arm64/etc).
	// Required: true
	// Enum: [x86_64 aarch64 arm64 ppc64le s390x multi]
	CPUArchitecture *string `json:"cpu_architecture" gorm:"default:'x86_64'"`

	// List of CPU architectures provided by the image.
	CPUArchitectures pq.StringArray `json:"cpu_architectures" gorm:"type:text[]"`

	// Indication that the version is the recommended one.
	Default bool `json:"default,omitempty"`

	// Version of the OpenShift cluster.
	// Required: true
	OpenshiftVersion *string `json:"openshift_version"`

	// Level of support of the version.
	// Enum: [beta production maintenance end-of-life]
	SupportLevel string `json:"support_level,omitempty"`

	// The installation image of the OpenShift cluster.
	// Required: true
	URL *string `json:"url" gorm:"primarykey"`

	// OCP version from the release metadata.
	// Required: true
	Version *string `json:"version"`
}

ReleaseImage release image

swagger:model release-image

func (*ReleaseImage) ContextValidate 

func (m *ReleaseImage) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this release image based on context it is used

func (*ReleaseImage) MarshalBinary 

func (m *ReleaseImage) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ReleaseImage) UnmarshalBinary 

func (m *ReleaseImage) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ReleaseImage) Validate 

func (m *ReleaseImage) Validate(formats strfmt.Registry) error

Validate validates this release image

type ReleaseImages 

type ReleaseImages []*ReleaseImage

ReleaseImages release images

swagger:model release-images

func (ReleaseImages) ContextValidate 

func (m ReleaseImages) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this release images based on the context it is used

func (ReleaseImages) Validate 

func (m ReleaseImages) Validate(formats strfmt.Registry) error

Validate validates this release images

type ReleaseSource 

type ReleaseSource struct {

	// multi cpu architectures
	// Required: true
	MultiCPUArchitectures []string `json:"multi_cpu_architectures"`

	// Version of the OpenShift cluster.
	// Example: 4.14
	// Required: true
	OpenshiftVersion *string `json:"openshift_version"`

	// upgrade channels
	// Required: true
	UpgradeChannels []*UpgradeChannel `json:"upgrade_channels"`
}

ReleaseSource release source

swagger:model release-source

func (*ReleaseSource) ContextValidate 

func (m *ReleaseSource) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this release source based on the context it is used

func (*ReleaseSource) MarshalBinary 

func (m *ReleaseSource) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ReleaseSource) UnmarshalBinary 

func (m *ReleaseSource) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ReleaseSource) Validate 

func (m *ReleaseSource) Validate(formats strfmt.Registry) error

Validate validates this release source

type ReleaseSources 

type ReleaseSources []*ReleaseSource

ReleaseSources release sources

swagger:model release-sources

func (ReleaseSources) ContextValidate 

func (m ReleaseSources) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this release sources based on the context it is used

func (ReleaseSources) Validate 

func (m ReleaseSources) Validate(formats strfmt.Registry) error

Validate validates this release sources

type Route 

type Route struct {

	// The destination network or destination host
	Destination string `json:"destination,omitempty"`

	// Defines whether this is an IPv4 (4) or IPv6 route (6)
	Family int32 `json:"family,omitempty"`

	// Gateway address where the packets are sent
	Gateway string `json:"gateway,omitempty"`

	// Interface to which packets for this route will be sent
	Interface string `json:"interface,omitempty"`

	// Route priority metric
	Metric int32 `json:"metric,omitempty"`
}

Route route

swagger:model route

func (*Route) ContextValidate 

func (m *Route) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this route based on context it is used

func (*Route) MarshalBinary 

func (m *Route) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Route) UnmarshalBinary 

func (m *Route) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Route) Validate 

func (m *Route) Validate(formats strfmt.Registry) error

Validate validates this route

type ServiceNetwork 

type ServiceNetwork struct {

	// The IP block address pool.
	Cidr Subnet `json:"cidr,omitempty" gorm:"primaryKey"`

	// A network to use for service IP addresses. If you need to access the services from an external network, configure load balancers and routers to manage the traffic.
	// Format: uuid
	ClusterID strfmt.UUID `json:"cluster_id,omitempty" gorm:"primaryKey"`
}

ServiceNetwork IP address block for service IP blocks.

swagger:model service_network

func (*ServiceNetwork) ContextValidate 

func (m *ServiceNetwork) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this service network based on the context it is used

func (*ServiceNetwork) MarshalBinary 

func (m *ServiceNetwork) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ServiceNetwork) UnmarshalBinary 

func (m *ServiceNetwork) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ServiceNetwork) Validate 

func (m *ServiceNetwork) Validate(formats strfmt.Registry) error

Validate validates this service network

type SourceState 

type SourceState string

SourceState source state

swagger:model source_state 

const (

	// SourceStateSynced captures enum value "synced"
	SourceStateSynced SourceState = "synced"

	// SourceStateCombined captures enum value "combined"
	SourceStateCombined SourceState = "combined"

	// SourceStateNotCombined captures enum value "not_combined"
	SourceStateNotCombined SourceState = "not_combined"

	// SourceStateError captures enum value "error"
	SourceStateError SourceState = "error"

	// SourceStateVariable captures enum value "variable"
	SourceStateVariable SourceState = "variable"

	// SourceStateUnreachable captures enum value "unreachable"
	SourceStateUnreachable SourceState = "unreachable"
)

func NewSourceState 

func NewSourceState(value SourceState) *SourceState

func (SourceState) ContextValidate 

func (m SourceState) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this source state based on context it is used

func (SourceState) Pointer 

func (m SourceState) Pointer() *SourceState

Pointer returns a pointer to a freshly-allocated SourceState.

func (SourceState) Validate 

func (m SourceState) Validate(formats strfmt.Registry) error

Validate validates this source state

type Step 

type Step struct {

	// args
	Args []string `json:"args"`

	// step id
	StepID string `json:"step_id,omitempty"`

	// step type
	StepType StepType `json:"step_type,omitempty"`
}

Step step

swagger:model step

func (*Step) ContextValidate 

func (m *Step) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this step based on the context it is used

func (*Step) MarshalBinary 

func (m *Step) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Step) UnmarshalBinary 

func (m *Step) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Step) Validate 

func (m *Step) Validate(formats strfmt.Registry) error

Validate validates this step

type StepReply 

type StepReply struct {

	// error
	Error string `json:"error,omitempty"`

	// exit code
	ExitCode int64 `json:"exit_code,omitempty"`

	// output
	Output string `json:"output,omitempty"`

	// step id
	StepID string `json:"step_id,omitempty"`

	// step type
	StepType StepType `json:"step_type,omitempty"`
}

StepReply step reply

swagger:model step-reply

func (*StepReply) ContextValidate 

func (m *StepReply) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this step reply based on the context it is used

func (*StepReply) MarshalBinary 

func (m *StepReply) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*StepReply) UnmarshalBinary 

func (m *StepReply) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*StepReply) Validate 

func (m *StepReply) Validate(formats strfmt.Registry) error

Validate validates this step reply

type StepType 

type StepType string

StepType step type

swagger:model step-type 

const (

	// StepTypeConnectivityCheck captures enum value "connectivity-check"
	StepTypeConnectivityCheck StepType = "connectivity-check"

	// StepTypeExecute captures enum value "execute"
	StepTypeExecute StepType = "execute"

	// StepTypeInventory captures enum value "inventory"
	StepTypeInventory StepType = "inventory"

	// StepTypeInstall captures enum value "install"
	StepTypeInstall StepType = "install"

	// StepTypeFreeNetworkAddresses captures enum value "free-network-addresses"
	StepTypeFreeNetworkAddresses StepType = "free-network-addresses"

	// StepTypeDhcpLeaseAllocate captures enum value "dhcp-lease-allocate"
	StepTypeDhcpLeaseAllocate StepType = "dhcp-lease-allocate"

	// StepTypeAPIVipConnectivityCheck captures enum value "api-vip-connectivity-check"
	StepTypeAPIVipConnectivityCheck StepType = "api-vip-connectivity-check"

	// StepTypeTangConnectivityCheck captures enum value "tang-connectivity-check"
	StepTypeTangConnectivityCheck StepType = "tang-connectivity-check"

	// StepTypeNtpSynchronizer captures enum value "ntp-synchronizer"
	StepTypeNtpSynchronizer StepType = "ntp-synchronizer"

	// StepTypeInstallationDiskSpeedCheck captures enum value "installation-disk-speed-check"
	StepTypeInstallationDiskSpeedCheck StepType = "installation-disk-speed-check"

	// StepTypeContainerImageAvailability captures enum value "container-image-availability"
	StepTypeContainerImageAvailability StepType = "container-image-availability"

	// StepTypeDomainResolution captures enum value "domain-resolution"
	StepTypeDomainResolution StepType = "domain-resolution"

	// StepTypeStopInstallation captures enum value "stop-installation"
	StepTypeStopInstallation StepType = "stop-installation"

	// StepTypeLogsGather captures enum value "logs-gather"
	StepTypeLogsGather StepType = "logs-gather"

	// StepTypeNextStepRunner captures enum value "next-step-runner"
	StepTypeNextStepRunner StepType = "next-step-runner"

	// StepTypeUpgradeAgent captures enum value "upgrade-agent"
	StepTypeUpgradeAgent StepType = "upgrade-agent"

	// StepTypeDownloadBootArtifacts captures enum value "download-boot-artifacts"
	StepTypeDownloadBootArtifacts StepType = "download-boot-artifacts"

	// StepTypeRebootForReclaim captures enum value "reboot-for-reclaim"
	StepTypeRebootForReclaim StepType = "reboot-for-reclaim"

	// StepTypeVerifyVips captures enum value "verify-vips"
	StepTypeVerifyVips StepType = "verify-vips"
)

func NewStepType 

func NewStepType(value StepType) *StepType

func (StepType) ContextValidate 

func (m StepType) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this step type based on context it is used

func (StepType) Pointer 

func (m StepType) Pointer() *StepType

Pointer returns a pointer to a freshly-allocated StepType.

func (StepType) Validate 

func (m StepType) Validate(formats strfmt.Registry) error

Validate validates this step type

type Steps 

type Steps struct {

	// instructions
	Instructions []*Step `json:"instructions"`

	// next instruction seconds
	NextInstructionSeconds int64 `json:"next_instruction_seconds,omitempty"`

	// What to do after finishing to run step instructions
	// Enum: [exit continue]
	PostStepAction *string `json:"post_step_action,omitempty"`
}

Steps steps

swagger:model steps

func (*Steps) ContextValidate 

func (m *Steps) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this steps based on the context it is used

func (*Steps) MarshalBinary 

func (m *Steps) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Steps) UnmarshalBinary 

func (m *Steps) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Steps) Validate 

func (m *Steps) Validate(formats strfmt.Registry) error

Validate validates this steps

type StepsReply 

type StepsReply []*StepReply

StepsReply steps reply

swagger:model steps-reply

func (StepsReply) ContextValidate 

func (m StepsReply) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this steps reply based on the context it is used

func (StepsReply) Validate 

func (m StepsReply) Validate(formats strfmt.Registry) error

Validate validates this steps reply

type Subnet 

type Subnet string

Subnet subnet

swagger:model subnet

func (Subnet) ContextValidate 

func (m Subnet) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this subnet based on context it is used

func (Subnet) Validate 

func (m Subnet) Validate(formats strfmt.Registry) error

Validate validates this subnet

type SupportLevel 

type SupportLevel string

SupportLevel support level

swagger:model support-level 

const (

	// SupportLevelSupported captures enum value "supported"
	SupportLevelSupported SupportLevel = "supported"

	// SupportLevelUnsupported captures enum value "unsupported"
	SupportLevelUnsupported SupportLevel = "unsupported"

	// SupportLevelTechPreview captures enum value "tech-preview"
	SupportLevelTechPreview SupportLevel = "tech-preview"

	// SupportLevelDevPreview captures enum value "dev-preview"
	SupportLevelDevPreview SupportLevel = "dev-preview"

	// SupportLevelUnavailable captures enum value "unavailable"
	SupportLevelUnavailable SupportLevel = "unavailable"
)

func NewSupportLevel 

func NewSupportLevel(value SupportLevel) *SupportLevel

func (SupportLevel) ContextValidate 

func (m SupportLevel) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this support level based on context it is used

func (SupportLevel) Pointer 

func (m SupportLevel) Pointer() *SupportLevel

Pointer returns a pointer to a freshly-allocated SupportLevel.

func (SupportLevel) Validate 

func (m SupportLevel) Validate(formats strfmt.Registry) error

Validate validates this support level

type SupportLevels 

type SupportLevels map[string]SupportLevel

SupportLevels Map of feature ID or CPU architecture alongside their support level

swagger:model support-levels

func (SupportLevels) ContextValidate 

func (m SupportLevels) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this support levels based on the context it is used

func (SupportLevels) Validate 

func (m SupportLevels) Validate(formats strfmt.Registry) error

Validate validates this support levels

type SystemVendor 

type SystemVendor struct {

	// manufacturer
	Manufacturer string `json:"manufacturer,omitempty"`

	// product name
	ProductName string `json:"product_name,omitempty"`

	// serial number
	SerialNumber string `json:"serial_number,omitempty"`

	// Whether the machine appears to be a virtual machine or not
	Virtual bool `json:"virtual,omitempty"`
}

SystemVendor system vendor

swagger:model system_vendor

func (*SystemVendor) ContextValidate 

func (m *SystemVendor) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this system vendor based on context it is used

func (*SystemVendor) MarshalBinary 

func (m *SystemVendor) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*SystemVendor) UnmarshalBinary 

func (m *SystemVendor) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*SystemVendor) Validate 

func (m *SystemVendor) Validate(formats strfmt.Registry) error

Validate validates this system vendor

type TangConnectivityRequest 

type TangConnectivityRequest struct {

	// JSON-formatted string containing additional information regarding tang's configuration
	// Required: true
	TangServers *string `json:"tang_servers"`
}

TangConnectivityRequest tang connectivity request

swagger:model tang_connectivity_request

func (*TangConnectivityRequest) ContextValidate 

func (m *TangConnectivityRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this tang connectivity request based on context it is used

func (*TangConnectivityRequest) MarshalBinary 

func (m *TangConnectivityRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*TangConnectivityRequest) UnmarshalBinary 

func (m *TangConnectivityRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*TangConnectivityRequest) Validate 

func (m *TangConnectivityRequest) Validate(formats strfmt.Registry) error

Validate validates this tang connectivity request

type TangConnectivityResponse 

type TangConnectivityResponse struct {

	// Tang check result.
	IsSuccess bool `json:"is_success,omitempty"`

	// tang server response
	TangServerResponse []*TangServerResponse `json:"tang_server_response"`
}

TangConnectivityResponse tang connectivity response

swagger:model tang_connectivity_response

func (*TangConnectivityResponse) ContextValidate 

func (m *TangConnectivityResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this tang connectivity response based on the context it is used

func (*TangConnectivityResponse) MarshalBinary 

func (m *TangConnectivityResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*TangConnectivityResponse) UnmarshalBinary 

func (m *TangConnectivityResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*TangConnectivityResponse) Validate 

func (m *TangConnectivityResponse) Validate(formats strfmt.Registry) error

Validate validates this tang connectivity response

type TangServerResponse 

type TangServerResponse struct {

	// Tang response payload.
	Payload string `json:"payload,omitempty"`

	// signatures
	Signatures []*TangServerSignatures `json:"signatures"`

	// Tang URL.
	TangURL string `json:"tang_url,omitempty"`
}

TangServerResponse tang server response

swagger:model TangServerResponse

func (*TangServerResponse) ContextValidate 

func (m *TangServerResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this tang server response based on the context it is used

func (*TangServerResponse) MarshalBinary 

func (m *TangServerResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*TangServerResponse) UnmarshalBinary 

func (m *TangServerResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*TangServerResponse) Validate 

func (m *TangServerResponse) Validate(formats strfmt.Registry) error

Validate validates this tang server response

type TangServerSignatures 

type TangServerSignatures struct {

	// protected
	Protected string `json:"protected,omitempty"`

	// signature
	Signature string `json:"signature,omitempty"`
}

TangServerSignatures tang server signatures

swagger:model TangServerSignatures

func (*TangServerSignatures) ContextValidate 

func (m *TangServerSignatures) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this tang server signatures based on context it is used

func (*TangServerSignatures) MarshalBinary 

func (m *TangServerSignatures) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*TangServerSignatures) UnmarshalBinary 

func (m *TangServerSignatures) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*TangServerSignatures) Validate 

func (m *TangServerSignatures) Validate(formats strfmt.Registry) error

Validate validates this tang server signatures

type UpdateManifestParams 

type UpdateManifestParams struct {

	// The file name for the manifest to modify.
	// Required: true
	// Pattern: ^[^\/]*\.(json|ya?ml(\.patch_?[a-zA-Z0-9_]*)?)$
	FileName string `json:"file_name"`

	// The folder for the manifest to modify.
	// Required: true
	// Enum: [manifests openshift]
	Folder string `json:"folder"`

	// The new base64 encoded manifest content.
	UpdatedContent *string `json:"updated_content,omitempty"`

	// The new file name for the manifest.
	// Pattern: ^[^\/]*\.(json|ya?ml(\.patch_?[a-zA-Z0-9_]*)?)$
	UpdatedFileName *string `json:"updated_file_name,omitempty"`

	// The new folder for the manifest. Manifests can be placed in 'manifests' or 'openshift' directories.
	// Enum: [manifests openshift]
	UpdatedFolder *string `json:"updated_folder,omitempty"`
}

UpdateManifestParams update manifest params

swagger:model update-manifest-params

func (*UpdateManifestParams) ContextValidate 

func (m *UpdateManifestParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this update manifest params based on context it is used

func (*UpdateManifestParams) MarshalBinary 

func (m *UpdateManifestParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*UpdateManifestParams) UnmarshalBinary 

func (m *UpdateManifestParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*UpdateManifestParams) Validate 

func (m *UpdateManifestParams) Validate(formats strfmt.Registry) error

Validate validates this update manifest params

type UpgradeAgentRequest 

type UpgradeAgentRequest struct {

	// Full image reference of the image that the agent should upgrade to, for example
	// `quay.io/registry-proxy.engineering.redhat.com/rh-osbs/openshift4-assisted-installer-agent-rhel8:v1.0.0-142`.
	//
	AgentImage string `json:"agent_image,omitempty"`
}

UpgradeAgentRequest upgrade agent request

swagger:model upgrade_agent_request

func (*UpgradeAgentRequest) ContextValidate 

func (m *UpgradeAgentRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this upgrade agent request based on context it is used

func (*UpgradeAgentRequest) MarshalBinary 

func (m *UpgradeAgentRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*UpgradeAgentRequest) UnmarshalBinary 

func (m *UpgradeAgentRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*UpgradeAgentRequest) Validate 

func (m *UpgradeAgentRequest) Validate(formats strfmt.Registry) error

Validate validates this upgrade agent request

type UpgradeAgentResponse 

type UpgradeAgentResponse struct {

	// Full image reference of the image that the agent has upgraded to, for example
	// `quay.io/registry-proxy.engineering.redhat.com/rh-osbs/openshift4-assisted-installer-agent-rhel8:v1.0.0-142`.
	//
	AgentImage string `json:"agent_image,omitempty"`

	// result
	Result UpgradeAgentResult `json:"result,omitempty"`
}

UpgradeAgentResponse upgrade agent response

swagger:model upgrade_agent_response

func (*UpgradeAgentResponse) ContextValidate 

func (m *UpgradeAgentResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this upgrade agent response based on the context it is used

func (*UpgradeAgentResponse) MarshalBinary 

func (m *UpgradeAgentResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*UpgradeAgentResponse) UnmarshalBinary 

func (m *UpgradeAgentResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*UpgradeAgentResponse) Validate 

func (m *UpgradeAgentResponse) Validate(formats strfmt.Registry) error

Validate validates this upgrade agent response

type UpgradeAgentResult 

type UpgradeAgentResult string

UpgradeAgentResult Agent upgrade result.

swagger:model upgrade_agent_result 

const (

	// UpgradeAgentResultSuccess captures enum value "success"
	UpgradeAgentResultSuccess UpgradeAgentResult = "success"

	// UpgradeAgentResultFailure captures enum value "failure"
	UpgradeAgentResultFailure UpgradeAgentResult = "failure"
)

func NewUpgradeAgentResult 

func NewUpgradeAgentResult(value UpgradeAgentResult) *UpgradeAgentResult

func (UpgradeAgentResult) ContextValidate 

func (m UpgradeAgentResult) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this upgrade agent result based on context it is used

func (UpgradeAgentResult) Pointer 

func (m UpgradeAgentResult) Pointer() *UpgradeAgentResult

Pointer returns a pointer to a freshly-allocated UpgradeAgentResult.

func (UpgradeAgentResult) Validate 

func (m UpgradeAgentResult) Validate(formats strfmt.Registry) error

Validate validates this upgrade agent result

type UpgradeChannel 

type UpgradeChannel struct {

	// channels
	// Required: true
	Channels []ReleaseChannel `json:"channels"`

	// The CPU architecture of the image.
	// Required: true
	// Enum: [x86_64 aarch64 arm64 ppc64le s390x multi]
	CPUArchitecture *string `json:"cpu_architecture"`
}

UpgradeChannel upgrade channel

swagger:model upgrade-channel

func (*UpgradeChannel) ContextValidate 

func (m *UpgradeChannel) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this upgrade channel based on the context it is used

func (*UpgradeChannel) MarshalBinary 

func (m *UpgradeChannel) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*UpgradeChannel) UnmarshalBinary 

func (m *UpgradeChannel) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*UpgradeChannel) Validate 

func (m *UpgradeChannel) Validate(formats strfmt.Registry) error

Validate validates this upgrade channel

type Usage 

type Usage struct {

	// additional properties of the feature
	Data map[string]interface{} `json:"data,omitempty"`

	// Unique idenftifier of the feature
	ID string `json:"id,omitempty"`

	// name of the feature to track
	Name string `json:"name,omitempty"`
}

Usage usage

swagger:model usage

func (*Usage) ContextValidate 

func (m *Usage) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this usage based on context it is used

func (*Usage) MarshalBinary 

func (m *Usage) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Usage) UnmarshalBinary 

func (m *Usage) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Usage) Validate 

func (m *Usage) Validate(formats strfmt.Registry) error

Validate validates this usage

type V2ClusterUpdateParams 

type V2ClusterUpdateParams struct {

	// A comma-separated list of NTP sources (name or IP) going to be added to all the hosts.
	AdditionalNtpSource *string `json:"additional_ntp_source,omitempty"`

	// The domain name used to reach the OpenShift cluster API.
	APIVipDNSName *string `json:"api_vip_dns_name,omitempty"`

	// The virtual IPs used to reach the OpenShift cluster's API. Enter one IP address for single-stack clusters, or up to two for dual-stack clusters (at most one IP address per IP stack used). The order of stacks should be the same as order of subnets in Cluster Networks, Service Networks, and Machine Networks.
	APIVips []*APIVip `json:"api_vips"`

	// Base domain of the cluster. All DNS records must be sub-domains of this base and include the cluster name.
	BaseDNSDomain *string `json:"base_dns_domain,omitempty"`

	// IP address block from which Pod IPs are allocated. This block must not overlap with existing physical networks. These IP addresses are used for the Pod network, and if you need to access the Pods from an external network, configure load balancers and routers to manage the traffic.
	// Pattern: ^(?:(?:(?:[0-9]{1,3}\.){3}[0-9]{1,3}\/(?:(?:[0-9])|(?:[1-2][0-9])|(?:3[0-2])))|(?:(?:[0-9a-fA-F]*:[0-9a-fA-F]*){2,})/(?:(?:[0-9])|(?:[1-9][0-9])|(?:1[0-1][0-9])|(?:12[0-8])))$
	ClusterNetworkCidr *string `json:"cluster_network_cidr,omitempty"`

	// The subnet prefix length to assign to each individual node. For example, if clusterNetworkHostPrefix is set to 23, then each node is assigned a /23 subnet out of the given cidr (clusterNetworkCIDR), which allows for 510 (2^(32 - 23) - 2) pod IPs addresses. If you are required to provide access to nodes from an external network, configure load balancers and routers to manage the traffic.
	// Maximum: 128
	// Minimum: 1
	ClusterNetworkHostPrefix *int64 `json:"cluster_network_host_prefix,omitempty"`

	// Cluster networks that are associated with this cluster.
	ClusterNetworks []*ClusterNetwork `json:"cluster_networks"`

	// Installation disks encryption mode and host roles to be applied.
	DiskEncryption *DiskEncryption `json:"disk_encryption,omitempty" gorm:"embedded;embeddedPrefix:disk_encryption_"`

	// A proxy URL to use for creating HTTP connections outside the cluster.
	// http://\<username\>:\<pswd\>@\<ip\>:\<port\>
	//
	HTTPProxy *string `json:"http_proxy,omitempty"`

	// A proxy URL to use for creating HTTPS connections outside the cluster.
	// http://\<username\>:\<pswd\>@\<ip\>:\<port\>
	//
	HTTPSProxy *string `json:"https_proxy,omitempty"`

	// Enable/disable hyperthreading on master nodes, worker nodes, or all nodes.
	// Enum: [masters workers all none]
	Hyperthreading *string `json:"hyperthreading,omitempty"`

	// Explicit ignition endpoint overrides the default ignition endpoint.
	IgnitionEndpoint *IgnitionEndpoint `json:"ignition_endpoint,omitempty" gorm:"embedded;embeddedPrefix:ignition_endpoint_"`

	// The virtual IPs used for cluster ingress traffic. Enter one IP address for single-stack clusters, or up to two for dual-stack clusters (at most one IP address per IP stack used). The order of stacks should be the same as order of subnets in Cluster Networks, Service Networks, and Machine Networks.
	IngressVips []*IngressVip `json:"ingress_vips"`

	// A CIDR that all hosts belonging to the cluster should have an interfaces with IP address that belongs to this CIDR. The api_vip belongs to this CIDR.
	// Pattern: ^(?:(?:(?:[0-9]{1,3}\.){3}[0-9]{1,3}\/(?:(?:[0-9])|(?:[1-2][0-9])|(?:3[0-2])))|(?:(?:[0-9a-fA-F]*:[0-9a-fA-F]*){2,})/(?:(?:[0-9])|(?:[1-9][0-9])|(?:1[0-1][0-9])|(?:12[0-8])))$
	MachineNetworkCidr *string `json:"machine_network_cidr,omitempty"`

	// Machine networks that are associated with this cluster.
	MachineNetworks []*MachineNetwork `json:"machine_networks"`

	// OpenShift cluster name.
	// Max Length: 54
	// Min Length: 1
	Name *string `json:"name,omitempty"`

	// The desired network type used.
	// Enum: [OpenShiftSDN OVNKubernetes]
	NetworkType *string `json:"network_type,omitempty"`

	// An "*" or a comma-separated list of destination domain names, domains, IP addresses, or other network CIDRs to exclude from proxying.
	NoProxy *string `json:"no_proxy,omitempty"`

	// List of OLM operators to be installed.
	OlmOperators []*OperatorCreateParams `json:"olm_operators"`

	// platform
	Platform *Platform `json:"platform,omitempty" gorm:"embedded;embeddedPrefix:platform_"`

	// The pull secret obtained from Red Hat OpenShift Cluster Manager at console.redhat.com/openshift/install/pull-secret.
	PullSecret *string `json:"pull_secret,omitempty"`

	// Schedule workloads on masters
	SchedulableMasters *bool `json:"schedulable_masters,omitempty"`

	// The IP address pool to use for service IP addresses. You can enter only one IP address pool. If you need to access the services from an external network, configure load balancers and routers to manage the traffic.
	// Pattern: ^(?:(?:(?:[0-9]{1,3}\.){3}[0-9]{1,3}\/(?:(?:[0-9])|(?:[1-2][0-9])|(?:3[0-2])))|(?:(?:[0-9a-fA-F]*:[0-9a-fA-F]*){2,})/(?:(?:[0-9])|(?:[1-9][0-9])|(?:1[0-1][0-9])|(?:12[0-8])))$
	ServiceNetworkCidr *string `json:"service_network_cidr,omitempty"`

	// Service networks that are associated with this cluster.
	ServiceNetworks []*ServiceNetwork `json:"service_networks"`

	// SSH public key for debugging OpenShift nodes.
	SSHPublicKey *string `json:"ssh_public_key,omitempty"`

	// A comma-separated list of tags that are associated to the cluster.
	Tags *string `json:"tags,omitempty"`

	// (DEPRECATED) Indicate if the networking is managed by the user.
	UserManagedNetworking *bool `json:"user_managed_networking,omitempty"`

	// Indicate if virtual IP DHCP allocation mode is enabled.
	VipDhcpAllocation *bool `json:"vip_dhcp_allocation,omitempty"`
}

V2ClusterUpdateParams v2 cluster update params

swagger:model v2-cluster-update-params

func (*V2ClusterUpdateParams) ContextValidate 

func (m *V2ClusterUpdateParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this v2 cluster update params based on the context it is used

func (*V2ClusterUpdateParams) MarshalBinary 

func (m *V2ClusterUpdateParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*V2ClusterUpdateParams) UnmarshalBinary 

func (m *V2ClusterUpdateParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*V2ClusterUpdateParams) Validate 

func (m *V2ClusterUpdateParams) Validate(formats strfmt.Registry) error

Validate validates this v2 cluster update params

type VerifiedVip 

type VerifiedVip struct {

	// verification
	Verification *VipVerification `json:"verification,omitempty"`

	// vip
	Vip IP `json:"vip,omitempty" gorm:"primaryKey"`

	// vip type
	VipType VipType `json:"vip_type,omitempty"`
}

VerifiedVip Single VIP verification result.

swagger:model verified_vip

func (*VerifiedVip) ContextValidate 

func (m *VerifiedVip) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this verified vip based on the context it is used

func (*VerifiedVip) MarshalBinary 

func (m *VerifiedVip) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*VerifiedVip) UnmarshalBinary 

func (m *VerifiedVip) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*VerifiedVip) Validate 

func (m *VerifiedVip) Validate(formats strfmt.Registry) error

Validate validates this verified vip

type VerifyVip 

type VerifyVip struct {

	// vip
	Vip IP `json:"vip,omitempty" gorm:"primaryKey"`

	// vip type
	VipType VipType `json:"vip_type,omitempty"`
}

VerifyVip Request to verify single vip.

swagger:model verify_vip

func (*VerifyVip) ContextValidate 

func (m *VerifyVip) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this verify vip based on the context it is used

func (*VerifyVip) MarshalBinary 

func (m *VerifyVip) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*VerifyVip) UnmarshalBinary 

func (m *VerifyVip) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*VerifyVip) Validate 

func (m *VerifyVip) Validate(formats strfmt.Registry) error

Validate validates this verify vip

type VerifyVipsRequest 

type VerifyVipsRequest []*VerifyVip

VerifyVipsRequest list of vips to be verified.

swagger:model verify_vips_request

func (VerifyVipsRequest) ContextValidate 

func (m VerifyVipsRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this verify vips request based on the context it is used

func (VerifyVipsRequest) Validate 

func (m VerifyVipsRequest) Validate(formats strfmt.Registry) error

Validate validates this verify vips request

type VerifyVipsResponse 

type VerifyVipsResponse []*VerifiedVip

VerifyVipsResponse list of verified vips.

swagger:model verify_vips_response

func (VerifyVipsResponse) ContextValidate 

func (m VerifyVipsResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this verify vips response based on the context it is used

func (VerifyVipsResponse) Validate 

func (m VerifyVipsResponse) Validate(formats strfmt.Registry) error

Validate validates this verify vips response

type VersionedHostRequirements 

type VersionedHostRequirements struct {

	// Edge Worker OpenShift node requirements
	EdgeWorkerRequirements *ClusterHostRequirementsDetails `json:"edge-worker,omitempty"`

	// Master node requirements
	MasterRequirements *ClusterHostRequirementsDetails `json:"master,omitempty"`

	// Single node OpenShift node requirements
	SNORequirements *ClusterHostRequirementsDetails `json:"sno,omitempty"`

	// Worker node requirements
	WorkerRequirements *ClusterHostRequirementsDetails `json:"worker,omitempty"`

	// Version of the component for which requirements are defined
	Version string `json:"version,omitempty"`
}

VersionedHostRequirements versioned host requirements

swagger:model versioned-host-requirements

func (*VersionedHostRequirements) ContextValidate 

func (m *VersionedHostRequirements) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this versioned host requirements based on the context it is used

func (*VersionedHostRequirements) MarshalBinary 

func (m *VersionedHostRequirements) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*VersionedHostRequirements) UnmarshalBinary 

func (m *VersionedHostRequirements) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*VersionedHostRequirements) Validate 

func (m *VersionedHostRequirements) Validate(formats strfmt.Registry) error

Validate validates this versioned host requirements

type Versions 

type Versions map[string]string

Versions versions

swagger:model versions

func (Versions) ContextValidate 

func (m Versions) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this versions based on context it is used

func (Versions) Validate 

func (m Versions) Validate(formats strfmt.Registry) error

Validate validates this versions

type VipType 

type VipType string

VipType The vip type.

swagger:model vip_type 

const (

	// VipTypeAPI captures enum value "api"
	VipTypeAPI VipType = "api"

	// VipTypeIngress captures enum value "ingress"
	VipTypeIngress VipType = "ingress"
)

func NewVipType 

func NewVipType(value VipType) *VipType

func (VipType) ContextValidate 

func (m VipType) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this vip type based on context it is used

func (VipType) Pointer 

func (m VipType) Pointer() *VipType

Pointer returns a pointer to a freshly-allocated VipType.

func (VipType) Validate 

func (m VipType) Validate(formats strfmt.Registry) error

Validate validates this vip type

type VipVerification 

type VipVerification string

VipVerification vip verification result.

swagger:model vip_verification 

const (

	// VipVerificationUnverified captures enum value "unverified"
	VipVerificationUnverified VipVerification = "unverified"

	// VipVerificationFailed captures enum value "failed"
	VipVerificationFailed VipVerification = "failed"

	// VipVerificationSucceeded captures enum value "succeeded"
	VipVerificationSucceeded VipVerification = "succeeded"
)

func NewVipVerification 

func NewVipVerification(value VipVerification) *VipVerification

func (VipVerification) ContextValidate 

func (m VipVerification) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this vip verification based on context it is used

func (VipVerification) Pointer 

func (m VipVerification) Pointer() *VipVerification

Pointer returns a pointer to a freshly-allocated VipVerification.

func (VipVerification) Validate 

func (m VipVerification) Validate(formats strfmt.Registry) error

Validate validates this vip verification

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.