):
    return [item, sub_item]


@app.post("/with-duplicates")
async def with_duplicates(item: Item, item2: Item = Depends(duplicate_dependency)):
    return [item, item2]


@app.post("/no-duplicates")
async def no_duplicates(item: Item, item2: Item = Depends(dependency)):
    return [item, item2]


@app.post("/with-duplicates-sub")
async def no_duplicates_sub(

  /**
   * Constructs a new entry array where each duplicated key from the original appears only once, at
   * its first position but with its final value. The {@code duplicates} map is modified.
   *
   * @param entries the original array of entries including duplicates
   * @param n the number of valid entries in {@code entries}
   * @param newN the expected number of entries once duplicates are removed

            @Override
            public String[] getRoles(LdapUser user, String baseDn, String accountFilter, String groupFilter, Consumer<String[]> callback) {
                // Return roles with duplicates
                String[] roles = new String[] { "role1", "role2", "role1", "Uuser", "role2" };
                callback.accept(roles);
                return roles;
            }

            @Override

        }
    }

    @Override
    public List<String> convert(final String text, final String field, final String... lang) throws IOException {
        // Use LinkedHashSet to maintain insertion order while eliminating duplicates
        final Set<String> resultSet = new LinkedHashSet<>();
        if (text != null) {
            resultSet.add(text);
        }

        // Start with the original text as the first input

        urls.add("http://example.com/page1"); // Duplicate
        urls.add("http://example.com/page3");
        urls.add("http://example.com/page2"); // Duplicate

        Set<RequestData> result = crawlerThread.getAnchorSet(urls);
        assertNotNull(result, "getAnchorSet should handle duplicates");

        // Since it returns a Set, duplicates should be handled by URL comparison

* `frozenset`:
    * In requests and responses, treated the same as a `set`:
        * In requests, a list will be read, eliminating duplicates and converting it to a `set`.
        * In responses, the `set` will be converted to a `list`.
        * The generated schema will specify that the `set` values are unique (using JSON Schema's `uniqueItems`).
* `bytes`:

            processor.register(new TestSearcherWithFixedIds("doc2", "doc3", "doc4")); // Some duplicates
            processor.init();

            final List<Map<String, Object>> results = processor.search("*", new TestSearchRequestParams(0, 10, 0), OptionalThing.empty());
            assertNotNull(results);
            // RRF should merge duplicates and boost their scores
        }
    }

    /**

   *
   * <p>Some algorithms that operate on a {@code PredecessorsFunction} may produce undesired results
   * if the returned {@link Iterable} contains duplicate elements. Implementations of such
   * algorithms should document their behavior in the presence of duplicates.
   *
   * <p>The elements of the returned {@code Iterable} must each be:
   *
   * <ul>
   *   <li>Non-null

   *
   * <p>Some algorithms that operate on a {@code SuccessorsFunction} may produce undesired results
   * if the returned {@link Iterable} contains duplicate elements. Implementations of such
   * algorithms should document their behavior in the presence of duplicates.
   *
   * <p>The elements of the returned {@code Iterable} must each be:
   *
   * <ul>
   *   <li>Non-null

        return SuggestItemSerializer.toUpdatedSource(this, existingSource);
    }

    /**
     * Concatenates values to a destination list, avoiding duplicates.
     * @param dest The destination list.
     * @param newValues The new values to add.
     * @param <T> The type of the values.
     */