device_airmax_schema.go

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

package models

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

import (
	"context"

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

// DeviceAirmaxSchema device airmax schema
//
// swagger:model DeviceAirmaxSchema
type DeviceAirmaxSchema struct {

	// airfiber
	Airfiber *DEPRECATEDDeviceAirFiberPartiallyMovedPropertiesToInterfaceOrStation `json:"airfiber,omitempty"`

	// airmax
	Airmax *DEPRECATEDDeviceAirmaxPartiallyMovedPropertiesToInterfaceOrStation1 `json:"airmax,omitempty"`

	// attributes
	Attributes *DeviceAttributes `json:"attributes,omitempty"`

	// discovery
	Discovery *Discovery `json:"discovery,omitempty"`

	// enabled
	// Required: true
	Enabled *bool `json:"enabled"`

	// eswitch
	Eswitch *Eswitch `json:"eswitch,omitempty"`

	// firmware
	Firmware *DeviceFirmware `json:"firmware,omitempty"`

	// identification
	Identification *DeviceIdentification `json:"identification,omitempty"`

	// interfaces
	Interfaces DeviceInterfaceListSchema `json:"interfaces,omitempty"`

	// Custom IP address in IPv4 or IPv6 format.
	// Example: 192.168.1.22
	// Required: true
	IPAddress *string `json:"ipAddress"`

	// latest backup
	LatestBackup *LatestBackup `json:"latestBackup,omitempty"`

	// location
	Location *DeviceLocation `json:"location,omitempty"`

	// meta
	Meta *DeviceMeta `json:"meta,omitempty"`

	// mode
	Mode string `json:"mode,omitempty"`

	// overview
	Overview *DeviceOverview `json:"overview,omitempty"`

	// uisps
	Uisps *Uisps `json:"uisps,omitempty"`

	// upgrade
	Upgrade *DeviceUpgrade `json:"upgrade,omitempty"`
}

// Validate validates this device airmax schema
func (m *DeviceAirmaxSchema) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *DeviceAirmaxSchema) validateAirfiber(formats strfmt.Registry) error {
	if swag.IsZero(m.Airfiber) { // not required
		return nil
	}

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

	return nil
}

func (m *DeviceAirmaxSchema) validateAirmax(formats strfmt.Registry) error {
	if swag.IsZero(m.Airmax) { // not required
		return nil
	}

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

	return nil
}

func (m *DeviceAirmaxSchema) validateAttributes(formats strfmt.Registry) error {
	if swag.IsZero(m.Attributes) { // not required
		return nil
	}

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

	return nil
}

func (m *DeviceAirmaxSchema) validateDiscovery(formats strfmt.Registry) error {
	if swag.IsZero(m.Discovery) { // not required
		return nil
	}

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

	return nil
}

func (m *DeviceAirmaxSchema) validateEnabled(formats strfmt.Registry) error {

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

	return nil
}

func (m *DeviceAirmaxSchema) validateEswitch(formats strfmt.Registry) error {
	if swag.IsZero(m.Eswitch) { // not required
		return nil
	}

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

	return nil
}

func (m *DeviceAirmaxSchema) validateFirmware(formats strfmt.Registry) error {
	if swag.IsZero(m.Firmware) { // not required
		return nil
	}

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

	return nil
}

func (m *DeviceAirmaxSchema) validateIdentification(formats strfmt.Registry) error {
	if swag.IsZero(m.Identification) { // not required
		return nil
	}

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

	return nil
}

func (m *DeviceAirmaxSchema) validateInterfaces(formats strfmt.Registry) error {
	if swag.IsZero(m.Interfaces) { // not required
		return nil
	}

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

	return nil
}

func (m *DeviceAirmaxSchema) validateIPAddress(formats strfmt.Registry) error {

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

	return nil
}

func (m *DeviceAirmaxSchema) validateLatestBackup(formats strfmt.Registry) error {
	if swag.IsZero(m.LatestBackup) { // not required
		return nil
	}

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

	return nil
}

func (m *DeviceAirmaxSchema) validateLocation(formats strfmt.Registry) error {
	if swag.IsZero(m.Location) { // not required
		return nil
	}

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

	return nil
}

func (m *DeviceAirmaxSchema) validateMeta(formats strfmt.Registry) error {
	if swag.IsZero(m.Meta) { // not required
		return nil
	}

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

	return nil
}

func (m *DeviceAirmaxSchema) validateOverview(formats strfmt.Registry) error {
	if swag.IsZero(m.Overview) { // not required
		return nil
	}

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

	return nil
}

func (m *DeviceAirmaxSchema) validateUisps(formats strfmt.Registry) error {
	if swag.IsZero(m.Uisps) { // not required
		return nil
	}

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

	return nil
}

func (m *DeviceAirmaxSchema) validateUpgrade(formats strfmt.Registry) error {
	if swag.IsZero(m.Upgrade) { // not required
		return nil
	}

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

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *DeviceAirmaxSchema) contextValidateAirfiber(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *DeviceAirmaxSchema) contextValidateAirmax(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *DeviceAirmaxSchema) contextValidateAttributes(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *DeviceAirmaxSchema) contextValidateDiscovery(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *DeviceAirmaxSchema) contextValidateEswitch(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *DeviceAirmaxSchema) contextValidateFirmware(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *DeviceAirmaxSchema) contextValidateIdentification(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *DeviceAirmaxSchema) contextValidateInterfaces(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *DeviceAirmaxSchema) contextValidateLatestBackup(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *DeviceAirmaxSchema) contextValidateLocation(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *DeviceAirmaxSchema) contextValidateMeta(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *DeviceAirmaxSchema) contextValidateOverview(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *DeviceAirmaxSchema) contextValidateUisps(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *DeviceAirmaxSchema) contextValidateUpgrade(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

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

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