Bir API oluştururken, "yol", "kaynaklar" ile "endişeleri" ayırmanın ana yöntemidir.

#### Operasyonlar

Burada "operasyon" HTTP "metodlarından" birini ifade eder.

Bunlardan biri:

* `POST`
* `GET`
* `PUT`
* `DELETE`

...veya daha az kullanılan diğerleri:

* `OPTIONS`
* `HEAD`
* `PATCH`
* `TRACE`

    name: str
    description: Union[str, None] = None
    price: float
    tax: Union[float, None] = None


class User(BaseModel):
    username: str
    full_name: Union[str, None] = None


@app.put("/items/{item_id}")
async def update_item(
    item_id: int, item: Item, user: User, importance: Annotated[int, Body()]
):
    results = {"item_id": item_id, "item": item, "user": user, "importance": importance}

from datetime import datetime, time, timedelta
from typing import Annotated, Union
from uuid import UUID

from fastapi import Body, FastAPI

app = FastAPI()


@app.put("/items/{item_id}")
async def read_items(
    item_id: UUID,
    start_datetime: Annotated[datetime, Body()],
    end_datetime: Annotated[datetime, Body()],
    process_after: Annotated[timedelta, Body()],
    repeat_at: Annotated[Union[time, None], Body()] = None,
):

  public void testEquals() {
    resetContainer(mapEntry(k0(), v0()), mapEntry(k1(), v0()), mapEntry(k0(), v3()));
    Map<K, Collection<V>> expected = Maps.newHashMap();
    expected.put(k0(), newHashSet(v0(), v3()));
    expected.put(k1(), newHashSet(v0()));
    new EqualsTester().addEqualityGroup(expected, multimap().asMap()).testEquals();
  }

  @CollectionSize.Require(SEVERAL)
  public void testEntrySetEquals() {

  @Override
  public boolean isEmpty() {
    return delegate().isEmpty();
  }

  @CanIgnoreReturnValue
  @Override
  @CheckForNull
  public V put(
      @ParametricNullness R rowKey, @ParametricNullness C columnKey, @ParametricNullness V value) {
    return delegate().put(rowKey, columnKey, value);
  }

  @Override
  public void putAll(Table<? extends R, ? extends C, ? extends V> table) {
    delegate().putAll(table);

            if (transferred == null) {
                transferred = (long) length;
            } else {
                transferred = transferred + length;
            }
            transfers.put(transferEvent.getResource(), transferred);
        }

        ArtifactTransferEvent event = wrap(transferEvent);
        event.setDataBuffer(buffer);
        event.setDataOffset(0);

                    if (queryMap == null) {
                        queryMap = new HashMap<>();
                        keyMatchQueryMap.put(virtualHost, queryMap);
                    }
                    final String termKey = toLowerCase(keyMatch.getTerm());

                    return null;
                })).status(ApiResult.Status.OK).result());
    }

    // PUT /api/admin/dict/mapping/setting/{dictId}
    @Execute
    public JsonResponse<ApiResult> put$setting(final String dictId, final CreateBody body) {
        body.dictId = dictId;
        validateApi(body, messages -> {});
        body.crudMode = CrudMode.CREATE;

                    return null;
                })).status(ApiResult.Status.OK).result());
    }

    // PUT /api/admin/dict/stemmerOverride/setting/{dictId}
    @Execute
    public JsonResponse<ApiResult> put$setting(final String dictId, final CreateBody body) {
        body.dictId = dictId;
        validateApi(body, messages -> {});
        body.crudMode = CrudMode.CREATE;

        Map<String, Artifact> artifactMap = new LinkedHashMap<>();

        if (artifacts != null) {
            for (Artifact artifact : artifacts) {
                artifactMap.put(versionlessKey(artifact), artifact);
            }
        }

        return artifactMap;
    }

    public static Artifact copyArtifactSafe(Artifact artifact) {