github.com/percona/percona-xtradb-cluster-operator@v1.14.0/version/client/models/version_version_matrix.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"
)

// VersionVersionMatrix VersionMatrix represents set of possible product versions.
//
// swagger:model versionVersionMatrix
type VersionVersionMatrix struct {

	// backup
	Backup map[string]VersionVersion `json:"backup,omitempty"`

	// haproxy
	Haproxy map[string]VersionVersion `json:"haproxy,omitempty"`

	// log collector
	LogCollector map[string]VersionVersion `json:"logCollector,omitempty"`

	// mongod
	Mongod map[string]VersionVersion `json:"mongod,omitempty"`

	// mysql
	Mysql map[string]VersionVersion `json:"mysql,omitempty"`

	// operator
	Operator map[string]VersionVersion `json:"operator,omitempty"`

	// orchestrator
	Orchestrator map[string]VersionVersion `json:"orchestrator,omitempty"`

	// pg operator
	PgOperator map[string]VersionVersion `json:"pgOperator,omitempty"`

	// pg operator apiserver
	PgOperatorApiserver map[string]VersionVersion `json:"pgOperatorApiserver,omitempty"`

	// pg operator deployer
	PgOperatorDeployer map[string]VersionVersion `json:"pgOperatorDeployer,omitempty"`

	// pg operator event
	PgOperatorEvent map[string]VersionVersion `json:"pgOperatorEvent,omitempty"`

	// pg operator rmdata
	PgOperatorRmdata map[string]VersionVersion `json:"pgOperatorRmdata,omitempty"`

	// pg operator scheduler
	PgOperatorScheduler map[string]VersionVersion `json:"pgOperatorScheduler,omitempty"`

	// pgbackrest
	Pgbackrest map[string]VersionVersion `json:"pgbackrest,omitempty"`

	// pgbackrest repo
	PgbackrestRepo map[string]VersionVersion `json:"pgbackrestRepo,omitempty"`

	// pgbadger
	Pgbadger map[string]VersionVersion `json:"pgbadger,omitempty"`

	// pgbouncer
	Pgbouncer map[string]VersionVersion `json:"pgbouncer,omitempty"`

	// pmm
	Pmm map[string]VersionVersion `json:"pmm,omitempty"`

	// postgresql
	Postgresql map[string]VersionVersion `json:"postgresql,omitempty"`

	// proxysql
	Proxysql map[string]VersionVersion `json:"proxysql,omitempty"`

	// ps operator
	PsOperator map[string]VersionVersion `json:"psOperator,omitempty"`

	// psmdb operator
	PsmdbOperator map[string]VersionVersion `json:"psmdbOperator,omitempty"`

	// pxc
	Pxc map[string]VersionVersion `json:"pxc,omitempty"`

	// pxc operator
	PxcOperator map[string]VersionVersion `json:"pxcOperator,omitempty"`

	// router
	Router map[string]VersionVersion `json:"router,omitempty"`
}

