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

package model

// 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"
	"strconv"

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

// OpenapiClusterItemStatus ClusterItemStatus
//
// ClusterItemStatus is the status of cluster.
//
// swagger:model openapiClusterItemStatus
type OpenapiClusterItemStatus struct {

	// Status of the cluster.
	// Example: AVAILABLE
	// Enum: [AVAILABLE CREATING MODIFYING PAUSED RESUMING UNAVAILABLE IMPORTING MAINTAINING PAUSING]
	ClusterStatus string `json:"cluster_status,omitempty"`

	// connection strings
	ConnectionStrings *OpenapiClusterItemStatusConnectionStrings `json:"connection_strings,omitempty"`

	// node map
	NodeMap *OpenapiClusterItemStatusNodeMap `json:"node_map,omitempty"`

	// TiDB version.
	// Example: v6.1.0
	TidbVersion string `json:"tidb_version,omitempty"`
}

// Validate validates this openapi cluster item status
func (m *OpenapiClusterItemStatus) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

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

var openapiClusterItemStatusTypeClusterStatusPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["AVAILABLE","CREATING","MODIFYING","PAUSED","RESUMING","UNAVAILABLE","IMPORTING","MAINTAINING","PAUSING"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		openapiClusterItemStatusTypeClusterStatusPropEnum = append(openapiClusterItemStatusTypeClusterStatusPropEnum, v)
	}
}

const (

	// OpenapiClusterItemStatusClusterStatusAVAILABLE captures enum value "AVAILABLE"
	OpenapiClusterItemStatusClusterStatusAVAILABLE string = "AVAILABLE"

	// OpenapiClusterItemStatusClusterStatusCREATING captures enum value "CREATING"
	OpenapiClusterItemStatusClusterStatusCREATING string = "CREATING"

	// OpenapiClusterItemStatusClusterStatusMODIFYING captures enum value "MODIFYING"
	OpenapiClusterItemStatusClusterStatusMODIFYING string = "MODIFYING"

	// OpenapiClusterItemStatusClusterStatusPAUSED captures enum value "PAUSED"
	OpenapiClusterItemStatusClusterStatusPAUSED string = "PAUSED"

	// OpenapiClusterItemStatusClusterStatusRESUMING captures enum value "RESUMING"
	OpenapiClusterItemStatusClusterStatusRESUMING string = "RESUMING"

	// OpenapiClusterItemStatusClusterStatusUNAVAILABLE captures enum value "UNAVAILABLE"
	OpenapiClusterItemStatusClusterStatusUNAVAILABLE string = "UNAVAILABLE"

	// OpenapiClusterItemStatusClusterStatusIMPORTING captures enum value "IMPORTING"
	OpenapiClusterItemStatusClusterStatusIMPORTING string = "IMPORTING"

	// OpenapiClusterItemStatusClusterStatusMAINTAINING captures enum value "MAINTAINING"
	OpenapiClusterItemStatusClusterStatusMAINTAINING string = "MAINTAINING"

	// OpenapiClusterItemStatusClusterStatusPAUSING captures enum value "PAUSING"
	OpenapiClusterItemStatusClusterStatusPAUSING string = "PAUSING"
)

// prop value enum
func (m *OpenapiClusterItemStatus) validateClusterStatusEnum(path, location string, value string) error {
	if err := validate.EnumCase(path, location, value, openapiClusterItemStatusTypeClusterStatusPropEnum, true); err != nil {
		return err
	}
	return nil
}

func (m *OpenapiClusterItemStatus) validateClusterStatus(formats strfmt.Registry) error {
	if swag.IsZero(m.ClusterStatus) { // not required
		return nil
	}

	// value enum
	if err := m.validateClusterStatusEnum("cluster_status", "body", m.ClusterStatus); err != nil {
		return err
	}

	return nil
}

func (m *OpenapiClusterItemStatus) validateConnectionStrings(formats strfmt.Registry) error {
	if swag.IsZero(m.ConnectionStrings) { // not required
		return nil
	}

	if m.ConnectionStrings != nil {
		if err := m.ConnectionStrings.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("connection_strings")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("connection_strings")
			}
			return err
		}
	}

	return nil
}

