* we wanted to support legacy classes that implement the raw type {@code Comparable} (instead of
   * implementing {@code Comparable<Foo>}) without producing warnings. If so, we would prefer today
   * to produce warnings in that case, and we may change this method to do so in the future. Support
   * for raw {@code Comparable} types in Guava in general is tracked as <a

        if (target != null) {
            setTargetInformation(getDefaultTargetInformation());
        }
    }

    /**
     * Creates a Type-2 message using the given raw Type-2 material.
     *
     * @param material The raw Type-2 material used to construct this message.
     * @throws IOException If an error occurs while parsing the material.
     */
    public Type2Message(final byte[] material) throws IOException {

	"github.com/minio/minio/internal/s3select/sql"
)

// Reader - CSV record reader for S3Select.
type Reader struct {
	args         *ReaderArgs
	readCloser   io.ReadCloser          // raw input
	buf          *bufio.Reader          // input to the splitter
	columnNames  []string               // names of columns
	nameIndexMap map[string]int64       // name to column index

		headers: []*Header{{
			Name:       "test2/",
			Mode:       16877,
			Uid:        1000,
			Gid:        1000,
			Size:       14,
			ModTime:    time.Unix(1441973427, 0),
			Typeflag:   'D',
			Uname:      "rawr",
			Gname:      "dsnet",
			AccessTime: time.Unix(1441974501, 0),
			ChangeTime: time.Unix(1441973436, 0),
			Format:     FormatGNU,
		}, {
			Name:       "test2/foo",
			Mode:       33188,

    private SID[] resourceGroupSids;
    private SID[] extraSids;
    private int userAccountControl;
    private int userFlags;

    /**
     * Constructs a PAC logon information object from raw PAC data.
     * @param data the raw PAC logon info buffer data
     * @throws PACDecodingException if the data is malformed or invalid
     */
    public PacLogonInfo(final byte[] data) throws PACDecodingException {
        try {

        keyManager.storeSessionKey(sessionId, testKey, "AES");

        byte[] rawKey = keyManager.getRawKey(sessionId);
        assertNotNull(rawKey, "Should retrieve raw key");
        assertArrayEquals(testKey, rawKey, "Raw key should match");

        // Verify we get a copy, not the original
        rawKey[0] = (byte) ~rawKey[0];
        byte[] rawKey2 = keyManager.getRawKey(sessionId);

El campo `data` siempre se codifica como JSON. Puedes pasar cualquier valor que pueda serializarse como JSON, incluidos modelos de Pydantic.

## Datos sin procesar { #raw-data }

Si necesitas enviar datos **sin** codificarlos a JSON, usa `raw_data` en lugar de `data`.

            Mutually exclusive with `raw_data`.
            """
        ),
    ] = None
    raw_data: Annotated[
        str | None,
        Doc(
            """
            Raw string to send as the `data:` field **without** JSON encoding.

            Use this when you need to send pre-formatted text, HTML fragments,
            CSV lines, or any non-JSON payload. The string is placed directly

   */
  @get:JvmName("socket") val socket: Socket?,
  /**
   * Returns the raw response received from the network. Will be null if this response didn't use
   * the network, such as when the response is fully cached. The body of the returned response
   * should not be read.
   */
  @get:JvmName("networkResponse") val networkResponse: Response?,
  /**
   * Returns the raw response received from the cache. Will be null if this response didn't use

        Model model = result.getRawModel();
        // For BOMs without flattening, we just need to transform the packaging from "bom" to "pom"
        // but keep everything else from the raw model (including unresolved versions)
        return transformBom(model, project);
    }

    protected Model buildBom(RepositorySystemSession session, MavenProject project, ModelSource src)