sqlalchemy_safe=sqlalchemy_safe,
        )
    if isinstance(obj, Enum):
        return obj.value
    if isinstance(obj, PurePath):
        return str(obj)
    if isinstance(obj, (str, int, float, type(None))):
        return obj
    if isinstance(obj, PydanticUndefinedType):
        return None
    if isinstance(obj, dict):
        encoded_dict = {}
        allowed_keys = set(obj.keys())

    callback_flat_models: list[ModelField] = []
    for route in routes:
        if getattr(route, "include_in_schema", None) and isinstance(
            route, routing.APIRoute
        ):
            if route.body_field:
                assert isinstance(route.body_field, ModelField), (
                    "A request body must be a Pydantic Field"
                )

    alias = alias or get_validation_alias(field)
    if is_sequence_field(field) and isinstance(values, (ImmutableMultiDict, Headers)):
        value = values.getlist(alias)
    else:
        value = values.get(alias, None)
    if (
        value is None
        or (
            isinstance(field.field_info, params.Form)
            and isinstance(value, str)  # For type checks
            and value == ""
        )

            value = schema["$ref"]
            if isinstance(value, str):
                ref_name = schema["$ref"].split("/")[-1]
                if ref_name in old_name_to_new_name_map:
                    new_name = old_name_to_new_name_map[ref_name]
                    new_schema["$ref"] = REF_TEMPLATE.format(model=new_name)
            continue
        if isinstance(value, dict):
            new_schema[key] = _replace_refs(

        final Type t3 = m3.getGenericReturnType();
        assertThat(GenericsUtil.isTypeOf(t3, Map.class), is(true));
        assertThat(WildcardType.class.isInstance(GenericsUtil.getKeyTypeOfMap(t3)), is(true));
        assertThat(WildcardType.class.isInstance(GenericsUtil.getValueTypeOfMap(t3)), is(true));
    }

    /**
     * @throws Exception
     */
    public void testGetTypeVariableMap() throws Exception {

   * This does perform a little more work than necessary, so another option is to insert an
   * unchecked cast at some later point:
   *
   * {@snippet :
   * @SuppressWarnings("unchecked") // safe because of ::isInstance check
   * ImmutableList<NewType> result =
   *     (ImmutableList) stream.filter(NewType.class::isInstance).collect(toImmutableList());
   * }
   */

   *
   * <p><b>Discouraged:</b> Prefer using {@code clazz::isInstance} or {@code x -> x instanceof
   * Clazz}, but note that lambdas do not have human-readable {@link #toString()} representations
   * and are not serializable.
   */
  @GwtIncompatible // Class.isInstance
  public static <T extends @Nullable Object> Predicate<T> instanceOf(Class<?> clazz) {

                stacklevel=4,
            )
        current_json_schema_extra = json_schema_extra or extra
        kwargs["deprecated"] = deprecated

        if serialization_alias in (_Unset, None) and isinstance(alias, str):
            serialization_alias = alias
        if validation_alias in (_Unset, None):
            validation_alias = alias
        kwargs.update(
            {

        // Act & Assert
        // unwrap to interface itself should return same instance
        CredentialsInternal unwrapped = creds.unwrap(CredentialsInternal.class);
        assertNotNull(unwrapped, "unwrap to CredentialsInternal returns instance");
        assertSame(creds, unwrapped, "unwrap returns the same object instance");

        // unwrap to unrelated type should return null (use another Credentials implementation)

   * This does perform a little more work than necessary, so another option is to insert an
   * unchecked cast at some later point:
   *
   * {@snippet :
   * @SuppressWarnings("unchecked") // safe because of ::isInstance check
   * ImmutableList<NewType> result =
   *     (ImmutableList) stream.filter(NewType.class::isInstance).collect(toImmutableList());
   * }
   */