text:
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"
	"encoding/json"
	"strconv"

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

// ConsistencyGroupChild consistency group child
//
// swagger:model consistency_group_child
type ConsistencyGroupChild struct {

	// links
	Links *SelfLink `json:"_links,omitempty"`

	// The LUNs array can be used to create or modify LUNs in a consistency group on a new or existing volume that is a member of the consistency group. LUNs are considered members of a consistency group if they are located on a volume that is a member of the consistency group.
	//
	// Max Items: 16
	// Min Items: 0
	// Unique: true
	Luns []*ConsistencyGroupChildLunsItems0 `json:"luns,omitempty"`

	// Name of the consistency group. The consistency group name must be unique within an SVM.

	// If not provided and the consistency group contains only one volume, the name will be generated based on the volume name. If the consistency group contains more than one volume, the name is required.
	//
	Name string `json:"name,omitempty"`

	// An NVMe namespace is a collection of addressable logical blocks presented to hosts connected to the SVM using the NVMe over Fabrics protocol.
	// In ONTAP, an NVMe namespace is located within a volume. Optionally, it can be located within a qtree in a volume.

	// An NVMe namespace is created to a specified size using thin or thick provisioning as determined by the volume on which it is created. NVMe namespaces support being cloned. An NVMe namespace cannot be renamed, resized, or moved to a different volume. NVMe namespaces do not support the assignment of a QoS policy for performance management, but a QoS policy can be assigned to the volume containing the namespace. See the NVMe namespace object model to learn more about each of the properties supported by the NVMe namespace REST API.

	// An NVMe namespace must be mapped to an NVMe subsystem to grant access to the subsystem's hosts. Hosts can then access the NVMe namespace and perform I/O using the NVMe over Fabrics protocol.
	//
	// Max Items: 16
	// Min Items: 0
	// Unique: true
	Namespaces []*ConsistencyGroupChildNamespacesItems0 `json:"namespaces,omitempty"`

	// parent consistency group
	ParentConsistencyGroup *ConsistencyGroupChildParentConsistencyGroup `json:"parent_consistency_group,omitempty"`

	// provisioning options
	ProvisioningOptions *ConsistencyGroupChildProvisioningOptions `json:"provisioning_options,omitempty"`

	// qos
	Qos *ConsistencyGroupChildQos `json:"qos,omitempty"`

	// restore to
	RestoreTo *ConsistencyGroupChildRestoreTo `json:"restore_to,omitempty"`

	// The Snapshot copy policy of the consistency group.

	// This is the dedicated consistency group Snapshot copy policy, not an aggregation of the volume granular Snapshot copy policy.
	//
	SnapshotPolicy *SnapshotPolicyReference `json:"snapshot_policy,omitempty"`

	// space
	Space *ConsistencyGroupChildSpace `json:"space,omitempty"`

	// svm
	Svm *ConsistencyGroupChildSvm `json:"svm,omitempty"`

	// tiering
	Tiering *ConsistencyGroupChildTiering `json:"tiering,omitempty"`

	// The unique identifier of the consistency group. The UUID is generated by ONTAP when the consistency group is created.
	//
	// Example: 1cd8a442-86d1-11e0-ae1c-123478563412
	UUID string `json:"uuid,omitempty"`

	// A consistency group is a mutually exclusive aggregation of volumes or other consistency groups. A volume can only be associated with one direct parent consistency group.

	// The volumes array can be used to create new volumes in the consistency group, add existing volumes to the consistency group, or modify existing volumes that are already members of the consistency group.

	// The total number of volumes across all child consistency groups contained in a consistency group is constrained by the same limit.
	//
	// Max Items: 80
	// Min Items: 0
	// Unique: true
	Volumes []*ConsistencyGroupChildVolumesItems0 `json:"volumes,omitempty"`
}

// Validate validates this consistency group child
func (m *ConsistencyGroupChild) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *ConsistencyGroupChild) validateLinks(formats strfmt.Registry) error {
	if swag.IsZero(m.Links) { // not required
		return nil
	}

	if m.Links != nil {
		if err := m.Links.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("_links")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChild) validateLuns(formats strfmt.Registry) error {
	if swag.IsZero(m.Luns) { // not required
		return nil
	}

	iLunsSize := int64(len(m.Luns))

	if err := validate.MinItems("luns", "body", iLunsSize, 0); err != nil {
		return err
	}

	if err := validate.MaxItems("luns", "body", iLunsSize, 16); err != nil {
		return err
	}

	if err := validate.UniqueItems("luns", "body", m.Luns); err != nil {
		return err
	}

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

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

	}

	return nil
}

func (m *ConsistencyGroupChild) validateNamespaces(formats strfmt.Registry) error {
	if swag.IsZero(m.Namespaces) { // not required
		return nil
	}

	iNamespacesSize := int64(len(m.Namespaces))

	if err := validate.MinItems("namespaces", "body", iNamespacesSize, 0); err != nil {
		return err
	}

	if err := validate.MaxItems("namespaces", "body", iNamespacesSize, 16); err != nil {
		return err
	}

	if err := validate.UniqueItems("namespaces", "body", m.Namespaces); err != nil {
		return err
	}

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

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

	}

	return nil
}

