// validateTags carries on validations for parameter Tags
545807
func (o *ListTasksParams) validateTags(formats strfmt.Registry) error {

	// uniqueItems: true
	if err := validate.UniqueItems("tags", "query", o.Tags); err != nil {
		return err
	}

	return nil
}
253426
func (s *AffectedEntity) SetTags(v map[string]*string) *AffectedEntity {
	s.Tags = v
	return s
}
499161
func parseFieldTags(f reflect.StructField) fieldTags {
	var ret fieldTags

	for i, s := range strings.Split(f.Tag.Get("json"), ",") {
		switch {
		case i == 0 && s == "-":
			ret.omit = true
		case i == 0:
			ret.name = s
		case s == "omitempty":
			ret.omitEmpty = true
		case s == "!omitempty":
			ret.noOmitEmpty = true
		case s == "string":
			ret.asString = true
		case s == "required":
			ret.required = true
		}
	}

	return ret
}
319081
func (r *TasksService) Tags() *TasksTagsCall {
	c := &TasksTagsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	return c
}
827302
func (s *Expression) SetTags(v *TagValues) *Expression {
	s.Tags = v
	return s
}
1371912
func SetTags(tags map[string]string) {
	singltonLock.RLock()
	defer singltonLock.RUnlock()

	blog.SetTags(tags)
}
163289
func (s *RotateIngestEndpointCredentialsOutput) SetTags(v map[string]*string) *RotateIngestEndpointCredentialsOutput {
	s.Tags = v
	return s
}
829865
func validateTagFilters(v interface{}, k string) (ws []string, errors []error) {
	value := v.(string)
	if value != "KEY_ONLY" && value != "VALUE_ONLY" && value != "KEY_AND_VALUE" {
		errors = append(errors, fmt.Errorf(
			"%q must be one of \"KEY_ONLY\", \"VALUE_ONLY\", or \"KEY_AND_VALUE\"", k))
	}
	return
}
1011779
func (s *DefinitionInformation) SetTags(v map[string]*string) *DefinitionInformation {
	s.Tags = v
	return s
}
527268
func (o *FindParams) bindTags(rawData []string, hasKey bool, formats strfmt.Registry) error {
	if !hasKey {
		return errors.Required("tags", "formData")
	}

	// CollectionFormat: multi
	tagsIC := rawData

	if len(tagsIC) == 0 {
		return nil
	}

	var tagsIR []int32
	for i, tagsIV := range tagsIC {
		// items.Format: "int32"
		tagsI, err := swag.ConvertInt32(tagsIV)
		if err != nil {
			return errors.InvalidType(fmt.Sprintf("%s.%v", "tags", i), "formData", "int32", tagsI)
		}

		tagsIR = append(tagsIR, tagsI)
	}

	o.Tags = tagsIR

	return nil
}
826311
func ValidateLabels(labels map[string]string, fldPath *validation.FieldPath) validation.ErrorList {
	allErrs := validation.ErrorList{}
	for k, v := range labels {
		allErrs = append(allErrs, ValidateLabelName(k, fldPath)...)
		if !validation.IsValidLabelValue(v) {
			allErrs = append(allErrs, validation.NewInvalidError(fldPath, v, labelValueErrorMsg))
		}
	}
	return allErrs
}
820447
func ValidateTag(tag string) ([]string, error) {
	ltag := strings.ToLower(tag)
	if !validTagRe.MatchString(ltag) {
		return nil, fmt.Errorf("invalid tag: %q", tag)
	}
	ltags := strings.Split(ltag, ":")
	return ltags, nil
}
1091305
func (s *DescribeSimulationApplicationOutput) SetTags(v map[string]*string) *DescribeSimulationApplicationOutput {
	s.Tags = v
	return s
}
283213
func validateTagList(tags []*api.Tag) error {
	if len(tags) == 0 {
		return status.Errorf(codes.InvalidArgument, "bad 'tags' - cannot be empty")
	}
	for _, t := range tags {
		kv := common.JoinInstanceTag(t)
		if err := common.ValidateInstanceTag(kv); err != nil {
			return status.Errorf(codes.InvalidArgument, "bad tag in 'tags' - %s", err)
		}
	}
	return nil
}
1161712
func (s *CreateSimulationApplicationOutput) SetTags(v map[string]*string) *CreateSimulationApplicationOutput {
	s.Tags = v
	return s
}
672523
func (xs *xstats) AddTags(tags ...string) {
	if xs.tags == nil {
		xs.tags = tags
	} else {
		xs.tags = append(xs.tags, tags...)
	}
}
656659
func (s *ApplicationResponse) SetTags(v map[string]*string) *ApplicationResponse {
	s.Tags = v
	return s
}