* @param id the ID of the synonym item to delete
     * @return JSON response indicating the deletion status
     */
    // DELETE /api/admin/dict/synonym/setting/{dictId}/{id}
    @Execute
    public JsonResponse<ApiResult> delete$setting(final String dictId, final long id) {
        synonymService.getSynonymItem(dictId, id).ifPresent(entity -> {
            synonymService.delete(dictId, entity);

	v := RStat{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

	m := v.Msgsize()
	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecodeRStat Msgsize() is inaccurate")
	}

	vn := RStat{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

	m := v.Msgsize()
	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecodeconnectReq Msgsize() is inaccurate")
	}

	vn := connectReq{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

        @DisplayName("fromUNIBytes should decode UTF-16LE bytes to string")
        void testFromUNIBytes() {
            // Given
            byte[] bytes = TEST_STRING.getBytes(StandardCharsets.UTF_16LE);

            // When
            String result = Strings.fromUNIBytes(bytes, 0, bytes.length);

            // Then
            assertEquals(TEST_STRING, result, "Should decode back to original string");
        }

            op.setRefreshPolicy(Constants.TRUE);
        });

    }

    /**
     * Deletes a role type.
     * @param roleType The role type to delete.
     */
    public void delete(final RoleType roleType) {

        roleTypeBhv.delete(roleType, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

    }

    /**
     * Sets up the list condition for the role type query.

    /**
     * Create a new durable handle V2 response
     */
    public DurableHandleV2Response() {
        // Will be populated during decode
    }

    @Override
    public byte[] getName() {
        return CONTEXT_NAME_BYTES;
    }

    @Override
    public int decode(byte[] buffer, int bufferIndex, int len) throws SMBProtocolDecodingException {
        if (len != 8) {

    super.atomicMove(source, target)
  }

  @Throws(IOException::class)
  override fun delete(
    path: Path,
    mustExist: Boolean,
  ) {
    if (deleteFaults.contains(path)) throw IOException("boom!")
    super.delete(path, mustExist)
  }

  @Throws(IOException::class)
  override fun deleteRecursively(
    fileOrDirectory: Path,
    mustExist: Boolean,
  ) {

     * @param id the ID of the stopwords item to delete
     * @return JSON response indicating the deletion status
     */
    // DELETE /api/admin/dict/stopwords/setting/{dictId}/{id}
    @Execute
    public JsonResponse<ApiResult> delete$setting(final String dictId, final long id) {
        stopwordsService.getStopwordsItem(dictId, id).ifPresent(entity -> {
            stopwordsService.delete(dictId, entity);

    }

    /**
     * Deletes a role setting by ID.
     *
     * @param id the ID of the role setting to delete
     * @return JSON response indicating success or failure
     */
    // DELETE /api/admin/role/setting/{id}
    @Execute
    public JsonResponse<ApiResult> delete$setting(final String id) {
        final Role entity = roleService.getRole(id).orElseGet(() -> {

    return {"item_id": item_id}


def get_not_decorated(item_id: str):
    return {"item_id": item_id}


app.add_api_route("/items-not-decorated/{item_id}", get_not_decorated)


@app.delete("/items/{item_id}")
def delete_item(item_id: str, item: Item):
    return {"item_id": item_id, "item": item}


@app.head("/items/{item_id}")
def head_item(item_id: str):