import jcifs.internal.AllocInfo;
import jcifs.internal.SMBProtocolDecodingException;
import jcifs.internal.util.SMBUtil;

/**
 * Represents the FILE_FS_FULL_SIZE_INFORMATION structure used to query comprehensive file system size information.
 * This structure provides complete allocation details including total allocation units, caller-available free units,
 * actual free allocation units, sectors per allocation unit, and bytes per sector.
 */

	// limit is selected automatically.
	Limit int
}

// CreateKeyRequest is a structure containing fields
// and options for creating keys.
type CreateKeyRequest struct {
	// Name is the name of the key that gets created.
	Name string
}

// DeleteKeyRequest is a structure containing fields
// and options for deleting keys.
type DeleteKeyRequest struct {

        byte[] pathBytes = TEST_PATH.getBytes(StandardCharsets.UTF_16LE);

        // Verify structure size (9)
        assertEquals(9, SMBUtil.readInt2(buffer, bodyOffset));

        // Verify tree flags (0)
        assertEquals(0, SMBUtil.readInt2(buffer, bodyOffset + 2));

        // Verify path offset (points to after the 8-byte structure)
        int expectedPathOffset = bodyOffset + 8 - headerStart;

   *
   * <p>You may also consider the equivalent {@code
   * MultimapBuilder.hashKeys().arrayListValues().build()}, which provides more control over the
   * underlying data structure.
   */
  public static <K extends @Nullable Object, V extends @Nullable Object>
      ArrayListMultimap<K, V> create() {
    return new ArrayListMultimap<>();
  }

  /**

**FastAPI** provides a convenience tool to structure your application while keeping all the flexibility.

/// info

If you come from Flask, this would be the equivalent of Flask's Blueprints.

///

## An example file structure { #an-example-file-structure }

Let's say you have a file structure like this:

```
.
├── app
│   ├── __init__.py
│   ├── main.py

    }

    /**
     * Creates a basic negotiate response buffer with minimum valid structure.
     */
    private byte[] createBasicNegotiateResponseBuffer() {
        byte[] buffer = new byte[300]; // Sufficient size for basic structure + offsets

        // Structure size (65)
        SMBUtil.writeInt2(65, buffer, 0);

        // Security mode

 */
package jcifs.internal.fscc;

import jcifs.internal.SMBProtocolDecodingException;
import jcifs.internal.util.SMBUtil;

/**
 * Represents the FILE_STANDARD_INFORMATION structure used in SMB2/3 file system control code (FSCC) operations.
 * This structure provides standard file information including allocation size, end-of-file position,
 * number of links, deletion status, and directory flag.
 */

        }

        @Test
        @DisplayName("Should throw exception for invalid structure size")
        void testReadBytesWireFormatWithInvalidStructureSize() {
            // Given
            byte[] buffer = new byte[60];
            SMBUtil.writeInt2(59, buffer, 0); // Invalid structure size (should be 60)

            // When & Then
            assertThrows(SMBProtocolDecodingException.class, () -> {

* This change add nonResourceURL to kubectl auth cani ([#46432](https://github.com/kubernetes/kubernetes/pull/46432), [@CaoShuFeng](https://github.com/CaoShuFeng))
* Webhook added to the API server which omits structured audit log events. ([#45919](https://github.com/kubernetes/kubernetes/pull/45919), [@ericchiang](https://github.com/ericchiang))

* The PR doesn't add any additional or extraneous files.
* The translation seems to have a similar structure as the original English file.
* The translation doesn't seem to change the original content, for example with obvious additional documentation sections.
* The translation doesn't use different Markdown structures, for example adding HTML tags when the original didn't have them.