//                                                                              ======
    @Override
    public Map<String, Object> toSource() {
        Map<String, Object> sourceMap = new HashMap<>();
        if (boost != null) {
            addFieldToSource(sourceMap, "boost", boost);
        }
        if (createdBy != null) {

        }

        @Override
        public Object evaluate(String template, Map<String, Object> paramMap) {
            return "TestEngine[" + identifier + "]: " + template;
        }
    }

    private static class CustomScriptEngine implements ScriptEngine {
        @Override
        public Object evaluate(String template, Map<String, Object> paramMap) {
            return "CustomEngine: " + template;
        }

            return new ForwardingRunnable(runnable) {

              @SuppressWarnings("EqualsHashCode")
              @Override
              public boolean equals(@Nullable Object o) {
                if (o instanceof ForwardingRunnable) {
                  ForwardingRunnable that = (ForwardingRunnable) o;
                  return runnable.equals(that.runnable);
                }

  }

  @J2ktIncompatible
  @GwtIncompatible
  @J2ObjCIncompatible // gc
  @AndroidIncompatible
  public void testCancellationWithReferencedObject() throws Exception {
    Object toBeGCed = new Object();
    WeakReference<Object> ref = new WeakReference<>(toBeGCed);
    SettableFuture<@Nullable Void> settableFuture = SettableFuture.create();
    ListenableFuture<?> ignored =
        serializer.submitAsync(

      }
    };
  }

  @J2ktIncompatible
  @GwtIncompatible // java.lang.reflect
  private static Object invokeAccessibleNonThrowingMethod(
      Method method, Object receiver, Object... params) {
    try {
      return method.invoke(receiver, params);
    } catch (IllegalAccessException e) {
      throw new RuntimeException(e);

        @Override
        public ComparisonChain compare(Comparable<?> left, Comparable<?> right) {
          return classify(((Comparable<Object>) left).compareTo(right));
        }

        @Override
        public <T extends @Nullable Object> ComparisonChain compare(
            @ParametricNullness T left, @ParametricNullness T right, Comparator<T> comparator) {

{
    "components": {
        "schemas": {
            "Message": {
                "title": "Message",
                "required": [
                    "message"
                ],
                "type": "object",
                "properties": {
                    "message": {
                        "title": "Message",
                        "type": "string"
                    }
                }
            },

And then you can set headers in that *temporal* response object.

{* ../../docs_src/response_headers/tutorial002.py hl[1, 7:8] *}

And then you can return any object you need, as you normally would (a `dict`, a database model, etc).

And if you declared a `response_model`, it will still be used to filter and convert the object you returned.

                /* The NbtAddress object used to query this node will be in the list
                 * returned by the Node Status. A new NbtAddress object should not be
                 * created for it because the original is potentially being actively
                 * referenced by other objects. We must populate the existing object's
                 * data explicitly (and carefully).

/**
 * Creates map entries using sample keys and sample values.
 *
 * @author Jesse Wilson
 */
@GwtCompatible
@NullMarked
public abstract class TestMapEntrySetGenerator<
        K extends @Nullable Object, V extends @Nullable Object>
    implements TestSetGenerator<Map.Entry<K, V>> {
  private final SampleElements<K> keys;
  private final SampleElements<V> values;