info_responses.go

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

package operations

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

import (
	"context"
	"encoding/json"
	stderrors "errors"
	"fmt"
	"io"

	"github.com/go-openapi/errors"
	"github.com/go-openapi/runtime"
	"github.com/go-openapi/strfmt"
	"github.com/go-openapi/swag"
)

// InfoReader is a Reader for the Info structure.
type InfoReader struct {
	formats strfmt.Registry
}

// ReadResponse reads a server response into the received o.
func (o *InfoReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (any, error) {
	switch response.Code() {
	case 200:
		result := NewInfoOK()
		if err := result.readResponse(response, consumer, o.formats); err != nil {
			return nil, err
		}
		return result, nil
	case 500:
		result := NewInfoInternalServerError()
		if err := result.readResponse(response, consumer, o.formats); err != nil {
			return nil, err
		}
		return nil, result
	default:
		return nil, runtime.NewAPIError("[GET /api/info] info", response, response.Code())
	}
}

// NewInfoOK creates a InfoOK with default headers values
func NewInfoOK() *InfoOK {
	return &InfoOK{}
}

/*
InfoOK describes a response with status code 200, with default header values.

Request succeeded. The response contains general info about the cluster.
*/
type InfoOK struct {
	Payload *InfoOKBody
}

// IsSuccess returns true when this info o k response has a 2xx status code
func (o *InfoOK) IsSuccess() bool {
	return true
}

// IsRedirect returns true when this info o k response has a 3xx status code
func (o *InfoOK) IsRedirect() bool {
	return false
}

// IsClientError returns true when this info o k response has a 4xx status code
func (o *InfoOK) IsClientError() bool {
	return false
}

// IsServerError returns true when this info o k response has a 5xx status code
func (o *InfoOK) IsServerError() bool {
	return false
}

// IsCode returns true when this info o k response a status code equal to that given
func (o *InfoOK) IsCode(code int) bool {
	return code == 200
}

// Code gets the status code for the info o k response
func (o *InfoOK) Code() int {
	return 200
}

func (o *InfoOK) Error() string {
	payload, _ := json.Marshal(o.Payload)
	return fmt.Sprintf("[GET /api/info][%d] infoOK %s", 200, payload)
}

func (o *InfoOK) String() string {
	payload, _ := json.Marshal(o.Payload)
	return fmt.Sprintf("[GET /api/info][%d] infoOK %s", 200, payload)
}

func (o *InfoOK) GetPayload() *InfoOKBody {
	return o.Payload
}

func (o *InfoOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {

	o.Payload = new(InfoOKBody)

	// response payload
	if err := consumer.Consume(response.Body(), o.Payload); err != nil && !stderrors.Is(err, io.EOF) {
		return err
	}

	return nil
}

// NewInfoInternalServerError creates a InfoInternalServerError with default headers values
func NewInfoInternalServerError() *InfoInternalServerError {
	return &InfoInternalServerError{}
}

/*
InfoInternalServerError describes a response with status code 500, with default header values.

Request failed. Internal controller error.
*/
type InfoInternalServerError struct {
	Payload *InfoInternalServerErrorBody
}

// IsSuccess returns true when this info internal server error response has a 2xx status code
func (o *InfoInternalServerError) IsSuccess() bool {
	return false
}

// IsRedirect returns true when this info internal server error response has a 3xx status code
func (o *InfoInternalServerError) IsRedirect() bool {
	return false
}

// IsClientError returns true when this info internal server error response has a 4xx status code
func (o *InfoInternalServerError) IsClientError() bool {
	return false
}

// IsServerError returns true when this info internal server error response has a 5xx status code
func (o *InfoInternalServerError) IsServerError() bool {
	return true
}

// IsCode returns true when this info internal server error response a status code equal to that given
func (o *InfoInternalServerError) IsCode(code int) bool {
	return code == 500
}

// Code gets the status code for the info internal server error response
func (o *InfoInternalServerError) Code() int {
	return 500
}

func (o *InfoInternalServerError) Error() string {
	payload, _ := json.Marshal(o.Payload)
	return fmt.Sprintf("[GET /api/info][%d] infoInternalServerError %s", 500, payload)
}

func (o *InfoInternalServerError) String() string {
	payload, _ := json.Marshal(o.Payload)
	return fmt.Sprintf("[GET /api/info][%d] infoInternalServerError %s", 500, payload)
}

func (o *InfoInternalServerError) GetPayload() *InfoInternalServerErrorBody {
	return o.Payload
}

func (o *InfoInternalServerError) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {

	o.Payload = new(InfoInternalServerErrorBody)

	// response payload
	if err := consumer.Consume(response.Body(), o.Payload); err != nil && !stderrors.Is(err, io.EOF) {
		return err
	}

	return nil
}

/*
InfoInternalServerErrorBody info internal server error body
swagger:model InfoInternalServerErrorBody
*/
type InfoInternalServerErrorBody struct {

	// message
	Message string `json:"message,omitempty"`
}

// Validate validates this info internal server error body
func (o *InfoInternalServerErrorBody) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info internal server error body based on context it is used
func (o *InfoInternalServerErrorBody) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBody info o k body
swagger:model InfoOKBody
*/
type InfoOKBody struct {

	// compute backends
	ComputeBackends *InfoOKBodyComputeBackends `json:"compute_backends,omitempty"`

	// cwl engine tool
	CwlEngineTool *InfoOKBodyCwlEngineTool `json:"cwl_engine_tool,omitempty"`

	// cwl engine version
	CwlEngineVersion *InfoOKBodyCwlEngineVersion `json:"cwl_engine_version,omitempty"`

	// dask autoscaler enabled
	DaskAutoscalerEnabled *InfoOKBodyDaskAutoscalerEnabled `json:"dask_autoscaler_enabled,omitempty"`

	// dask cluster default number of workers
	DaskClusterDefaultNumberOfWorkers *InfoOKBodyDaskClusterDefaultNumberOfWorkers `json:"dask_cluster_default_number_of_workers,omitempty"`

	// dask cluster default single worker memory
	DaskClusterDefaultSingleWorkerMemory *InfoOKBodyDaskClusterDefaultSingleWorkerMemory `json:"dask_cluster_default_single_worker_memory,omitempty"`

	// dask cluster default single worker threads
	DaskClusterDefaultSingleWorkerThreads *InfoOKBodyDaskClusterDefaultSingleWorkerThreads `json:"dask_cluster_default_single_worker_threads,omitempty"`

	// dask cluster max memory limit
	DaskClusterMaxMemoryLimit *InfoOKBodyDaskClusterMaxMemoryLimit `json:"dask_cluster_max_memory_limit,omitempty"`

	// dask cluster max number of workers
	DaskClusterMaxNumberOfWorkers *InfoOKBodyDaskClusterMaxNumberOfWorkers `json:"dask_cluster_max_number_of_workers,omitempty"`

	// dask cluster max single worker memory
	DaskClusterMaxSingleWorkerMemory *InfoOKBodyDaskClusterMaxSingleWorkerMemory `json:"dask_cluster_max_single_worker_memory,omitempty"`

	// dask cluster max single worker threads
	DaskClusterMaxSingleWorkerThreads *InfoOKBodyDaskClusterMaxSingleWorkerThreads `json:"dask_cluster_max_single_worker_threads,omitempty"`

	// dask enabled
	DaskEnabled *InfoOKBodyDaskEnabled `json:"dask_enabled,omitempty"`

	// default kubernetes cpu limit
	DefaultKubernetesCPULimit *InfoOKBodyDefaultKubernetesCPULimit `json:"default_kubernetes_cpu_limit,omitempty"`

	// default kubernetes cpu request
	DefaultKubernetesCPURequest *InfoOKBodyDefaultKubernetesCPURequest `json:"default_kubernetes_cpu_request,omitempty"`

	// default kubernetes jobs timeout
	DefaultKubernetesJobsTimeout *InfoOKBodyDefaultKubernetesJobsTimeout `json:"default_kubernetes_jobs_timeout,omitempty"`

	// default kubernetes memory limit
	DefaultKubernetesMemoryLimit *InfoOKBodyDefaultKubernetesMemoryLimit `json:"default_kubernetes_memory_limit,omitempty"`

	// default kubernetes memory request
	DefaultKubernetesMemoryRequest *InfoOKBodyDefaultKubernetesMemoryRequest `json:"default_kubernetes_memory_request,omitempty"`

	// default workspace
	DefaultWorkspace *InfoOKBodyDefaultWorkspace `json:"default_workspace,omitempty"`

	// gitlab host
	GitlabHost *InfoOKBodyGitlabHost `json:"gitlab_host,omitempty"`

	// interactive session recommended jupyter images
	InteractiveSessionRecommendedJupyterImages *InfoOKBodyInteractiveSessionRecommendedJupyterImages `json:"interactive_session_recommended_jupyter_images,omitempty"`

	// interactive sessions custom image allowed
	InteractiveSessionsCustomImageAllowed *InfoOKBodyInteractiveSessionsCustomImageAllowed `json:"interactive_sessions_custom_image_allowed,omitempty"`

	// kubernetes max cpu limit
	KubernetesMaxCPULimit *InfoOKBodyKubernetesMaxCPULimit `json:"kubernetes_max_cpu_limit,omitempty"`

	// kubernetes max cpu request
	KubernetesMaxCPURequest *InfoOKBodyKubernetesMaxCPURequest `json:"kubernetes_max_cpu_request,omitempty"`

	// kubernetes max memory limit
	KubernetesMaxMemoryLimit *InfoOKBodyKubernetesMaxMemoryLimit `json:"kubernetes_max_memory_limit,omitempty"`

	// kubernetes max memory request
	KubernetesMaxMemoryRequest *InfoOKBodyKubernetesMaxMemoryRequest `json:"kubernetes_max_memory_request,omitempty"`

	// kubernetes min user uid
	KubernetesMinUserUID *InfoOKBodyKubernetesMinUserUID `json:"kubernetes_min_user_uid,omitempty"`

	// maximum interactive session inactivity period
	MaximumInteractiveSessionInactivityPeriod *InfoOKBodyMaximumInteractiveSessionInactivityPeriod `json:"maximum_interactive_session_inactivity_period,omitempty"`

	// maximum kubernetes jobs timeout
	MaximumKubernetesJobsTimeout *InfoOKBodyMaximumKubernetesJobsTimeout `json:"maximum_kubernetes_jobs_timeout,omitempty"`

	// maximum workspace retention period
	MaximumWorkspaceRetentionPeriod *InfoOKBodyMaximumWorkspaceRetentionPeriod `json:"maximum_workspace_retention_period,omitempty"`

	// snakemake engine version
	SnakemakeEngineVersion *InfoOKBodySnakemakeEngineVersion `json:"snakemake_engine_version,omitempty"`

	// supported workflow engines
	SupportedWorkflowEngines *InfoOKBodySupportedWorkflowEngines `json:"supported_workflow_engines,omitempty"`

	// vetted container images allowlist
	VettedContainerImagesAllowlist *InfoOKBodyVettedContainerImagesAllowlist `json:"vetted_container_images_allowlist,omitempty"`

	// vetted container images enabled
	VettedContainerImagesEnabled *InfoOKBodyVettedContainerImagesEnabled `json:"vetted_container_images_enabled,omitempty"`

	// workspaces available
	WorkspacesAvailable *InfoOKBodyWorkspacesAvailable `json:"workspaces_available,omitempty"`

	// yadage engine adage version
	YadageEngineAdageVersion *InfoOKBodyYadageEngineAdageVersion `json:"yadage_engine_adage_version,omitempty"`

	// yadage engine packtivity version
	YadageEnginePacktivityVersion *InfoOKBodyYadageEnginePacktivityVersion `json:"yadage_engine_packtivity_version,omitempty"`

	// yadage engine version
	YadageEngineVersion *InfoOKBodyYadageEngineVersion `json:"yadage_engine_version,omitempty"`
}

// Validate validates this info o k body
func (o *InfoOKBody) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (o *InfoOKBody) validateComputeBackends(formats strfmt.Registry) error {
	if swag.IsZero(o.ComputeBackends) { // not required
		return nil
	}

	if o.ComputeBackends != nil {
		if err := o.ComputeBackends.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "compute_backends")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "compute_backends")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateCwlEngineTool(formats strfmt.Registry) error {
	if swag.IsZero(o.CwlEngineTool) { // not required
		return nil
	}

	if o.CwlEngineTool != nil {
		if err := o.CwlEngineTool.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "cwl_engine_tool")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "cwl_engine_tool")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateCwlEngineVersion(formats strfmt.Registry) error {
	if swag.IsZero(o.CwlEngineVersion) { // not required
		return nil
	}

	if o.CwlEngineVersion != nil {
		if err := o.CwlEngineVersion.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "cwl_engine_version")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "cwl_engine_version")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateDaskAutoscalerEnabled(formats strfmt.Registry) error {
	if swag.IsZero(o.DaskAutoscalerEnabled) { // not required
		return nil
	}

	if o.DaskAutoscalerEnabled != nil {
		if err := o.DaskAutoscalerEnabled.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "dask_autoscaler_enabled")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "dask_autoscaler_enabled")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateDaskClusterDefaultNumberOfWorkers(formats strfmt.Registry) error {
	if swag.IsZero(o.DaskClusterDefaultNumberOfWorkers) { // not required
		return nil
	}

	if o.DaskClusterDefaultNumberOfWorkers != nil {
		if err := o.DaskClusterDefaultNumberOfWorkers.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "dask_cluster_default_number_of_workers")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "dask_cluster_default_number_of_workers")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateDaskClusterDefaultSingleWorkerMemory(formats strfmt.Registry) error {
	if swag.IsZero(o.DaskClusterDefaultSingleWorkerMemory) { // not required
		return nil
	}

	if o.DaskClusterDefaultSingleWorkerMemory != nil {
		if err := o.DaskClusterDefaultSingleWorkerMemory.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "dask_cluster_default_single_worker_memory")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "dask_cluster_default_single_worker_memory")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateDaskClusterDefaultSingleWorkerThreads(formats strfmt.Registry) error {
	if swag.IsZero(o.DaskClusterDefaultSingleWorkerThreads) { // not required
		return nil
	}

	if o.DaskClusterDefaultSingleWorkerThreads != nil {
		if err := o.DaskClusterDefaultSingleWorkerThreads.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "dask_cluster_default_single_worker_threads")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "dask_cluster_default_single_worker_threads")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateDaskClusterMaxMemoryLimit(formats strfmt.Registry) error {
	if swag.IsZero(o.DaskClusterMaxMemoryLimit) { // not required
		return nil
	}

	if o.DaskClusterMaxMemoryLimit != nil {
		if err := o.DaskClusterMaxMemoryLimit.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "dask_cluster_max_memory_limit")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "dask_cluster_max_memory_limit")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateDaskClusterMaxNumberOfWorkers(formats strfmt.Registry) error {
	if swag.IsZero(o.DaskClusterMaxNumberOfWorkers) { // not required
		return nil
	}

	if o.DaskClusterMaxNumberOfWorkers != nil {
		if err := o.DaskClusterMaxNumberOfWorkers.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "dask_cluster_max_number_of_workers")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "dask_cluster_max_number_of_workers")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateDaskClusterMaxSingleWorkerMemory(formats strfmt.Registry) error {
	if swag.IsZero(o.DaskClusterMaxSingleWorkerMemory) { // not required
		return nil
	}

	if o.DaskClusterMaxSingleWorkerMemory != nil {
		if err := o.DaskClusterMaxSingleWorkerMemory.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "dask_cluster_max_single_worker_memory")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "dask_cluster_max_single_worker_memory")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateDaskClusterMaxSingleWorkerThreads(formats strfmt.Registry) error {
	if swag.IsZero(o.DaskClusterMaxSingleWorkerThreads) { // not required
		return nil
	}

	if o.DaskClusterMaxSingleWorkerThreads != nil {
		if err := o.DaskClusterMaxSingleWorkerThreads.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "dask_cluster_max_single_worker_threads")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "dask_cluster_max_single_worker_threads")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateDaskEnabled(formats strfmt.Registry) error {
	if swag.IsZero(o.DaskEnabled) { // not required
		return nil
	}

	if o.DaskEnabled != nil {
		if err := o.DaskEnabled.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "dask_enabled")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "dask_enabled")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateDefaultKubernetesCPULimit(formats strfmt.Registry) error {
	if swag.IsZero(o.DefaultKubernetesCPULimit) { // not required
		return nil
	}

	if o.DefaultKubernetesCPULimit != nil {
		if err := o.DefaultKubernetesCPULimit.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "default_kubernetes_cpu_limit")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "default_kubernetes_cpu_limit")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateDefaultKubernetesCPURequest(formats strfmt.Registry) error {
	if swag.IsZero(o.DefaultKubernetesCPURequest) { // not required
		return nil
	}

	if o.DefaultKubernetesCPURequest != nil {
		if err := o.DefaultKubernetesCPURequest.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "default_kubernetes_cpu_request")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "default_kubernetes_cpu_request")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateDefaultKubernetesJobsTimeout(formats strfmt.Registry) error {
	if swag.IsZero(o.DefaultKubernetesJobsTimeout) { // not required
		return nil
	}

	if o.DefaultKubernetesJobsTimeout != nil {
		if err := o.DefaultKubernetesJobsTimeout.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "default_kubernetes_jobs_timeout")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "default_kubernetes_jobs_timeout")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateDefaultKubernetesMemoryLimit(formats strfmt.Registry) error {
	if swag.IsZero(o.DefaultKubernetesMemoryLimit) { // not required
		return nil
	}

	if o.DefaultKubernetesMemoryLimit != nil {
		if err := o.DefaultKubernetesMemoryLimit.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "default_kubernetes_memory_limit")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "default_kubernetes_memory_limit")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateDefaultKubernetesMemoryRequest(formats strfmt.Registry) error {
	if swag.IsZero(o.DefaultKubernetesMemoryRequest) { // not required
		return nil
	}

	if o.DefaultKubernetesMemoryRequest != nil {
		if err := o.DefaultKubernetesMemoryRequest.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "default_kubernetes_memory_request")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "default_kubernetes_memory_request")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateDefaultWorkspace(formats strfmt.Registry) error {
	if swag.IsZero(o.DefaultWorkspace) { // not required
		return nil
	}

	if o.DefaultWorkspace != nil {
		if err := o.DefaultWorkspace.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "default_workspace")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "default_workspace")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateGitlabHost(formats strfmt.Registry) error {
	if swag.IsZero(o.GitlabHost) { // not required
		return nil
	}

	if o.GitlabHost != nil {
		if err := o.GitlabHost.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "gitlab_host")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "gitlab_host")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateInteractiveSessionRecommendedJupyterImages(formats strfmt.Registry) error {
	if swag.IsZero(o.InteractiveSessionRecommendedJupyterImages) { // not required
		return nil
	}

	if o.InteractiveSessionRecommendedJupyterImages != nil {
		if err := o.InteractiveSessionRecommendedJupyterImages.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "interactive_session_recommended_jupyter_images")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "interactive_session_recommended_jupyter_images")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateInteractiveSessionsCustomImageAllowed(formats strfmt.Registry) error {
	if swag.IsZero(o.InteractiveSessionsCustomImageAllowed) { // not required
		return nil
	}

	if o.InteractiveSessionsCustomImageAllowed != nil {
		if err := o.InteractiveSessionsCustomImageAllowed.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "interactive_sessions_custom_image_allowed")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "interactive_sessions_custom_image_allowed")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateKubernetesMaxCPULimit(formats strfmt.Registry) error {
	if swag.IsZero(o.KubernetesMaxCPULimit) { // not required
		return nil
	}

	if o.KubernetesMaxCPULimit != nil {
		if err := o.KubernetesMaxCPULimit.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "kubernetes_max_cpu_limit")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "kubernetes_max_cpu_limit")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateKubernetesMaxCPURequest(formats strfmt.Registry) error {
	if swag.IsZero(o.KubernetesMaxCPURequest) { // not required
		return nil
	}

	if o.KubernetesMaxCPURequest != nil {
		if err := o.KubernetesMaxCPURequest.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "kubernetes_max_cpu_request")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "kubernetes_max_cpu_request")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateKubernetesMaxMemoryLimit(formats strfmt.Registry) error {
	if swag.IsZero(o.KubernetesMaxMemoryLimit) { // not required
		return nil
	}

	if o.KubernetesMaxMemoryLimit != nil {
		if err := o.KubernetesMaxMemoryLimit.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "kubernetes_max_memory_limit")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "kubernetes_max_memory_limit")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateKubernetesMaxMemoryRequest(formats strfmt.Registry) error {
	if swag.IsZero(o.KubernetesMaxMemoryRequest) { // not required
		return nil
	}

	if o.KubernetesMaxMemoryRequest != nil {
		if err := o.KubernetesMaxMemoryRequest.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "kubernetes_max_memory_request")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "kubernetes_max_memory_request")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateKubernetesMinUserUID(formats strfmt.Registry) error {
	if swag.IsZero(o.KubernetesMinUserUID) { // not required
		return nil
	}

	if o.KubernetesMinUserUID != nil {
		if err := o.KubernetesMinUserUID.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "kubernetes_min_user_uid")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "kubernetes_min_user_uid")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateMaximumInteractiveSessionInactivityPeriod(formats strfmt.Registry) error {
	if swag.IsZero(o.MaximumInteractiveSessionInactivityPeriod) { // not required
		return nil
	}

	if o.MaximumInteractiveSessionInactivityPeriod != nil {
		if err := o.MaximumInteractiveSessionInactivityPeriod.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "maximum_interactive_session_inactivity_period")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "maximum_interactive_session_inactivity_period")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateMaximumKubernetesJobsTimeout(formats strfmt.Registry) error {
	if swag.IsZero(o.MaximumKubernetesJobsTimeout) { // not required
		return nil
	}

	if o.MaximumKubernetesJobsTimeout != nil {
		if err := o.MaximumKubernetesJobsTimeout.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "maximum_kubernetes_jobs_timeout")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "maximum_kubernetes_jobs_timeout")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateMaximumWorkspaceRetentionPeriod(formats strfmt.Registry) error {
	if swag.IsZero(o.MaximumWorkspaceRetentionPeriod) { // not required
		return nil
	}

	if o.MaximumWorkspaceRetentionPeriod != nil {
		if err := o.MaximumWorkspaceRetentionPeriod.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "maximum_workspace_retention_period")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "maximum_workspace_retention_period")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateSnakemakeEngineVersion(formats strfmt.Registry) error {
	if swag.IsZero(o.SnakemakeEngineVersion) { // not required
		return nil
	}

	if o.SnakemakeEngineVersion != nil {
		if err := o.SnakemakeEngineVersion.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "snakemake_engine_version")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "snakemake_engine_version")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateSupportedWorkflowEngines(formats strfmt.Registry) error {
	if swag.IsZero(o.SupportedWorkflowEngines) { // not required
		return nil
	}

	if o.SupportedWorkflowEngines != nil {
		if err := o.SupportedWorkflowEngines.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "supported_workflow_engines")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "supported_workflow_engines")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateVettedContainerImagesAllowlist(formats strfmt.Registry) error {
	if swag.IsZero(o.VettedContainerImagesAllowlist) { // not required
		return nil
	}

	if o.VettedContainerImagesAllowlist != nil {
		if err := o.VettedContainerImagesAllowlist.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "vetted_container_images_allowlist")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "vetted_container_images_allowlist")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateVettedContainerImagesEnabled(formats strfmt.Registry) error {
	if swag.IsZero(o.VettedContainerImagesEnabled) { // not required
		return nil
	}

	if o.VettedContainerImagesEnabled != nil {
		if err := o.VettedContainerImagesEnabled.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "vetted_container_images_enabled")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "vetted_container_images_enabled")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateWorkspacesAvailable(formats strfmt.Registry) error {
	if swag.IsZero(o.WorkspacesAvailable) { // not required
		return nil
	}

	if o.WorkspacesAvailable != nil {
		if err := o.WorkspacesAvailable.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "workspaces_available")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "workspaces_available")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateYadageEngineAdageVersion(formats strfmt.Registry) error {
	if swag.IsZero(o.YadageEngineAdageVersion) { // not required
		return nil
	}

	if o.YadageEngineAdageVersion != nil {
		if err := o.YadageEngineAdageVersion.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "yadage_engine_adage_version")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "yadage_engine_adage_version")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateYadageEnginePacktivityVersion(formats strfmt.Registry) error {
	if swag.IsZero(o.YadageEnginePacktivityVersion) { // not required
		return nil
	}

	if o.YadageEnginePacktivityVersion != nil {
		if err := o.YadageEnginePacktivityVersion.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "yadage_engine_packtivity_version")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "yadage_engine_packtivity_version")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) validateYadageEngineVersion(formats strfmt.Registry) error {
	if swag.IsZero(o.YadageEngineVersion) { // not required
		return nil
	}

	if o.YadageEngineVersion != nil {
		if err := o.YadageEngineVersion.Validate(formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "yadage_engine_version")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "yadage_engine_version")
			}

			return err
		}
	}

	return nil
}

