The JSON body structure can be seen from this sample:

<details><summary>Request Body Sample</summary>

```json
{
  "input": {
    "account": "minio",
    "groups": null,
    "action": "s3:ListBucket",
    "bucket": "test",
    "conditions": {
      "Authorization": [

	}
	return nums
}

// Reads all `xl.meta` metadata as a FileInfo slice.
// Returns error slice indicating the failed metadata reads.
func readAllFileInfo(ctx context.Context, disks []StorageAPI, origbucket string, bucket, object, versionID string, readData, healing bool) ([]FileInfo, []error) {
	metadataArray := make([]FileInfo, len(disks))

	opts := ReadOptions{
		ReadData: readData,
		Healing:  healing,
	}

    /**
     * Process the response without even attempting to reading the request body. For HTTP/2 this
     * will close the response stream after the response body or trailers. For HTTP/1 this will
     * close the socket after the response body or trailers.
     */
    public fun doNotReadRequestBody(): Builder =
      apply {
        doNotReadRequestBody = true
        onResponseEnd = CloseStream(ErrorCode.NO_ERROR.httpCode)

        } catch (IOException e) {
            throw new PACDecodingException("Malformed kerberos token", e);
        }
    }

    /**
     * Returns the Kerberos ticket.
     *
     * @return the KerberosTicket object
     */
    public KerberosTicket getTicket() {
        return this.apRequest.getTicket();
    }

    /**
     * Returns the Kerberos AP request.

    public void setMaxConnectionsPerRoute(final Integer maxConnectionsPerRoute) {
        this.maxConnectionsPerRoute = maxConnectionsPerRoute;
    }

    /**
     * Sets the socket timeout in milliseconds.
     *
     * @param soTimeout The socket timeout
     */
    public void setSoTimeout(final Integer soTimeout) {
        this.soTimeout = soTimeout;
    }

    /**

import org.mockserver.logging.MockServerLogger
import org.mockserver.model.HttpRequest.request
import org.mockserver.model.HttpResponse.response
import org.mockserver.proxyconfiguration.ProxyConfiguration
import org.mockserver.socket.tls.KeyStoreFactory
import org.testcontainers.containers.MockServerContainer
import org.testcontainers.junit.jupiter.Container
import org.testcontainers.junit.jupiter.Testcontainers

@Testcontainers
class BasicProxyTest {

			timeToFirstByte = tc.ResponseRecorder.TTFB()
		}

		entry.AccessKey = reqInfo.Cred.AccessKey
		entry.ParentUser = reqInfo.Cred.ParentUser

		entry.API.Name = reqInfo.API
		entry.API.Bucket = reqInfo.BucketName
		entry.API.Object = reqInfo.ObjectName
		entry.API.Objects = make([]audit.ObjectVersion, 0, len(reqInfo.Objects))
		for _, ov := range reqInfo.Objects {

}

// Represents the V2 backend disk structure version
// under `.minio.sys` and actual data namespace.
// formatErasureV2 - structure holds format config version '2'.
// The V2 format to support "large bucket" support where a bucket
// can span multiple erasure sets.
type formatErasureV2 struct {
	formatMetaV1
	Erasure struct {
		Version string `json:"version"` // Version of 'xl' format.

                final boolean closed = msg != null && msg.equals("Socket closed");

                if (closed) {
                    log.trace("Remote closed connection");
                } else if (timeout) {
                    log.debug("socket timeout in non peek state", ex);
                } else {
                    log.debug("recv failed", ex);
                }

        // RPC endpoint mapper port and connection timeout
        final int RPC_ENDPOINT_PORT = 135;
        final int RPC_CONNECT_TIMEOUT_MS = 5000;

        try (Socket socket = new Socket()) {
            socket.connect(new InetSocketAddress(address, RPC_ENDPOINT_PORT), RPC_CONNECT_TIMEOUT_MS);
            return true;
        } catch (IOException e) {
            return false;
        }
    }