func (m *OpenapiClusterItemStatus) validateNodeMap(formats strfmt.Registry) error {
	if swag.IsZero(m.NodeMap) { // not required
		return nil
	}

	if m.NodeMap != nil {
		if err := m.NodeMap.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("node_map")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("node_map")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this openapi cluster item status based on the context it is used
func (m *OpenapiClusterItemStatus) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

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

func (m *OpenapiClusterItemStatus) contextValidateConnectionStrings(ctx context.Context, formats strfmt.Registry) error {

	if m.ConnectionStrings != nil {

		if swag.IsZero(m.ConnectionStrings) { // not required
			return nil
		}

		if err := m.ConnectionStrings.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("connection_strings")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("connection_strings")
			}
			return err
		}
	}

	return nil
}

func (m *OpenapiClusterItemStatus) contextValidateNodeMap(ctx context.Context, formats strfmt.Registry) error {

	if m.NodeMap != nil {

		if swag.IsZero(m.NodeMap) { // not required
			return nil
		}

		if err := m.NodeMap.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("node_map")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("node_map")
			}
			return err
		}
	}

	return nil
}

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

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

// OpenapiClusterItemStatusConnectionStrings Connection strings.
//
// swagger:model OpenapiClusterItemStatusConnectionStrings
type OpenapiClusterItemStatusConnectionStrings struct {

	// The default TiDB user for connection.
	// Example: root
	DefaultUser string `json:"default_user,omitempty"`

	// standard
	Standard *OpenapiClusterItemStatusConnectionStringsStandard `json:"standard,omitempty"`

	// vpc peering
	VpcPeering *OpenapiClusterItemStatusConnectionStringsVpcPeering `json:"vpc_peering,omitempty"`
}

// Validate validates this openapi cluster item status connection strings
func (m *OpenapiClusterItemStatusConnectionStrings) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

func (m *OpenapiClusterItemStatusConnectionStrings) validateStandard(formats strfmt.Registry) error {
	if swag.IsZero(m.Standard) { // not required
		return nil
	}

	if m.Standard != nil {
		if err := m.Standard.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("connection_strings" + "." + "standard")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("connection_strings" + "." + "standard")
			}
			return err
		}
	}

	return nil
}

func (m *OpenapiClusterItemStatusConnectionStrings) validateVpcPeering(formats strfmt.Registry) error {
	if swag.IsZero(m.VpcPeering) { // not required
		return nil
	}

	if m.VpcPeering != nil {
		if err := m.VpcPeering.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("connection_strings" + "." + "vpc_peering")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("connection_strings" + "." + "vpc_peering")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this openapi cluster item status connection strings based on the context it is used
func (m *OpenapiClusterItemStatusConnectionStrings) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

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

func (m *OpenapiClusterItemStatusConnectionStrings) contextValidateStandard(ctx context.Context, formats strfmt.Registry) error {

	if m.Standard != nil {

		if swag.IsZero(m.Standard) { // not required
			return nil
		}

		if err := m.Standard.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("connection_strings" + "." + "standard")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("connection_strings" + "." + "standard")
			}
			return err
		}
	}

	return nil
}

func (m *OpenapiClusterItemStatusConnectionStrings) contextValidateVpcPeering(ctx context.Context, formats strfmt.Registry) error {

	if m.VpcPeering != nil {

		if swag.IsZero(m.VpcPeering) { // not required
			return nil
		}

		if err := m.VpcPeering.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("connection_strings" + "." + "vpc_peering")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("connection_strings" + "." + "vpc_peering")
			}
			return err
		}
	}

	return nil
}

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

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

// OpenapiClusterItemStatusConnectionStringsStandard Standard connection string.
//
// You must configure the [IP Access List](https://docs.pingcap.com/tidbcloud/connect-to-tidb-cluster#connect-via-standard-connection) for the cluster you created on [TiDB Cloud console](https://tidbcloud.com/) before connecting to this connection string.
//
// swagger:model OpenapiClusterItemStatusConnectionStringsStandard
type OpenapiClusterItemStatusConnectionStringsStandard struct {

	// The host of standard connection.
	// Example: tidb.f69f3808.acea1f2a.us-east-1.shared.aws.tidbcloud.com
	Host string `json:"host,omitempty"`

	// The TiDB port for connection. The port must be in the range of 1024-65535 except 10080.
	//
	// **Limitations**:
	// - For a TiDB Serverless cluster, only port `4000` is available.
	// Example: 4000
	// Maximum: 65535
	// Minimum: 1024
	Port int32 `json:"port,omitempty"`
}

