{{- end }}
  {{- end }}
---
kind: NetworkPolicy
apiVersion: {{ template "minio.networkPolicy.apiVersion" . }}
metadata:
  name: {{ template "minio.fullname" . }}-post-job
  labels:
    app: {{ template "minio.name" . }}-post-job
    chart: {{ template "minio.chart" . }}
    release: {{ .Release.Name }}
    heritage: {{ .Release.Service }}
spec:
  podSelector:
    matchLabels:

	public static final field MAX_RESPONSE_SIZE I
	public final fun client ()Lokhttp3/OkHttpClient;
	public final fun includeIPv6 ()Z
	public fun lookup (Ljava/lang/String;)Ljava/util/List;
	public final fun post ()Z
	public final fun resolvePrivateAddresses ()Z
	public final fun resolvePublicAddresses ()Z
	public final fun url ()Lokhttp3/HttpUrl;
}

public final class okhttp3/dnsoverhttps/DnsOverHttps$Builder {

from fastapi import FastAPI, File, UploadFile
from fastapi.responses import HTMLResponse

app = FastAPI()


@app.post("/files/")
async def create_files(
    files: list[bytes] = File(description="Multiple files as bytes"),
):
    return {"file_sizes": [len(file) for file in files]}


@app.post("/uploadfiles/")
async def create_upload_files(
    files: list[UploadFile] = File(description="Multiple files as UploadFile"),
):

            .post(RequestBody.create(MEDIA_TYPE_MARKDOWN, postBody))
            .build();

        try (Response response = client.newCall(request).execute()) {
          if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

          System.out.println(response.body().string());
        }
      }
    ```

  fun invalidatesCache(method: String): Boolean =
    (
      method == "POST" ||
        method == "PATCH" ||
        method == "PUT" ||
        method == "DELETE" ||
        method == "MOVE"
    )

  @JvmStatic // Despite being 'internal', this method is called by popular 3rd party SDKs.
  fun requiresRequestBody(method: String): Boolean =
    (
      method == "POST" ||
        method == "PUT" ||
        method == "PATCH" ||

def get_app_client(separate_input_output_schemas: bool = True) -> TestClient:
    app = FastAPI(separate_input_output_schemas=separate_input_output_schemas)

    @app.post("/items/", responses={402: {"model": Item}})
    def create_item(item: Item) -> Item:
        return item

    @app.post("/items-list/")
    def create_item_list(item: list[Item]):
        return item

    @app.get("/items/")
    def read_items() -> list[Item]:

  <name>Model inheritance test</name>
  <description>Model inheritance description</description>
  <url>http://www.apache.org/</url>

  <mailingLists>
    <mailingList>
      <name>parent</name>
      <post>post@mailing.list.com</post>
      <subscribe>******@****.***</subscribe>
      <unsubscribe>******@****.***</unsubscribe>
    </mailingList>
  </mailingLists>

  <build>
    <plugins>
      <plugin>

    bootstrapClient: OkHttpClient,
    includeIPv6: Boolean,
    post: Boolean = false,
  ): DnsOverHttps {
    val url = server.url("/lookup?ct")
    return DnsOverHttps
      .Builder()
      .client(bootstrapClient)
      .includeIPv6(includeIPv6)
      .resolvePrivateAddresses(true)
      .url(url)
      .post(post)
      .build()
  }

  companion object {

        else -> header("Cache-Control", value)
      }
    }

    open fun get(): Builder = method("GET", null)

    open fun head(): Builder = method("HEAD", null)

    open fun post(body: RequestBody): Builder = method("POST", body)

    @JvmOverloads
    open fun delete(body: RequestBody? = RequestBody.EMPTY): Builder = method("DELETE", body)

    open fun put(body: RequestBody): Builder = method("PUT", body)

{* ../../docs_src/server_sent_events/tutorial004_py310.py hl[25,27,31] *}

## SSE with POST { #sse-with-post }

SSE works with **any HTTP method**, not just `GET`.

This is useful for protocols like [MCP](https://modelcontextprotocol.io) that stream SSE over `POST`:

{* ../../docs_src/server_sent_events/tutorial005_py310.py hl[14] *}

## Technical Details { #technical-details }