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

package models

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

import (
	"context"
	"strconv"

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

// CentralCluster central cluster
//
// swagger:model centralCluster
type CentralCluster struct {

	// capacity
	// Required: true
	Capacity *int64 `json:"capacity"`

	// cluster components
	// Required: true
	ClusterComponents *CentralClusterComponents `json:"cluster_components"`

	// cluster type
	// Required: true
	ClusterType *ClusterClusterType `json:"cluster_type"`

	// create progress
	// Required: true
	CreateProgress *ClusterCreateProgress `json:"create_progress"`

	// created at
	// Required: true
	// Format: date-time
	CreatedAt *strfmt.DateTime `json:"created_at"`

	// created by
	// Required: true
	CreatedBy *CentralUser `json:"created_by"`

	// cross account deployment id
	CrossAccountDeploymentID string `json:"cross_account_deployment_id,omitempty"`

	// endpoint
	// Required: true
	Endpoint *CentralEndpoint `json:"endpoint"`

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

	// import id
	// Required: true
	ImportID *string `json:"import_id"`

	// is dev tier
	IsDevTier bool `json:"is_dev_tier,omitempty"`

	// last errors
	// Required: true
	LastErrors []*CentralLastError `json:"lastErrors"`

	// name
	// Required: true
	Name *string `json:"name"`

	// private endpoint
	// Required: true
	PrivateEndpoint *CentralEndpoint `json:"privateEndpoint"`

	// prometheus ready
	// Required: true
	PrometheusReady *bool `json:"prometheus_ready"`

	// provider
	// Required: true
	Provider *string `json:"provider"`

	// region
	// Required: true
	Region *string `json:"region"`

	// replications
	// Required: true
	Replications []*CentralReplication `json:"replications"`

	// restored
	// Required: true
	Restored *bool `json:"restored"`

	// only set when status is IMPORTING
	// Required: true
	RoleArn *string `json:"role_arn"`

	// secondary status
	// Required: true
	SecondaryStatus *ClusterSecondaryStatus `json:"secondary_status"`

	// status
	// Required: true
	Status *CentralClusterStatus `json:"status"`

	// version
	// Required: true
	Version *string `json:"version"`

	// vpc cidr block
	// Required: true
	VpcCidrBlock *string `json:"vpc_cidr_block"`

	// write status
	// Required: true
	WriteStatus *CentralWriteStatus `json:"write_status"`
}

// Validate validates this central cluster
func (m *CentralCluster) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *CentralCluster) validateCapacity(formats strfmt.Registry) error {

	if err := validate.Required("capacity", "body", m.Capacity); err != nil {
		return err
	}

	return nil
}

func (m *CentralCluster) validateClusterComponents(formats strfmt.Registry) error {

	if err := validate.Required("cluster_components", "body", m.ClusterComponents); err != nil {
		return err
	}

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

	return nil
}

func (m *CentralCluster) validateClusterType(formats strfmt.Registry) error {

	if err := validate.Required("cluster_type", "body", m.ClusterType); err != nil {
		return err
	}

	if err := validate.Required("cluster_type", "body", m.ClusterType); err != nil {
		return err
	}

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

	return nil
}

func (m *CentralCluster) validateCreateProgress(formats strfmt.Registry) error {

	if err := validate.Required("create_progress", "body", m.CreateProgress); err != nil {
		return err
	}

	if err := validate.Required("create_progress", "body", m.CreateProgress); err != nil {
		return err
	}

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

	return nil
}

func (m *CentralCluster) validateCreatedAt(formats strfmt.Registry) error {

	if err := validate.Required("created_at", "body", m.CreatedAt); err != nil {
		return err
	}

	if err := validate.FormatOf("created_at", "body", "date-time", m.CreatedAt.String(), formats); err != nil {
		return err
	}

	return nil
}

func (m *CentralCluster) validateCreatedBy(formats strfmt.Registry) error {

	if err := validate.Required("created_by", "body", m.CreatedBy); err != nil {
		return err
	}

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

	return nil
}

func (m *CentralCluster) validateEndpoint(formats strfmt.Registry) error {

	if err := validate.Required("endpoint", "body", m.Endpoint); err != nil {
		return err
	}

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

	return nil
}