// ContextValidate validate this info o k body based on the context it is used
func (o *InfoOKBody) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := o.contextValidateComputeBackends(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateCwlEngineTool(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateCwlEngineVersion(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateDaskAutoscalerEnabled(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateDaskClusterDefaultNumberOfWorkers(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateDaskClusterDefaultSingleWorkerMemory(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateDaskClusterDefaultSingleWorkerThreads(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateDaskClusterMaxMemoryLimit(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateDaskClusterMaxNumberOfWorkers(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateDaskClusterMaxSingleWorkerMemory(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateDaskClusterMaxSingleWorkerThreads(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateDaskEnabled(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateDefaultKubernetesCPULimit(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateDefaultKubernetesCPURequest(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateDefaultKubernetesJobsTimeout(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateDefaultKubernetesMemoryLimit(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateDefaultKubernetesMemoryRequest(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateDefaultWorkspace(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateGitlabHost(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateInteractiveSessionRecommendedJupyterImages(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateInteractiveSessionsCustomImageAllowed(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateKubernetesMaxCPULimit(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateKubernetesMaxCPURequest(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateKubernetesMaxMemoryLimit(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateKubernetesMaxMemoryRequest(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateKubernetesMinUserUID(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateMaximumInteractiveSessionInactivityPeriod(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateMaximumKubernetesJobsTimeout(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateMaximumWorkspaceRetentionPeriod(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateSnakemakeEngineVersion(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateSupportedWorkflowEngines(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateVettedContainerImagesAllowlist(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateVettedContainerImagesEnabled(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateWorkspacesAvailable(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateYadageEngineAdageVersion(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateYadageEnginePacktivityVersion(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := o.contextValidateYadageEngineVersion(ctx, formats); err != nil {
		res = append(res, err)
	}

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

func (o *InfoOKBody) contextValidateComputeBackends(ctx context.Context, formats strfmt.Registry) error {

	if o.ComputeBackends != nil {

		if swag.IsZero(o.ComputeBackends) { // not required
			return nil
		}

		if err := o.ComputeBackends.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "compute_backends")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "compute_backends")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateCwlEngineTool(ctx context.Context, formats strfmt.Registry) error {

	if o.CwlEngineTool != nil {

		if swag.IsZero(o.CwlEngineTool) { // not required
			return nil
		}

		if err := o.CwlEngineTool.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "cwl_engine_tool")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "cwl_engine_tool")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateCwlEngineVersion(ctx context.Context, formats strfmt.Registry) error {

	if o.CwlEngineVersion != nil {

		if swag.IsZero(o.CwlEngineVersion) { // not required
			return nil
		}

		if err := o.CwlEngineVersion.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "cwl_engine_version")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "cwl_engine_version")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateDaskAutoscalerEnabled(ctx context.Context, formats strfmt.Registry) error {

	if o.DaskAutoscalerEnabled != nil {

		if swag.IsZero(o.DaskAutoscalerEnabled) { // not required
			return nil
		}

		if err := o.DaskAutoscalerEnabled.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "dask_autoscaler_enabled")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "dask_autoscaler_enabled")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateDaskClusterDefaultNumberOfWorkers(ctx context.Context, formats strfmt.Registry) error {

	if o.DaskClusterDefaultNumberOfWorkers != nil {

		if swag.IsZero(o.DaskClusterDefaultNumberOfWorkers) { // not required
			return nil
		}

		if err := o.DaskClusterDefaultNumberOfWorkers.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "dask_cluster_default_number_of_workers")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "dask_cluster_default_number_of_workers")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateDaskClusterDefaultSingleWorkerMemory(ctx context.Context, formats strfmt.Registry) error {

	if o.DaskClusterDefaultSingleWorkerMemory != nil {

		if swag.IsZero(o.DaskClusterDefaultSingleWorkerMemory) { // not required
			return nil
		}

		if err := o.DaskClusterDefaultSingleWorkerMemory.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "dask_cluster_default_single_worker_memory")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "dask_cluster_default_single_worker_memory")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateDaskClusterDefaultSingleWorkerThreads(ctx context.Context, formats strfmt.Registry) error {

	if o.DaskClusterDefaultSingleWorkerThreads != nil {

		if swag.IsZero(o.DaskClusterDefaultSingleWorkerThreads) { // not required
			return nil
		}

		if err := o.DaskClusterDefaultSingleWorkerThreads.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "dask_cluster_default_single_worker_threads")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "dask_cluster_default_single_worker_threads")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateDaskClusterMaxMemoryLimit(ctx context.Context, formats strfmt.Registry) error {

	if o.DaskClusterMaxMemoryLimit != nil {

		if swag.IsZero(o.DaskClusterMaxMemoryLimit) { // not required
			return nil
		}

		if err := o.DaskClusterMaxMemoryLimit.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "dask_cluster_max_memory_limit")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "dask_cluster_max_memory_limit")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateDaskClusterMaxNumberOfWorkers(ctx context.Context, formats strfmt.Registry) error {

	if o.DaskClusterMaxNumberOfWorkers != nil {

		if swag.IsZero(o.DaskClusterMaxNumberOfWorkers) { // not required
			return nil
		}

		if err := o.DaskClusterMaxNumberOfWorkers.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "dask_cluster_max_number_of_workers")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "dask_cluster_max_number_of_workers")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateDaskClusterMaxSingleWorkerMemory(ctx context.Context, formats strfmt.Registry) error {

	if o.DaskClusterMaxSingleWorkerMemory != nil {

		if swag.IsZero(o.DaskClusterMaxSingleWorkerMemory) { // not required
			return nil
		}

		if err := o.DaskClusterMaxSingleWorkerMemory.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "dask_cluster_max_single_worker_memory")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "dask_cluster_max_single_worker_memory")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateDaskClusterMaxSingleWorkerThreads(ctx context.Context, formats strfmt.Registry) error {

	if o.DaskClusterMaxSingleWorkerThreads != nil {

		if swag.IsZero(o.DaskClusterMaxSingleWorkerThreads) { // not required
			return nil
		}

		if err := o.DaskClusterMaxSingleWorkerThreads.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "dask_cluster_max_single_worker_threads")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "dask_cluster_max_single_worker_threads")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateDaskEnabled(ctx context.Context, formats strfmt.Registry) error {

	if o.DaskEnabled != nil {

		if swag.IsZero(o.DaskEnabled) { // not required
			return nil
		}

		if err := o.DaskEnabled.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "dask_enabled")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "dask_enabled")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateDefaultKubernetesCPULimit(ctx context.Context, formats strfmt.Registry) error {

	if o.DefaultKubernetesCPULimit != nil {

		if swag.IsZero(o.DefaultKubernetesCPULimit) { // not required
			return nil
		}

		if err := o.DefaultKubernetesCPULimit.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "default_kubernetes_cpu_limit")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "default_kubernetes_cpu_limit")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateDefaultKubernetesCPURequest(ctx context.Context, formats strfmt.Registry) error {

	if o.DefaultKubernetesCPURequest != nil {

		if swag.IsZero(o.DefaultKubernetesCPURequest) { // not required
			return nil
		}

		if err := o.DefaultKubernetesCPURequest.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "default_kubernetes_cpu_request")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "default_kubernetes_cpu_request")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateDefaultKubernetesJobsTimeout(ctx context.Context, formats strfmt.Registry) error {

	if o.DefaultKubernetesJobsTimeout != nil {

		if swag.IsZero(o.DefaultKubernetesJobsTimeout) { // not required
			return nil
		}

		if err := o.DefaultKubernetesJobsTimeout.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "default_kubernetes_jobs_timeout")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "default_kubernetes_jobs_timeout")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateDefaultKubernetesMemoryLimit(ctx context.Context, formats strfmt.Registry) error {

	if o.DefaultKubernetesMemoryLimit != nil {

		if swag.IsZero(o.DefaultKubernetesMemoryLimit) { // not required
			return nil
		}

		if err := o.DefaultKubernetesMemoryLimit.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "default_kubernetes_memory_limit")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "default_kubernetes_memory_limit")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateDefaultKubernetesMemoryRequest(ctx context.Context, formats strfmt.Registry) error {

	if o.DefaultKubernetesMemoryRequest != nil {

		if swag.IsZero(o.DefaultKubernetesMemoryRequest) { // not required
			return nil
		}

		if err := o.DefaultKubernetesMemoryRequest.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "default_kubernetes_memory_request")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "default_kubernetes_memory_request")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateDefaultWorkspace(ctx context.Context, formats strfmt.Registry) error {

	if o.DefaultWorkspace != nil {

		if swag.IsZero(o.DefaultWorkspace) { // not required
			return nil
		}

		if err := o.DefaultWorkspace.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "default_workspace")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "default_workspace")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateGitlabHost(ctx context.Context, formats strfmt.Registry) error {

	if o.GitlabHost != nil {

		if swag.IsZero(o.GitlabHost) { // not required
			return nil
		}

		if err := o.GitlabHost.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "gitlab_host")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "gitlab_host")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateInteractiveSessionRecommendedJupyterImages(ctx context.Context, formats strfmt.Registry) error {

	if o.InteractiveSessionRecommendedJupyterImages != nil {

		if swag.IsZero(o.InteractiveSessionRecommendedJupyterImages) { // not required
			return nil
		}

		if err := o.InteractiveSessionRecommendedJupyterImages.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "interactive_session_recommended_jupyter_images")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "interactive_session_recommended_jupyter_images")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateInteractiveSessionsCustomImageAllowed(ctx context.Context, formats strfmt.Registry) error {

	if o.InteractiveSessionsCustomImageAllowed != nil {

		if swag.IsZero(o.InteractiveSessionsCustomImageAllowed) { // not required
			return nil
		}

		if err := o.InteractiveSessionsCustomImageAllowed.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "interactive_sessions_custom_image_allowed")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "interactive_sessions_custom_image_allowed")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateKubernetesMaxCPULimit(ctx context.Context, formats strfmt.Registry) error {

	if o.KubernetesMaxCPULimit != nil {

		if swag.IsZero(o.KubernetesMaxCPULimit) { // not required
			return nil
		}

		if err := o.KubernetesMaxCPULimit.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "kubernetes_max_cpu_limit")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "kubernetes_max_cpu_limit")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateKubernetesMaxCPURequest(ctx context.Context, formats strfmt.Registry) error {

	if o.KubernetesMaxCPURequest != nil {

		if swag.IsZero(o.KubernetesMaxCPURequest) { // not required
			return nil
		}

		if err := o.KubernetesMaxCPURequest.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "kubernetes_max_cpu_request")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "kubernetes_max_cpu_request")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateKubernetesMaxMemoryLimit(ctx context.Context, formats strfmt.Registry) error {

	if o.KubernetesMaxMemoryLimit != nil {

		if swag.IsZero(o.KubernetesMaxMemoryLimit) { // not required
			return nil
		}

		if err := o.KubernetesMaxMemoryLimit.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "kubernetes_max_memory_limit")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "kubernetes_max_memory_limit")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateKubernetesMaxMemoryRequest(ctx context.Context, formats strfmt.Registry) error {

	if o.KubernetesMaxMemoryRequest != nil {

		if swag.IsZero(o.KubernetesMaxMemoryRequest) { // not required
			return nil
		}

		if err := o.KubernetesMaxMemoryRequest.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "kubernetes_max_memory_request")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "kubernetes_max_memory_request")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateKubernetesMinUserUID(ctx context.Context, formats strfmt.Registry) error {

	if o.KubernetesMinUserUID != nil {

		if swag.IsZero(o.KubernetesMinUserUID) { // not required
			return nil
		}

		if err := o.KubernetesMinUserUID.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "kubernetes_min_user_uid")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "kubernetes_min_user_uid")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateMaximumInteractiveSessionInactivityPeriod(ctx context.Context, formats strfmt.Registry) error {

	if o.MaximumInteractiveSessionInactivityPeriod != nil {

		if swag.IsZero(o.MaximumInteractiveSessionInactivityPeriod) { // not required
			return nil
		}

		if err := o.MaximumInteractiveSessionInactivityPeriod.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "maximum_interactive_session_inactivity_period")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "maximum_interactive_session_inactivity_period")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateMaximumKubernetesJobsTimeout(ctx context.Context, formats strfmt.Registry) error {

	if o.MaximumKubernetesJobsTimeout != nil {

		if swag.IsZero(o.MaximumKubernetesJobsTimeout) { // not required
			return nil
		}

		if err := o.MaximumKubernetesJobsTimeout.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "maximum_kubernetes_jobs_timeout")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "maximum_kubernetes_jobs_timeout")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateMaximumWorkspaceRetentionPeriod(ctx context.Context, formats strfmt.Registry) error {

	if o.MaximumWorkspaceRetentionPeriod != nil {

		if swag.IsZero(o.MaximumWorkspaceRetentionPeriod) { // not required
			return nil
		}

		if err := o.MaximumWorkspaceRetentionPeriod.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "maximum_workspace_retention_period")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "maximum_workspace_retention_period")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateSnakemakeEngineVersion(ctx context.Context, formats strfmt.Registry) error {

	if o.SnakemakeEngineVersion != nil {

		if swag.IsZero(o.SnakemakeEngineVersion) { // not required
			return nil
		}

		if err := o.SnakemakeEngineVersion.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "snakemake_engine_version")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "snakemake_engine_version")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateSupportedWorkflowEngines(ctx context.Context, formats strfmt.Registry) error {

	if o.SupportedWorkflowEngines != nil {

		if swag.IsZero(o.SupportedWorkflowEngines) { // not required
			return nil
		}

		if err := o.SupportedWorkflowEngines.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "supported_workflow_engines")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "supported_workflow_engines")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateVettedContainerImagesAllowlist(ctx context.Context, formats strfmt.Registry) error {

	if o.VettedContainerImagesAllowlist != nil {

		if swag.IsZero(o.VettedContainerImagesAllowlist) { // not required
			return nil
		}

		if err := o.VettedContainerImagesAllowlist.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "vetted_container_images_allowlist")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "vetted_container_images_allowlist")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateVettedContainerImagesEnabled(ctx context.Context, formats strfmt.Registry) error {

	if o.VettedContainerImagesEnabled != nil {

		if swag.IsZero(o.VettedContainerImagesEnabled) { // not required
			return nil
		}

		if err := o.VettedContainerImagesEnabled.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "vetted_container_images_enabled")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "vetted_container_images_enabled")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateWorkspacesAvailable(ctx context.Context, formats strfmt.Registry) error {

	if o.WorkspacesAvailable != nil {

		if swag.IsZero(o.WorkspacesAvailable) { // not required
			return nil
		}

		if err := o.WorkspacesAvailable.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "workspaces_available")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "workspaces_available")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateYadageEngineAdageVersion(ctx context.Context, formats strfmt.Registry) error {

	if o.YadageEngineAdageVersion != nil {

		if swag.IsZero(o.YadageEngineAdageVersion) { // not required
			return nil
		}

		if err := o.YadageEngineAdageVersion.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "yadage_engine_adage_version")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "yadage_engine_adage_version")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateYadageEnginePacktivityVersion(ctx context.Context, formats strfmt.Registry) error {

	if o.YadageEnginePacktivityVersion != nil {

		if swag.IsZero(o.YadageEnginePacktivityVersion) { // not required
			return nil
		}

		if err := o.YadageEnginePacktivityVersion.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "yadage_engine_packtivity_version")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "yadage_engine_packtivity_version")
			}

			return err
		}
	}

	return nil
}

func (o *InfoOKBody) contextValidateYadageEngineVersion(ctx context.Context, formats strfmt.Registry) error {

	if o.YadageEngineVersion != nil {

		if swag.IsZero(o.YadageEngineVersion) { // not required
			return nil
		}

		if err := o.YadageEngineVersion.ContextValidate(ctx, formats); err != nil {
			ve := new(errors.Validation)
			if stderrors.As(err, &ve) {
				return ve.ValidateName("infoOK" + "." + "yadage_engine_version")
			}
			ce := new(errors.CompositeError)
			if stderrors.As(err, &ce) {
				return ce.ValidateName("infoOK" + "." + "yadage_engine_version")
			}

			return err
		}
	}

	return nil
}

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

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

/*
InfoOKBodyComputeBackends info o k body compute backends
swagger:model InfoOKBodyComputeBackends
*/
type InfoOKBodyComputeBackends struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value []string `json:"value"`
}

// Validate validates this info o k body compute backends
func (o *InfoOKBodyComputeBackends) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body compute backends based on context it is used
func (o *InfoOKBodyComputeBackends) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyCwlEngineTool info o k body cwl engine tool
swagger:model InfoOKBodyCwlEngineTool
*/
type InfoOKBodyCwlEngineTool struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

// Validate validates this info o k body cwl engine tool
func (o *InfoOKBodyCwlEngineTool) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body cwl engine tool based on context it is used
func (o *InfoOKBodyCwlEngineTool) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyCwlEngineVersion info o k body cwl engine version
swagger:model InfoOKBodyCwlEngineVersion
*/
type InfoOKBodyCwlEngineVersion struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

// Validate validates this info o k body cwl engine version
func (o *InfoOKBodyCwlEngineVersion) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body cwl engine version based on context it is used
func (o *InfoOKBodyCwlEngineVersion) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyDaskAutoscalerEnabled info o k body dask autoscaler enabled
swagger:model InfoOKBodyDaskAutoscalerEnabled
*/
type InfoOKBodyDaskAutoscalerEnabled struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

// Validate validates this info o k body dask autoscaler enabled
func (o *InfoOKBodyDaskAutoscalerEnabled) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body dask autoscaler enabled based on context it is used
func (o *InfoOKBodyDaskAutoscalerEnabled) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyDaskClusterDefaultNumberOfWorkers info o k body dask cluster default number of workers
swagger:model InfoOKBodyDaskClusterDefaultNumberOfWorkers
*/
type InfoOKBodyDaskClusterDefaultNumberOfWorkers struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

// Validate validates this info o k body dask cluster default number of workers
func (o *InfoOKBodyDaskClusterDefaultNumberOfWorkers) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body dask cluster default number of workers based on context it is used
func (o *InfoOKBodyDaskClusterDefaultNumberOfWorkers) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyDaskClusterDefaultSingleWorkerMemory info o k body dask cluster default single worker memory
swagger:model InfoOKBodyDaskClusterDefaultSingleWorkerMemory
*/
type InfoOKBodyDaskClusterDefaultSingleWorkerMemory struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

// Validate validates this info o k body dask cluster default single worker memory
func (o *InfoOKBodyDaskClusterDefaultSingleWorkerMemory) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body dask cluster default single worker memory based on context it is used
func (o *InfoOKBodyDaskClusterDefaultSingleWorkerMemory) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyDaskClusterDefaultSingleWorkerThreads info o k body dask cluster default single worker threads
swagger:model InfoOKBodyDaskClusterDefaultSingleWorkerThreads
*/
type InfoOKBodyDaskClusterDefaultSingleWorkerThreads struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

// Validate validates this info o k body dask cluster default single worker threads
func (o *InfoOKBodyDaskClusterDefaultSingleWorkerThreads) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body dask cluster default single worker threads based on context it is used
func (o *InfoOKBodyDaskClusterDefaultSingleWorkerThreads) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyDaskClusterMaxMemoryLimit info o k body dask cluster max memory limit
swagger:model InfoOKBodyDaskClusterMaxMemoryLimit
*/
type InfoOKBodyDaskClusterMaxMemoryLimit struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

// Validate validates this info o k body dask cluster max memory limit
func (o *InfoOKBodyDaskClusterMaxMemoryLimit) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body dask cluster max memory limit based on context it is used
func (o *InfoOKBodyDaskClusterMaxMemoryLimit) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyDaskClusterMaxNumberOfWorkers info o k body dask cluster max number of workers
swagger:model InfoOKBodyDaskClusterMaxNumberOfWorkers
*/
type InfoOKBodyDaskClusterMaxNumberOfWorkers struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

// Validate validates this info o k body dask cluster max number of workers
func (o *InfoOKBodyDaskClusterMaxNumberOfWorkers) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body dask cluster max number of workers based on context it is used
func (o *InfoOKBodyDaskClusterMaxNumberOfWorkers) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyDaskClusterMaxSingleWorkerMemory info o k body dask cluster max single worker memory
swagger:model InfoOKBodyDaskClusterMaxSingleWorkerMemory
*/
type InfoOKBodyDaskClusterMaxSingleWorkerMemory struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

// Validate validates this info o k body dask cluster max single worker memory
func (o *InfoOKBodyDaskClusterMaxSingleWorkerMemory) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body dask cluster max single worker memory based on context it is used
func (o *InfoOKBodyDaskClusterMaxSingleWorkerMemory) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyDaskClusterMaxSingleWorkerThreads info o k body dask cluster max single worker threads
swagger:model InfoOKBodyDaskClusterMaxSingleWorkerThreads
*/
type InfoOKBodyDaskClusterMaxSingleWorkerThreads struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

// Validate validates this info o k body dask cluster max single worker threads
func (o *InfoOKBodyDaskClusterMaxSingleWorkerThreads) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body dask cluster max single worker threads based on context it is used
func (o *InfoOKBodyDaskClusterMaxSingleWorkerThreads) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyDaskEnabled info o k body dask enabled
swagger:model InfoOKBodyDaskEnabled
*/
type InfoOKBodyDaskEnabled struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

// Validate validates this info o k body dask enabled
func (o *InfoOKBodyDaskEnabled) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body dask enabled based on context it is used
func (o *InfoOKBodyDaskEnabled) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyDefaultKubernetesCPULimit info o k body default kubernetes CPU limit
swagger:model InfoOKBodyDefaultKubernetesCPULimit
*/
type InfoOKBodyDefaultKubernetesCPULimit struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value *string `json:"value,omitempty"`
}

// Validate validates this info o k body default kubernetes CPU limit
func (o *InfoOKBodyDefaultKubernetesCPULimit) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body default kubernetes CPU limit based on context it is used
func (o *InfoOKBodyDefaultKubernetesCPULimit) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyDefaultKubernetesCPURequest info o k body default kubernetes CPU request
swagger:model InfoOKBodyDefaultKubernetesCPURequest
*/
type InfoOKBodyDefaultKubernetesCPURequest struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value *string `json:"value,omitempty"`
}

// Validate validates this info o k body default kubernetes CPU request
func (o *InfoOKBodyDefaultKubernetesCPURequest) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body default kubernetes CPU request based on context it is used
func (o *InfoOKBodyDefaultKubernetesCPURequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyDefaultKubernetesJobsTimeout info o k body default kubernetes jobs timeout
swagger:model InfoOKBodyDefaultKubernetesJobsTimeout
*/
type InfoOKBodyDefaultKubernetesJobsTimeout struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

// Validate validates this info o k body default kubernetes jobs timeout
func (o *InfoOKBodyDefaultKubernetesJobsTimeout) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body default kubernetes jobs timeout based on context it is used
func (o *InfoOKBodyDefaultKubernetesJobsTimeout) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyDefaultKubernetesMemoryLimit info o k body default kubernetes memory limit
swagger:model InfoOKBodyDefaultKubernetesMemoryLimit
*/
type InfoOKBodyDefaultKubernetesMemoryLimit struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value *string `json:"value,omitempty"`
}

// Validate validates this info o k body default kubernetes memory limit
func (o *InfoOKBodyDefaultKubernetesMemoryLimit) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body default kubernetes memory limit based on context it is used
func (o *InfoOKBodyDefaultKubernetesMemoryLimit) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyDefaultKubernetesMemoryRequest info o k body default kubernetes memory request
swagger:model InfoOKBodyDefaultKubernetesMemoryRequest
*/
type InfoOKBodyDefaultKubernetesMemoryRequest struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value *string `json:"value,omitempty"`
}

// Validate validates this info o k body default kubernetes memory request
func (o *InfoOKBodyDefaultKubernetesMemoryRequest) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body default kubernetes memory request based on context it is used
func (o *InfoOKBodyDefaultKubernetesMemoryRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyDefaultWorkspace info o k body default workspace
swagger:model InfoOKBodyDefaultWorkspace
*/
type InfoOKBodyDefaultWorkspace struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

// Validate validates this info o k body default workspace
func (o *InfoOKBodyDefaultWorkspace) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body default workspace based on context it is used
func (o *InfoOKBodyDefaultWorkspace) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyGitlabHost info o k body gitlab host
swagger:model InfoOKBodyGitlabHost
*/
type InfoOKBodyGitlabHost struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

// Validate validates this info o k body gitlab host
func (o *InfoOKBodyGitlabHost) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body gitlab host based on context it is used
func (o *InfoOKBodyGitlabHost) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyInteractiveSessionRecommendedJupyterImages info o k body interactive session recommended jupyter images
swagger:model InfoOKBodyInteractiveSessionRecommendedJupyterImages
*/
type InfoOKBodyInteractiveSessionRecommendedJupyterImages struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value []string `json:"value"`
}

// Validate validates this info o k body interactive session recommended jupyter images
func (o *InfoOKBodyInteractiveSessionRecommendedJupyterImages) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body interactive session recommended jupyter images based on context it is used
func (o *InfoOKBodyInteractiveSessionRecommendedJupyterImages) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyInteractiveSessionsCustomImageAllowed info o k body interactive sessions custom image allowed
swagger:model InfoOKBodyInteractiveSessionsCustomImageAllowed
*/
type InfoOKBodyInteractiveSessionsCustomImageAllowed struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

// Validate validates this info o k body interactive sessions custom image allowed
func (o *InfoOKBodyInteractiveSessionsCustomImageAllowed) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body interactive sessions custom image allowed based on context it is used
func (o *InfoOKBodyInteractiveSessionsCustomImageAllowed) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyKubernetesMaxCPULimit info o k body kubernetes max CPU limit
swagger:model InfoOKBodyKubernetesMaxCPULimit
*/
type InfoOKBodyKubernetesMaxCPULimit struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value *string `json:"value,omitempty"`
}

// Validate validates this info o k body kubernetes max CPU limit
func (o *InfoOKBodyKubernetesMaxCPULimit) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body kubernetes max CPU limit based on context it is used
func (o *InfoOKBodyKubernetesMaxCPULimit) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyKubernetesMaxCPURequest info o k body kubernetes max CPU request
swagger:model InfoOKBodyKubernetesMaxCPURequest
*/
type InfoOKBodyKubernetesMaxCPURequest struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value *string `json:"value,omitempty"`
}

// Validate validates this info o k body kubernetes max CPU request
func (o *InfoOKBodyKubernetesMaxCPURequest) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body kubernetes max CPU request based on context it is used
func (o *InfoOKBodyKubernetesMaxCPURequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyKubernetesMaxMemoryLimit info o k body kubernetes max memory limit
swagger:model InfoOKBodyKubernetesMaxMemoryLimit
*/
type InfoOKBodyKubernetesMaxMemoryLimit struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value *string `json:"value,omitempty"`
}

// Validate validates this info o k body kubernetes max memory limit
func (o *InfoOKBodyKubernetesMaxMemoryLimit) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body kubernetes max memory limit based on context it is used
func (o *InfoOKBodyKubernetesMaxMemoryLimit) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyKubernetesMaxMemoryRequest info o k body kubernetes max memory request
swagger:model InfoOKBodyKubernetesMaxMemoryRequest
*/
type InfoOKBodyKubernetesMaxMemoryRequest struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value *string `json:"value,omitempty"`
}

// Validate validates this info o k body kubernetes max memory request
func (o *InfoOKBodyKubernetesMaxMemoryRequest) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body kubernetes max memory request based on context it is used
func (o *InfoOKBodyKubernetesMaxMemoryRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyKubernetesMinUserUID info o k body kubernetes min user UID
swagger:model InfoOKBodyKubernetesMinUserUID
*/
type InfoOKBodyKubernetesMinUserUID struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value int64 `json:"value,omitempty"`
}

// Validate validates this info o k body kubernetes min user UID
func (o *InfoOKBodyKubernetesMinUserUID) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body kubernetes min user UID based on context it is used
func (o *InfoOKBodyKubernetesMinUserUID) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyMaximumInteractiveSessionInactivityPeriod info o k body maximum interactive session inactivity period
swagger:model InfoOKBodyMaximumInteractiveSessionInactivityPeriod
*/
type InfoOKBodyMaximumInteractiveSessionInactivityPeriod struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value *string `json:"value,omitempty"`
}

// Validate validates this info o k body maximum interactive session inactivity period
func (o *InfoOKBodyMaximumInteractiveSessionInactivityPeriod) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body maximum interactive session inactivity period based on context it is used
func (o *InfoOKBodyMaximumInteractiveSessionInactivityPeriod) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyMaximumKubernetesJobsTimeout info o k body maximum kubernetes jobs timeout
swagger:model InfoOKBodyMaximumKubernetesJobsTimeout
*/
type InfoOKBodyMaximumKubernetesJobsTimeout struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

// Validate validates this info o k body maximum kubernetes jobs timeout
func (o *InfoOKBodyMaximumKubernetesJobsTimeout) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body maximum kubernetes jobs timeout based on context it is used
func (o *InfoOKBodyMaximumKubernetesJobsTimeout) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyMaximumWorkspaceRetentionPeriod info o k body maximum workspace retention period
swagger:model InfoOKBodyMaximumWorkspaceRetentionPeriod
*/
type InfoOKBodyMaximumWorkspaceRetentionPeriod struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value *string `json:"value,omitempty"`
}

// Validate validates this info o k body maximum workspace retention period
func (o *InfoOKBodyMaximumWorkspaceRetentionPeriod) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body maximum workspace retention period based on context it is used
func (o *InfoOKBodyMaximumWorkspaceRetentionPeriod) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodySnakemakeEngineVersion info o k body snakemake engine version
swagger:model InfoOKBodySnakemakeEngineVersion
*/
type InfoOKBodySnakemakeEngineVersion struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

// Validate validates this info o k body snakemake engine version
func (o *InfoOKBodySnakemakeEngineVersion) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body snakemake engine version based on context it is used
func (o *InfoOKBodySnakemakeEngineVersion) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodySupportedWorkflowEngines info o k body supported workflow engines
swagger:model InfoOKBodySupportedWorkflowEngines
*/
type InfoOKBodySupportedWorkflowEngines struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value []string `json:"value"`
}

// Validate validates this info o k body supported workflow engines
func (o *InfoOKBodySupportedWorkflowEngines) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body supported workflow engines based on context it is used
func (o *InfoOKBodySupportedWorkflowEngines) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyVettedContainerImagesAllowlist info o k body vetted container images allowlist
swagger:model InfoOKBodyVettedContainerImagesAllowlist
*/
type InfoOKBodyVettedContainerImagesAllowlist struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value []string `json:"value"`
}

// Validate validates this info o k body vetted container images allowlist
func (o *InfoOKBodyVettedContainerImagesAllowlist) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body vetted container images allowlist based on context it is used
func (o *InfoOKBodyVettedContainerImagesAllowlist) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyVettedContainerImagesEnabled info o k body vetted container images enabled
swagger:model InfoOKBodyVettedContainerImagesEnabled
*/
type InfoOKBodyVettedContainerImagesEnabled struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value bool `json:"value"`
}

// Validate validates this info o k body vetted container images enabled
func (o *InfoOKBodyVettedContainerImagesEnabled) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body vetted container images enabled based on context it is used
func (o *InfoOKBodyVettedContainerImagesEnabled) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyWorkspacesAvailable info o k body workspaces available
swagger:model InfoOKBodyWorkspacesAvailable
*/
type InfoOKBodyWorkspacesAvailable struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value []string `json:"value"`
}

// Validate validates this info o k body workspaces available
func (o *InfoOKBodyWorkspacesAvailable) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body workspaces available based on context it is used
func (o *InfoOKBodyWorkspacesAvailable) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyYadageEngineAdageVersion info o k body yadage engine adage version
swagger:model InfoOKBodyYadageEngineAdageVersion
*/
type InfoOKBodyYadageEngineAdageVersion struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

// Validate validates this info o k body yadage engine adage version
func (o *InfoOKBodyYadageEngineAdageVersion) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body yadage engine adage version based on context it is used
func (o *InfoOKBodyYadageEngineAdageVersion) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyYadageEnginePacktivityVersion info o k body yadage engine packtivity version
swagger:model InfoOKBodyYadageEnginePacktivityVersion
*/
type InfoOKBodyYadageEnginePacktivityVersion struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

// Validate validates this info o k body yadage engine packtivity version
func (o *InfoOKBodyYadageEnginePacktivityVersion) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body yadage engine packtivity version based on context it is used
func (o *InfoOKBodyYadageEnginePacktivityVersion) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

/*
InfoOKBodyYadageEngineVersion info o k body yadage engine version
swagger:model InfoOKBodyYadageEngineVersion
*/
type InfoOKBodyYadageEngineVersion struct {

	// title
	Title string `json:"title,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

// Validate validates this info o k body yadage engine version
func (o *InfoOKBodyYadageEngineVersion) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this info o k body yadage engine version based on context it is used
func (o *InfoOKBodyYadageEngineVersion) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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