// Validate validates this openapi cluster item status connection strings standard
func (m *OpenapiClusterItemStatusConnectionStringsStandard) Validate(formats strfmt.Registry) error {
	var res []error

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

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

func (m *OpenapiClusterItemStatusConnectionStringsStandard) validatePort(formats strfmt.Registry) error {
	if swag.IsZero(m.Port) { // not required
		return nil
	}

	if err := validate.MinimumInt("connection_strings"+"."+"standard"+"."+"port", "body", int64(m.Port), 1024, false); err != nil {
		return err
	}

	if err := validate.MaximumInt("connection_strings"+"."+"standard"+"."+"port", "body", int64(m.Port), 65535, false); err != nil {
		return err
	}

	return nil
}

// ContextValidate validates this openapi cluster item status connection strings standard based on context it is used
func (m *OpenapiClusterItemStatusConnectionStringsStandard) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

// OpenapiClusterItemStatusConnectionStringsVpcPeering [VPC peering](https://docs.pingcap.com/tidbcloud/tidb-cloud-glossary#vpc-peering) connection string.
//
// You must [Set up VPC peering connections](https://docs.pingcap.com/tidbcloud/set-up-vpc-peering-connections) for the project before connecting to this private connection string.
//
// swagger:model OpenapiClusterItemStatusConnectionStringsVpcPeering
type OpenapiClusterItemStatusConnectionStringsVpcPeering struct {

	// The host of VPC peering connection.
	// Example: private-tidb.f69f3808.acea1f2a.us-east-1.shared.aws.tidbcloud.com
	Host string `json:"host,omitempty"`

	// The TiDB port for connection. The port must be in the range of 1024-65535 except 10080.
	//
	// **Limitations**:
	// - For a TiDB Serverless cluster, only port `4000` is available.
	// Example: 4000
	// Maximum: 65535
	// Minimum: 1024
	Port int32 `json:"port,omitempty"`
}

// Validate validates this openapi cluster item status connection strings vpc peering
func (m *OpenapiClusterItemStatusConnectionStringsVpcPeering) Validate(formats strfmt.Registry) error {
	var res []error

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

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

func (m *OpenapiClusterItemStatusConnectionStringsVpcPeering) validatePort(formats strfmt.Registry) error {
	if swag.IsZero(m.Port) { // not required
		return nil
	}

	if err := validate.MinimumInt("connection_strings"+"."+"vpc_peering"+"."+"port", "body", int64(m.Port), 1024, false); err != nil {
		return err
	}

	if err := validate.MaximumInt("connection_strings"+"."+"vpc_peering"+"."+"port", "body", int64(m.Port), 65535, false); err != nil {
		return err
	}

	return nil
}

// ContextValidate validates this openapi cluster item status connection strings vpc peering based on context it is used
func (m *OpenapiClusterItemStatusConnectionStringsVpcPeering) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

// OpenapiClusterItemStatusNodeMap Node map. The `node_map` is returned only when the `cluster_status` is `"AVAILABLE"` or `"MODIFYING"`.
//
// swagger:model OpenapiClusterItemStatusNodeMap
type OpenapiClusterItemStatusNodeMap struct {

	// TiDB node map.
	// Example: [{"availability_zone":"us-west-2a","node_name":"tidb-0","node_size":"8C16G","ram_bytes":"17179869184","status":"NODE_STATUS_AVAILABLE","vcpu_num":8},{"availability_zone":"us-west-2b","node_name":"tidb-1","node_size":"8C16G","ram_bytes":"17179869184","status":"NODE_STATUS_AVAILABLE","vcpu_num":8}]
	// Required: true
	Tidb []*OpenapiClusterItemStatusNodeMapTidbItems0 `json:"tidb"`

	// TiFlash node map.
	// Example: [{"availability_zone":"us-west-2a","node_name":"tiflash-0","node_size":"8C64G","ram_bytes":"68719476736","status":"NODE_STATUS_AVAILABLE","storage_size_gib":1024,"vcpu_num":8},{"availability_zone":"us-west-2b","node_name":"tiflash-1","node_size":"8C64G","ram_bytes":"68719476736","status":"NODE_STATUS_AVAILABLE","storage_size_gib":1024,"vcpu_num":8}]
	Tiflash []*OpenapiClusterItemStatusNodeMapTiflashItems0 `json:"tiflash"`

	// TiKV node map.
	// Example: [{"availability_zone":"us-west-2a","node_name":"tikv-0","node_size":"8C32G","ram_bytes":"68719476736","status":"NODE_STATUS_AVAILABLE","storage_size_gib":1024,"vcpu_num":8},{"availability_zone":"us-west-2b","node_name":"tikv-1","node_size":"8C64G","ram_bytes":"68719476736","status":"NODE_STATUS_AVAILABLE","storage_size_gib":1024,"vcpu_num":8},{"availability_zone":"us-west-2c","node_name":"tikv-2","node_size":"8C64G","ram_bytes":"68719476736","status":"NODE_STATUS_AVAILABLE","storage_size_gib":1024,"vcpu_num":8}]
	// Required: true
	Tikv []*OpenapiClusterItemStatusNodeMapTikvItems0 `json:"tikv"`
}

// Validate validates this openapi cluster item status node map
func (m *OpenapiClusterItemStatusNodeMap) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

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

func (m *OpenapiClusterItemStatusNodeMap) validateTidb(formats strfmt.Registry) error {

	if err := validate.Required("node_map"+"."+"tidb", "body", m.Tidb); err != nil {
		return err
	}

	for i := 0; i < len(m.Tidb); i++ {
		if swag.IsZero(m.Tidb[i]) { // not required
			continue
		}

		if m.Tidb[i] != nil {
			if err := m.Tidb[i].Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("node_map" + "." + "tidb" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("node_map" + "." + "tidb" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

func (m *OpenapiClusterItemStatusNodeMap) validateTiflash(formats strfmt.Registry) error {
	if swag.IsZero(m.Tiflash) { // not required
		return nil
	}

	for i := 0; i < len(m.Tiflash); i++ {
		if swag.IsZero(m.Tiflash[i]) { // not required
			continue
		}

		if m.Tiflash[i] != nil {
			if err := m.Tiflash[i].Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("node_map" + "." + "tiflash" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("node_map" + "." + "tiflash" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

func (m *OpenapiClusterItemStatusNodeMap) validateTikv(formats strfmt.Registry) error {

	if err := validate.Required("node_map"+"."+"tikv", "body", m.Tikv); err != nil {
		return err
	}

	for i := 0; i < len(m.Tikv); i++ {
		if swag.IsZero(m.Tikv[i]) { // not required
			continue
		}

		if m.Tikv[i] != nil {
			if err := m.Tikv[i].Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("node_map" + "." + "tikv" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("node_map" + "." + "tikv" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

// ContextValidate validate this openapi cluster item status node map based on the context it is used
func (m *OpenapiClusterItemStatusNodeMap) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

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

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

func (m *OpenapiClusterItemStatusNodeMap) contextValidateTidb(ctx context.Context, formats strfmt.Registry) error {

	for i := 0; i < len(m.Tidb); i++ {

		if m.Tidb[i] != nil {

			if swag.IsZero(m.Tidb[i]) { // not required
				return nil
			}

			if err := m.Tidb[i].ContextValidate(ctx, formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("node_map" + "." + "tidb" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("node_map" + "." + "tidb" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

func (m *OpenapiClusterItemStatusNodeMap) contextValidateTiflash(ctx context.Context, formats strfmt.Registry) error {

	for i := 0; i < len(m.Tiflash); i++ {

		if m.Tiflash[i] != nil {

			if swag.IsZero(m.Tiflash[i]) { // not required
				return nil
			}

			if err := m.Tiflash[i].ContextValidate(ctx, formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("node_map" + "." + "tiflash" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("node_map" + "." + "tiflash" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

func (m *OpenapiClusterItemStatusNodeMap) contextValidateTikv(ctx context.Context, formats strfmt.Registry) error {

	for i := 0; i < len(m.Tikv); i++ {

		if m.Tikv[i] != nil {

			if swag.IsZero(m.Tikv[i]) { // not required
				return nil
			}

			if err := m.Tikv[i].ContextValidate(ctx, formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("node_map" + "." + "tikv" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("node_map" + "." + "tikv" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

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

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

// OpenapiClusterItemStatusNodeMapTidbItems0 openapi cluster item status node map tidb items0
//
// swagger:model OpenapiClusterItemStatusNodeMapTidbItems0
type OpenapiClusterItemStatusNodeMapTidbItems0 struct {

	// The availability zone of a node in the cluster.
	// Example: us-west-2a
	AvailabilityZone string `json:"availability_zone,omitempty"`

	// The name of a node in the cluster.
	// Example: tidb-0
	NodeName string `json:"node_name,omitempty"`

	// The size of the TiDB component in the cluster.
	// Example: 8C16G
	NodeSize string `json:"node_size,omitempty"`

	// The RAM size of a node in the cluster. If the `cluster_type` is `"DEVELOPER"`, `ram_bytes` is always 0.
	// Example: 17179869184
	RAMBytes string `json:"ram_bytes,omitempty"`

	// The status of a node in the cluster.
	// Example: NODE_STATUS_AVAILABLE
	// Enum: [NODE_STATUS_AVAILABLE NODE_STATUS_UNAVAILABLE NODE_STATUS_CREATING NODE_STATUS_DELETING]
	Status string `json:"status,omitempty"`

	// The total vCPUs of a node in the cluster. If the `cluster_type` is `"DEVELOPER"`, `vcpu_num` is always 0.
	// Example: 8
	VcpuNum int32 `json:"vcpu_num,omitempty"`
}

// Validate validates this openapi cluster item status node map tidb items0
func (m *OpenapiClusterItemStatusNodeMapTidbItems0) Validate(formats strfmt.Registry) error {
	var res []error

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

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

var openapiClusterItemStatusNodeMapTidbItems0TypeStatusPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["NODE_STATUS_AVAILABLE","NODE_STATUS_UNAVAILABLE","NODE_STATUS_CREATING","NODE_STATUS_DELETING"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		openapiClusterItemStatusNodeMapTidbItems0TypeStatusPropEnum = append(openapiClusterItemStatusNodeMapTidbItems0TypeStatusPropEnum, v)
	}
}

const (

	// OpenapiClusterItemStatusNodeMapTidbItems0StatusNODESTATUSAVAILABLE captures enum value "NODE_STATUS_AVAILABLE"
	OpenapiClusterItemStatusNodeMapTidbItems0StatusNODESTATUSAVAILABLE string = "NODE_STATUS_AVAILABLE"

	// OpenapiClusterItemStatusNodeMapTidbItems0StatusNODESTATUSUNAVAILABLE captures enum value "NODE_STATUS_UNAVAILABLE"
	OpenapiClusterItemStatusNodeMapTidbItems0StatusNODESTATUSUNAVAILABLE string = "NODE_STATUS_UNAVAILABLE"

	// OpenapiClusterItemStatusNodeMapTidbItems0StatusNODESTATUSCREATING captures enum value "NODE_STATUS_CREATING"
	OpenapiClusterItemStatusNodeMapTidbItems0StatusNODESTATUSCREATING string = "NODE_STATUS_CREATING"

	// OpenapiClusterItemStatusNodeMapTidbItems0StatusNODESTATUSDELETING captures enum value "NODE_STATUS_DELETING"
	OpenapiClusterItemStatusNodeMapTidbItems0StatusNODESTATUSDELETING string = "NODE_STATUS_DELETING"
)

// prop value enum
func (m *OpenapiClusterItemStatusNodeMapTidbItems0) validateStatusEnum(path, location string, value string) error {
	if err := validate.EnumCase(path, location, value, openapiClusterItemStatusNodeMapTidbItems0TypeStatusPropEnum, true); err != nil {
		return err
	}
	return nil
}

func (m *OpenapiClusterItemStatusNodeMapTidbItems0) validateStatus(formats strfmt.Registry) error {
	if swag.IsZero(m.Status) { // not required
		return nil
	}

	// value enum
	if err := m.validateStatusEnum("status", "body", m.Status); err != nil {
		return err
	}

	return nil
}

// ContextValidate validates this openapi cluster item status node map tidb items0 based on context it is used
func (m *OpenapiClusterItemStatusNodeMapTidbItems0) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

// OpenapiClusterItemStatusNodeMapTiflashItems0 openapi cluster item status node map tiflash items0
//
// swagger:model OpenapiClusterItemStatusNodeMapTiflashItems0
type OpenapiClusterItemStatusNodeMapTiflashItems0 struct {

	// The availability zone of a node in the cluster.
	// Example: us-west-2a
	AvailabilityZone string `json:"availability_zone,omitempty"`

	// The name of a node in the cluster.
	// Example: tiflash-0
	NodeName string `json:"node_name,omitempty"`

	// The size of the TiFlash component in the cluster.
	// Example: 8C64G
	NodeSize string `json:"node_size,omitempty"`

	// The RAM size of a node in the cluster. If the `cluster_type` is `"DEVELOPER"`, `ram_bytes` is always 0.
	// Example: 68719476736
	RAMBytes string `json:"ram_bytes,omitempty"`

	// The status of a node in the cluster.
	// Example: NODE_STATUS_AVAILABLE
	// Enum: [NODE_STATUS_AVAILABLE NODE_STATUS_UNAVAILABLE NODE_STATUS_CREATING NODE_STATUS_DELETING]
	Status string `json:"status,omitempty"`

	// The storage size of a node in the cluster.
	// Example: 1024
	StorageSizeGib int32 `json:"storage_size_gib,omitempty"`

	// The total vCPUs of a node in the cluster. If the `cluster_type` is `"DEVELOPER"`, `vcpu_num` is always 0.
	// Example: 8
	VcpuNum int32 `json:"vcpu_num,omitempty"`
}

// Validate validates this openapi cluster item status node map tiflash items0
func (m *OpenapiClusterItemStatusNodeMapTiflashItems0) Validate(formats strfmt.Registry) error {
	var res []error

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

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

var openapiClusterItemStatusNodeMapTiflashItems0TypeStatusPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["NODE_STATUS_AVAILABLE","NODE_STATUS_UNAVAILABLE","NODE_STATUS_CREATING","NODE_STATUS_DELETING"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		openapiClusterItemStatusNodeMapTiflashItems0TypeStatusPropEnum = append(openapiClusterItemStatusNodeMapTiflashItems0TypeStatusPropEnum, v)
	}
}

const (

	// OpenapiClusterItemStatusNodeMapTiflashItems0StatusNODESTATUSAVAILABLE captures enum value "NODE_STATUS_AVAILABLE"
	OpenapiClusterItemStatusNodeMapTiflashItems0StatusNODESTATUSAVAILABLE string = "NODE_STATUS_AVAILABLE"

	// OpenapiClusterItemStatusNodeMapTiflashItems0StatusNODESTATUSUNAVAILABLE captures enum value "NODE_STATUS_UNAVAILABLE"
	OpenapiClusterItemStatusNodeMapTiflashItems0StatusNODESTATUSUNAVAILABLE string = "NODE_STATUS_UNAVAILABLE"

	// OpenapiClusterItemStatusNodeMapTiflashItems0StatusNODESTATUSCREATING captures enum value "NODE_STATUS_CREATING"
	OpenapiClusterItemStatusNodeMapTiflashItems0StatusNODESTATUSCREATING string = "NODE_STATUS_CREATING"

	// OpenapiClusterItemStatusNodeMapTiflashItems0StatusNODESTATUSDELETING captures enum value "NODE_STATUS_DELETING"
	OpenapiClusterItemStatusNodeMapTiflashItems0StatusNODESTATUSDELETING string = "NODE_STATUS_DELETING"
)

// prop value enum
func (m *OpenapiClusterItemStatusNodeMapTiflashItems0) validateStatusEnum(path, location string, value string) error {
	if err := validate.EnumCase(path, location, value, openapiClusterItemStatusNodeMapTiflashItems0TypeStatusPropEnum, true); err != nil {
		return err
	}
	return nil
}

func (m *OpenapiClusterItemStatusNodeMapTiflashItems0) validateStatus(formats strfmt.Registry) error {
	if swag.IsZero(m.Status) { // not required
		return nil
	}

	// value enum
	if err := m.validateStatusEnum("status", "body", m.Status); err != nil {
		return err
	}

	return nil
}

// ContextValidate validates this openapi cluster item status node map tiflash items0 based on context it is used
func (m *OpenapiClusterItemStatusNodeMapTiflashItems0) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

// OpenapiClusterItemStatusNodeMapTikvItems0 openapi cluster item status node map tikv items0
//
// swagger:model OpenapiClusterItemStatusNodeMapTikvItems0
type OpenapiClusterItemStatusNodeMapTikvItems0 struct {

	// The availability zone of a node in the cluster.
	// Example: us-west-2a
	AvailabilityZone string `json:"availability_zone,omitempty"`

	// The name of a node in the cluster.
	// Example: tikv-0
	NodeName string `json:"node_name,omitempty"`

	// The size of the TiKV component in the cluster.
	// Example: 8C32G
	NodeSize string `json:"node_size,omitempty"`

	// The RAM size of a node in the cluster. If the `cluster_type` is `"DEVELOPER"`, `ram_bytes` is always 0.
	// Example: 68719476736
	RAMBytes string `json:"ram_bytes,omitempty"`

	// The status of a node in the cluster.
	// Example: NODE_STATUS_AVAILABLE
	// Enum: [NODE_STATUS_AVAILABLE NODE_STATUS_UNAVAILABLE NODE_STATUS_CREATING NODE_STATUS_DELETING]
	Status string `json:"status,omitempty"`

	// The storage size of a node in the cluster.
	// Example: 1024
	StorageSizeGib int32 `json:"storage_size_gib,omitempty"`

	// The total vCPUs of a node in the cluster. If the `cluster_type` is `"DEVELOPER"`, `vcpu_num` is always 0.
	// Example: 8
	VcpuNum int32 `json:"vcpu_num,omitempty"`
}

// Validate validates this openapi cluster item status node map tikv items0
func (m *OpenapiClusterItemStatusNodeMapTikvItems0) Validate(formats strfmt.Registry) error {
	var res []error

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

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

var openapiClusterItemStatusNodeMapTikvItems0TypeStatusPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["NODE_STATUS_AVAILABLE","NODE_STATUS_UNAVAILABLE","NODE_STATUS_CREATING","NODE_STATUS_DELETING"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		openapiClusterItemStatusNodeMapTikvItems0TypeStatusPropEnum = append(openapiClusterItemStatusNodeMapTikvItems0TypeStatusPropEnum, v)
	}
}

const (

	// OpenapiClusterItemStatusNodeMapTikvItems0StatusNODESTATUSAVAILABLE captures enum value "NODE_STATUS_AVAILABLE"
	OpenapiClusterItemStatusNodeMapTikvItems0StatusNODESTATUSAVAILABLE string = "NODE_STATUS_AVAILABLE"

	// OpenapiClusterItemStatusNodeMapTikvItems0StatusNODESTATUSUNAVAILABLE captures enum value "NODE_STATUS_UNAVAILABLE"
	OpenapiClusterItemStatusNodeMapTikvItems0StatusNODESTATUSUNAVAILABLE string = "NODE_STATUS_UNAVAILABLE"

	// OpenapiClusterItemStatusNodeMapTikvItems0StatusNODESTATUSCREATING captures enum value "NODE_STATUS_CREATING"
	OpenapiClusterItemStatusNodeMapTikvItems0StatusNODESTATUSCREATING string = "NODE_STATUS_CREATING"

	// OpenapiClusterItemStatusNodeMapTikvItems0StatusNODESTATUSDELETING captures enum value "NODE_STATUS_DELETING"
	OpenapiClusterItemStatusNodeMapTikvItems0StatusNODESTATUSDELETING string = "NODE_STATUS_DELETING"
)

// prop value enum
func (m *OpenapiClusterItemStatusNodeMapTikvItems0) validateStatusEnum(path, location string, value string) error {
	if err := validate.EnumCase(path, location, value, openapiClusterItemStatusNodeMapTikvItems0TypeStatusPropEnum, true); err != nil {
		return err
	}
	return nil
}

func (m *OpenapiClusterItemStatusNodeMapTikvItems0) validateStatus(formats strfmt.Registry) error {
	if swag.IsZero(m.Status) { // not required
		return nil
	}

	// value enum
	if err := m.validateStatusEnum("status", "body", m.Status); err != nil {
		return err
	}

	return nil
}

// ContextValidate validates this openapi cluster item status node map tikv items0 based on context it is used
func (m *OpenapiClusterItemStatusNodeMapTikvItems0) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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