* @param request The model building request that holds further settings, must not be {@code null}.
     * @param problems The container used to collect problems that were encountered, must not be {@code null}.
     */
    void mergeDuplicates(Model model, ModelBuildingRequest request, ModelProblemCollector problems);

    /**

        @Test
        @DisplayName("Should create request with configuration only")
        void testConstructorWithConfig() {
            TestServerMessageBlock2Request request = new TestServerMessageBlock2Request(mockConfig);
            assertNotNull(request);
            assertEquals(mockConfig, request.getConfig());
        }

        @Test
        @DisplayName("Should create request with configuration and command")

Podrías crear una API con una *path operation* que podría desencadenar un request a una *API externa* creada por alguien más (probablemente el mismo desarrollador que estaría *usando* tu API).

    raw_body = await request.body()
    try:
        data = yaml.safe_load(raw_body)
    except yaml.YAMLError:
        raise HTTPException(status_code=422, detail="Invalid YAML")
    try:
        item = Item.model_validate(data)
    except ValidationError as e:
        raise HTTPException(status_code=422, detail=e.errors(include_url=False))

from fastapi import FastAPI, Request

app = FastAPI(
    servers=[
        {"url": "https://stag.example.com", "description": "Staging environment"},
        {"url": "https://prod.example.com", "description": "Production environment"},
    ],
    root_path="/api/v1",
)


@app.get("/app")
def read_main(request: Request):

  public void run() throws Exception {
    File file = new File("README.md");

    Request request = new Request.Builder()
        .url("https://api.github.com/markdown/raw")
        .post(RequestBody.create(file, MEDIA_TYPE_MARKDOWN))
        .build();

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

      .build()

  fun run() {
    try {
      val request = Request(server.url("/"))

      client.newCall(request).execute().use { response ->
        if (!response.isSuccessful) throw IOException("Unexpected code $response")

        println(response.request.url)
      }
    } finally {
      server.shutdown()
    }
  }
}

fun main() {

}

// Returns access credentials in the request Authorization header.
func getReqAccessCred(r *http.Request, region string) (cred auth.Credentials) {
	cred, _, _ = getReqAccessKeyV4(r, region, serviceS3)
	if cred.AccessKey == "" {
		cred, _, _ = getReqAccessKeyV2(r)
	}
	return cred
}

// Extract request params to be sent with event notification.
func extractReqParams(r *http.Request) map[string]string {
	if r == nil {

from fastapi import FastAPI, Request
from fastapi.testclient import TestClient
from inline_snapshot import snapshot

app = FastAPI(openapi_prefix="/api/v1")


@app.get("/app")
def read_main(request: Request):
    return {"message": "Hello World", "root_path": request.scope.get("root_path")}


client = TestClient(app)


def test_main():
    response = client.get("/app")
    assert response.status_code == 200

    /**
     * The unique identifier of the request header.
     */
    public String id;

    /**
     * The name of the request header.
     */
    public String name;

    /**
     * The value of the request header.
     */
    public String value;

    /**
     * The web configuration ID associated with this request header.
     */
    public String webConfigId;

    /**