override fun source() = buffer()

  override fun read(
    sink: Buffer,
    byteCount: Long,
  ): Long =
    throw IllegalStateException(
      """
      |Unreadable ResponseBody! These Response objects have bodies that are stripped:
      | * Response.cacheResponse
      | * Response.networkResponse
      | * Response.priorResponse
      | * EventSourceListener
      | * WebSocketListener

import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * The {@code ThreadSafe} annotation can be used to indicate a given type
 * is thread safe.  {@link Immutable} objects are automatically thread safe.
 *
 * @see Immutable
 * @see NotThreadSafe
 * @since 4.0.0
 */
@Experimental
@Documented
@Retention(RetentionPolicy.CLASS)
@Target(ElementType.TYPE)

    }

    /**
     * Compares two {@code NtlmPasswordAuthentication} objects for
     * equality. Two {@code NtlmPasswordAuthentication} objects are equal if
     * their caseless domain and username fields are equal and either both hashes are external and they are equal or
     * both internally supplied passwords are equal. If one {@code NtlmPasswordAuthentication} object has external

		// if uv has tiered content we add a
		// free-version to track it for asynchronous
		// deletion via scanner.
		ver, err := x.getIdx(i)
		if err != nil {
			return err
		}

		if freeVersion, toFree := ver.ObjectV2.InitFreeVersion(fi); toFree {
			return x.addVersion(freeVersion)
		}
		return nil
	}
	return nil

    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        InputSource that = (InputSource) o;
        return java.util.Objects.equals(modelId, that.modelId)
                && java.util.Objects.equals(location, that.location)

   * @return the stripes corresponding to the objects (one per each object, derived by delegating to
   *     {@link #get(Object)}; may contain duplicates), in an increasing index order.
   */
  public Iterable<L> bulkGet(Iterable<? extends Object> keys) {
    // Initially using the list to store the keys, then reusing it to store the respective L's
    List<Object> result = newArrayList(keys);
    if (result.isEmpty()) {

    /** The object name is invalid */
    int NT_STATUS_OBJECT_NAME_INVALID = 0xC0000033;
    /** The object was not found */
    int NT_STATUS_OBJECT_NAME_NOT_FOUND = 0xC0000034;
    /** The object name already exists */
    int NT_STATUS_OBJECT_NAME_COLLISION = 0xC0000035;
    /** The port is disconnected */
    int NT_STATUS_PORT_DISCONNECTED = 0xC0000037;
    /** The object path is invalid */

            }
            return new ByteArrayOutputStream();
        }
    }

    /**
     * Creates an OutputStream from a ToXContent object with the specified media type.
     *
     * @param xContent the content object to convert
     * @param mediaType the media type for the output
     * @return an OutputStream containing the converted content
     */

            This is mainly a hack for compatibility with SQLAlchemy objects, they
            store internal SQLAlchemy-specific state in attributes named with `_sa`,
            and those objects can't (and shouldn't be) serialized to JSON.
            """
        ),
    ] = True,
) -> Any:
    """
    Convert any object to something that can be encoded in JSON.

For example, it doesn't receive `datetime` objects, as those are not compatible with JSON.

So, a `datetime` object would have to be converted to a `str` containing the data in <a href="https://en.wikipedia.org/wiki/ISO_8601" class="external-link" target="_blank">ISO format</a>.

The same way, this database wouldn't receive a Pydantic model (an object with attributes), only a `dict`.

You can use `jsonable_encoder` for that.