// Validate validates this version version matrix
func (m *VersionVersionMatrix) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *VersionVersionMatrix) validateBackup(formats strfmt.Registry) error {
	if swag.IsZero(m.Backup) { // not required
		return nil
	}

	for k := range m.Backup {

		if err := validate.Required("backup"+"."+k, "body", m.Backup[k]); err != nil {
			return err
		}
		if val, ok := m.Backup[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("backup" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("backup" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validateHaproxy(formats strfmt.Registry) error {
	if swag.IsZero(m.Haproxy) { // not required
		return nil
	}

	for k := range m.Haproxy {

		if err := validate.Required("haproxy"+"."+k, "body", m.Haproxy[k]); err != nil {
			return err
		}
		if val, ok := m.Haproxy[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("haproxy" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("haproxy" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validateLogCollector(formats strfmt.Registry) error {
	if swag.IsZero(m.LogCollector) { // not required
		return nil
	}

	for k := range m.LogCollector {

		if err := validate.Required("logCollector"+"."+k, "body", m.LogCollector[k]); err != nil {
			return err
		}
		if val, ok := m.LogCollector[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("logCollector" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("logCollector" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validateMongod(formats strfmt.Registry) error {
	if swag.IsZero(m.Mongod) { // not required
		return nil
	}

	for k := range m.Mongod {

		if err := validate.Required("mongod"+"."+k, "body", m.Mongod[k]); err != nil {
			return err
		}
		if val, ok := m.Mongod[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("mongod" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("mongod" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validateMysql(formats strfmt.Registry) error {
	if swag.IsZero(m.Mysql) { // not required
		return nil
	}

	for k := range m.Mysql {

		if err := validate.Required("mysql"+"."+k, "body", m.Mysql[k]); err != nil {
			return err
		}
		if val, ok := m.Mysql[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("mysql" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("mysql" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validateOperator(formats strfmt.Registry) error {
	if swag.IsZero(m.Operator) { // not required
		return nil
	}

	for k := range m.Operator {

		if err := validate.Required("operator"+"."+k, "body", m.Operator[k]); err != nil {
			return err
		}
		if val, ok := m.Operator[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("operator" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("operator" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validateOrchestrator(formats strfmt.Registry) error {
	if swag.IsZero(m.Orchestrator) { // not required
		return nil
	}

	for k := range m.Orchestrator {

		if err := validate.Required("orchestrator"+"."+k, "body", m.Orchestrator[k]); err != nil {
			return err
		}
		if val, ok := m.Orchestrator[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("orchestrator" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("orchestrator" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validatePgOperator(formats strfmt.Registry) error {
	if swag.IsZero(m.PgOperator) { // not required
		return nil
	}

	for k := range m.PgOperator {

		if err := validate.Required("pgOperator"+"."+k, "body", m.PgOperator[k]); err != nil {
			return err
		}
		if val, ok := m.PgOperator[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("pgOperator" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("pgOperator" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validatePgOperatorApiserver(formats strfmt.Registry) error {
	if swag.IsZero(m.PgOperatorApiserver) { // not required
		return nil
	}

	for k := range m.PgOperatorApiserver {

		if err := validate.Required("pgOperatorApiserver"+"."+k, "body", m.PgOperatorApiserver[k]); err != nil {
			return err
		}
		if val, ok := m.PgOperatorApiserver[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("pgOperatorApiserver" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("pgOperatorApiserver" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validatePgOperatorDeployer(formats strfmt.Registry) error {
	if swag.IsZero(m.PgOperatorDeployer) { // not required
		return nil
	}

	for k := range m.PgOperatorDeployer {

		if err := validate.Required("pgOperatorDeployer"+"."+k, "body", m.PgOperatorDeployer[k]); err != nil {
			return err
		}
		if val, ok := m.PgOperatorDeployer[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("pgOperatorDeployer" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("pgOperatorDeployer" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validatePgOperatorEvent(formats strfmt.Registry) error {
	if swag.IsZero(m.PgOperatorEvent) { // not required
		return nil
	}

	for k := range m.PgOperatorEvent {

		if err := validate.Required("pgOperatorEvent"+"."+k, "body", m.PgOperatorEvent[k]); err != nil {
			return err
		}
		if val, ok := m.PgOperatorEvent[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("pgOperatorEvent" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("pgOperatorEvent" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validatePgOperatorRmdata(formats strfmt.Registry) error {
	if swag.IsZero(m.PgOperatorRmdata) { // not required
		return nil
	}

	for k := range m.PgOperatorRmdata {

		if err := validate.Required("pgOperatorRmdata"+"."+k, "body", m.PgOperatorRmdata[k]); err != nil {
			return err
		}
		if val, ok := m.PgOperatorRmdata[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("pgOperatorRmdata" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("pgOperatorRmdata" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validatePgOperatorScheduler(formats strfmt.Registry) error {
	if swag.IsZero(m.PgOperatorScheduler) { // not required
		return nil
	}

	for k := range m.PgOperatorScheduler {

		if err := validate.Required("pgOperatorScheduler"+"."+k, "body", m.PgOperatorScheduler[k]); err != nil {
			return err
		}
		if val, ok := m.PgOperatorScheduler[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("pgOperatorScheduler" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("pgOperatorScheduler" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validatePgbackrest(formats strfmt.Registry) error {
	if swag.IsZero(m.Pgbackrest) { // not required
		return nil
	}

	for k := range m.Pgbackrest {

		if err := validate.Required("pgbackrest"+"."+k, "body", m.Pgbackrest[k]); err != nil {
			return err
		}
		if val, ok := m.Pgbackrest[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("pgbackrest" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("pgbackrest" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validatePgbackrestRepo(formats strfmt.Registry) error {
	if swag.IsZero(m.PgbackrestRepo) { // not required
		return nil
	}

	for k := range m.PgbackrestRepo {

		if err := validate.Required("pgbackrestRepo"+"."+k, "body", m.PgbackrestRepo[k]); err != nil {
			return err
		}
		if val, ok := m.PgbackrestRepo[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("pgbackrestRepo" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("pgbackrestRepo" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validatePgbadger(formats strfmt.Registry) error {
	if swag.IsZero(m.Pgbadger) { // not required
		return nil
	}

	for k := range m.Pgbadger {

		if err := validate.Required("pgbadger"+"."+k, "body", m.Pgbadger[k]); err != nil {
			return err
		}
		if val, ok := m.Pgbadger[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("pgbadger" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("pgbadger" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validatePgbouncer(formats strfmt.Registry) error {
	if swag.IsZero(m.Pgbouncer) { // not required
		return nil
	}

	for k := range m.Pgbouncer {

		if err := validate.Required("pgbouncer"+"."+k, "body", m.Pgbouncer[k]); err != nil {
			return err
		}
		if val, ok := m.Pgbouncer[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("pgbouncer" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("pgbouncer" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validatePmm(formats strfmt.Registry) error {
	if swag.IsZero(m.Pmm) { // not required
		return nil
	}

	for k := range m.Pmm {

		if err := validate.Required("pmm"+"."+k, "body", m.Pmm[k]); err != nil {
			return err
		}
		if val, ok := m.Pmm[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("pmm" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("pmm" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validatePostgresql(formats strfmt.Registry) error {
	if swag.IsZero(m.Postgresql) { // not required
		return nil
	}

	for k := range m.Postgresql {

		if err := validate.Required("postgresql"+"."+k, "body", m.Postgresql[k]); err != nil {
			return err
		}
		if val, ok := m.Postgresql[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("postgresql" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("postgresql" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validateProxysql(formats strfmt.Registry) error {
	if swag.IsZero(m.Proxysql) { // not required
		return nil
	}

	for k := range m.Proxysql {

		if err := validate.Required("proxysql"+"."+k, "body", m.Proxysql[k]); err != nil {
			return err
		}
		if val, ok := m.Proxysql[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("proxysql" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("proxysql" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validatePsOperator(formats strfmt.Registry) error {
	if swag.IsZero(m.PsOperator) { // not required
		return nil
	}

	for k := range m.PsOperator {

		if err := validate.Required("psOperator"+"."+k, "body", m.PsOperator[k]); err != nil {
			return err
		}
		if val, ok := m.PsOperator[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("psOperator" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("psOperator" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validatePsmdbOperator(formats strfmt.Registry) error {
	if swag.IsZero(m.PsmdbOperator) { // not required
		return nil
	}

	for k := range m.PsmdbOperator {

		if err := validate.Required("psmdbOperator"+"."+k, "body", m.PsmdbOperator[k]); err != nil {
			return err
		}
		if val, ok := m.PsmdbOperator[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("psmdbOperator" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("psmdbOperator" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validatePxc(formats strfmt.Registry) error {
	if swag.IsZero(m.Pxc) { // not required
		return nil
	}

	for k := range m.Pxc {

		if err := validate.Required("pxc"+"."+k, "body", m.Pxc[k]); err != nil {
			return err
		}
		if val, ok := m.Pxc[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("pxc" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("pxc" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validatePxcOperator(formats strfmt.Registry) error {
	if swag.IsZero(m.PxcOperator) { // not required
		return nil
	}

	for k := range m.PxcOperator {

		if err := validate.Required("pxcOperator"+"."+k, "body", m.PxcOperator[k]); err != nil {
			return err
		}
		if val, ok := m.PxcOperator[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("pxcOperator" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("pxcOperator" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) validateRouter(formats strfmt.Registry) error {
	if swag.IsZero(m.Router) { // not required
		return nil
	}

	for k := range m.Router {

		if err := validate.Required("router"+"."+k, "body", m.Router[k]); err != nil {
			return err
		}
		if val, ok := m.Router[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("router" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("router" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *VersionVersionMatrix) contextValidateBackup(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.Backup {

		if val, ok := m.Backup[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidateHaproxy(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.Haproxy {

		if val, ok := m.Haproxy[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidateLogCollector(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.LogCollector {

		if val, ok := m.LogCollector[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidateMongod(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.Mongod {

		if val, ok := m.Mongod[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidateMysql(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.Mysql {

		if val, ok := m.Mysql[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidateOperator(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.Operator {

		if val, ok := m.Operator[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidateOrchestrator(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.Orchestrator {

		if val, ok := m.Orchestrator[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidatePgOperator(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.PgOperator {

		if val, ok := m.PgOperator[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidatePgOperatorApiserver(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.PgOperatorApiserver {

		if val, ok := m.PgOperatorApiserver[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidatePgOperatorDeployer(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.PgOperatorDeployer {

		if val, ok := m.PgOperatorDeployer[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidatePgOperatorEvent(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.PgOperatorEvent {

		if val, ok := m.PgOperatorEvent[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidatePgOperatorRmdata(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.PgOperatorRmdata {

		if val, ok := m.PgOperatorRmdata[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidatePgOperatorScheduler(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.PgOperatorScheduler {

		if val, ok := m.PgOperatorScheduler[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidatePgbackrest(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.Pgbackrest {

		if val, ok := m.Pgbackrest[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidatePgbackrestRepo(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.PgbackrestRepo {

		if val, ok := m.PgbackrestRepo[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidatePgbadger(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.Pgbadger {

		if val, ok := m.Pgbadger[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidatePgbouncer(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.Pgbouncer {

		if val, ok := m.Pgbouncer[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidatePmm(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.Pmm {

		if val, ok := m.Pmm[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidatePostgresql(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.Postgresql {

		if val, ok := m.Postgresql[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidateProxysql(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.Proxysql {

		if val, ok := m.Proxysql[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidatePsOperator(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.PsOperator {

		if val, ok := m.PsOperator[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidatePsmdbOperator(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.PsmdbOperator {

		if val, ok := m.PsmdbOperator[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidatePxc(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.Pxc {

		if val, ok := m.Pxc[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidatePxcOperator(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.PxcOperator {

		if val, ok := m.PxcOperator[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *VersionVersionMatrix) contextValidateRouter(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.Router {

		if val, ok := m.Router[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

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

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