// TagsUnset removes an app's tags.
495639
func TagsUnset(appID string, tags []string) error {
	c, appID, err := load(appID)

	if err != nil {
		return err
	}

	fmt.Print("Applying tags... ")

	quit := progress()

	configObj := api.Config{}

	tagsMap := make(map[string]interface{})

	for _, tag := range tags {
		tagsMap[tag] = nil
	}

	configObj.Tags = tagsMap

	_, err = config.Set(c, appID, configObj)

	quit <- true
	<-quit

	if err != nil {
		return err
	}

	fmt.Print("done\n\n")

	return TagsList(appID)
}
887027
func (s *CreateStageInput) SetTags(v map[string]*string) *CreateStageInput {
	s.Tags = v
	return s
}
364117
func (s *UntagResourceOutput) SetTags(v []*Tag) *UntagResourceOutput {
	s.Tags = v
	return s
}
207113
func (s *SetTagsForResourceInput) SetTags(v []*Tag) *SetTagsForResourceInput {
	s.Tags = v
	return s
}
185128
func (v *RsyncVolume) UntagSnapshot(tagName string) (string, error) {
	v.Lock()
	defer v.Unlock()
	// find the snapshot with the provided tag
	info, err := v.getSnapshotWithTag(tagName, false)
	if err != nil {
		glog.Errorf("Could not find snapshot with tag %s: %s", tagName, err)
		return "", err
	}
	// remove the tag and update the snapshot
	var tags []string
	for _, tag := range info.Tags {
		if tag != tagName {
			tags = append(tags, tag)
		}
	}
	info.Tags = tags
	if err := v.writeSnapshotInfo(info.Label, info); err != nil {
		glog.Errorf("Could not remove tag '%s' from snapshot %s: %s", tagName, info.Name, err)
		return "", err
	}
	return info.Label, err
}
894634
func (s *GetGroupOutput) SetTags(v map[string]*string) *GetGroupOutput {
	s.Tags = v
	return s
}
802822
func (s *UntagProjectInput) SetTags(v []*string) *UntagProjectInput {
	s.Tags = v
	return s
}
827302
func (s *Expression) SetTags(v *TagValues) *Expression {
	s.Tags = v
	return s
}
762799
func (s *Snapshot) SetTags(v []*Tag) *Snapshot {
	s.Tags = v
	return s
}
1068700
func (s *StopChannelOutput) SetTags(v map[string]*string) *StopChannelOutput {
	s.Tags = v
	return s
}
453903
func (s *GetBucketTaggingOutput) SetTagSet(v []*Tag) *GetBucketTaggingOutput {
	s.TagSet = v
	return s
}
303461
func (b *Bag) UnparsedTagFiles() ([]string, error) {
	var files []string

	// WalkDir function to collect files in the bag..
	visit := func(pathToFile string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}

		relativePath, err := filepath.Rel(b.Path(), pathToFile)
		if err != nil {
			return err
		}

		isPayload := strings.HasPrefix(pathToFile, b.payload.Name())
		isManifest := (strings.HasPrefix(relativePath, "tagmanifest-") ||
			strings.HasPrefix(relativePath, "manifest-"))
		_, isParsedTagFile := b.tagfiles[relativePath]

		if !info.IsDir() && !isPayload && !isParsedTagFile && !isManifest {
			if relativePath != "." {
				files = append(files, relativePath)
			}
		}
		return err
	}

	if err := filepath.Walk(b.Path(), visit); err != nil {
		return nil, err
	}

	return files, nil
}
390749
func (s *CreateStreamInput) SetTags(v map[string]*string) *CreateStreamInput {
	s.Tags = v
	return s
}
42502
func (s *Tagging) SetTagSet(v []*Tag) *Tagging {
	s.TagSet = v
	return s
}
639998
func (s *TargetInstances) SetEc2TagSet(v *EC2TagSet) *TargetInstances {
	s.Ec2TagSet = v
	return s
}
111008
func (ts *tagStore) Untag(ctx context.Context, tag string) error {
	tagPath, err := pathFor(manifestTagPathSpec{
		name: ts.repository.Named().Name(),
		tag:  tag,
	})
	if err != nil {
		return err
	}

	if err := ts.blobStore.driver.Delete(ctx, tagPath); err != nil {
		switch err.(type) {
		case storagedriver.PathNotFoundError:
			return nil // Untag is idempotent, we don't care if it didn't exist
		default:
			return err
		}
	}

	return nil
}
790949
func (s *CreateTopicRuleInput) SetTags(v string) *CreateTopicRuleInput {
	s.Tags = &v
	return s
}