}

    /**
     * Sorts the given list of [AcceptedApiChange]s by type and member.
     * <p>
     * This sort ought to remain consistent with the sort used by the [EnrichedReportRenderer].
     */
    @Suppress("KDocUnresolvedReference")
    protected
    fun sortChanges(originalChanges: List<AcceptedApiChange>) = originalChanges.toMutableList().sortedBy { it.type + '#' + it.member }

    }

    private static void addZeroTokens(List<String> tokens, int max) {
        while (tokens.size() < max) {
            tokens.add("0");
        }
    }

    private static boolean isRange(String value) {
        return value.startsWith("[") || value.startsWith("(");
    }

    private static List<RangeValue> getRange(String range) {
        List<RangeValue> ranges = new ArrayList<>();

            values[key] = value
    return values


async def request_body_to_args(
    body_fields: List[ModelField],
    received_body: Optional[Union[Dict[str, Any], FormData]],
    embed_body_fields: bool,
) -> Tuple[Dict[str, Any], List[Dict[str, Any]]]:
    values: Dict[str, Any] = {}
    errors: List[Dict[str, Any]] = []
    assert body_fields, "request_body_to_args() should be called with fields"

      protected Multiset<String> create(String[] elements) {
        return unmodifiableMultiset(LinkedHashMultiset.create(asList(elements)));
      }

      @Override
      public List<String> order(List<String> insertionOrder) {
        List<String> order = new ArrayList<>();
        for (String s : insertionOrder) {
          int index = order.indexOf(s);
          if (index == -1) {
            order.add(s);
          } else {

        private final Logger logger;
        private final List<ValueSource> valueSources;
        private final List<InterpolationPostProcessor> postProcessors;

        InterpolateObjectAction(
                Object target,
                List<ValueSource> valueSources,
                List<InterpolationPostProcessor> postProcessors,
                boolean debugEnabled,

     */
    @Nonnull
    List<Exception> getExceptions();

    /**
     * Gets the root node of the dependency graph.
     *
     * @return the root node of the dependency graph or {@code null} if none
     */
    @Nullable
    Node getRoot();

    /**
     * The ordered list of the flattened dependency nodes.
     *
     * @return the ordered list of the flattened dependency nodes
     */

from typing import List, Union

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    description: Union[str, None] = None
    price: float
    tax: Union[float, None] = None
    tags: List[str] = []


@app.post("/items/")
async def create_item(item: Item) -> Item:
    return item


@app.get("/items/")
async def read_items() -> List[Item]:

        } else {
            if (value instanceof final Collection<?> coll && !coll.isEmpty()) {
                // care performance for List that the most frequent pattern
                final Object first = coll instanceof List<?> ? ((List<?>) coll).get(0) : coll.iterator().next();
                if (first instanceof Entity) {

@Deprecated(since = "4.0.0")
class DefaultSettingsBuildingResult implements SettingsBuildingResult {

    private Settings effectiveSettings;

    private List<SettingsProblem> problems;

    DefaultSettingsBuildingResult(Settings effectiveSettings, List<SettingsProblem> problems) {
        this.effectiveSettings = effectiveSettings;
        this.problems = (problems != null) ? problems : new ArrayList<>();
    }

    @Override

package org.codelibs.fess.suggest.index;

import java.util.ArrayList;
import java.util.List;

import org.codelibs.fess.suggest.request.Response;

public class SuggestIndexResponse implements Response {
    protected final int numberOfSuggestDocs;
    protected final int numberOfInputDocs;
    protected final boolean hasError;
    protected final List<Throwable> errors = new ArrayList<>();
    protected final long took;