And it can return anything you want.

In this case, this dependency expects:

* An optional query parameter `q` that is a `str`.
* An optional query parameter `skip` that is an `int`, and by default is `0`.
* An optional query parameter `limit` that is an `int`, and by default is `100`.

And then it just returns a `dict` containing those values.

/// info

* Якщо параметр оголошується як тип **Pydantic моделі**, він інтерпретується як **тіло** запиту.

/// note

FastAPI буде знати, що значення "q" не є обов'язковим через значення за замовчуванням "= None".

`Optional` у `Optional[str]` не використовується FastAPI, але дозволить вашому редактору надати вам кращу підтримку та виявляти помилки.

///

## Без Pydantic

* Créer un répertoire `app` et y entrer.
* Créez un fichier `main.py` avec :

```Python
from typing import Optional

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: Optional[str] = None):
    return {"item_id": item_id, "q": q}
```

            Artifact artifact = (Artifact) iter.next();
            System.out.println("Artifact: " + artifact.getDependencyConflictId() + " " + artifact.getVersion()
                    + " Optional=" + (artifact.isOptional() ? "true" : "false"));
            assertTrue(
                    artifact.getVersion().equals("1.0"), "Incorrect version for " + artifact.getDependencyConflictId());
        }
    }

      this.path = checkNotNull(path);
      this.options = options.clone();
      this.followLinks = followLinks(this.options);
      // TODO(cgdecker): validate the provided options... for example, just WRITE seems wrong
    }

    private static boolean followLinks(OpenOption[] options) {
      for (OpenOption option : options) {
        if (option == NOFOLLOW_LINKS) {
          return false;
        }
      }

    return new PathByteSource(path, options);
  }

  private static final class PathByteSource extends
      ByteSource
  {

    private static final LinkOption[] FOLLOW_LINKS = {};

    private final Path path;
    private final OpenOption[] options;
    private final boolean followLinks;

    private PathByteSource(Path path, OpenOption... options) {
      this.path = checkNotNull(path);

import org.codelibs.core.lang.ThreadUtil;
import org.codelibs.fess.es.config.bsbhv.BsScheduledJobBhv;
import org.codelibs.fess.es.config.exentity.ScheduledJob;
import org.codelibs.fess.util.ComponentUtil;
import org.dbflute.optional.OptionalEntity;

/**
 * @author FreeGen
 */
public class ScheduledJobBhv extends BsScheduledJobBhv {

    private static final Logger logger = LogManager.getLogger(ScheduledJobBhv.class);

func NewRemoteErrf(format string, a ...any) *RemoteErr {
	r := RemoteErr(fmt.Sprintf(format, a...))
	return &r
}

// NewNPErr is a helper to no payload and optional remote error.
// The error type is not preserved.
func NewNPErr(err error) (NoPayload, *RemoteErr) {
	if err == nil {
		return NoPayload{}, nil
	}
	r := RemoteErr(err.Error())
	return NoPayload{}, &r
}

	m        *Monitor
	opts     *MonitorReaderOptions
}

// BucketOptions represents the bucket and optionally its replication target pair.
type BucketOptions struct {
	Name           string
	ReplicationARN string // This is optional, and not mandatory.
}

// MonitorReaderOptions provides configurable options for monitor reader implementation.
type MonitorReaderOptions struct {
	BucketOptions
	HeaderSize int
}

import com.google.common.annotations.GwtCompatible;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.Set;

/**
 * Optional features of classes derived from {@code Set}.
 *
 * @author George van den Driessche
 */
@SuppressWarnings("rawtypes") // maybe avoidable if we rework the whole package?
@GwtCompatible