func (m *ConsistencyGroupChild) validateParentConsistencyGroup(formats strfmt.Registry) error {
	if swag.IsZero(m.ParentConsistencyGroup) { // not required
		return nil
	}

	if m.ParentConsistencyGroup != nil {
		if err := m.ParentConsistencyGroup.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("parent_consistency_group")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChild) validateProvisioningOptions(formats strfmt.Registry) error {
	if swag.IsZero(m.ProvisioningOptions) { // not required
		return nil
	}

	if m.ProvisioningOptions != nil {
		if err := m.ProvisioningOptions.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("provisioning_options")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChild) validateQos(formats strfmt.Registry) error {
	if swag.IsZero(m.Qos) { // not required
		return nil
	}

	if m.Qos != nil {
		if err := m.Qos.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("qos")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChild) validateRestoreTo(formats strfmt.Registry) error {
	if swag.IsZero(m.RestoreTo) { // not required
		return nil
	}

	if m.RestoreTo != nil {
		if err := m.RestoreTo.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("restore_to")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChild) validateSnapshotPolicy(formats strfmt.Registry) error {
	if swag.IsZero(m.SnapshotPolicy) { // not required
		return nil
	}

	if m.SnapshotPolicy != nil {
		if err := m.SnapshotPolicy.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("snapshot_policy")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChild) validateSpace(formats strfmt.Registry) error {
	if swag.IsZero(m.Space) { // not required
		return nil
	}

	if m.Space != nil {
		if err := m.Space.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("space")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChild) validateSvm(formats strfmt.Registry) error {
	if swag.IsZero(m.Svm) { // not required
		return nil
	}

	if m.Svm != nil {
		if err := m.Svm.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("svm")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChild) validateTiering(formats strfmt.Registry) error {
	if swag.IsZero(m.Tiering) { // not required
		return nil
	}

	if m.Tiering != nil {
		if err := m.Tiering.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("tiering")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChild) validateVolumes(formats strfmt.Registry) error {
	if swag.IsZero(m.Volumes) { // not required
		return nil
	}

	iVolumesSize := int64(len(m.Volumes))

	if err := validate.MinItems("volumes", "body", iVolumesSize, 0); err != nil {
		return err
	}

	if err := validate.MaxItems("volumes", "body", iVolumesSize, 80); err != nil {
		return err
	}

	if err := validate.UniqueItems("volumes", "body", m.Volumes); err != nil {
		return err
	}

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

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

	}

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *ConsistencyGroupChild) contextValidateLinks(ctx context.Context, formats strfmt.Registry) error {

	if m.Links != nil {
		if err := m.Links.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("_links")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChild) contextValidateLuns(ctx context.Context, formats strfmt.Registry) error {

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

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

	}

	return nil
}

func (m *ConsistencyGroupChild) contextValidateNamespaces(ctx context.Context, formats strfmt.Registry) error {

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

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

	}

	return nil
}

func (m *ConsistencyGroupChild) contextValidateParentConsistencyGroup(ctx context.Context, formats strfmt.Registry) error {

	if m.ParentConsistencyGroup != nil {
		if err := m.ParentConsistencyGroup.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("parent_consistency_group")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChild) contextValidateProvisioningOptions(ctx context.Context, formats strfmt.Registry) error {

	if m.ProvisioningOptions != nil {
		if err := m.ProvisioningOptions.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("provisioning_options")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChild) contextValidateQos(ctx context.Context, formats strfmt.Registry) error {

	if m.Qos != nil {
		if err := m.Qos.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("qos")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChild) contextValidateRestoreTo(ctx context.Context, formats strfmt.Registry) error {

	if m.RestoreTo != nil {
		if err := m.RestoreTo.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("restore_to")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChild) contextValidateSnapshotPolicy(ctx context.Context, formats strfmt.Registry) error {

	if m.SnapshotPolicy != nil {
		if err := m.SnapshotPolicy.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("snapshot_policy")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChild) contextValidateSpace(ctx context.Context, formats strfmt.Registry) error {

	if m.Space != nil {
		if err := m.Space.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("space")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChild) contextValidateSvm(ctx context.Context, formats strfmt.Registry) error {

	if m.Svm != nil {
		if err := m.Svm.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("svm")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChild) contextValidateTiering(ctx context.Context, formats strfmt.Registry) error {

	if m.Tiering != nil {
		if err := m.Tiering.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("tiering")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChild) contextValidateVolumes(ctx context.Context, formats strfmt.Registry) error {

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

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

	}

	return nil
}

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

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

// ConsistencyGroupChildLunsItems0 A LUN is the logical representation of storage in a storage area network (SAN).

// In ONTAP, a LUN is located within a volume. Optionally, it can be located within a qtree in a volume.

// A LUN can be created to a specified size using thin or thick provisioning. A LUN can then be renamed, resized, cloned, and moved to a different volume. LUNs support the assignment of a quality of service (QoS) policy for performance management or a QoS policy can be assigned to the volume containing the LUN. See the LUN object model to learn more about each of the properties supported by the LUN REST API.

// A LUN must be mapped to an initiator group to grant access to the initiator group's initiators (client hosts). Initiators can then access the LUN and perform I/O over a Fibre Channel (FC) fabric using the Fibre Channel Protocol or a TCP/IP network using iSCSI.
//
// swagger:model ConsistencyGroupChildLunsItems0
type ConsistencyGroupChildLunsItems0 struct {

	// clone
	Clone *ConsistencyGroupChildLunsItems0Clone `json:"clone,omitempty"`

	// A configurable comment available for use by the administrator. Valid in POST and PATCH.
	//
	// Max Length: 254
	// Min Length: 0
	Comment *string `json:"comment,omitempty"`

	// The time the LUN was created.
	// Example: 2018-06-04T19:00:00Z
	// Read Only: true
	// Format: date-time
	CreateTime *strfmt.DateTime `json:"create_time,omitempty"`

	// The enabled state of the LUN. LUNs can be disabled to prevent access to the LUN. Certain error conditions also cause the LUN to become disabled. If the LUN is disabled, you can consult the `state` property to determine if the LUN is administratively disabled (_offline_) or has become disabled as a result of an error. A LUN in an error condition can be brought online by setting the `enabled` property to _true_ or brought administratively offline by setting the `enabled` property to _false_. Upon creation, a LUN is enabled by default. Valid in PATCH.
	//
	Enabled bool `json:"enabled,omitempty"`

	// An array of LUN maps.

	// A LUN map is an association between a LUN and an initiator group. When a LUN is mapped to an initiator group, the initiator group's initiators are granted access to the LUN. The relationship between a LUN and an initiator group is many LUNs to many initiator groups.
	//
	LunMaps []*ConsistencyGroupChildLunsItems0LunMapsItems0 `json:"lun_maps,omitempty"`

	// The fully qualified path name of the LUN composed of the "/vol" prefix, the volume name, the qtree name (optional), and the base name of the LUN. Valid in POST and PATCH.
	//
	// Example: /vol/volume1/lun1
	Name string `json:"name,omitempty"`

	// The operating system type of the LUN.

	// Required in POST when creating a LUN that is not a clone of another. Disallowed in POST when creating a LUN clone.
	//
	// Enum: [aix hpux hyper_v linux netware openvms solaris solaris_efi vmware windows windows_2008 windows_gpt xen]
	OsType string `json:"os_type,omitempty"`

	// provisioning options
	ProvisioningOptions *ConsistencyGroupChildLunsItems0ProvisioningOptions `json:"provisioning_options,omitempty"`

	// qos
	Qos *ConsistencyGroupChildLunsItems0Qos `json:"qos,omitempty"`

	// The LUN serial number. The serial number is generated by ONTAP when the LUN is created.
	//
	// Read Only: true
	// Max Length: 12
	// Min Length: 12
	SerialNumber string `json:"serial_number,omitempty"`

	// space
	Space *ConsistencyGroupChildLunsItems0Space `json:"space,omitempty"`

	// The unique identifier of the LUN.  The UUID is generated by ONTAP when the LUN is created.
	//
	// Example: 1cd8a442-86d1-11e0-ae1c-123478563412
	// Read Only: true
	UUID string `json:"uuid,omitempty"`
}

// Validate validates this consistency group child luns items0
func (m *ConsistencyGroupChildLunsItems0) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

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

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

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

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

func (m *ConsistencyGroupChildLunsItems0) validateClone(formats strfmt.Registry) error {
	if swag.IsZero(m.Clone) { // not required
		return nil
	}

	if m.Clone != nil {
		if err := m.Clone.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("clone")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChildLunsItems0) validateComment(formats strfmt.Registry) error {
	if swag.IsZero(m.Comment) { // not required
		return nil
	}

	if err := validate.MinLength("comment", "body", *m.Comment, 0); err != nil {
		return err
	}

	if err := validate.MaxLength("comment", "body", *m.Comment, 254); err != nil {
		return err
	}

	return nil
}

func (m *ConsistencyGroupChildLunsItems0) validateCreateTime(formats strfmt.Registry) error {
	if swag.IsZero(m.CreateTime) { // not required
		return nil
	}

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

	return nil
}

func (m *ConsistencyGroupChildLunsItems0) validateLunMaps(formats strfmt.Registry) error {
	if swag.IsZero(m.LunMaps) { // not required
		return nil
	}

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

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

	}

	return nil
}

var consistencyGroupChildLunsItems0TypeOsTypePropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["aix","hpux","hyper_v","linux","netware","openvms","solaris","solaris_efi","vmware","windows","windows_2008","windows_gpt","xen"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		consistencyGroupChildLunsItems0TypeOsTypePropEnum = append(consistencyGroupChildLunsItems0TypeOsTypePropEnum, v)
	}
}

const (

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0
	// ConsistencyGroupChildLunsItems0
	// os_type
	// OsType
	// aix
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0OsTypeAix captures enum value "aix"
	ConsistencyGroupChildLunsItems0OsTypeAix string = "aix"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0
	// ConsistencyGroupChildLunsItems0
	// os_type
	// OsType
	// hpux
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0OsTypeHpux captures enum value "hpux"
	ConsistencyGroupChildLunsItems0OsTypeHpux string = "hpux"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0
	// ConsistencyGroupChildLunsItems0
	// os_type
	// OsType
	// hyper_v
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0OsTypeHyperv captures enum value "hyper_v"
	ConsistencyGroupChildLunsItems0OsTypeHyperv string = "hyper_v"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0
	// ConsistencyGroupChildLunsItems0
	// os_type
	// OsType
	// linux
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0OsTypeLinux captures enum value "linux"
	ConsistencyGroupChildLunsItems0OsTypeLinux string = "linux"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0
	// ConsistencyGroupChildLunsItems0
	// os_type
	// OsType
	// netware
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0OsTypeNetware captures enum value "netware"
	ConsistencyGroupChildLunsItems0OsTypeNetware string = "netware"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0
	// ConsistencyGroupChildLunsItems0
	// os_type
	// OsType
	// openvms
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0OsTypeOpenvms captures enum value "openvms"
	ConsistencyGroupChildLunsItems0OsTypeOpenvms string = "openvms"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0
	// ConsistencyGroupChildLunsItems0
	// os_type
	// OsType
	// solaris
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0OsTypeSolaris captures enum value "solaris"
	ConsistencyGroupChildLunsItems0OsTypeSolaris string = "solaris"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0
	// ConsistencyGroupChildLunsItems0
	// os_type
	// OsType
	// solaris_efi
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0OsTypeSolarisEfi captures enum value "solaris_efi"
	ConsistencyGroupChildLunsItems0OsTypeSolarisEfi string = "solaris_efi"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0
	// ConsistencyGroupChildLunsItems0
	// os_type
	// OsType
	// vmware
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0OsTypeVmware captures enum value "vmware"
	ConsistencyGroupChildLunsItems0OsTypeVmware string = "vmware"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0
	// ConsistencyGroupChildLunsItems0
	// os_type
	// OsType
	// windows
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0OsTypeWindows captures enum value "windows"
	ConsistencyGroupChildLunsItems0OsTypeWindows string = "windows"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0
	// ConsistencyGroupChildLunsItems0
	// os_type
	// OsType
	// windows_2008
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0OsTypeWindows2008 captures enum value "windows_2008"
	ConsistencyGroupChildLunsItems0OsTypeWindows2008 string = "windows_2008"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0
	// ConsistencyGroupChildLunsItems0
	// os_type
	// OsType
	// windows_gpt
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0OsTypeWindowsGpt captures enum value "windows_gpt"
	ConsistencyGroupChildLunsItems0OsTypeWindowsGpt string = "windows_gpt"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0
	// ConsistencyGroupChildLunsItems0
	// os_type
	// OsType
	// xen
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0OsTypeXen captures enum value "xen"
	ConsistencyGroupChildLunsItems0OsTypeXen string = "xen"
)

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

func (m *ConsistencyGroupChildLunsItems0) validateOsType(formats strfmt.Registry) error {
	if swag.IsZero(m.OsType) { // not required
		return nil
	}

	// value enum
	if err := m.validateOsTypeEnum("os_type", "body", m.OsType); err != nil {
		return err
	}

	return nil
}

func (m *ConsistencyGroupChildLunsItems0) validateProvisioningOptions(formats strfmt.Registry) error {
	if swag.IsZero(m.ProvisioningOptions) { // not required
		return nil
	}

	if m.ProvisioningOptions != nil {
		if err := m.ProvisioningOptions.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("provisioning_options")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChildLunsItems0) validateQos(formats strfmt.Registry) error {
	if swag.IsZero(m.Qos) { // not required
		return nil
	}

	if m.Qos != nil {
		if err := m.Qos.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("qos")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChildLunsItems0) validateSerialNumber(formats strfmt.Registry) error {
	if swag.IsZero(m.SerialNumber) { // not required
		return nil
	}

	if err := validate.MinLength("serial_number", "body", m.SerialNumber, 12); err != nil {
		return err
	}

	if err := validate.MaxLength("serial_number", "body", m.SerialNumber, 12); err != nil {
		return err
	}

	return nil
}

func (m *ConsistencyGroupChildLunsItems0) validateSpace(formats strfmt.Registry) error {
	if swag.IsZero(m.Space) { // not required
		return nil
	}

	if m.Space != nil {
		if err := m.Space.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("space")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this consistency group child luns items0 based on the context it is used
func (m *ConsistencyGroupChildLunsItems0) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

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

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

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

func (m *ConsistencyGroupChildLunsItems0) contextValidateClone(ctx context.Context, formats strfmt.Registry) error {

	if m.Clone != nil {
		if err := m.Clone.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("clone")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChildLunsItems0) contextValidateCreateTime(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "create_time", "body", m.CreateTime); err != nil {
		return err
	}

	return nil
}

func (m *ConsistencyGroupChildLunsItems0) contextValidateLunMaps(ctx context.Context, formats strfmt.Registry) error {

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

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

	}

	return nil
}

func (m *ConsistencyGroupChildLunsItems0) contextValidateProvisioningOptions(ctx context.Context, formats strfmt.Registry) error {

	if m.ProvisioningOptions != nil {
		if err := m.ProvisioningOptions.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("provisioning_options")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChildLunsItems0) contextValidateQos(ctx context.Context, formats strfmt.Registry) error {

	if m.Qos != nil {
		if err := m.Qos.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("qos")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChildLunsItems0) contextValidateSerialNumber(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "serial_number", "body", string(m.SerialNumber)); err != nil {
		return err
	}

	return nil
}

func (m *ConsistencyGroupChildLunsItems0) contextValidateSpace(ctx context.Context, formats strfmt.Registry) error {

	if m.Space != nil {
		if err := m.Space.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("space")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChildLunsItems0) contextValidateUUID(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "uuid", "body", string(m.UUID)); err != nil {
		return err
	}

	return nil
}

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

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

// ConsistencyGroupChildLunsItems0Clone This sub-object is used in POST to create a new LUN as a clone of an existing LUN, or PATCH to overwrite an existing LUN as a clone of another. Setting a property in this sub-object indicates that a LUN clone is desired. Consider the following other properties when cloning a LUN: `auto_delete`, `qos_policy`, `space.guarantee.requested` and `space.scsi_thin_provisioning_support_enabled`.

// When used in a PATCH, the patched LUN's data is over-written as a clone of the source and the following properties are preserved from the patched LUN unless otherwise specified as part of the PATCH: `class`, `auto_delete`, `lun_maps`, `serial_number`, `status.state`, and `uuid`.

// Persistent reservations for the patched LUN are also preserved.
//
// swagger:model ConsistencyGroupChildLunsItems0Clone
type ConsistencyGroupChildLunsItems0Clone struct {

	// source
	Source *ConsistencyGroupChildLunsItems0CloneSource `json:"source,omitempty"`
}

// Validate validates this consistency group child luns items0 clone
func (m *ConsistencyGroupChildLunsItems0Clone) Validate(formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildLunsItems0Clone) validateSource(formats strfmt.Registry) error {
	if swag.IsZero(m.Source) { // not required
		return nil
	}

	if m.Source != nil {
		if err := m.Source.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("clone" + "." + "source")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this consistency group child luns items0 clone based on the context it is used
func (m *ConsistencyGroupChildLunsItems0Clone) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildLunsItems0Clone) contextValidateSource(ctx context.Context, formats strfmt.Registry) error {

	if m.Source != nil {
		if err := m.Source.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("clone" + "." + "source")
			}
			return err
		}
	}

	return nil
}

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

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

// ConsistencyGroupChildLunsItems0CloneSource The source LUN for a LUN clone operation. This can be specified using property `clone.source.uuid` or `clone.source.name`. If both properties are supplied, they must refer to the same LUN.

// Valid in POST to create a new LUN as a clone of the source.

// Valid in PATCH to overwrite an existing LUN's data as a clone of another.
//
// swagger:model ConsistencyGroupChildLunsItems0CloneSource
type ConsistencyGroupChildLunsItems0CloneSource struct {

	// The fully qualified path name of the clone source LUN composed of a "/vol" prefix, the volume name, the (optional) qtree name, and base name of the LUN. Valid in POST and PATCH.
	//
	// Example: /vol/volume1/lun1
	Name string `json:"name,omitempty"`

	// The unique identifier of the clone source LUN. Valid in POST and PATCH.
	//
	// Example: 1cd8a442-86d1-11e0-ae1c-123478563412
	UUID string `json:"uuid,omitempty"`
}

// Validate validates this consistency group child luns items0 clone source
func (m *ConsistencyGroupChildLunsItems0CloneSource) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this consistency group child luns items0 clone source based on context it is used
func (m *ConsistencyGroupChildLunsItems0CloneSource) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

// ConsistencyGroupChildLunsItems0LunMapsItems0 A LUN map is an association between a LUN and an initiator group.

// When a LUN is mapped to an initiator group, the initiator group's initiators are granted access to the LUN. The relationship between a LUN and an initiator group is many LUNs to many initiator groups.
//
// swagger:model ConsistencyGroupChildLunsItems0LunMapsItems0
type ConsistencyGroupChildLunsItems0LunMapsItems0 struct {

	// igroup
	Igroup *ConsistencyGroupChildLunsItems0LunMapsItems0Igroup `json:"igroup,omitempty"`

	// The logical unit number assigned to the LUN when mapped to the specified initiator group. The number is used to identify the LUN to initiators in the initiator group when communicating through the Fibre Channel Protocol or iSCSI. Optional in POST; if no value is provided, ONTAP assigns the lowest available value.
	//
	LogicalUnitNumber int64 `json:"logical_unit_number,omitempty"`
}

// Validate validates this consistency group child luns items0 lun maps items0
func (m *ConsistencyGroupChildLunsItems0LunMapsItems0) Validate(formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildLunsItems0LunMapsItems0) validateIgroup(formats strfmt.Registry) error {
	if swag.IsZero(m.Igroup) { // not required
		return nil
	}

	if m.Igroup != nil {
		if err := m.Igroup.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("igroup")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this consistency group child luns items0 lun maps items0 based on the context it is used
func (m *ConsistencyGroupChildLunsItems0LunMapsItems0) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildLunsItems0LunMapsItems0) contextValidateIgroup(ctx context.Context, formats strfmt.Registry) error {

	if m.Igroup != nil {
		if err := m.Igroup.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("igroup")
			}
			return err
		}
	}

	return nil
}

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

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

// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup The initiator group that directly owns the initiator, which is where modification of the initiator is supported. This property will only be populated when the initiator is a member of a nested initiator group.
//
// swagger:model ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
type ConsistencyGroupChildLunsItems0LunMapsItems0Igroup struct {

	// A comment available for use by the administrator. Valid in POST and PATCH.
	//
	// Max Length: 254
	// Min Length: 0
	Comment *string `json:"comment,omitempty"`

	// Separate igroup definitions to include in this igroup.
	//
	Igroups []*ConsistencyGroupChildLunsItems0LunMapsItems0IgroupIgroupsItems0 `json:"igroups,omitempty"`

	// The initiators that are members of the group.
	//
	Initiators []*ConsistencyGroupChildLunsItems0LunMapsItems0IgroupInitiatorsItems0 `json:"initiators,omitempty"`

	// The name of the initiator group. Required in POST; optional in PATCH.
	//
	// Example: igroup1
	// Max Length: 96
	// Min Length: 1
	Name string `json:"name,omitempty"`

	// The host operating system of the initiator group. All initiators in the group should be hosts of the same operating system. Required in POST; optional in PATCH.
	//
	// Enum: [aix hpux hyper_v linux netware openvms solaris vmware windows xen]
	OsType string `json:"os_type,omitempty"`

	// The protocols supported by the initiator group. This restricts the type of initiators that can be added to the initiator group. Optional in POST; if not supplied, this defaults to _mixed_.

	// The protocol of an initiator group cannot be changed after creation of the group.
	//
	// Enum: [fcp iscsi mixed]
	Protocol *string `json:"protocol,omitempty"`

	// The unique identifier of the initiator group.
	//
	// Example: 4ea7a442-86d1-11e0-ae1c-123478563412
	// Read Only: true
	UUID string `json:"uuid,omitempty"`
}

// Validate validates this consistency group child luns items0 lun maps items0 igroup
func (m *ConsistencyGroupChildLunsItems0LunMapsItems0Igroup) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

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

func (m *ConsistencyGroupChildLunsItems0LunMapsItems0Igroup) validateComment(formats strfmt.Registry) error {
	if swag.IsZero(m.Comment) { // not required
		return nil
	}

	if err := validate.MinLength("igroup"+"."+"comment", "body", *m.Comment, 0); err != nil {
		return err
	}

	if err := validate.MaxLength("igroup"+"."+"comment", "body", *m.Comment, 254); err != nil {
		return err
	}

	return nil
}

func (m *ConsistencyGroupChildLunsItems0LunMapsItems0Igroup) validateIgroups(formats strfmt.Registry) error {
	if swag.IsZero(m.Igroups) { // not required
		return nil
	}

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

		if m.Igroups[i] != nil {
			if err := m.Igroups[i].Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("igroup" + "." + "igroups" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

func (m *ConsistencyGroupChildLunsItems0LunMapsItems0Igroup) validateInitiators(formats strfmt.Registry) error {
	if swag.IsZero(m.Initiators) { // not required
		return nil
	}

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

		if m.Initiators[i] != nil {
			if err := m.Initiators[i].Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("igroup" + "." + "initiators" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

func (m *ConsistencyGroupChildLunsItems0LunMapsItems0Igroup) validateName(formats strfmt.Registry) error {
	if swag.IsZero(m.Name) { // not required
		return nil
	}

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

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

	return nil
}

var consistencyGroupChildLunsItems0LunMapsItems0IgroupTypeOsTypePropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["aix","hpux","hyper_v","linux","netware","openvms","solaris","vmware","windows","xen"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		consistencyGroupChildLunsItems0LunMapsItems0IgroupTypeOsTypePropEnum = append(consistencyGroupChildLunsItems0LunMapsItems0IgroupTypeOsTypePropEnum, v)
	}
}

const (

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// os_type
	// OsType
	// aix
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0IgroupOsTypeAix captures enum value "aix"
	ConsistencyGroupChildLunsItems0LunMapsItems0IgroupOsTypeAix string = "aix"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// os_type
	// OsType
	// hpux
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0IgroupOsTypeHpux captures enum value "hpux"
	ConsistencyGroupChildLunsItems0LunMapsItems0IgroupOsTypeHpux string = "hpux"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// os_type
	// OsType
	// hyper_v
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0IgroupOsTypeHyperv captures enum value "hyper_v"
	ConsistencyGroupChildLunsItems0LunMapsItems0IgroupOsTypeHyperv string = "hyper_v"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// os_type
	// OsType
	// linux
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0IgroupOsTypeLinux captures enum value "linux"
	ConsistencyGroupChildLunsItems0LunMapsItems0IgroupOsTypeLinux string = "linux"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// os_type
	// OsType
	// netware
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0IgroupOsTypeNetware captures enum value "netware"
	ConsistencyGroupChildLunsItems0LunMapsItems0IgroupOsTypeNetware string = "netware"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// os_type
	// OsType
	// openvms
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0IgroupOsTypeOpenvms captures enum value "openvms"
	ConsistencyGroupChildLunsItems0LunMapsItems0IgroupOsTypeOpenvms string = "openvms"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// os_type
	// OsType
	// solaris
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0IgroupOsTypeSolaris captures enum value "solaris"
	ConsistencyGroupChildLunsItems0LunMapsItems0IgroupOsTypeSolaris string = "solaris"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// os_type
	// OsType
	// vmware
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0IgroupOsTypeVmware captures enum value "vmware"
	ConsistencyGroupChildLunsItems0LunMapsItems0IgroupOsTypeVmware string = "vmware"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// os_type
	// OsType
	// windows
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0IgroupOsTypeWindows captures enum value "windows"
	ConsistencyGroupChildLunsItems0LunMapsItems0IgroupOsTypeWindows string = "windows"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// os_type
	// OsType
	// xen
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0IgroupOsTypeXen captures enum value "xen"
	ConsistencyGroupChildLunsItems0LunMapsItems0IgroupOsTypeXen string = "xen"
)

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

func (m *ConsistencyGroupChildLunsItems0LunMapsItems0Igroup) validateOsType(formats strfmt.Registry) error {
	if swag.IsZero(m.OsType) { // not required
		return nil
	}

	// value enum
	if err := m.validateOsTypeEnum("igroup"+"."+"os_type", "body", m.OsType); err != nil {
		return err
	}

	return nil
}

var consistencyGroupChildLunsItems0LunMapsItems0IgroupTypeProtocolPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["fcp","iscsi","mixed"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		consistencyGroupChildLunsItems0LunMapsItems0IgroupTypeProtocolPropEnum = append(consistencyGroupChildLunsItems0LunMapsItems0IgroupTypeProtocolPropEnum, v)
	}
}

const (

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// protocol
	// Protocol
	// fcp
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0IgroupProtocolFcp captures enum value "fcp"
	ConsistencyGroupChildLunsItems0LunMapsItems0IgroupProtocolFcp string = "fcp"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// protocol
	// Protocol
	// iscsi
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0IgroupProtocolIscsi captures enum value "iscsi"
	ConsistencyGroupChildLunsItems0LunMapsItems0IgroupProtocolIscsi string = "iscsi"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// ConsistencyGroupChildLunsItems0LunMapsItems0Igroup
	// protocol
	// Protocol
	// mixed
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0LunMapsItems0IgroupProtocolMixed captures enum value "mixed"
	ConsistencyGroupChildLunsItems0LunMapsItems0IgroupProtocolMixed string = "mixed"
)

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

func (m *ConsistencyGroupChildLunsItems0LunMapsItems0Igroup) validateProtocol(formats strfmt.Registry) error {
	if swag.IsZero(m.Protocol) { // not required
		return nil
	}

	// value enum
	if err := m.validateProtocolEnum("igroup"+"."+"protocol", "body", *m.Protocol); err != nil {
		return err
	}

	return nil
}

// ContextValidate validate this consistency group child luns items0 lun maps items0 igroup based on the context it is used
func (m *ConsistencyGroupChildLunsItems0LunMapsItems0Igroup) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

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

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

func (m *ConsistencyGroupChildLunsItems0LunMapsItems0Igroup) contextValidateIgroups(ctx context.Context, formats strfmt.Registry) error {

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

		if m.Igroups[i] != nil {
			if err := m.Igroups[i].ContextValidate(ctx, formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("igroup" + "." + "igroups" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

func (m *ConsistencyGroupChildLunsItems0LunMapsItems0Igroup) contextValidateInitiators(ctx context.Context, formats strfmt.Registry) error {

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

		if m.Initiators[i] != nil {
			if err := m.Initiators[i].ContextValidate(ctx, formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("igroup" + "." + "initiators" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

func (m *ConsistencyGroupChildLunsItems0LunMapsItems0Igroup) contextValidateUUID(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "igroup"+"."+"uuid", "body", string(m.UUID)); err != nil {
		return err
	}

	return nil
}

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

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

// ConsistencyGroupChildLunsItems0LunMapsItems0IgroupIgroupsItems0 consistency group child luns items0 lun maps items0 igroup igroups items0
//
// swagger:model ConsistencyGroupChildLunsItems0LunMapsItems0IgroupIgroupsItems0
type ConsistencyGroupChildLunsItems0LunMapsItems0IgroupIgroupsItems0 struct {

	// links
	Links *SelfLink `json:"_links,omitempty"`

	// The name of the initiator group.
	//
	// Example: igroup1
	// Max Length: 96
	// Min Length: 1
	Name string `json:"name,omitempty"`

	// The unique identifier of the initiator group.
	//
	// Example: 4ea7a442-86d1-11e0-ae1c-123478563412
	UUID string `json:"uuid,omitempty"`
}

// Validate validates this consistency group child luns items0 lun maps items0 igroup igroups items0
func (m *ConsistencyGroupChildLunsItems0LunMapsItems0IgroupIgroupsItems0) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

func (m *ConsistencyGroupChildLunsItems0LunMapsItems0IgroupIgroupsItems0) validateLinks(formats strfmt.Registry) error {
	if swag.IsZero(m.Links) { // not required
		return nil
	}

	if m.Links != nil {
		if err := m.Links.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("_links")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChildLunsItems0LunMapsItems0IgroupIgroupsItems0) validateName(formats strfmt.Registry) error {
	if swag.IsZero(m.Name) { // not required
		return nil
	}

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

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

	return nil
}

// ContextValidate validate this consistency group child luns items0 lun maps items0 igroup igroups items0 based on the context it is used
func (m *ConsistencyGroupChildLunsItems0LunMapsItems0IgroupIgroupsItems0) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildLunsItems0LunMapsItems0IgroupIgroupsItems0) contextValidateLinks(ctx context.Context, formats strfmt.Registry) error {

	if m.Links != nil {
		if err := m.Links.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("_links")
			}
			return err
		}
	}

	return nil
}

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

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

// ConsistencyGroupChildLunsItems0LunMapsItems0IgroupInitiatorsItems0 The initiators that are members of the initiator group.
//
// swagger:model ConsistencyGroupChildLunsItems0LunMapsItems0IgroupInitiatorsItems0
type ConsistencyGroupChildLunsItems0LunMapsItems0IgroupInitiatorsItems0 struct {

	// A comment available for use by the administrator.
	//
	// Example: my comment
	// Max Length: 254
	// Min Length: 0
	Comment *string `json:"comment,omitempty"`

	// Name of initiator that is a member of the initiator group.
	//
	// Example: iqn.1998-01.com.corp.iscsi:name1
	Name string `json:"name,omitempty"`
}

// Validate validates this consistency group child luns items0 lun maps items0 igroup initiators items0
func (m *ConsistencyGroupChildLunsItems0LunMapsItems0IgroupInitiatorsItems0) Validate(formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildLunsItems0LunMapsItems0IgroupInitiatorsItems0) validateComment(formats strfmt.Registry) error {
	if swag.IsZero(m.Comment) { // not required
		return nil
	}

	if err := validate.MinLength("comment", "body", *m.Comment, 0); err != nil {
		return err
	}

	if err := validate.MaxLength("comment", "body", *m.Comment, 254); err != nil {
		return err
	}

	return nil
}

// ContextValidate validates this consistency group child luns items0 lun maps items0 igroup initiators items0 based on context it is used
func (m *ConsistencyGroupChildLunsItems0LunMapsItems0IgroupInitiatorsItems0) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

// ConsistencyGroupChildLunsItems0ProvisioningOptions Options that are applied to the operation.
//
// swagger:model ConsistencyGroupChildLunsItems0ProvisioningOptions
type ConsistencyGroupChildLunsItems0ProvisioningOptions struct {

	// Operation to perform
	// Enum: [create]
	Action string `json:"action,omitempty"`

	// Number of elements to perform the operation on.
	Count int64 `json:"count,omitempty"`
}

// Validate validates this consistency group child luns items0 provisioning options
func (m *ConsistencyGroupChildLunsItems0ProvisioningOptions) Validate(formats strfmt.Registry) error {
	var res []error

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

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

var consistencyGroupChildLunsItems0ProvisioningOptionsTypeActionPropEnum []interface{}

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

const (

	// BEGIN DEBUGGING
	// ConsistencyGroupChildLunsItems0ProvisioningOptions
	// ConsistencyGroupChildLunsItems0ProvisioningOptions
	// action
	// Action
	// create
	// END DEBUGGING
	// ConsistencyGroupChildLunsItems0ProvisioningOptionsActionCreate captures enum value "create"
	ConsistencyGroupChildLunsItems0ProvisioningOptionsActionCreate string = "create"
)

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

func (m *ConsistencyGroupChildLunsItems0ProvisioningOptions) validateAction(formats strfmt.Registry) error {
	if swag.IsZero(m.Action) { // not required
		return nil
	}

	// value enum
	if err := m.validateActionEnum("provisioning_options"+"."+"action", "body", m.Action); err != nil {
		return err
	}

	return nil
}

// ContextValidate validates this consistency group child luns items0 provisioning options based on context it is used
func (m *ConsistencyGroupChildLunsItems0ProvisioningOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

// ConsistencyGroupChildLunsItems0Qos consistency group child luns items0 qos
//
// swagger:model ConsistencyGroupChildLunsItems0Qos
type ConsistencyGroupChildLunsItems0Qos struct {

	// policy
	Policy *ConsistencyGroupChildLunsItems0QosPolicy `json:"policy,omitempty"`
}

// Validate validates this consistency group child luns items0 qos
func (m *ConsistencyGroupChildLunsItems0Qos) Validate(formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildLunsItems0Qos) validatePolicy(formats strfmt.Registry) error {
	if swag.IsZero(m.Policy) { // not required
		return nil
	}

	if m.Policy != nil {
		if err := m.Policy.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("qos" + "." + "policy")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this consistency group child luns items0 qos based on the context it is used
func (m *ConsistencyGroupChildLunsItems0Qos) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildLunsItems0Qos) contextValidatePolicy(ctx context.Context, formats strfmt.Registry) error {

	if m.Policy != nil {
		if err := m.Policy.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("qos" + "." + "policy")
			}
			return err
		}
	}

	return nil
}

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

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

// ConsistencyGroupChildLunsItems0QosPolicy The QoS policy
//
// swagger:model ConsistencyGroupChildLunsItems0QosPolicy
type ConsistencyGroupChildLunsItems0QosPolicy struct {

	// links
	Links *SelfLink `json:"_links,omitempty"`

	// Specifies the maximum throughput in IOPS, 0 means none. This is mutually exclusive with name and UUID during POST and PATCH.
	// Example: 10000
	MaxThroughputIops int64 `json:"max_throughput_iops,omitempty"`

	// Specifies the maximum throughput in Megabytes per sec, 0 means none. This is mutually exclusive with name and UUID during POST and PATCH.
	// Example: 500
	MaxThroughputMbps int64 `json:"max_throughput_mbps,omitempty"`

	// Specifies the minimum throughput in IOPS, 0 means none. Setting "min_throughput" is supported on AFF platforms only, unless FabricPool tiering policies are set. This is mutually exclusive with name and UUID during POST and PATCH.
	// Example: 2000
	MinThroughputIops int64 `json:"min_throughput_iops,omitempty"`

	// Specifies the minimum throughput in Megabytes per sec, 0 means none. This is mutually exclusive with name and UUID during POST and PATCH.
	// Example: 500
	MinThroughputMbps int64 `json:"min_throughput_mbps,omitempty"`

	// The QoS policy group name. This is mutually exclusive with UUID and other QoS attributes during POST and PATCH.
	// Example: performance
	Name string `json:"name,omitempty"`

	// The QoS policy group UUID. This is mutually exclusive with name and other QoS attributes during POST and PATCH.
	// Example: 1cd8a442-86d1-11e0-ae1c-123478563412
	UUID string `json:"uuid,omitempty"`
}

// Validate validates this consistency group child luns items0 qos policy
func (m *ConsistencyGroupChildLunsItems0QosPolicy) Validate(formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildLunsItems0QosPolicy) validateLinks(formats strfmt.Registry) error {
	if swag.IsZero(m.Links) { // not required
		return nil
	}

	if m.Links != nil {
		if err := m.Links.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("qos" + "." + "policy" + "." + "_links")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this consistency group child luns items0 qos policy based on the context it is used
func (m *ConsistencyGroupChildLunsItems0QosPolicy) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildLunsItems0QosPolicy) contextValidateLinks(ctx context.Context, formats strfmt.Registry) error {

	if m.Links != nil {
		if err := m.Links.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("qos" + "." + "policy" + "." + "_links")
			}
			return err
		}
	}

	return nil
}

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

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

// ConsistencyGroupChildLunsItems0Space The storage space related properties of the LUN.
//
// swagger:model ConsistencyGroupChildLunsItems0Space
type ConsistencyGroupChildLunsItems0Space struct {

	// guarantee
	Guarantee *ConsistencyGroupChildLunsItems0SpaceGuarantee `json:"guarantee,omitempty"`

	// The total provisioned size of the LUN. The LUN size can be increased but not reduced using the REST interface.
	// The maximum and minimum sizes listed here are the absolute maximum and absolute minimum sizes, in bytes. The actual minimum and maxiumum sizes vary depending on the ONTAP version, ONTAP platform, and the available space in the containing volume and aggregate.
	// For more information, see _Size properties_ in the _docs_ section of the ONTAP REST API documentation.
	//
	// Example: 1073741824
	// Maximum: 1.40737488355328e+14
	// Minimum: 4096
	Size int64 `json:"size,omitempty"`

	// The amount of space consumed by the main data stream of the LUN.

	// This value is the total space consumed in the volume by the LUN, including filesystem overhead, but excluding prefix and suffix streams. Due to internal filesystem overhead and the many ways SAN filesystems and applications utilize blocks within a LUN, this value does not necessarily reflect actual consumption/availability from the perspective of the filesystem or application. Without specific knowledge of how the LUN blocks are utilized outside of ONTAP, this property should not be used as an indicator for an out-of-space condition.

	// For more information, see _Size properties_ in the _docs_ section of the ONTAP REST API documentation.
	//
	Used int64 `json:"used,omitempty"`
}

// Validate validates this consistency group child luns items0 space
func (m *ConsistencyGroupChildLunsItems0Space) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

func (m *ConsistencyGroupChildLunsItems0Space) validateGuarantee(formats strfmt.Registry) error {
	if swag.IsZero(m.Guarantee) { // not required
		return nil
	}

	if m.Guarantee != nil {
		if err := m.Guarantee.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("space" + "." + "guarantee")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChildLunsItems0Space) validateSize(formats strfmt.Registry) error {
	if swag.IsZero(m.Size) { // not required
		return nil
	}

	if err := validate.MinimumInt("space"+"."+"size", "body", m.Size, 4096, false); err != nil {
		return err
	}

	if err := validate.MaximumInt("space"+"."+"size", "body", m.Size, 1.40737488355328e+14, false); err != nil {
		return err
	}

	return nil
}

// ContextValidate validate this consistency group child luns items0 space based on the context it is used
func (m *ConsistencyGroupChildLunsItems0Space) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildLunsItems0Space) contextValidateGuarantee(ctx context.Context, formats strfmt.Registry) error {

	if m.Guarantee != nil {
		if err := m.Guarantee.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("space" + "." + "guarantee")
			}
			return err
		}
	}

	return nil
}

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

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

// ConsistencyGroupChildLunsItems0SpaceGuarantee Properties that request and report the space guarantee for the LUN.
//
// swagger:model ConsistencyGroupChildLunsItems0SpaceGuarantee
type ConsistencyGroupChildLunsItems0SpaceGuarantee struct {

	// The requested space reservation policy for the LUN. If _true_, a space reservation is requested for the LUN; if _false_, the LUN is thin provisioned. Guaranteeing a space reservation request for a LUN requires that the volume in which the LUN resides is also space reserved and that the fractional reserve for the volume is 100%. Valid in POST and PATCH.
	//
	Requested *bool `json:"requested,omitempty"`

	// Reports if the LUN is space guaranteed.

	// If _true_, a space guarantee is requested and the containing volume and aggregate support the request. If _false_, a space guarantee is not requested or a space guarantee is requested and either the containing volume or aggregate do not support the request.
	//
	Reserved bool `json:"reserved,omitempty"`
}

// Validate validates this consistency group child luns items0 space guarantee
func (m *ConsistencyGroupChildLunsItems0SpaceGuarantee) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this consistency group child luns items0 space guarantee based on context it is used
func (m *ConsistencyGroupChildLunsItems0SpaceGuarantee) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

// ConsistencyGroupChildNamespacesItems0 An NVMe namespace is a collection of addressable logical blocks presented to hosts connected to the storage virtual machine using the NVMe over Fabrics protocol.

// In ONTAP, an NVMe namespace is located within a volume. Optionally, it can be located within a qtree in a volume.

// An NVMe namespace is created to a specified size using thin or thick provisioning as determined by the volume on which it is created. NVMe namespaces support being cloned. An NVMe namespace cannot be renamed, resized, or moved to a different volume. NVMe namespaces do not support the assignment of a QoS policy for performance management, but a QoS policy can be assigned to the volume containing the namespace. See the NVMe namespace object model to learn more about each of the properties supported by the NVMe namespace REST API.

// An NVMe namespace must be mapped to an NVMe subsystem to grant access to the subsystem's hosts. Hosts can then access the NVMe namespace and perform I/O using the NVMe over Fabrics protocol.
//
// swagger:model ConsistencyGroupChildNamespacesItems0
type ConsistencyGroupChildNamespacesItems0 struct {

	// This property marks the NVMe namespace for auto deletion when the volume containing the namespace runs out of space. This is most commonly set on namespace clones.

	// When set to _true_, the NVMe namespace becomes eligible for automatic deletion when the volume runs out of space. Auto deletion only occurs when the volume containing the namespace is also configured for auto deletion and free space in the volume decreases below a particular threshold.

	// This property is optional in POST and PATCH. The default value for a new NVMe namespace is _false_.

	// There is an added cost to retrieving this property's value. It is not populated for either a collection GET or an instance GET unless it is explicitly requested using the `fields` query parameter. See [`Requesting specific fields`](#Requesting_specific_fields) to learn more.
	//
	AutoDelete *bool `json:"auto_delete,omitempty"`

	// A configurable comment available for use by the administrator. Valid in POST and PATCH.
	//
	// Max Length: 254
	// Min Length: 0
	Comment *string `json:"comment,omitempty"`

	// The time the NVMe namespace was created.
	// Example: 2018-06-04T19:00:00Z
	// Read Only: true
	// Format: date-time
	CreateTime *strfmt.DateTime `json:"create_time,omitempty"`

	// The enabled state of the NVMe namespace. Certain error conditions cause the namespace to become disabled. If the namespace is disabled, you can check the `state` property to determine what error disabled the namespace. An NVMe namespace is enabled automatically when it is created.
	//
	// Read Only: true
	Enabled *bool `json:"enabled,omitempty"`

	// The fully qualified path name of the NVMe namespace composed of a "/vol" prefix, the volume name, the (optional) qtree name and base name of the namespace. Valid in POST.

	// NVMe namespaces do not support rename, or movement between volumes.
	//
	// Example: /vol/volume1/qtree1/namespace1
	Name string `json:"name,omitempty"`

	// The operating system type of the NVMe namespace.

	// Required in POST when creating an NVMe namespace that is not a clone of another. Disallowed in POST when creating a namespace clone.
	//
	// Enum: [aix linux vmware windows]
	OsType string `json:"os_type,omitempty"`

	// provisioning options
	ProvisioningOptions *ConsistencyGroupChildNamespacesItems0ProvisioningOptions `json:"provisioning_options,omitempty"`

	// The NVMe subsystem with which the NVMe namespace is associated. A namespace can be mapped to zero (0) or one (1) subsystems.

	// There is an added cost to retrieving property values for `subsystem_map`. They are not populated for either a collection GET or an instance GET unless explicitly requested using the `fields` query parameter.
	//
	SubsystemMap []*ConsistencyGroupChildNamespacesItems0SubsystemMapItems0 `json:"subsystem_map,omitempty"`

	// The unique identifier of the NVMe namespace.
	//
	// Example: 1cd8a442-86d1-11e0-ae1c-123478563412
	// Read Only: true
	UUID string `json:"uuid,omitempty"`
}

// Validate validates this consistency group child namespaces items0
func (m *ConsistencyGroupChildNamespacesItems0) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

func (m *ConsistencyGroupChildNamespacesItems0) validateComment(formats strfmt.Registry) error {
	if swag.IsZero(m.Comment) { // not required
		return nil
	}

	if err := validate.MinLength("comment", "body", *m.Comment, 0); err != nil {
		return err
	}

	if err := validate.MaxLength("comment", "body", *m.Comment, 254); err != nil {
		return err
	}

	return nil
}

func (m *ConsistencyGroupChildNamespacesItems0) validateCreateTime(formats strfmt.Registry) error {
	if swag.IsZero(m.CreateTime) { // not required
		return nil
	}

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

	return nil
}

var consistencyGroupChildNamespacesItems0TypeOsTypePropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["aix","linux","vmware","windows"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		consistencyGroupChildNamespacesItems0TypeOsTypePropEnum = append(consistencyGroupChildNamespacesItems0TypeOsTypePropEnum, v)
	}
}

const (

	// BEGIN DEBUGGING
	// ConsistencyGroupChildNamespacesItems0
	// ConsistencyGroupChildNamespacesItems0
	// os_type
	// OsType
	// aix
	// END DEBUGGING
	// ConsistencyGroupChildNamespacesItems0OsTypeAix captures enum value "aix"
	ConsistencyGroupChildNamespacesItems0OsTypeAix string = "aix"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildNamespacesItems0
	// ConsistencyGroupChildNamespacesItems0
	// os_type
	// OsType
	// linux
	// END DEBUGGING
	// ConsistencyGroupChildNamespacesItems0OsTypeLinux captures enum value "linux"
	ConsistencyGroupChildNamespacesItems0OsTypeLinux string = "linux"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildNamespacesItems0
	// ConsistencyGroupChildNamespacesItems0
	// os_type
	// OsType
	// vmware
	// END DEBUGGING
	// ConsistencyGroupChildNamespacesItems0OsTypeVmware captures enum value "vmware"
	ConsistencyGroupChildNamespacesItems0OsTypeVmware string = "vmware"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildNamespacesItems0
	// ConsistencyGroupChildNamespacesItems0
	// os_type
	// OsType
	// windows
	// END DEBUGGING
	// ConsistencyGroupChildNamespacesItems0OsTypeWindows captures enum value "windows"
	ConsistencyGroupChildNamespacesItems0OsTypeWindows string = "windows"
)

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

func (m *ConsistencyGroupChildNamespacesItems0) validateOsType(formats strfmt.Registry) error {
	if swag.IsZero(m.OsType) { // not required
		return nil
	}

	// value enum
	if err := m.validateOsTypeEnum("os_type", "body", m.OsType); err != nil {
		return err
	}

	return nil
}

func (m *ConsistencyGroupChildNamespacesItems0) validateProvisioningOptions(formats strfmt.Registry) error {
	if swag.IsZero(m.ProvisioningOptions) { // not required
		return nil
	}

	if m.ProvisioningOptions != nil {
		if err := m.ProvisioningOptions.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("provisioning_options")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChildNamespacesItems0) validateSubsystemMap(formats strfmt.Registry) error {
	if swag.IsZero(m.SubsystemMap) { // not required
		return nil
	}

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

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

	}

	return nil
}

// ContextValidate validate this consistency group child namespaces items0 based on the context it is used
func (m *ConsistencyGroupChildNamespacesItems0) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

func (m *ConsistencyGroupChildNamespacesItems0) contextValidateCreateTime(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "create_time", "body", m.CreateTime); err != nil {
		return err
	}

	return nil
}

func (m *ConsistencyGroupChildNamespacesItems0) contextValidateEnabled(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "enabled", "body", m.Enabled); err != nil {
		return err
	}

	return nil
}

func (m *ConsistencyGroupChildNamespacesItems0) contextValidateProvisioningOptions(ctx context.Context, formats strfmt.Registry) error {

	if m.ProvisioningOptions != nil {
		if err := m.ProvisioningOptions.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("provisioning_options")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChildNamespacesItems0) contextValidateSubsystemMap(ctx context.Context, formats strfmt.Registry) error {

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

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

	}

	return nil
}

func (m *ConsistencyGroupChildNamespacesItems0) contextValidateUUID(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "uuid", "body", string(m.UUID)); err != nil {
		return err
	}

	return nil
}

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

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

// ConsistencyGroupChildNamespacesItems0ProvisioningOptions Options that are applied to the operation.
//
// swagger:model ConsistencyGroupChildNamespacesItems0ProvisioningOptions
type ConsistencyGroupChildNamespacesItems0ProvisioningOptions struct {

	// Operation to perform
	// Enum: [create]
	Action string `json:"action,omitempty"`

	// Number of elements to perform the operation on.
	Count int64 `json:"count,omitempty"`
}

// Validate validates this consistency group child namespaces items0 provisioning options
func (m *ConsistencyGroupChildNamespacesItems0ProvisioningOptions) Validate(formats strfmt.Registry) error {
	var res []error

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

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

var consistencyGroupChildNamespacesItems0ProvisioningOptionsTypeActionPropEnum []interface{}

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

const (

	// BEGIN DEBUGGING
	// ConsistencyGroupChildNamespacesItems0ProvisioningOptions
	// ConsistencyGroupChildNamespacesItems0ProvisioningOptions
	// action
	// Action
	// create
	// END DEBUGGING
	// ConsistencyGroupChildNamespacesItems0ProvisioningOptionsActionCreate captures enum value "create"
	ConsistencyGroupChildNamespacesItems0ProvisioningOptionsActionCreate string = "create"
)

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

func (m *ConsistencyGroupChildNamespacesItems0ProvisioningOptions) validateAction(formats strfmt.Registry) error {
	if swag.IsZero(m.Action) { // not required
		return nil
	}

	// value enum
	if err := m.validateActionEnum("provisioning_options"+"."+"action", "body", m.Action); err != nil {
		return err
	}

	return nil
}

// ContextValidate validates this consistency group child namespaces items0 provisioning options based on context it is used
func (m *ConsistencyGroupChildNamespacesItems0ProvisioningOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

// ConsistencyGroupChildNamespacesItems0SubsystemMapItems0 The NVMe subsystem with which the NVMe namespace is associated. A namespace can be mapped to zero (0) or one (1) subsystems.

// There is an added cost to retrieving property values for `subsystem_map`.
// They are not populated for either a collection GET or an instance GET unless explicitly requested using the `fields` query parameter.
//
// swagger:model ConsistencyGroupChildNamespacesItems0SubsystemMapItems0
type ConsistencyGroupChildNamespacesItems0SubsystemMapItems0 struct {

	// links
	Links *SelfLink `json:"_links,omitempty"`

	// The Asymmetric Namespace Access Group ID (ANAGRPID) of the NVMe namespace.

	// The format for an ANAGRPID is 8 hexadecimal digits (zero-filled) followed by a lower case "h".
	//
	// Example: 00103050h
	Anagrpid string `json:"anagrpid,omitempty"`

	// The NVMe namespace identifier. This is an identifier used by an NVMe controller to provide access to the NVMe namespace.

	// The format for an NVMe namespace identifier is 8 hexadecimal digits (zero-filled) followed by a lower case "h".
	//
	// Example: 00000001h
	Nsid string `json:"nsid,omitempty"`

	// The NVMe subsystem to which the NVMe namespace is mapped.
	//
	Subsystem *NvmeSubsystemReference `json:"subsystem,omitempty"`
}

// Validate validates this consistency group child namespaces items0 subsystem map items0
func (m *ConsistencyGroupChildNamespacesItems0SubsystemMapItems0) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

func (m *ConsistencyGroupChildNamespacesItems0SubsystemMapItems0) validateLinks(formats strfmt.Registry) error {
	if swag.IsZero(m.Links) { // not required
		return nil
	}

	if m.Links != nil {
		if err := m.Links.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("_links")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChildNamespacesItems0SubsystemMapItems0) validateSubsystem(formats strfmt.Registry) error {
	if swag.IsZero(m.Subsystem) { // not required
		return nil
	}

	if m.Subsystem != nil {
		if err := m.Subsystem.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("subsystem")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this consistency group child namespaces items0 subsystem map items0 based on the context it is used
func (m *ConsistencyGroupChildNamespacesItems0SubsystemMapItems0) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

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

func (m *ConsistencyGroupChildNamespacesItems0SubsystemMapItems0) contextValidateLinks(ctx context.Context, formats strfmt.Registry) error {

	if m.Links != nil {
		if err := m.Links.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("_links")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChildNamespacesItems0SubsystemMapItems0) contextValidateSubsystem(ctx context.Context, formats strfmt.Registry) error {

	if m.Subsystem != nil {
		if err := m.Subsystem.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("subsystem")
			}
			return err
		}
	}

	return nil
}

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

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

// ConsistencyGroupChildParentConsistencyGroup The parent consistency group.
//
// swagger:model ConsistencyGroupChildParentConsistencyGroup
type ConsistencyGroupChildParentConsistencyGroup struct {

	// links
	Links *SelfLink `json:"_links,omitempty"`

	// The name of the consistency group.
	// Example: my_consistency_group
	Name string `json:"name,omitempty"`

	// The unique identifier of the consistency group.
	// Example: 02c9e252-41be-11e9-81d5-00a0986138f7
	UUID string `json:"uuid,omitempty"`
}

// Validate validates this consistency group child parent consistency group
func (m *ConsistencyGroupChildParentConsistencyGroup) Validate(formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildParentConsistencyGroup) validateLinks(formats strfmt.Registry) error {
	if swag.IsZero(m.Links) { // not required
		return nil
	}

	if m.Links != nil {
		if err := m.Links.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("parent_consistency_group" + "." + "_links")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this consistency group child parent consistency group based on the context it is used
func (m *ConsistencyGroupChildParentConsistencyGroup) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildParentConsistencyGroup) contextValidateLinks(ctx context.Context, formats strfmt.Registry) error {

	if m.Links != nil {
		if err := m.Links.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("parent_consistency_group" + "." + "_links")
			}
			return err
		}
	}

	return nil
}

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

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

// ConsistencyGroupChildProvisioningOptions Options that are applied to the operation.
//
// swagger:model ConsistencyGroupChildProvisioningOptions
type ConsistencyGroupChildProvisioningOptions struct {

	// Operation to perform
	// Enum: [create]
	Action string `json:"action,omitempty"`

	// storage service
	StorageService *ConsistencyGroupChildProvisioningOptionsStorageService `json:"storage_service,omitempty"`
}

// Validate validates this consistency group child provisioning options
func (m *ConsistencyGroupChildProvisioningOptions) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

var consistencyGroupChildProvisioningOptionsTypeActionPropEnum []interface{}

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

const (

	// BEGIN DEBUGGING
	// ConsistencyGroupChildProvisioningOptions
	// ConsistencyGroupChildProvisioningOptions
	// action
	// Action
	// create
	// END DEBUGGING
	// ConsistencyGroupChildProvisioningOptionsActionCreate captures enum value "create"
	ConsistencyGroupChildProvisioningOptionsActionCreate string = "create"
)

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

func (m *ConsistencyGroupChildProvisioningOptions) validateAction(formats strfmt.Registry) error {
	if swag.IsZero(m.Action) { // not required
		return nil
	}

	// value enum
	if err := m.validateActionEnum("provisioning_options"+"."+"action", "body", m.Action); err != nil {
		return err
	}

	return nil
}

func (m *ConsistencyGroupChildProvisioningOptions) validateStorageService(formats strfmt.Registry) error {
	if swag.IsZero(m.StorageService) { // not required
		return nil
	}

	if m.StorageService != nil {
		if err := m.StorageService.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("provisioning_options" + "." + "storage_service")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this consistency group child provisioning options based on the context it is used
func (m *ConsistencyGroupChildProvisioningOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildProvisioningOptions) contextValidateStorageService(ctx context.Context, formats strfmt.Registry) error {

	if m.StorageService != nil {
		if err := m.StorageService.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("provisioning_options" + "." + "storage_service")
			}
			return err
		}
	}

	return nil
}

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

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

// ConsistencyGroupChildProvisioningOptionsStorageService Determines the placement of any storage object created during this operation.
//
// swagger:model ConsistencyGroupChildProvisioningOptionsStorageService
type ConsistencyGroupChildProvisioningOptionsStorageService struct {

	// Storage service name. If not specified, the default value is the most performant for the platform.
	//
	// Enum: [extreme performance value]
	Name string `json:"name,omitempty"`
}

// Validate validates this consistency group child provisioning options storage service
func (m *ConsistencyGroupChildProvisioningOptionsStorageService) Validate(formats strfmt.Registry) error {
	var res []error

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

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

var consistencyGroupChildProvisioningOptionsStorageServiceTypeNamePropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["extreme","performance","value"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		consistencyGroupChildProvisioningOptionsStorageServiceTypeNamePropEnum = append(consistencyGroupChildProvisioningOptionsStorageServiceTypeNamePropEnum, v)
	}
}

const (

	// BEGIN DEBUGGING
	// ConsistencyGroupChildProvisioningOptionsStorageService
	// ConsistencyGroupChildProvisioningOptionsStorageService
	// name
	// Name
	// extreme
	// END DEBUGGING
	// ConsistencyGroupChildProvisioningOptionsStorageServiceNameExtreme captures enum value "extreme"
	ConsistencyGroupChildProvisioningOptionsStorageServiceNameExtreme string = "extreme"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildProvisioningOptionsStorageService
	// ConsistencyGroupChildProvisioningOptionsStorageService
	// name
	// Name
	// performance
	// END DEBUGGING
	// ConsistencyGroupChildProvisioningOptionsStorageServiceNamePerformance captures enum value "performance"
	ConsistencyGroupChildProvisioningOptionsStorageServiceNamePerformance string = "performance"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildProvisioningOptionsStorageService
	// ConsistencyGroupChildProvisioningOptionsStorageService
	// name
	// Name
	// value
	// END DEBUGGING
	// ConsistencyGroupChildProvisioningOptionsStorageServiceNameValue captures enum value "value"
	ConsistencyGroupChildProvisioningOptionsStorageServiceNameValue string = "value"
)

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

func (m *ConsistencyGroupChildProvisioningOptionsStorageService) validateName(formats strfmt.Registry) error {
	if swag.IsZero(m.Name) { // not required
		return nil
	}

	// value enum
	if err := m.validateNameEnum("provisioning_options"+"."+"storage_service"+"."+"name", "body", m.Name); err != nil {
		return err
	}

	return nil
}

// ContextValidate validates this consistency group child provisioning options storage service based on context it is used
func (m *ConsistencyGroupChildProvisioningOptionsStorageService) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

// ConsistencyGroupChildQos consistency group child qos
//
// swagger:model ConsistencyGroupChildQos
type ConsistencyGroupChildQos struct {

	// policy
	Policy *ConsistencyGroupChildQosPolicy `json:"policy,omitempty"`
}

// Validate validates this consistency group child qos
func (m *ConsistencyGroupChildQos) Validate(formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildQos) validatePolicy(formats strfmt.Registry) error {
	if swag.IsZero(m.Policy) { // not required
		return nil
	}

	if m.Policy != nil {
		if err := m.Policy.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("qos" + "." + "policy")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this consistency group child qos based on the context it is used
func (m *ConsistencyGroupChildQos) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildQos) contextValidatePolicy(ctx context.Context, formats strfmt.Registry) error {

	if m.Policy != nil {
		if err := m.Policy.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("qos" + "." + "policy")
			}
			return err
		}
	}

	return nil
}

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

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

// ConsistencyGroupChildQosPolicy The QoS policy
//
// swagger:model ConsistencyGroupChildQosPolicy
type ConsistencyGroupChildQosPolicy struct {

	// links
	Links *SelfLink `json:"_links,omitempty"`

	// Specifies the maximum throughput in IOPS, 0 means none. This is mutually exclusive with name and UUID during POST and PATCH.
	// Example: 10000
	MaxThroughputIops int64 `json:"max_throughput_iops,omitempty"`

	// Specifies the maximum throughput in Megabytes per sec, 0 means none. This is mutually exclusive with name and UUID during POST and PATCH.
	// Example: 500
	MaxThroughputMbps int64 `json:"max_throughput_mbps,omitempty"`

	// Specifies the minimum throughput in IOPS, 0 means none. Setting "min_throughput" is supported on AFF platforms only, unless FabricPool tiering policies are set. This is mutually exclusive with name and UUID during POST and PATCH.
	// Example: 2000
	MinThroughputIops int64 `json:"min_throughput_iops,omitempty"`

	// Specifies the minimum throughput in Megabytes per sec, 0 means none. This is mutually exclusive with name and UUID during POST and PATCH.
	// Example: 500
	MinThroughputMbps int64 `json:"min_throughput_mbps,omitempty"`

	// The QoS policy group name. This is mutually exclusive with UUID and other QoS attributes during POST and PATCH.
	// Example: performance
	Name string `json:"name,omitempty"`

	// The QoS policy group UUID. This is mutually exclusive with name and other QoS attributes during POST and PATCH.
	// Example: 1cd8a442-86d1-11e0-ae1c-123478563412
	UUID string `json:"uuid,omitempty"`
}

// Validate validates this consistency group child qos policy
func (m *ConsistencyGroupChildQosPolicy) Validate(formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildQosPolicy) validateLinks(formats strfmt.Registry) error {
	if swag.IsZero(m.Links) { // not required
		return nil
	}

	if m.Links != nil {
		if err := m.Links.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("qos" + "." + "policy" + "." + "_links")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this consistency group child qos policy based on the context it is used
func (m *ConsistencyGroupChildQosPolicy) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildQosPolicy) contextValidateLinks(ctx context.Context, formats strfmt.Registry) error {

	if m.Links != nil {
		if err := m.Links.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("qos" + "." + "policy" + "." + "_links")
			}
			return err
		}
	}

	return nil
}

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

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

// ConsistencyGroupChildRestoreTo Use to restore a consistency group to a previous Snapshot copy
//
// swagger:model ConsistencyGroupChildRestoreTo
type ConsistencyGroupChildRestoreTo struct {

	// snapshot
	Snapshot *ConsistencyGroupChildRestoreToSnapshot `json:"snapshot,omitempty"`
}

// Validate validates this consistency group child restore to
func (m *ConsistencyGroupChildRestoreTo) Validate(formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildRestoreTo) validateSnapshot(formats strfmt.Registry) error {
	if swag.IsZero(m.Snapshot) { // not required
		return nil
	}

	if m.Snapshot != nil {
		if err := m.Snapshot.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("restore_to" + "." + "snapshot")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this consistency group child restore to based on the context it is used
func (m *ConsistencyGroupChildRestoreTo) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildRestoreTo) contextValidateSnapshot(ctx context.Context, formats strfmt.Registry) error {

	if m.Snapshot != nil {
		if err := m.Snapshot.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("restore_to" + "." + "snapshot")
			}
			return err
		}
	}

	return nil
}

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

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

// ConsistencyGroupChildRestoreToSnapshot A consistency group's Snapshot copy
//
// swagger:model ConsistencyGroupChildRestoreToSnapshot
type ConsistencyGroupChildRestoreToSnapshot struct {

	// The name of the consistency group's Snapshot copy to restore to.
	Name string `json:"name,omitempty"`

	// The UUID of the consistency group's Snapshot copy to restore to.
	UUID string `json:"uuid,omitempty"`
}

// Validate validates this consistency group child restore to snapshot
func (m *ConsistencyGroupChildRestoreToSnapshot) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this consistency group child restore to snapshot based on context it is used
func (m *ConsistencyGroupChildRestoreToSnapshot) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

// ConsistencyGroupChildSpace Space information for the consistency group.
//
// swagger:model ConsistencyGroupChildSpace
type ConsistencyGroupChildSpace struct {

	// The amount of space available in the consistency group, in bytes.

	//
	// Example: 5737418
	Available int64 `json:"available,omitempty"`

	// The total provisioned size of the consistency group, in bytes.

	//
	// Example: 1073741824
	Size int64 `json:"size,omitempty"`

	// The amount of space consumed in the consistency group, in bytes.

	//
	// Example: 5737418
	Used int64 `json:"used,omitempty"`
}

// Validate validates this consistency group child space
func (m *ConsistencyGroupChildSpace) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this consistency group child space based on context it is used
func (m *ConsistencyGroupChildSpace) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

// ConsistencyGroupChildSvm The Storage Virtual Machine (SVM) in which the consistency group is located.
//
// swagger:model ConsistencyGroupChildSvm
type ConsistencyGroupChildSvm struct {

	// links
	Links *ConsistencyGroupChildSvmLinks `json:"_links,omitempty"`

	// The name of the SVM.
	//
	// Example: svm1
	Name string `json:"name,omitempty"`

	// The unique identifier of the SVM.
	//
	// Example: 02c9e252-41be-11e9-81d5-00a0986138f7
	UUID string `json:"uuid,omitempty"`
}

// Validate validates this consistency group child svm
func (m *ConsistencyGroupChildSvm) Validate(formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildSvm) validateLinks(formats strfmt.Registry) error {
	if swag.IsZero(m.Links) { // not required
		return nil
	}

	if m.Links != nil {
		if err := m.Links.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("svm" + "." + "_links")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this consistency group child svm based on the context it is used
func (m *ConsistencyGroupChildSvm) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildSvm) contextValidateLinks(ctx context.Context, formats strfmt.Registry) error {

	if m.Links != nil {
		if err := m.Links.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("svm" + "." + "_links")
			}
			return err
		}
	}

	return nil
}

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

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

// ConsistencyGroupChildSvmLinks consistency group child svm links
//
// swagger:model ConsistencyGroupChildSvmLinks
type ConsistencyGroupChildSvmLinks struct {

	// self
	Self *Href `json:"self,omitempty"`
}

// Validate validates this consistency group child svm links
func (m *ConsistencyGroupChildSvmLinks) Validate(formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildSvmLinks) validateSelf(formats strfmt.Registry) error {
	if swag.IsZero(m.Self) { // not required
		return nil
	}

	if m.Self != nil {
		if err := m.Self.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("svm" + "." + "_links" + "." + "self")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this consistency group child svm links based on the context it is used
func (m *ConsistencyGroupChildSvmLinks) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildSvmLinks) contextValidateSelf(ctx context.Context, formats strfmt.Registry) error {

	if m.Self != nil {
		if err := m.Self.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("svm" + "." + "_links" + "." + "self")
			}
			return err
		}
	}

	return nil
}

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

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

// ConsistencyGroupChildTiering The tiering placement and policy definitions for volumes in this consistency group.
//
// swagger:model ConsistencyGroupChildTiering
type ConsistencyGroupChildTiering struct {

	// Storage tiering placement rules for the object.
	// Enum: [allowed best_effort disallowed required]
	Control string `json:"control,omitempty"`

	// Policy that determines whether the user data blocks of a volume in a FabricPool will be tiered to the cloud store when they become cold.
	//
FabricPool combines flash (performance tier) with a cloud store into a single aggregate. Temperature of a volume block increases if it is accessed frequently and decreases when it is not. Valid in POST or PATCH.
all ‐ Allows tiering of both Snapshot copies and active file system user data to the cloud store as soon as possible by ignoring the temperature on the volume blocks.
auto ‐ Allows tiering of both snapshot and active file system user data to the cloud store
none ‐ Volume blocks are not be tiered to the cloud store.
snapshot_only ‐ Allows tiering of only the volume Snapshot copies not associated with the active file system.
	//
The default tiering policy is "snapshot-only" for a FlexVol volume and "none" for a FlexGroup volume. The default minimum cooling period for the "snapshot-only" tiering policy is 2 days and for the "auto" tiering policy it is 31 days.
	//
	// Enum: [all auto backup none snapshot_only]
	Policy string `json:"policy,omitempty"`
}

// Validate validates this consistency group child tiering
func (m *ConsistencyGroupChildTiering) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

var consistencyGroupChildTieringTypeControlPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["allowed","best_effort","disallowed","required"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		consistencyGroupChildTieringTypeControlPropEnum = append(consistencyGroupChildTieringTypeControlPropEnum, v)
	}
}

const (

	// BEGIN DEBUGGING
	// ConsistencyGroupChildTiering
	// ConsistencyGroupChildTiering
	// control
	// Control
	// allowed
	// END DEBUGGING
	// ConsistencyGroupChildTieringControlAllowed captures enum value "allowed"
	ConsistencyGroupChildTieringControlAllowed string = "allowed"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildTiering
	// ConsistencyGroupChildTiering
	// control
	// Control
	// best_effort
	// END DEBUGGING
	// ConsistencyGroupChildTieringControlBestEffort captures enum value "best_effort"
	ConsistencyGroupChildTieringControlBestEffort string = "best_effort"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildTiering
	// ConsistencyGroupChildTiering
	// control
	// Control
	// disallowed
	// END DEBUGGING
	// ConsistencyGroupChildTieringControlDisallowed captures enum value "disallowed"
	ConsistencyGroupChildTieringControlDisallowed string = "disallowed"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildTiering
	// ConsistencyGroupChildTiering
	// control
	// Control
	// required
	// END DEBUGGING
	// ConsistencyGroupChildTieringControlRequired captures enum value "required"
	ConsistencyGroupChildTieringControlRequired string = "required"
)

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

func (m *ConsistencyGroupChildTiering) validateControl(formats strfmt.Registry) error {
	if swag.IsZero(m.Control) { // not required
		return nil
	}

	// value enum
	if err := m.validateControlEnum("tiering"+"."+"control", "body", m.Control); err != nil {
		return err
	}

	return nil
}

var consistencyGroupChildTieringTypePolicyPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["all","auto","backup","none","snapshot_only"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		consistencyGroupChildTieringTypePolicyPropEnum = append(consistencyGroupChildTieringTypePolicyPropEnum, v)
	}
}

const (

	// BEGIN DEBUGGING
	// ConsistencyGroupChildTiering
	// ConsistencyGroupChildTiering
	// policy
	// Policy
	// all
	// END DEBUGGING
	// ConsistencyGroupChildTieringPolicyAll captures enum value "all"
	ConsistencyGroupChildTieringPolicyAll string = "all"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildTiering
	// ConsistencyGroupChildTiering
	// policy
	// Policy
	// auto
	// END DEBUGGING
	// ConsistencyGroupChildTieringPolicyAuto captures enum value "auto"
	ConsistencyGroupChildTieringPolicyAuto string = "auto"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildTiering
	// ConsistencyGroupChildTiering
	// policy
	// Policy
	// backup
	// END DEBUGGING
	// ConsistencyGroupChildTieringPolicyBackup captures enum value "backup"
	ConsistencyGroupChildTieringPolicyBackup string = "backup"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildTiering
	// ConsistencyGroupChildTiering
	// policy
	// Policy
	// none
	// END DEBUGGING
	// ConsistencyGroupChildTieringPolicyNone captures enum value "none"
	ConsistencyGroupChildTieringPolicyNone string = "none"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildTiering
	// ConsistencyGroupChildTiering
	// policy
	// Policy
	// snapshot_only
	// END DEBUGGING
	// ConsistencyGroupChildTieringPolicySnapshotOnly captures enum value "snapshot_only"
	ConsistencyGroupChildTieringPolicySnapshotOnly string = "snapshot_only"
)

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

func (m *ConsistencyGroupChildTiering) validatePolicy(formats strfmt.Registry) error {
	if swag.IsZero(m.Policy) { // not required
		return nil
	}

	// value enum
	if err := m.validatePolicyEnum("tiering"+"."+"policy", "body", m.Policy); err != nil {
		return err
	}

	return nil
}

// ContextValidate validates this consistency group child tiering based on context it is used
func (m *ConsistencyGroupChildTiering) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

// ConsistencyGroupChildVolumesItems0 consistency group child volumes items0
//
// swagger:model ConsistencyGroupChildVolumesItems0
type ConsistencyGroupChildVolumesItems0 struct {

	// A comment for the volume. Valid in POST or PATCH.
	// Max Length: 1023
	// Min Length: 0
	Comment *string `json:"comment,omitempty"`

	// Language encoding setting for volume. If no language is specified, the volume inherits its SVM language encoding setting.
	// Enum: [ar ar.utf_8 c c.utf_8 cs cs.utf_8 da da.utf_8 de de.utf_8 en en.utf_8 en_us en_us.utf_8 es es.utf_8 fi fi.utf_8 fr fr.utf_8 he he.utf_8 hr hr.utf_8 hu hu.utf_8 it it.utf_8 ja ja.utf_8 ja_jp.932 ja_jp.932.utf_8 ja_jp.pck ja_jp.pck.utf_8 ja_jp.pck_v2 ja_jp.pck_v2.utf_8 ja_v1 ja_v1.utf_8 ko ko.utf_8 nl nl.utf_8 no no.utf_8 pl pl.utf_8 pt pt.utf_8 ro ro.utf_8 ru ru.utf_8 sk sk.utf_8 sl sl.utf_8 sv sv.utf_8 tr tr.utf_8 utf8mb4 zh zh.gbk zh.gbk.utf_8 zh.utf_8 zh_tw zh_tw.big5 zh_tw.big5.utf_8 zh_tw.utf_8]
	Language string `json:"language,omitempty"`

	// Volume name. The name of volume must start with an alphabetic character (a to z or A to Z) or an underscore (_). The name must be 197 or fewer characters in length for FlexGroups, and 203 or fewer characters in length for all other types of volumes. Volume names must be unique within an SVM. Required on POST.
	// Example: vol_cs_dept
	// Max Length: 203
	// Min Length: 1
	Name string `json:"name,omitempty"`

	// provisioning options
	ProvisioningOptions *ConsistencyGroupChildVolumesItems0ProvisioningOptions `json:"provisioning_options,omitempty"`

	// qos
	Qos *ConsistencyGroupChildVolumesItems0Qos `json:"qos,omitempty"`

	// The Snapshot copy policy for this volume.
	//
	SnapshotPolicy *SnapshotPolicyReference `json:"snapshot_policy,omitempty"`

	// space
	Space *ConsistencyGroupChildVolumesItems0Space `json:"space,omitempty"`

	// tiering
	Tiering *ConsistencyGroupChildVolumesItems0Tiering `json:"tiering,omitempty"`

	// Unique identifier for the volume. This corresponds to the instance-uuid that is exposed in the CLI and ONTAPI. It does not change due to a volume move.
	// Example: 028baa66-41bd-11e9-81d5-00a0986138f7
	// Read Only: true
	UUID string `json:"uuid,omitempty"`
}

// Validate validates this consistency group child volumes items0
func (m *ConsistencyGroupChildVolumesItems0) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

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

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

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

func (m *ConsistencyGroupChildVolumesItems0) validateComment(formats strfmt.Registry) error {
	if swag.IsZero(m.Comment) { // not required
		return nil
	}

	if err := validate.MinLength("comment", "body", *m.Comment, 0); err != nil {
		return err
	}

	if err := validate.MaxLength("comment", "body", *m.Comment, 1023); err != nil {
		return err
	}

	return nil
}

var consistencyGroupChildVolumesItems0TypeLanguagePropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["ar","ar.utf_8","c","c.utf_8","cs","cs.utf_8","da","da.utf_8","de","de.utf_8","en","en.utf_8","en_us","en_us.utf_8","es","es.utf_8","fi","fi.utf_8","fr","fr.utf_8","he","he.utf_8","hr","hr.utf_8","hu","hu.utf_8","it","it.utf_8","ja","ja.utf_8","ja_jp.932","ja_jp.932.utf_8","ja_jp.pck","ja_jp.pck.utf_8","ja_jp.pck_v2","ja_jp.pck_v2.utf_8","ja_v1","ja_v1.utf_8","ko","ko.utf_8","nl","nl.utf_8","no","no.utf_8","pl","pl.utf_8","pt","pt.utf_8","ro","ro.utf_8","ru","ru.utf_8","sk","sk.utf_8","sl","sl.utf_8","sv","sv.utf_8","tr","tr.utf_8","utf8mb4","zh","zh.gbk","zh.gbk.utf_8","zh.utf_8","zh_tw","zh_tw.big5","zh_tw.big5.utf_8","zh_tw.utf_8"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		consistencyGroupChildVolumesItems0TypeLanguagePropEnum = append(consistencyGroupChildVolumesItems0TypeLanguagePropEnum, v)
	}
}

const (

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// ar
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageAr captures enum value "ar"
	ConsistencyGroupChildVolumesItems0LanguageAr string = "ar"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// ar.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageArDotUTF8 captures enum value "ar.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageArDotUTF8 string = "ar.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// c
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageC captures enum value "c"
	ConsistencyGroupChildVolumesItems0LanguageC string = "c"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// c.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageCDotUTF8 captures enum value "c.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageCDotUTF8 string = "c.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// cs
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageCs captures enum value "cs"
	ConsistencyGroupChildVolumesItems0LanguageCs string = "cs"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// cs.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageCsDotUTF8 captures enum value "cs.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageCsDotUTF8 string = "cs.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// da
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageDa captures enum value "da"
	ConsistencyGroupChildVolumesItems0LanguageDa string = "da"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// da.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageDaDotUTF8 captures enum value "da.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageDaDotUTF8 string = "da.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// de
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageDe captures enum value "de"
	ConsistencyGroupChildVolumesItems0LanguageDe string = "de"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// de.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageDeDotUTF8 captures enum value "de.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageDeDotUTF8 string = "de.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// en
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageEn captures enum value "en"
	ConsistencyGroupChildVolumesItems0LanguageEn string = "en"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// en.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageEnDotUTF8 captures enum value "en.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageEnDotUTF8 string = "en.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// en_us
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageEnUs captures enum value "en_us"
	ConsistencyGroupChildVolumesItems0LanguageEnUs string = "en_us"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// en_us.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageEnUsDotUTF8 captures enum value "en_us.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageEnUsDotUTF8 string = "en_us.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// es
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageEs captures enum value "es"
	ConsistencyGroupChildVolumesItems0LanguageEs string = "es"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// es.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageEsDotUTF8 captures enum value "es.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageEsDotUTF8 string = "es.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// fi
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageFi captures enum value "fi"
	ConsistencyGroupChildVolumesItems0LanguageFi string = "fi"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// fi.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageFiDotUTF8 captures enum value "fi.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageFiDotUTF8 string = "fi.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// fr
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageFr captures enum value "fr"
	ConsistencyGroupChildVolumesItems0LanguageFr string = "fr"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// fr.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageFrDotUTF8 captures enum value "fr.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageFrDotUTF8 string = "fr.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// he
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageHe captures enum value "he"
	ConsistencyGroupChildVolumesItems0LanguageHe string = "he"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// he.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageHeDotUTF8 captures enum value "he.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageHeDotUTF8 string = "he.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// hr
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageHr captures enum value "hr"
	ConsistencyGroupChildVolumesItems0LanguageHr string = "hr"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// hr.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageHrDotUTF8 captures enum value "hr.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageHrDotUTF8 string = "hr.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// hu
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageHu captures enum value "hu"
	ConsistencyGroupChildVolumesItems0LanguageHu string = "hu"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// hu.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageHuDotUTF8 captures enum value "hu.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageHuDotUTF8 string = "hu.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// it
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageIt captures enum value "it"
	ConsistencyGroupChildVolumesItems0LanguageIt string = "it"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// it.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageItDotUTF8 captures enum value "it.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageItDotUTF8 string = "it.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// ja
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageJa captures enum value "ja"
	ConsistencyGroupChildVolumesItems0LanguageJa string = "ja"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// ja.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageJaDotUTF8 captures enum value "ja.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageJaDotUTF8 string = "ja.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// ja_jp.932
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageJaJpDot932 captures enum value "ja_jp.932"
	ConsistencyGroupChildVolumesItems0LanguageJaJpDot932 string = "ja_jp.932"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// ja_jp.932.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageJaJpDot932DotUTF8 captures enum value "ja_jp.932.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageJaJpDot932DotUTF8 string = "ja_jp.932.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// ja_jp.pck
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageJaJpDotPck captures enum value "ja_jp.pck"
	ConsistencyGroupChildVolumesItems0LanguageJaJpDotPck string = "ja_jp.pck"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// ja_jp.pck.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageJaJpDotPckDotUTF8 captures enum value "ja_jp.pck.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageJaJpDotPckDotUTF8 string = "ja_jp.pck.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// ja_jp.pck_v2
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageJaJpDotPckV2 captures enum value "ja_jp.pck_v2"
	ConsistencyGroupChildVolumesItems0LanguageJaJpDotPckV2 string = "ja_jp.pck_v2"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// ja_jp.pck_v2.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageJaJpDotPckV2DotUTF8 captures enum value "ja_jp.pck_v2.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageJaJpDotPckV2DotUTF8 string = "ja_jp.pck_v2.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// ja_v1
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageJaV1 captures enum value "ja_v1"
	ConsistencyGroupChildVolumesItems0LanguageJaV1 string = "ja_v1"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// ja_v1.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageJaV1DotUTF8 captures enum value "ja_v1.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageJaV1DotUTF8 string = "ja_v1.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// ko
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageKo captures enum value "ko"
	ConsistencyGroupChildVolumesItems0LanguageKo string = "ko"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// ko.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageKoDotUTF8 captures enum value "ko.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageKoDotUTF8 string = "ko.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// nl
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageNl captures enum value "nl"
	ConsistencyGroupChildVolumesItems0LanguageNl string = "nl"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// nl.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageNlDotUTF8 captures enum value "nl.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageNlDotUTF8 string = "nl.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// no
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageNo captures enum value "no"
	ConsistencyGroupChildVolumesItems0LanguageNo string = "no"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// no.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageNoDotUTF8 captures enum value "no.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageNoDotUTF8 string = "no.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// pl
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguagePl captures enum value "pl"
	ConsistencyGroupChildVolumesItems0LanguagePl string = "pl"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// pl.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguagePlDotUTF8 captures enum value "pl.utf_8"
	ConsistencyGroupChildVolumesItems0LanguagePlDotUTF8 string = "pl.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// pt
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguagePt captures enum value "pt"
	ConsistencyGroupChildVolumesItems0LanguagePt string = "pt"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// pt.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguagePtDotUTF8 captures enum value "pt.utf_8"
	ConsistencyGroupChildVolumesItems0LanguagePtDotUTF8 string = "pt.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// ro
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageRo captures enum value "ro"
	ConsistencyGroupChildVolumesItems0LanguageRo string = "ro"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// ro.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageRoDotUTF8 captures enum value "ro.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageRoDotUTF8 string = "ro.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// ru
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageRu captures enum value "ru"
	ConsistencyGroupChildVolumesItems0LanguageRu string = "ru"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// ru.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageRuDotUTF8 captures enum value "ru.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageRuDotUTF8 string = "ru.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// sk
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageSk captures enum value "sk"
	ConsistencyGroupChildVolumesItems0LanguageSk string = "sk"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// sk.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageSkDotUTF8 captures enum value "sk.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageSkDotUTF8 string = "sk.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// sl
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageSl captures enum value "sl"
	ConsistencyGroupChildVolumesItems0LanguageSl string = "sl"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// sl.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageSlDotUTF8 captures enum value "sl.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageSlDotUTF8 string = "sl.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// sv
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageSv captures enum value "sv"
	ConsistencyGroupChildVolumesItems0LanguageSv string = "sv"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// sv.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageSvDotUTF8 captures enum value "sv.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageSvDotUTF8 string = "sv.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// tr
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageTr captures enum value "tr"
	ConsistencyGroupChildVolumesItems0LanguageTr string = "tr"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// tr.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageTrDotUTF8 captures enum value "tr.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageTrDotUTF8 string = "tr.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// utf8mb4
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageUtf8mb4 captures enum value "utf8mb4"
	ConsistencyGroupChildVolumesItems0LanguageUtf8mb4 string = "utf8mb4"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// zh
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageZh captures enum value "zh"
	ConsistencyGroupChildVolumesItems0LanguageZh string = "zh"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// zh.gbk
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageZhDotGbk captures enum value "zh.gbk"
	ConsistencyGroupChildVolumesItems0LanguageZhDotGbk string = "zh.gbk"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// zh.gbk.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageZhDotGbkDotUTF8 captures enum value "zh.gbk.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageZhDotGbkDotUTF8 string = "zh.gbk.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// zh.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageZhDotUTF8 captures enum value "zh.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageZhDotUTF8 string = "zh.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// zh_tw
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageZhTw captures enum value "zh_tw"
	ConsistencyGroupChildVolumesItems0LanguageZhTw string = "zh_tw"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// zh_tw.big5
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageZhTwDotBig5 captures enum value "zh_tw.big5"
	ConsistencyGroupChildVolumesItems0LanguageZhTwDotBig5 string = "zh_tw.big5"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// zh_tw.big5.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageZhTwDotBig5DotUTF8 captures enum value "zh_tw.big5.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageZhTwDotBig5DotUTF8 string = "zh_tw.big5.utf_8"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0
	// ConsistencyGroupChildVolumesItems0
	// language
	// Language
	// zh_tw.utf_8
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0LanguageZhTwDotUTF8 captures enum value "zh_tw.utf_8"
	ConsistencyGroupChildVolumesItems0LanguageZhTwDotUTF8 string = "zh_tw.utf_8"
)

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

func (m *ConsistencyGroupChildVolumesItems0) validateLanguage(formats strfmt.Registry) error {
	if swag.IsZero(m.Language) { // not required
		return nil
	}

	// value enum
	if err := m.validateLanguageEnum("language", "body", m.Language); err != nil {
		return err
	}

	return nil
}

func (m *ConsistencyGroupChildVolumesItems0) validateName(formats strfmt.Registry) error {
	if swag.IsZero(m.Name) { // not required
		return nil
	}

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

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

	return nil
}

func (m *ConsistencyGroupChildVolumesItems0) validateProvisioningOptions(formats strfmt.Registry) error {
	if swag.IsZero(m.ProvisioningOptions) { // not required
		return nil
	}

	if m.ProvisioningOptions != nil {
		if err := m.ProvisioningOptions.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("provisioning_options")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChildVolumesItems0) validateQos(formats strfmt.Registry) error {
	if swag.IsZero(m.Qos) { // not required
		return nil
	}

	if m.Qos != nil {
		if err := m.Qos.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("qos")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChildVolumesItems0) validateSnapshotPolicy(formats strfmt.Registry) error {
	if swag.IsZero(m.SnapshotPolicy) { // not required
		return nil
	}

	if m.SnapshotPolicy != nil {
		if err := m.SnapshotPolicy.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("snapshot_policy")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChildVolumesItems0) validateSpace(formats strfmt.Registry) error {
	if swag.IsZero(m.Space) { // not required
		return nil
	}

	if m.Space != nil {
		if err := m.Space.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("space")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChildVolumesItems0) validateTiering(formats strfmt.Registry) error {
	if swag.IsZero(m.Tiering) { // not required
		return nil
	}

	if m.Tiering != nil {
		if err := m.Tiering.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("tiering")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this consistency group child volumes items0 based on the context it is used
func (m *ConsistencyGroupChildVolumesItems0) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

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

func (m *ConsistencyGroupChildVolumesItems0) contextValidateProvisioningOptions(ctx context.Context, formats strfmt.Registry) error {

	if m.ProvisioningOptions != nil {
		if err := m.ProvisioningOptions.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("provisioning_options")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChildVolumesItems0) contextValidateQos(ctx context.Context, formats strfmt.Registry) error {

	if m.Qos != nil {
		if err := m.Qos.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("qos")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChildVolumesItems0) contextValidateSnapshotPolicy(ctx context.Context, formats strfmt.Registry) error {

	if m.SnapshotPolicy != nil {
		if err := m.SnapshotPolicy.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("snapshot_policy")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChildVolumesItems0) contextValidateSpace(ctx context.Context, formats strfmt.Registry) error {

	if m.Space != nil {
		if err := m.Space.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("space")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChildVolumesItems0) contextValidateTiering(ctx context.Context, formats strfmt.Registry) error {

	if m.Tiering != nil {
		if err := m.Tiering.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("tiering")
			}
			return err
		}
	}

	return nil
}

func (m *ConsistencyGroupChildVolumesItems0) contextValidateUUID(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "uuid", "body", string(m.UUID)); err != nil {
		return err
	}

	return nil
}

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

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

// ConsistencyGroupChildVolumesItems0ProvisioningOptions Options that are applied to the operation.
//
// swagger:model ConsistencyGroupChildVolumesItems0ProvisioningOptions
type ConsistencyGroupChildVolumesItems0ProvisioningOptions struct {

	// Operation to perform
	// Enum: [create add]
	Action string `json:"action,omitempty"`

	// Number of elements to perform the operation on.
	Count int64 `json:"count,omitempty"`

	// storage service
	StorageService *ConsistencyGroupChildVolumesItems0ProvisioningOptionsStorageService `json:"storage_service,omitempty"`
}

// Validate validates this consistency group child volumes items0 provisioning options
func (m *ConsistencyGroupChildVolumesItems0ProvisioningOptions) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

var consistencyGroupChildVolumesItems0ProvisioningOptionsTypeActionPropEnum []interface{}

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

const (

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0ProvisioningOptions
	// ConsistencyGroupChildVolumesItems0ProvisioningOptions
	// action
	// Action
	// create
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0ProvisioningOptionsActionCreate captures enum value "create"
	ConsistencyGroupChildVolumesItems0ProvisioningOptionsActionCreate string = "create"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0ProvisioningOptions
	// ConsistencyGroupChildVolumesItems0ProvisioningOptions
	// action
	// Action
	// add
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0ProvisioningOptionsActionAdd captures enum value "add"
	ConsistencyGroupChildVolumesItems0ProvisioningOptionsActionAdd string = "add"
)

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

func (m *ConsistencyGroupChildVolumesItems0ProvisioningOptions) validateAction(formats strfmt.Registry) error {
	if swag.IsZero(m.Action) { // not required
		return nil
	}

	// value enum
	if err := m.validateActionEnum("provisioning_options"+"."+"action", "body", m.Action); err != nil {
		return err
	}

	return nil
}

func (m *ConsistencyGroupChildVolumesItems0ProvisioningOptions) validateStorageService(formats strfmt.Registry) error {
	if swag.IsZero(m.StorageService) { // not required
		return nil
	}

	if m.StorageService != nil {
		if err := m.StorageService.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("provisioning_options" + "." + "storage_service")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this consistency group child volumes items0 provisioning options based on the context it is used
func (m *ConsistencyGroupChildVolumesItems0ProvisioningOptions) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildVolumesItems0ProvisioningOptions) contextValidateStorageService(ctx context.Context, formats strfmt.Registry) error {

	if m.StorageService != nil {
		if err := m.StorageService.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("provisioning_options" + "." + "storage_service")
			}
			return err
		}
	}

	return nil
}

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

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

// ConsistencyGroupChildVolumesItems0ProvisioningOptionsStorageService Determines the placement of any storage object created during this operation.
//
// swagger:model ConsistencyGroupChildVolumesItems0ProvisioningOptionsStorageService
type ConsistencyGroupChildVolumesItems0ProvisioningOptionsStorageService struct {

	// Storage service name. If not specified, the default value is the most performant for the platform.
	//
	// Enum: [extreme performance value]
	Name string `json:"name,omitempty"`
}

// Validate validates this consistency group child volumes items0 provisioning options storage service
func (m *ConsistencyGroupChildVolumesItems0ProvisioningOptionsStorageService) Validate(formats strfmt.Registry) error {
	var res []error

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

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

var consistencyGroupChildVolumesItems0ProvisioningOptionsStorageServiceTypeNamePropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["extreme","performance","value"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		consistencyGroupChildVolumesItems0ProvisioningOptionsStorageServiceTypeNamePropEnum = append(consistencyGroupChildVolumesItems0ProvisioningOptionsStorageServiceTypeNamePropEnum, v)
	}
}

const (

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0ProvisioningOptionsStorageService
	// ConsistencyGroupChildVolumesItems0ProvisioningOptionsStorageService
	// name
	// Name
	// extreme
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0ProvisioningOptionsStorageServiceNameExtreme captures enum value "extreme"
	ConsistencyGroupChildVolumesItems0ProvisioningOptionsStorageServiceNameExtreme string = "extreme"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0ProvisioningOptionsStorageService
	// ConsistencyGroupChildVolumesItems0ProvisioningOptionsStorageService
	// name
	// Name
	// performance
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0ProvisioningOptionsStorageServiceNamePerformance captures enum value "performance"
	ConsistencyGroupChildVolumesItems0ProvisioningOptionsStorageServiceNamePerformance string = "performance"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0ProvisioningOptionsStorageService
	// ConsistencyGroupChildVolumesItems0ProvisioningOptionsStorageService
	// name
	// Name
	// value
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0ProvisioningOptionsStorageServiceNameValue captures enum value "value"
	ConsistencyGroupChildVolumesItems0ProvisioningOptionsStorageServiceNameValue string = "value"
)

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

func (m *ConsistencyGroupChildVolumesItems0ProvisioningOptionsStorageService) validateName(formats strfmt.Registry) error {
	if swag.IsZero(m.Name) { // not required
		return nil
	}

	// value enum
	if err := m.validateNameEnum("provisioning_options"+"."+"storage_service"+"."+"name", "body", m.Name); err != nil {
		return err
	}

	return nil
}

// ContextValidate validates this consistency group child volumes items0 provisioning options storage service based on context it is used
func (m *ConsistencyGroupChildVolumesItems0ProvisioningOptionsStorageService) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

// ConsistencyGroupChildVolumesItems0Qos The QoS policy for this volume.
//
// swagger:model ConsistencyGroupChildVolumesItems0Qos
type ConsistencyGroupChildVolumesItems0Qos struct {

	// policy
	Policy *ConsistencyGroupChildVolumesItems0QosPolicy `json:"policy,omitempty"`
}

// Validate validates this consistency group child volumes items0 qos
func (m *ConsistencyGroupChildVolumesItems0Qos) Validate(formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildVolumesItems0Qos) validatePolicy(formats strfmt.Registry) error {
	if swag.IsZero(m.Policy) { // not required
		return nil
	}

	if m.Policy != nil {
		if err := m.Policy.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("qos" + "." + "policy")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this consistency group child volumes items0 qos based on the context it is used
func (m *ConsistencyGroupChildVolumesItems0Qos) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildVolumesItems0Qos) contextValidatePolicy(ctx context.Context, formats strfmt.Registry) error {

	if m.Policy != nil {
		if err := m.Policy.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("qos" + "." + "policy")
			}
			return err
		}
	}

	return nil
}

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

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

// ConsistencyGroupChildVolumesItems0QosPolicy The QoS policy
//
// swagger:model ConsistencyGroupChildVolumesItems0QosPolicy
type ConsistencyGroupChildVolumesItems0QosPolicy struct {

	// links
	Links *SelfLink `json:"_links,omitempty"`

	// Specifies the maximum throughput in IOPS, 0 means none. This is mutually exclusive with name and UUID during POST and PATCH.
	// Example: 10000
	MaxThroughputIops int64 `json:"max_throughput_iops,omitempty"`

	// Specifies the maximum throughput in Megabytes per sec, 0 means none. This is mutually exclusive with name and UUID during POST and PATCH.
	// Example: 500
	MaxThroughputMbps int64 `json:"max_throughput_mbps,omitempty"`

	// Specifies the minimum throughput in IOPS, 0 means none. Setting "min_throughput" is supported on AFF platforms only, unless FabricPool tiering policies are set. This is mutually exclusive with name and UUID during POST and PATCH.
	// Example: 2000
	MinThroughputIops int64 `json:"min_throughput_iops,omitempty"`

	// Specifies the minimum throughput in Megabytes per sec, 0 means none. This is mutually exclusive with name and UUID during POST and PATCH.
	// Example: 500
	MinThroughputMbps int64 `json:"min_throughput_mbps,omitempty"`

	// The QoS policy group name. This is mutually exclusive with UUID and other QoS attributes during POST and PATCH.
	// Example: performance
	Name string `json:"name,omitempty"`

	// The QoS policy group UUID. This is mutually exclusive with name and other QoS attributes during POST and PATCH.
	// Example: 1cd8a442-86d1-11e0-ae1c-123478563412
	UUID string `json:"uuid,omitempty"`
}

// Validate validates this consistency group child volumes items0 qos policy
func (m *ConsistencyGroupChildVolumesItems0QosPolicy) Validate(formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildVolumesItems0QosPolicy) validateLinks(formats strfmt.Registry) error {
	if swag.IsZero(m.Links) { // not required
		return nil
	}

	if m.Links != nil {
		if err := m.Links.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("qos" + "." + "policy" + "." + "_links")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this consistency group child volumes items0 qos policy based on the context it is used
func (m *ConsistencyGroupChildVolumesItems0QosPolicy) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

func (m *ConsistencyGroupChildVolumesItems0QosPolicy) contextValidateLinks(ctx context.Context, formats strfmt.Registry) error {

	if m.Links != nil {
		if err := m.Links.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("qos" + "." + "policy" + "." + "_links")
			}
			return err
		}
	}

	return nil
}

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

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

// ConsistencyGroupChildVolumesItems0Space consistency group child volumes items0 space
//
// swagger:model ConsistencyGroupChildVolumesItems0Space
type ConsistencyGroupChildVolumesItems0Space struct {

	// The available space, in bytes.
	Available int64 `json:"available,omitempty"`

	// Total provisioned size, in bytes.
	Size int64 `json:"size,omitempty"`

	// The virtual space used (includes volume reserves) before storage efficiency, in bytes.
	Used int64 `json:"used,omitempty"`
}

// Validate validates this consistency group child volumes items0 space
func (m *ConsistencyGroupChildVolumesItems0Space) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this consistency group child volumes items0 space based on context it is used
func (m *ConsistencyGroupChildVolumesItems0Space) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

// ConsistencyGroupChildVolumesItems0Tiering The tiering placement and policy definitions for this volume.
//
// swagger:model ConsistencyGroupChildVolumesItems0Tiering
type ConsistencyGroupChildVolumesItems0Tiering struct {

	// Storage tiering placement rules for the object.
	// Enum: [allowed best_effort disallowed required]
	Control string `json:"control,omitempty"`

	// Policy that determines whether the user data blocks of a volume in a FabricPool will be tiered to the cloud store when they become cold.
	//
FabricPool combines flash (performance tier) with a cloud store into a single aggregate. Temperature of a volume block increases if it is accessed frequently and decreases when it is not. Valid in POST or PATCH.
all ‐ Allows tiering of both Snapshot copies and active file system user data to the cloud store as soon as possible by ignoring the temperature on the volume blocks.
auto ‐ Allows tiering of both snapshot and active file system user data to the cloud store
none ‐ Volume blocks are not be tiered to the cloud store.
snapshot_only ‐ Allows tiering of only the volume Snapshot copies not associated with the active file system.
	//
The default tiering policy is "snapshot-only" for a FlexVol volume and "none" for a FlexGroup volume. The default minimum cooling period for the "snapshot-only" tiering policy is 2 days and for the "auto" tiering policy it is 31 days.
	//
	// Enum: [all auto backup none snapshot_only]
	Policy string `json:"policy,omitempty"`
}

// Validate validates this consistency group child volumes items0 tiering
func (m *ConsistencyGroupChildVolumesItems0Tiering) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

var consistencyGroupChildVolumesItems0TieringTypeControlPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["allowed","best_effort","disallowed","required"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		consistencyGroupChildVolumesItems0TieringTypeControlPropEnum = append(consistencyGroupChildVolumesItems0TieringTypeControlPropEnum, v)
	}
}

const (

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0Tiering
	// ConsistencyGroupChildVolumesItems0Tiering
	// control
	// Control
	// allowed
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0TieringControlAllowed captures enum value "allowed"
	ConsistencyGroupChildVolumesItems0TieringControlAllowed string = "allowed"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0Tiering
	// ConsistencyGroupChildVolumesItems0Tiering
	// control
	// Control
	// best_effort
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0TieringControlBestEffort captures enum value "best_effort"
	ConsistencyGroupChildVolumesItems0TieringControlBestEffort string = "best_effort"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0Tiering
	// ConsistencyGroupChildVolumesItems0Tiering
	// control
	// Control
	// disallowed
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0TieringControlDisallowed captures enum value "disallowed"
	ConsistencyGroupChildVolumesItems0TieringControlDisallowed string = "disallowed"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0Tiering
	// ConsistencyGroupChildVolumesItems0Tiering
	// control
	// Control
	// required
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0TieringControlRequired captures enum value "required"
	ConsistencyGroupChildVolumesItems0TieringControlRequired string = "required"
)

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

func (m *ConsistencyGroupChildVolumesItems0Tiering) validateControl(formats strfmt.Registry) error {
	if swag.IsZero(m.Control) { // not required
		return nil
	}

	// value enum
	if err := m.validateControlEnum("tiering"+"."+"control", "body", m.Control); err != nil {
		return err
	}

	return nil
}

var consistencyGroupChildVolumesItems0TieringTypePolicyPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["all","auto","backup","none","snapshot_only"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		consistencyGroupChildVolumesItems0TieringTypePolicyPropEnum = append(consistencyGroupChildVolumesItems0TieringTypePolicyPropEnum, v)
	}
}

const (

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0Tiering
	// ConsistencyGroupChildVolumesItems0Tiering
	// policy
	// Policy
	// all
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0TieringPolicyAll captures enum value "all"
	ConsistencyGroupChildVolumesItems0TieringPolicyAll string = "all"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0Tiering
	// ConsistencyGroupChildVolumesItems0Tiering
	// policy
	// Policy
	// auto
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0TieringPolicyAuto captures enum value "auto"
	ConsistencyGroupChildVolumesItems0TieringPolicyAuto string = "auto"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0Tiering
	// ConsistencyGroupChildVolumesItems0Tiering
	// policy
	// Policy
	// backup
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0TieringPolicyBackup captures enum value "backup"
	ConsistencyGroupChildVolumesItems0TieringPolicyBackup string = "backup"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0Tiering
	// ConsistencyGroupChildVolumesItems0Tiering
	// policy
	// Policy
	// none
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0TieringPolicyNone captures enum value "none"
	ConsistencyGroupChildVolumesItems0TieringPolicyNone string = "none"

	// BEGIN DEBUGGING
	// ConsistencyGroupChildVolumesItems0Tiering
	// ConsistencyGroupChildVolumesItems0Tiering
	// policy
	// Policy
	// snapshot_only
	// END DEBUGGING
	// ConsistencyGroupChildVolumesItems0TieringPolicySnapshotOnly captures enum value "snapshot_only"
	ConsistencyGroupChildVolumesItems0TieringPolicySnapshotOnly string = "snapshot_only"
)

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

func (m *ConsistencyGroupChildVolumesItems0Tiering) validatePolicy(formats strfmt.Registry) error {
	if swag.IsZero(m.Policy) { // not required
		return nil
	}

	// value enum
	if err := m.validatePolicyEnum("tiering"+"."+"policy", "body", m.Policy); err != nil {
		return err
	}

	return nil
}

// ContextValidate validates this consistency group child volumes items0 tiering based on context it is used
func (m *ConsistencyGroupChildVolumesItems0Tiering) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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