// Version returns 0.0.1
193510
func (x *XC) Version(ctx context.Context) semver.Version {
	return semver.Version{
		Patch: 1,
	}
}
225825
func (c *Client) Version() (*Version, error) {
	v := &Version{}
	if _, err := c.ExecCmd(NewCmd("version").WithResponse(v)); err != nil {
		return nil, err
	}

	return v, nil
}
1305816
func (c *ShardedClient) Version() VersionResponse {
	shardConns := c.manager.GetAllShards()

	var err error
	versions := make(map[int]string)
	for shard, conn := range shardConns {
		response := c.versionHelper(shard, conn)
		if response.Error() != nil {
			if err == nil {
				err = response.Error()
			} else {
				err = errors.Wrap(response.Error(), err.Error())
			}
			continue
		}

		for shardId, versionString := range response.Versions() {
			versions[shardId] = versionString
		}
	}

	if err != nil {
		return NewVersionErrorResponse(err, versions)
	}

	return NewVersionResponse(StatusNoError, versions)
}
281787
func (s *Store) Version(context.Context) semver.Version {
	return semver.Version{Minor: 1}
}
803761
func (s *DeleteTemplateService) Version(version int) *DeleteTemplateService {
	s.version = &version
	return s
}
224220
func (c *Clamd) Version() (chan *ScanResult, error) {
	dataArrays, err := c.simpleCommand("VERSION")
	return dataArrays, err
}
164704
func (c *Client) Version() (map[string]btcjson.VersionResult, error) {
	return c.VersionAsync().Receive()
}
261348
func (f *RemoteRuntime) Version(ctx context.Context, req *kubeapi.VersionRequest) (*kubeapi.VersionResponse, error) {
	return f.RuntimeService.Version(req.Version)
}
1185181
func (s *IdentityServer) Version(
	ctx context.Context,
	req *api.SdkIdentityVersionRequest,
) (*api.SdkIdentityVersionResponse, error) {

	var (
		version *api.StorageVersion
		err     error
	)
	if s.driver(ctx) == nil {
		version = &api.StorageVersion{
			Driver: "no driver running",
		}
	} else {
		version, err = s.driver(ctx).Version()
		if err != nil {
			return nil, status.Errorf(
				codes.Internal,
				"Failed to get version information: %v", err,
			)
		}
	}

	sdkVersion := &api.SdkVersion{
		Major: int32(api.SdkVersion_Major),
		Minor: int32(api.SdkVersion_Minor),
		Patch: int32(api.SdkVersion_Patch),
		Version: fmt.Sprintf("%d.%d.%d",
			api.SdkVersion_Major,
			api.SdkVersion_Minor,
			api.SdkVersion_Patch,
		),
	}

	return &api.SdkIdentityVersionResponse{
		SdkVersion: sdkVersion,
		Version:    version,
	}, nil
}
700759
func (svc *Service) Version() string {
	parts := strings.Split(svc.Image, ":")
	if len(parts) > 1 {
		return parts[1]
	}

	return parts[0]
}
52315
func (linux Linux) Version() string {
	if len(linux.lsbrelease) == 0 {
		return ""
	}

	rVersion := regexp.MustCompile(versionPattern)
	return rVersion.FindAllStringSubmatch(linux.lsbrelease, 1)[0][1]
}
259200
func (r *Containerd) Version() (string, error) {
	ver, err := r.Runner.CombinedOutput("containerd --version")
	if err != nil {
		return "", err
	}

	// containerd github.com/containerd/containerd v1.2.0 c4446665cb9c30056f4998ed953e6d4ff22c7c39
	words := strings.Split(ver, " ")
	if len(words) >= 4 && words[0] == "containerd" {
		return strings.Replace(words[2], "v", "", 1), nil
	}
	return "", fmt.Errorf("unknown version: %q", ver)
}
1262149
func (r *CRIO) Version() (string, error) {
	ver, err := r.Runner.CombinedOutput("crio --version")
	if err != nil {
		return "", err
	}

	// crio version 1.13.0
	// commit: ""
	line := strings.Split(ver, "\n")[0]
	return strings.Replace(line, "crio version ", "", 1), nil
}
948959
func (r *BulkUpdateRequest) Version(version int64) *BulkUpdateRequest {
	r.version = version
	r.source = nil
	return r
}
659369
func (s *ScanService) Version(version bool) *ScanService {
	s.searchSource = s.searchSource.Version(version)
	return s
}
35641
func Version(url string, kvdbOptions map[string]string) (string, error) {
	return kvdb.BoltVersion1, nil
}
257220
func (s *UpdateByQueryService) Version(version bool) *UpdateByQueryService {
	s.version = &version
	return s
}