// ApplicationVersions is a list of versions which has been deployed with marathon for a specific application
//		name:		the id used to identify the application
507244
func (r *marathonClient) ApplicationVersions(name string) (*ApplicationVersions, error) {
	path := fmt.Sprintf("%s/versions", buildPath(name))
	versions := new(ApplicationVersions)
	if err := r.apiGet(path, nil, versions); err != nil {
		return nil, err
	}
	return versions, nil
}
1104056
func (s *DeleteApplicationCloudWatchLoggingOptionOutput) SetApplicationVersionId(v int64) *DeleteApplicationCloudWatchLoggingOptionOutput {
	s.ApplicationVersionId = &v
	return s
}
454129
func (s *DeleteApplicationReferenceDataSourceOutput) SetApplicationVersionId(v int64) *DeleteApplicationReferenceDataSourceOutput {
	s.ApplicationVersionId = &v
	return s
}
707903
func (v *version) Applications() ApplicationInformer {
	return &applicationInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
}
1205517
func (s *Image) SetAppstreamAgentVersion(v string) *Image {
	s.AppstreamAgentVersion = &v
	return s
}
609889
func (c *Client) ConfigVarInfoByReleaseVersion(appIdentity, version string) (map[string]string, error) {
	var configVar map[string]string
	return configVar, c.Get(&configVar, fmt.Sprintf("/apps/%s/config-vars/%s", appIdentity, version))
}
713868
func (cli *Client) Versions() (resp *RespVersions, err error) {
	urlPath := cli.BuildBaseURL("_matrix", "client", "versions")
	_, err = cli.MakeRequest("GET", urlPath, nil, &resp)
	return
}
206928
func (s *ApplicationVersionDescriptionMessage) SetApplicationVersion(v *ApplicationVersionDescription) *ApplicationVersionDescriptionMessage {
	s.ApplicationVersion = v
	return s
}
1339128
func Versions(url, migrationsPath string) (versions file.Versions, err error) {
	d, err := driver.New(url)
	if err != nil {
		return file.Versions{}, err
	}
	return d.Versions()
}
589922
func (f *Function) versions() ([]*lambda.FunctionConfiguration, error) {
	var list []*lambda.FunctionConfiguration
	request := lambda.ListVersionsByFunctionInput{
		FunctionName: &f.FunctionName,
	}

	for {
		page, err := f.Service.ListVersionsByFunction(&request)

		if err != nil {
			return nil, err
		}

		list = append(list, page.Versions...)

		if page.NextMarker == nil {
			break
		}

		request.Marker = page.NextMarker
	}

	versions := list[1:] // remove $LATEST
	return versions, nil
}
744347
func GetEngineVersions(ctx context.Context, registryClient registryclient.RegistryClient, registryPrefix, imageName, versionString string) (clitypes.AvailableVersions, error) {

	if imageName == "" {
		var err error
		localMetadata, err := GetCurrentRuntimeMetadata("")
		if err != nil {
			return clitypes.AvailableVersions{}, err
		}
		imageName = localMetadata.EngineImage
	}
	imageRef, err := reference.ParseNormalizedNamed(path.Join(registryPrefix, imageName))
	if err != nil {
		return clitypes.AvailableVersions{}, err
	}

	tags, err := registryClient.GetTags(ctx, imageRef)
	if err != nil {
		return clitypes.AvailableVersions{}, err
	}

	return parseTags(tags, versionString)
}
1000201
func (s *ImageBuilder) SetAppstreamAgentVersion(v string) *ImageBuilder {
	s.AppstreamAgentVersion = &v
	return s
}
599677
func (s *SimulationApplicationConfig) SetApplicationVersion(v string) *SimulationApplicationConfig {
	s.ApplicationVersion = &v
	return s
}
440653
func (c *Client) Versions(endpoint string) ([]string, error) {
	versions := []string{}
	err := c.Get().Resource(endpoint + "/versions").Do().Unmarshal(&versions)
	return versions, err
}
912682
func VersionsToApply(currentVersion uint32, versions []Version) []Version {
	// Assuming the migration versions are in increasing order, we'll apply
	// any migrations that have a version number lower than our current one.
	var upgradeVersions []Version
	for _, version := range versions {
		if version.Number > currentVersion {
			upgradeVersions = append(upgradeVersions, version)
		}
	}

	// Before returning, we'll sort the slice by its version number to
	// ensure the migrations are applied in their intended order.
	sort.Slice(upgradeVersions, func(i, j int) bool {
		return upgradeVersions[i].Number < upgradeVersions[j].Number
	})

	return upgradeVersions
}
1052054
func (s *DeleteApplicationOutputOutput) SetApplicationVersionId(v int64) *DeleteApplicationOutputOutput {
	s.ApplicationVersionId = &v
	return s
}
1259333
func (c *BasicClient) Version() String {
	if len(c.AppVer) > 0 {
		return String(c.AppVer)
	}
	return String("0001")
}