}{Version: healthInfo.Version}

	enc := json.NewEncoder(gzWriter)
	if e := enc.Encode(header); e != nil {
		internalLogIf(ctx, fmt.Errorf("Could not encode health info header: %w", e))
		return nil
	}

	if e := enc.Encode(healthInfo); e != nil {
		internalLogIf(ctx, fmt.Errorf("Could not encode health info: %w", e))
		return nil
	}

	gzWriter.Flush()
	gzWriter.Close()

        return asJson(new ApiResult.ApiLogFilesResponse().files(list).total(list.size()).status(ApiResult.Status.OK).result());
    }

    /**
     * Downloads a specific log file by ID.
     *
     * @param id the base64-encoded filename of the log file to download
     * @return stream response containing the log file content
     */
    // GET /api/admin/log/file/{id}
    @Execute
    public StreamResponse get$file(final String id) {

  },
  {
    "input": "نامه‌ای",
    "output": "xn--mgba3gch31f060k"
  },
  {
    "comment": "U+FFFD",
    "input": "\uFFFD.com",
    "output": null
  },
  {
    "comment": "U+FFFD character encoded in Punycode",
    "input": "xn--zn7c.com",
    "output": null
  },
  {
    "comment": "Label longer than 63 code points",
    "input": "x01234567890123456789012345678901234567890123456789012345678901x",

## Daten in etwas JSON-kompatibles konvertieren

Um Daten in etwas JSON-kompatibles zu konvertieren, lesen Sie die Dokumentation unter [Tutorial – JSON-kompatibler Encoder](../tutorial/encoder.md){.internal-link target=_blank}.

## OpenAPI-Metadaten – Dokumentation

	enc := json.NewEncoder(os.Stdout)
	if err = enc.Encode(&start); err != nil {
		log.Fatalln(err)
	}

	fmt.Println()
	for {
		_, status, err := madmClnt.Heal(context.Background(), "healing-rewrite-bucket", "", opts, start.ClientToken, false, false)
		if status.Summary == "finished" {
			fmt.Println("Healstatus on items ===")
			for _, item := range status.Items {
				if err = enc.Encode(&item); err != nil {
					log.Fatalln(err)
				}

   * double-duty to make sure the counting and content are consistent, particularly when it comes
   * to awkward operations like measuring the encoded length of header strings, or the
   * length-in-digits of an encoded integer.
   */
  @Throws(IOException::class)
  private fun writeOrCountBytes(
    sink: BufferedSink?,
    countBytes: Boolean,
  ): Long {
    var sink = sink

        byte[] buffer = new byte[22];
        int idFileSystem = 0x12345678;
        int sectPerAlloc = 8;
        long alloc = 1000000L;
        long free = 500000L;
        int bytesPerSect = 512;

        // Encode test data
        int offset = 0;
        SMBUtil.writeInt4(idFileSystem, buffer, offset); // idFileSystem (skipped)
        offset += 4;
        SMBUtil.writeInt4(sectPerAlloc, buffer, offset);
        offset += 4;

        byte[] buffer = new byte[256];
        int encodedSize = context.encode(buffer, 0);

        assertTrue(encodedSize > 8); // Minimum size: count + padding + flags + algorithms
        assertEquals(context.size(), encodedSize);
    }

    @Test
    @DisplayName("Test context decoding")
    public void testDecoding() throws SMBProtocolDecodingException {
        // Encode first
        byte[] buffer = new byte[256];

            }
        }
    }

    /**
     * Encrypt credentials to a base64 string for storage
     *
     * @param plaintext the credentials to encrypt
     * @return base64 encoded encrypted credentials
     * @throws GeneralSecurityException if encryption fails
     */
    public String encryptToString(char[] plaintext) throws GeneralSecurityException {

        return transform;
    }

    /**
     * Encode to byte array for SMB2 READ/WRITE channel info
     *
     * @param dst destination buffer
     * @param dstIndex starting index
     * @return number of bytes written
     */
    public int encode(byte[] dst, int dstIndex) {
        return transform.encode(dst, dstIndex);
    }

    @Override
    public String toString() {