return
	}

	data, err := io.ReadAll(r.Body)
	if err != nil {
		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(ErrInvalidRequest), r.URL)
		return
	}
	reader := bytes.NewReader(data)
	zr, err := zip.NewReader(reader, int64(len(data)))
	if err != nil {
		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(ErrInvalidRequest), r.URL)

data/folder/file.html テスト data/file.txt テキスト...

import org.codelibs.fess.helper.SystemHelper;
import org.codelibs.fess.opensearch.log.exbhv.UserInfoBhv;

import jakarta.annotation.Resource;

/**
 * Service class for managing user information data.
 * This service provides operations for maintaining and cleaning up user information records.
 */
public class UserInfoService {

    @Resource
    private UserInfoBhv userInfoBhv;

    @Resource

     *
     * @throws CIFSException
     *
     * @see jcifs.smb.SSPContext#calculateMIC(byte[])
     */
    @Override
    public byte[] calculateMIC(byte[] data) throws CIFSException {
        try {
            return this.gssContext.getMIC(data, 0, data.length, new MessageProp(false));
        } catch (GSSException e) {
            throw new CIFSException("Failed to calculate MIC", e);
        }
    }

    /**

test.tar data/folder/file.html テスト data/file.txt テキスト...

You declare the "shape" of the data as classes with attributes.

And each attribute has a type.

Then you create an instance of that class with some values and it will validate the values, convert them to the appropriate type (if that's the case) and give you an object with all the data.

And you get all the editor support with that resulting object.

		return
	}

	// Encode result and send response.

	data, err := json.Marshal(res)
	if err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}
	password := cred.SecretKey
	econfigData, err := madmin.EncryptData(password, data)
	if err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}

        }
        out.writeByte(value)
      }

      @Throws(IOException::class)
      fun writeByteString(data: ByteString) {
        if (useCompression && Huffman.encodedLength(data) < data.size) {
          val huffmanBuffer = Buffer()
          Huffman.encode(data, huffmanBuffer)
          val huffmanBytes = huffmanBuffer.readByteString()
          writeInt(huffmanBytes.size, PREFIX_7_BITS, 0x80)

It will perform the validation of the compound data, and will document it like that for the OpenAPI schema and automatic docs.

## Singular values in body { #singular-values-in-body }

The same way there is a `Query` and `Path` to define extra data for query and path parameters, **FastAPI** provides an equivalent `Body`.

        result = netShareEnum.writeSetupWireFormat(dst, 50);
        assertEquals(0, result);

        // Verify no data was written
        assertArrayEquals(new byte[100], dst);
    }

    @Test
    @DisplayName("Test writeParametersWireFormat writes correct data")
    void testWriteParametersWireFormat() throws Exception {
        netShareEnum = new NetShareEnum(realConfig);