}

	// For now, ldapConfigs will only have a single entry for the default
	// configuration.

	var res []madmin.IDPListItem
	for _, cfg := range ldapConfigs {
		res = append(res, madmin.IDPListItem{
			Type:    "ldap",
			Name:    cfg,
			Enabled: l.Enabled(),
		})
	}

	return res, nil
}

// ErrProviderConfigNotFound - represents a non-existing provider error.

		}); err != nil {
			res.Buckets = append(res.Buckets, madmin.ResyncBucketStatus{
				ErrDetail: err.Error(),
				Bucket:    bucket,
			})
			continue
		}
	}
	res = madmin.SRResyncOpStatus{
		Status:   ResyncStarted.String(),
		OpType:   "start",
		ResyncID: rs.ResyncID,
		Buckets:  res.Buckets,
	}
	if len(res.Buckets) > 0 {

	partSize, err := optimalPartSize(length)
	if err != nil {
		return remoteVersionID(""), err
	}
	res, err := m.client.PutObject(ctx, m.Bucket, m.getDest(object), r, length, minio.PutObjectOptions{
		StorageClass:         m.StorageClass,
		PartSize:             uint64(partSize),
		DisableContentSha256: true,
	})
	return remoteVersionID(res.VersionID), m.ToObjectError(err, object)
}

func (s *NetServer) scanProcForPodsAndCache(pods map[types.UID]*corev1.Pod) error {
	// TODO: maybe remove existing uids in s.currentPodSnapshot from the filter set.
	res, err := s.podNs.FindNetnsForPods(pods)
	if err != nil {
		return err
	}

	for uid, wl := range res {
		s.currentPodSnapshot.UpsertPodCacheWithNetns(uid, wl)
	}
	return nil
}

func realDependencies() *dep.RealDependencies {

	}
	if h.callReuseReq {
		defer h.recycleReq(req)
	}
	res, err := c.Request(ctx, h.id, payload)
	PutByteBuffer(payload)
	if err != nil {
		return resp, err
	}
	defer PutByteBuffer(res)
	r := h.NewResponse()
	_, err = r.UnmarshalMsg(res)
	if err != nil {
		h.PutResponse(r)
		return resp, err
	}
	return r, err
}

			if len(fivs.FreeVersions) > 0 {
				res["free-versions"] = strconv.Itoa(len(fivs.FreeVersions))
			}

			if sizeS.versions > 0 {
				res["versions"] = strconv.FormatUint(sizeS.versions, 10)
			}
			res["size"] = strconv.FormatInt(sizeS.totalSize, 10)
			for name, tier := range sizeS.tiers {
				res["tier-size-"+name] = strconv.FormatUint(tier.TotalSize, 10)
				res["tier-versions-"+name] = strconv.Itoa(tier.NumVersions)

	cache := store.rlock()
	defer store.runlock()

	var res []auth.Credentials
	for _, u := range cache.iamUsersMap {
		cred := u.Credentials
		if cred.IsServiceAccount() {
			res = append(res, cred)
		}
	}
	for _, u := range cache.iamSTSAccountsMap {
		res = append(res, u.Credentials)
	}

	return res
}

// UpdateUserIdentity - updates a user credential.

		}
		return eventC
	}

	testServer := httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
		cniAddServerCalled = true
		if serverErr {
			res.WriteHeader(http.StatusInternalServerError)
			res.Write([]byte("server not happy"))
			return
		}
		res.WriteHeader(http.StatusOK)
		res.Write([]byte("server happy"))
	}))

	return testServer.URL, func() bool {

	}

	if objInfo.isMultipart() {
		res, err := z.NewMultipartUpload(ctx, bucket, objInfo.Name, ObjectOptions{
			VersionID:   objInfo.VersionID,
			UserDefined: objInfo.UserDefined,
			NoAuditLog:  true,
		})
		if err != nil {
			return fmt.Errorf("decommissionObject: NewMultipartUpload() %w", err)
		}
		defer z.AbortMultipartUpload(ctx, bucket, objInfo.Name, res.UploadID, ObjectOptions{NoAuditLog: true})

func (client *storageRESTClient) RenameData(ctx context.Context, srcVolume, srcPath string, fi FileInfo,
	dstVolume, dstPath string, opts RenameOptions,
) (res RenameDataResp, err error) {
	params := RenameDataHandlerParams{
		DiskID:    *client.diskID.Load(),
		SrcVolume: srcVolume,
		SrcPath:   srcPath,
		DstPath:   dstPath,
		DstVolume: dstVolume,
		FI:        fi,