// IncludeLastImportAttempt sets the optional parameter
// "include_last_import_attempt":
331182
func (c *GetConfigSetsCall) IncludeLastImportAttempt(includeLastImportAttempt bool) *GetConfigSetsCall {
	c.urlParams_.Set("include_last_import_attempt", fmt.Sprint(includeLastImportAttempt))
	return c
}
981621
func (s *DescribeSimulationApplicationOutput) SetLastUpdatedAt(v time.Time) *DescribeSimulationApplicationOutput {
	s.LastUpdatedAt = &v
	return s
}
684186
func (fs *FSObjects) cleanupStaleMultipartUploads(ctx context.Context, cleanupInterval, expiry time.Duration, doneCh chan struct{}) {
	ticker := time.NewTicker(cleanupInterval)
	defer ticker.Stop()

	for {
		select {
		case <-doneCh:
			return
		case <-ticker.C:
			now := time.Now()
			entries, err := readDir(pathJoin(fs.fsPath, minioMetaMultipartBucket))
			if err != nil {
				continue
			}
			for _, entry := range entries {
				uploadIDs, err := readDir(pathJoin(fs.fsPath, minioMetaMultipartBucket, entry))
				if err != nil {
					continue
				}
				for _, uploadID := range uploadIDs {
					fi, err := fsStatDir(ctx, pathJoin(fs.fsPath, minioMetaMultipartBucket, entry, uploadID))
					if err != nil {
						continue
					}
					if now.Sub(fi.ModTime()) > expiry {
						fsRemoveAll(ctx, pathJoin(fs.fsPath, minioMetaMultipartBucket, entry, uploadID))
						// It is safe to ignore any directory not empty error (in case there were multiple uploadIDs on the same object)
						fsRemoveDir(ctx, pathJoin(fs.fsPath, minioMetaMultipartBucket, entry))

					}
				}
			}
		}
	}
}
273451
func appendImports(i, a []*ImportSpec) []*ImportSpec {
	for _, v := range a {
		contains := false
		for _, att := range i {
			if att.Path == v.Path {
				contains = true
				break
			}
		}
		if contains != true {
			i = append(i, v)
		}
	}
	return i
}
87877
func (s *LambdaTarget) SetLastUpdatedAt(v time.Time) *LambdaTarget {
	s.LastUpdatedAt = &v
	return s
}
411290
func MaxLastCharsWithDots(inStr string, maxCharCount int) string {
	return genericTrim(inStr, maxCharCount, true, true)
}
501050
func (ce *ContainerEndpoints) AddImport(cancel <-chan struct{}, application string, bind zkservice.ImportBinding) {
	logger := plog.WithFields(log.Fields{
		"application":     application,
		"applicationglob": bind.Application,
		"purpose":         bind.Purpose,
	})
	logger.Debug("Tracking exports for endpoint")
	defer logger.Debug("Exited export tracking for endpoint")
	bind.Application = application

	for {
		select {
		case conn := <-zzk.Connect("/", zzk.GetLocalConnection):
			if conn != nil {

				logger.Debug("Received coordinator connection")

				ch := registry.TrackExports(cancel, conn, ce.opts.TenantID, application)
				for exports := range ch {
					ce.UpdateRemoteExports(bind, exports)
				}

				select {
				case <-cancel:
					return
				default:
				}
			}
		case <-cancel:
			return
		}
	}
}
379760
func (s *Evaluation) SetLastUpdatedAt(v time.Time) *Evaluation {
	s.LastUpdatedAt = &v
	return s
}
784906
func (s *GetGroupOutput) SetLastUpdatedTimestamp(v string) *GetGroupOutput {
	s.LastUpdatedTimestamp = &v
	return s
}
1190709
func (i *ImportRestriction) isIncludedInRestrictedPackages(packageToCheck string) bool {
	// some subtrees are specifically excluded.  Not sure if we still need this given
	// explicit inclusion
	for _, ignored := range i.IgnoredSubTrees {
		if strings.HasPrefix(packageToCheck, ignored) {
			return false
		}
	}

	for _, currBase := range i.CheckedPackageRoots {
		if strings.HasPrefix(packageToCheck, currBase) {
			return true
		}
	}
	for _, currPackageName := range i.CheckedPackages {
		if currPackageName == packageToCheck {
			return true
		}
	}
	return false
}
1040793
func (s *DescribeRobotApplicationOutput) SetLastUpdatedAt(v time.Time) *DescribeRobotApplicationOutput {
	s.LastUpdatedAt = &v
	return s
}
1137594
func (s *StackDriftInformationSummary) SetLastCheckTimestamp(v time.Time) *StackDriftInformationSummary {
	s.LastCheckTimestamp = &v
	return s
}
371341
func (s *SimulationApplicationSummary) SetLastUpdatedAt(v time.Time) *SimulationApplicationSummary {
	s.LastUpdatedAt = &v
	return s
}
1163606
func (xl xlObjects) cleanupStaleMultipartUploads(ctx context.Context, cleanupInterval, expiry time.Duration, doneCh chan struct{}) {
	ticker := time.NewTicker(cleanupInterval)
	defer ticker.Stop()

	for {
		select {
		case <-doneCh:
			return
		case <-ticker.C:
			var disk StorageAPI
			for _, d := range xl.getLoadBalancedDisks() {
				if d != nil {
					disk = d
					break
				}
			}
			if disk == nil {
				continue
			}
			xl.cleanupStaleMultipartUploadsOnDisk(ctx, disk, expiry)
		}
	}
}
348994
func (s *ConfigExportDeliveryInfo) SetLastAttemptTime(v time.Time) *ConfigExportDeliveryInfo {
	s.LastAttemptTime = &v
	return s
}
798295
func (s *JobExecutionSummary) SetLastUpdatedAt(v time.Time) *JobExecutionSummary {
	s.LastUpdatedAt = &v
	return s
}
912882
func (s *CreateGroupOutput) SetLastUpdatedTimestamp(v string) *CreateGroupOutput {
	s.LastUpdatedTimestamp = &v
	return s
}