var trw transitionWrapper
	err := d.DecodeElement(&trw, &startElement)
	if err != nil {
		return err
	}
	*t = Transition(trw)
	t.set = true
	return nil
}

// Validate - validates the "Transition" element
func (t Transition) Validate() error {
	if !t.set {
		return nil
	}

	if !t.IsDateNull() && t.Days > 0 {
		return errTransitionInvalid
	}

	if t.StorageClass == "" {

// isEmpty returns true if Tags field is null
func (a And) isEmpty() bool {
	return len(a.Tags) == 0 && !a.Prefix.set &&
		a.ObjectSizeGreaterThan == 0 && a.ObjectSizeLessThan == 0
}

// Validate - validates the And field
func (a And) Validate() error {
	// > This is used in a Lifecycle Rule Filter to apply a logical AND to two or more predicates.
	// ref: https://docs.aws.amazon.com/AmazonS3/latest/API/API_LifecycleRuleAndOperator.html

	var exp expirationWrapper
	err := d.DecodeElement(&exp, &startElement)
	if err != nil {
		return err
	}
	*e = Expiration(exp)
	e.set = true
	return nil
}

// Validate - validates the "Expiration" element
func (e Expiration) Validate() error {
	if !e.set {
		return nil
	}

	// DeleteMarker cannot be specified if date or dates are specified.
	if (!e.IsDaysNull() || !e.IsDateNull()) && e.DeleteMarker.set {

	return e.EncodeToken(xml.EndElement{Name: start.Name})
}

// Validate - validates the filter element
func (f Filter) Validate() error {
	// A Filter must have exactly one of Prefix, Tag, or And specified.
	if !f.And.isEmpty() {
		if f.Prefix != "" {
			return errInvalidFilter
		}
		if !f.Tag.IsEmpty() {
			return errInvalidFilter
		}
		if err := f.And.Validate(); err != nil {
			return err
		}
	}
	if f.Prefix != "" {

	// Requires versioning to be enabled
	ExcludedPrefixes []ExcludedPrefix `xml:",omitempty"`
	ExcludeFolders   bool             `xml:",omitempty"`
}

// Validate - validates the versioning configuration
func (v Versioning) Validate() error {
	// Not supported yet
	// switch v.MFADelete {
	// case Enabled, Disabled:
	// default:
	// 	return Errorf("unsupported MFADelete state %s", v.MFADelete)
	// }

            return 4000;
        }
    }

    /**
     * Parses and validates field filter parameters from the request.
     * Only configured label values are accepted to prevent query injection.
     *
     * @param request the HTTP request
     * @return a map of field names to their validated filter values
     */
    protected Map<String, String[]> parseFieldFilters(final HttpServletRequest request) {

        return this.credentialType;
    }

    /**
     * Returns the server signature used to validate PAC integrity.
     * @return the server signature
     */
    public PacSignature getServerSignature() {
        return this.serverSignature;
    }

    /**
     * Returns the KDC signature used to validate PAC authenticity.
     * @return the KDC signature
     */
    public PacSignature getKdcSignature() {

     */
    protected boolean isFileSystemPath(final String url) {
        return ComponentUtil.getProtocolHelper().isFileSystemPath(url);
    }

    /**
     * Validates if the URL is safe for redirection.
     *
     * @param url the URL to validate
     * @return true if the URL is valid for redirection, false otherwise
     */
    protected boolean isValidRedirectUrl(final String url) {

        bean.setSpecialCron("invalid");

        // Validate default group
        Set<ConstraintViolation<GroupTestBean>> violations = validator.validate(bean, Default.class);
        assertEquals(1, violations.size());
        assertTrue(violations.iterator().next().getPropertyPath().toString().contains("defaultCron"));

        // Validate special group
        violations = validator.validate(bean, SpecialGroup.class);

	}
	if err := r.Encryption.Validate(); err != nil {
		return err
	}

	for _, tag := range r.Flags.Filter.Tags {
		if err := tag.Validate(); err != nil {
			return err
		}
	}

	for _, meta := range r.Flags.Filter.Metadata {
		if err := meta.Validate(); err != nil {
			return err
		}
	}

	return r.Flags.Retry.Validate()