"Item": {
                    "title": "Item",
                    "required": IsOneOf(
                        ["name", "description", "price", "tax"],
                        # TODO: remove when deprecating Pydantic v1
                        ["name", "price"],
                    ),
                    "type": "object",
                    "properties": {

    }

    @Override
    public Object put(final String key, final Object value) {
        return parent.put(key, value);
    }

    @Override
    public Object remove(final Object key) {
        return parent.remove(key);
    }

    @Override
    public void putAll(final Map<? extends String, ? extends Object> m) {
        parent.putAll(m);
    }

    @Override
    public void clear() {

   *
   * <p>Calls to {@code peek()} should not change the state of the iteration, except that it
   * <i>may</i> prevent removal of the most recent element via {@link #remove()}.
   *
   * @throws NoSuchElementException if the iteration has no more elements according to {@link
   *     #hasNext()}
   */
  @ParametricNullness
  E peek();

  /**
   * {@inheritDoc}
   *

            float.class,
            int.class,
            long.class,
            short.class,
            void.class);

    assertThrows(UnsupportedOperationException.class, () -> primitives.remove(boolean.class));
  }

  public void testAllWrapperTypes() {
    Set<Class<?>> wrappers = Primitives.allWrapperTypes();
    assertThat(wrappers)
        .containsExactly(
            Boolean.class,

  @CheckForNull
  public V putIfAbsent(K key, V value) {
    return delegate().putIfAbsent(key, value);
  }

  @CanIgnoreReturnValue
  @Override
  public boolean remove(@CheckForNull Object key, @CheckForNull Object value) {
    return delegate().remove(key, value);
  }

  @CanIgnoreReturnValue
  @Override
  @CheckForNull
  public V replace(K key, V value) {
    return delegate().replace(key, value);
  }

   */
  N adjacentNode(E edge);

  /**
   * Remove {@code edge} from the set of incoming edges. Returns the former predecessor node.
   *
   * <p>In the undirected case, returns {@code null} if {@code isSelfLoop} is true.
   */
  @CanIgnoreReturnValue
  @CheckForNull
  N removeInEdge(E edge, boolean isSelfLoop);

  /** Remove {@code edge} from the set of outgoing edges. Returns the former successor node. */

        return map.containsKey(o);
    }

    @Override
    public boolean add(final String o) {
        return map.put(o, PRESENT) == null;
    }

    @Override
    public boolean remove(final Object o) {
        return map.remove(o) == PRESENT;
    }

    @Override
    public void clear() {
        map.clear();
    }

          }

          @Override
          public T next() {
            return listIter.previous();
          }

          @Override
          public void remove() {
            listIter.remove();
          }
        };
      }
    };
  }

  static <T extends @Nullable Object> Iterator<T> cycle(Iterable<T> iterable) {
    return new Iterator<T>() {

    map.put(one, two);
    map.remove(one);
    assertNotified(listener, one, two, RemovalCause.EXPLICIT);

    map.put(two, three);
    map.remove(two, three);
    assertNotified(listener, two, three, RemovalCause.EXPLICIT);

    map.put(three, four);
    Iterator<?> i = map.entrySet().iterator();
    i.next();
    i.remove();
    assertNotified(listener, three, four, RemovalCause.EXPLICIT);

    map.put(3, "d");
    map.put(2, "c");
    map.remove(1);
    testHasMapEntriesInOrder(map, 4, "b", 3, "d", 2, "c");
  }

  public void testInsertionOrderAfterRemoveMiddleEntry() {
    Map<Integer, String> map = CompactLinkedHashMap.create();
    map.put(1, "a");
    map.put(4, "b");
    map.put(3, "d");
    map.put(2, "c");
    map.remove(4);
    testHasMapEntriesInOrder(map, 1, "a", 3, "d", 2, "c");
  }