match="Query parameter 'q' must be one of the supported types",
    ):
        app = FastAPI()

        class Item(BaseModel):
            title: str

        @app.get("/items/")
        def read_items(q: dict[str, Item] = Query(default=None)):
            pass  # pragma: no cover


def test_invalid_simple_dict():
    with pytest.raises(
        AssertionError,

              warnings:
                - "warning to remove"
          - match: { _source.values: ["foo"] }
          - match: { _type: "_foo" }
          - match: { _source.blah: 1234 }
          - match: { _source.junk: true }
          - match: { match_.some.key_to_replace: true }
          - is_true: "value_to_replace"
          - is_false: "value_to_replace"

    public void test_update_callsLoad() throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(1);
        configHelper.setLoadCallback(() -> {
            latch.countDown();
            return 1;
        });

        configHelper.update();

        assertTrue("Load method should be called within 5 seconds", latch.await(5, TimeUnit.SECONDS));
        assertEquals(1, configHelper.getLoadCallCount());
    }

			return err
		}
	}
	if k.BatchSize > 1 {
		if k.QueueDir == "" {
			return errors.New("batch should be enabled only if queue dir is enabled")
		}
	}
	if k.BatchCommitTimeout > 0 {
		if k.QueueDir == "" || k.BatchSize <= 1 {
			return errors.New("batch commit timeout should be set only if queue dir is enabled and batch size > 1")
		}
	}
	return nil
}

// KafkaTarget - Kafka target.

    @ValidateTypeFailure
    public Float boost;

    /**
     * The virtual host for the key match.
     */
    @Size(max = 1000)
    public String virtualHost;

    /**
     * The user who created this key match.
     */
    @Size(max = 255)
    public String createdBy;

    /**
     * The timestamp when this key match was created.
     */
    @ValidateTypeFailure
    public Long createdTime;

    /**

package org.elasticsearch.gradle.internal.test.rest.transform.match;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import org.elasticsearch.gradle.internal.test.rest.transform.ReplaceByKey;
import org.gradle.api.tasks.Internal;

/**
 * A transformation to replace the value of a match. For example, change from "match":{"_type": "foo"} to "match":{"_type": "bar"}
 */

## Partial updates with `PATCH` { #partial-updates-with-patch }

You can also use the [HTTP `PATCH`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH) operation to *partially* update data.

This means that you can send only the data that you want to update, leaving the rest intact.

/// note

`PATCH` is less commonly used and known than `PUT`.

## Atualizações parciais com `PATCH` { #partial-updates-with-patch }

Você também pode usar a operação [HTTP `PATCH`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH) para atualizar dados *parcialmente*.

Isso significa que você pode enviar apenas os dados que deseja atualizar, deixando o restante intacto.

/// note | Nota

`PATCH` é menos comumente usado e conhecido do que `PUT`.

* Update Cluster Autoscaler to version 1.3.7. ([#74136](https://github.com/kubernetes/kubernetes/pull/74136), [@jkaniuk](https://github.com/jkaniuk))

                val match = dependencyRegex.find(dependency)
                if (match != null) {
                    val oldDependency = match.groupValues[3] + match.groupValues[2]
                    val newDependency = match.groupValues[1] + match.groupValues[2]
                    lines.replaceAll { it.replace(oldDependency, newDependency) }
                }