# Path Operation Configuration

There are several parameters that you can pass to your *path operation decorator* to configure it.

!!! warning
    Notice that these parameters are passed directly to the *path operation decorator*, not to your *path operation function*.

## Response Status Code

You can define the (HTTP) `status_code` to be used in the response of your *path operation*.

You can pass directly the `int` code, like `404`.

      algorithmParameters,
      decompose = {
        listOf(
          it.algorithm,
          it.parameters,
        )
      },
      construct = {
        AlgorithmIdentifier(
          algorithm = it[0] as String,
          parameters = it[1],
        )
      },
    )

  /**
   * ```
   * BasicConstraints ::= SEQUENCE {

            override fun publish(record: LogRecord) {
              super.publish(record)

              val parameters = record.parameters
              if (sslDebug && record.loggerName == "javax.net.ssl" && parameters != null) {
                System.err.println(parameters[0])
              }
            }
          }

        if (debug) {
          handler.level = Level.ALL

            options.release = null
            options.compilerArgs.remove("-parameters")
            sourceCompatibility = "$majorVersion"
            targetCompatibility = "$majorVersion"
        }
        // Apply ParameterNamesIndex since 6 doesn't support -parameters
        project.apply(plugin = "gradlebuild.api-parameter-names-index")
    }

    failureConditions.supportTestRetry = false

    val extraParameters = functionalTestExtraParameters("RerunFlakyTest", os, arch, "%$testJvmVersionParameter%", "%$testJvmVendorParameter%")
    val parameters = (
        buildToolGradleParameters(daemon) +
            listOf(extraParameters) +
            functionalTestParameters(os)
        ).joinToString(separator = " ")

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
          val parameters = sslSocket.sslParameters
          val sni = parameters.serverNames
          Log.d("CustomSSLSocketFactory", "old SNI: $sni")
          parameters.serverNames = mutableListOf<SNIServerName>(SNIHostName("cloudflare-dns.com"))
          sslSocket.sslParameters = parameters
        }

        return sslSocket
      }
    }

    client =

# Path Parameters and Numeric Validations

In the same way that you can declare more validations and metadata for query parameters with `Query`, you can declare the same type of validations and metadata for path parameters with `Path`.

## Import Path

First, import `Path` from `fastapi`, and import `Annotated`:

=== "Python 3.10+"

    ```Python hl_lines="1  3"
    {!> ../../../docs_src/path_params_numeric_validations/tutorial001_an_py310.py!}
    ```

    ```

    as it will use that `None` as the default value, and that way make the parameter **not required**.

    The `Union[str, None]` part allows your editor to provide better support, but it is not what tells FastAPI that this parameter is not required.

Then, we can pass more parameters to `Query`. In this case, the `max_length` parameter that applies to strings:

```Python

# Header Parameters

You can define Header parameters the same way you define `Query`, `Path` and `Cookie` parameters.

## Import `Header`

First import `Header`:

=== "Python 3.10+"

    ```Python hl_lines="3"
    {!> ../../../docs_src/header_params/tutorial001_an_py310.py!}
    ```

=== "Python 3.9+"

    ```Python hl_lines="3"
    {!> ../../../docs_src/header_params/tutorial001_an_py39.py!}
    ```

=== "Python 3.8+"

        val packageName: Property<String>
        val destDir: DirectoryProperty
    }

    override fun execute() {
        val packageName = parameters.packageName.get()
        val sourceRootDirectory = parameters.destDir.get()
        val packageNamePath = packageName.replace(".", File.separator)
        val packageDirectory = sourceRootDirectory.file(packageNamePath).asFile