}
	}
	return status, nil
}

func (c *kesConn) ListKeys(ctx context.Context, req *ListRequest) ([]madmin.KMSKeyInfo, string, error) {
	names, continueAt, err := c.client.ListKeys(ctx, req.Prefix, req.Limit)
	if err != nil {
		return nil, "", err
	}
	keyInfos := make([]madmin.KMSKeyInfo, len(names))
	for i := range names {
		keyInfos[i].Name = names[i]
	}
	return keyInfos, continueAt, nil
}

    }

    private static UnaryOperator<String> prefix(String prefix, UnaryOperator<String> cb) {
        return s -> {
            String v = null;
            if (s.startsWith(prefix)) {
                v = cb.apply(s.substring(prefix.length()));
            }
            return v;
        };
    }

		}
	}
	wg.Wait()
}

func (er erasureObjects) deleteAll(ctx context.Context, bucket, prefix string) {
	var wg sync.WaitGroup
	for _, disk := range er.getDisks() {
		if disk == nil {
			continue
		}
		wg.Add(1)
		go func(disk StorageAPI) {
			defer wg.Done()
			disk.Delete(ctx, bucket, prefix, DeleteOptions{
				Recursive: true,
				Immediate: false,
			})
		}(disk)
	}
	wg.Wait()

		return
	}

	if GlobalKMS == nil {
		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(ErrKMSNotConfigured), r.URL)
		return
	}
	allKeys, _, err := GlobalKMS.ListKeys(ctx, &kms.ListRequest{
		Prefix: r.Form.Get("pattern"),
	})
	if err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}

	// Get the cred and owner for checking authz below.

    warpspin)
 *  Include `Content-Type` and `Content-Encoding` in the Apache HTTP client
    adapter. (thanks kwuollett)
 *  Add a media type class to OkHttp.
 *  Change custom header prefix:

    ```
    X-Android-Sent-Millis is now OkHttp-Sent-Millis
    X-Android-Received-Millis is now OkHttp-Received-Millis
    X-Android-Response-Source is now OkHttp-Response-Source

				bts, err = z.Uploads[za0001].UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Uploads", za0001)
					return
				}
			}
		case "Prefix":
			z.Prefix, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Prefix")
				return
			}
		case "Delimiter":
			z.Delimiter, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Delimiter")

        500: {"description": "Server error level 0"},
    },
    default_response_class=ResponseLevel0,
    callbacks=callback_router0.routes,
)

router2_override = APIRouter(
    prefix="/level2",
    tags=["level2a", "level2b"],
    dependencies=[Depends(dep2)],
    responses={
        402: {"description": "Client error level 2"},
        502: {"description": "Server error level 2"},
    },

   * href="http://en.wikipedia.org/wiki/Lexicographical_order">lexicographically</a>. That is, it
   * compares, using {@link #compare(byte, byte)}), the first pair of values that follow any common
   * prefix, or when one array is a prefix of the other, treats the shorter array as the lesser. For
   * example, {@code [] < [0x01] < [0x01, 0x7F] < [0x01, 0x80] < [0x02]}. Values are treated as
   * unsigned.
   *

        assertEquals("regex:", relatedContentHelper.regexPrefix);

        relatedContentHelper.setRegexPrefix("pattern:");
        assertEquals("pattern:", relatedContentHelper.regexPrefix);

        // Test with the new prefix
        List<RelatedContent> testData = new ArrayList<>();
        testData.add(createRelatedContent("pattern:test.*", "Pattern Match: __QUERY__", ""));
        mockBhv.setTestData(testData);

			wg.Add(1)
			var gotExpired []ObjectToDelete
			go expiryWorker(&wg, workerReady, workers[0], &gotExpired)
			<-workerReady

			item := scannerItem{
				Path:        obj,
				bucket:      bucket,
				prefix:      "",
				objectName:  obj,
				lifeCycle:   lc,
				replication: test.replCfg,
			}

			var (
				sizeS sizeSummary
				gots  []ObjectInfo
			)