bufferIndex += i.decode(buffer, bufferOffset, len);
        this.notifyInformation.add(i);

        while (i.getNextEntryOffset() > 0 && bufferIndex < bufferOffset + len) {
            bufferIndex = elemStart + i.getNextEntryOffset();
            elemStart = bufferIndex;

            i = new FileNotifyInformationImpl();
            bufferIndex += i.decode(buffer, bufferIndex, len);

    }

    @Override
    public long getSize() {
        return this.endOfFile;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        this.allocationSize = SMBUtil.readInt8(buffer, bufferIndex);

## Pydantic `bytes` { #pydantic-bytes }

You can declare a Pydantic model with `bytes` fields, and then use `val_json_bytes` in the model config to tell it to use base64 to *validate* input JSON data, as part of that validation it will decode the base64 string into bytes.

{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:9,29:35] hl[9] *}

If you check the `/docs`, they will show that the field `data` expects base64 encoded bytes:

        SMBUtil.writeInt4(DirectoryLeaseState.DIRECTORY_READ_HANDLE, buffer, 40);

        // Decode with partial data
        DirectoryLeaseContext context = new DirectoryLeaseContext(new Smb2LeaseKey(), 0, DirectoryCacheScope.IMMEDIATE_CHILDREN);
        context.decode(buffer, 0, 56);

        // Should decode standard lease data correctly
        assertArrayEquals(key.getKey(), context.getLeaseKey().getKey());

        }
    }

    /**
     * Performs RDMA read operation.
     *
     * @param buffer the buffer to read into
     * @param remoteAddress remote memory address
     * @param remoteKey remote access key
     * @param length number of bytes to read
     * @return number of bytes read
     * @throws IOException if operation fails
     */

     */
    LOCAL_READ,

    /**
     * Local write access to the memory region
     */
    LOCAL_WRITE,

    /**
     * Remote read access to the memory region
     */
    REMOTE_READ,

    /**
     * Remote write access to the memory region
     */
    REMOTE_WRITE,

    /**
     * Memory bind access for advanced operations
     */
    MEMORY_BIND

    }

    /**
     * Deletes a web authentication configuration.
     *
     * @param webAuthentication The web authentication configuration to delete
     */
    public void delete(final WebAuthentication webAuthentication) {

        webAuthenticationBhv.delete(webAuthentication, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

    }

    /**

                throw new RuntimeException("Delete operation failed");
            }
        };
        ComponentUtil.register(searchEngineClient, "searchEngineClient");

        // Execute the job
        String result = purgeDocJob.execute();

        // Assert error message is in the result
        assertTrue(result.contains("Delete operation failed"));
        assertTrue(result.endsWith("\n"));
    }

    }

    /**
     * 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):