func (m *CentralCluster) validateID(formats strfmt.Registry) error {

	if err := validate.Required("id", "body", m.ID); err != nil {
		return err
	}

	return nil
}

func (m *CentralCluster) validateImportID(formats strfmt.Registry) error {

	if err := validate.Required("import_id", "body", m.ImportID); err != nil {
		return err
	}

	return nil
}

func (m *CentralCluster) validateLastErrors(formats strfmt.Registry) error {

	if err := validate.Required("lastErrors", "body", m.LastErrors); err != nil {
		return err
	}

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

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

	}

	return nil
}

func (m *CentralCluster) validateName(formats strfmt.Registry) error {

	if err := validate.Required("name", "body", m.Name); err != nil {
		return err
	}

	return nil
}

func (m *CentralCluster) validatePrivateEndpoint(formats strfmt.Registry) error {

	if err := validate.Required("privateEndpoint", "body", m.PrivateEndpoint); err != nil {
		return err
	}

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

	return nil
}

func (m *CentralCluster) validatePrometheusReady(formats strfmt.Registry) error {

	if err := validate.Required("prometheus_ready", "body", m.PrometheusReady); err != nil {
		return err
	}

	return nil
}

func (m *CentralCluster) validateProvider(formats strfmt.Registry) error {

	if err := validate.Required("provider", "body", m.Provider); err != nil {
		return err
	}

	return nil
}

func (m *CentralCluster) validateRegion(formats strfmt.Registry) error {

	if err := validate.Required("region", "body", m.Region); err != nil {
		return err
	}

	return nil
}

func (m *CentralCluster) validateReplications(formats strfmt.Registry) error {

	if err := validate.Required("replications", "body", m.Replications); err != nil {
		return err
	}

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

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

	}

	return nil
}

func (m *CentralCluster) validateRestored(formats strfmt.Registry) error {

	if err := validate.Required("restored", "body", m.Restored); err != nil {
		return err
	}

	return nil
}

func (m *CentralCluster) validateRoleArn(formats strfmt.Registry) error {

	if err := validate.Required("role_arn", "body", m.RoleArn); err != nil {
		return err
	}

	return nil
}

func (m *CentralCluster) validateSecondaryStatus(formats strfmt.Registry) error {

	if err := validate.Required("secondary_status", "body", m.SecondaryStatus); err != nil {
		return err
	}

	if err := validate.Required("secondary_status", "body", m.SecondaryStatus); err != nil {
		return err
	}

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

	return nil
}

func (m *CentralCluster) validateStatus(formats strfmt.Registry) error {

	if err := validate.Required("status", "body", m.Status); err != nil {
		return err
	}

	if err := validate.Required("status", "body", m.Status); err != nil {
		return err
	}

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

	return nil
}

func (m *CentralCluster) validateVersion(formats strfmt.Registry) error {

	if err := validate.Required("version", "body", m.Version); err != nil {
		return err
	}

	return nil
}

func (m *CentralCluster) validateVpcCidrBlock(formats strfmt.Registry) error {

	if err := validate.Required("vpc_cidr_block", "body", m.VpcCidrBlock); err != nil {
		return err
	}

	return nil
}

func (m *CentralCluster) validateWriteStatus(formats strfmt.Registry) error {

	if err := validate.Required("write_status", "body", m.WriteStatus); err != nil {
		return err
	}

	if err := validate.Required("write_status", "body", m.WriteStatus); err != nil {
		return err
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *CentralCluster) contextValidateClusterComponents(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *CentralCluster) contextValidateClusterType(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *CentralCluster) contextValidateCreateProgress(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *CentralCluster) contextValidateCreatedBy(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *CentralCluster) contextValidateEndpoint(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *CentralCluster) contextValidateLastErrors(ctx context.Context, formats strfmt.Registry) error {

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

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

	}

	return nil
}

func (m *CentralCluster) contextValidatePrivateEndpoint(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *CentralCluster) contextValidateReplications(ctx context.Context, formats strfmt.Registry) error {

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

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

	}

	return nil
}

func (m *CentralCluster) contextValidateSecondaryStatus(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *CentralCluster) contextValidateStatus(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *CentralCluster) contextValidateWriteStatus(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

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

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