///

## Conversión de tipos de parámetros de query

También puedes declarar tipos `bool` y serán convertidos:

```Python hl_lines="9"
{!../../docs_src/query_params/tutorial003.py!}
```

En este caso, si vas a:

```
http://127.0.0.1:8000/items/foo?short=1

///

## Conversão dos tipos de parâmetros de consulta

Você também pode declarar tipos `bool`, e eles serão convertidos:

//// tab | Python 3.10+

```Python hl_lines="7"
{!> ../../docs_src/query_params/tutorial003_py310.py!}
```

////

 * Maven provides implementations of those types and may inject them in plugins.
 * <p>
 * A type can be marked {@link Consumer} or {@link Provider} but not both. A type is assumed to be
 * {@link Consumer} if it is not marked either {@link Consumer} or {@link Provider}.
 * <p>
 * A package can be marked {@link Provider}. In this case, all types in the package are considered

     * ({@value #JAR} or {@value #CLASSPATH_JAR} types), then the test artifact will also be placed on the class-path.
     * Otherwise, if the main artifact is placed on the module-path ({@value #JAR} or {@value #MODULAR_JAR} types),
     * then the test artifact will be added using {@code --patch-module} option.
     */
    String TEST_JAR = "test-jar";

And these models are all sharing a lot of the data and duplicating attribute names and types.

We could do better.

We can declare a `UserBase` model that serves as a base for our other models. And then we can make subclasses of that model that inherit its attributes (type declarations, validation, etc).

  pymdownx.tilde:

  # pymdownx blocks
  pymdownx.blocks.admonition:
    types:
    - note
    - attention
    - caution
    - danger
    - error
    - tip
    - hint
    - warning
    # Custom types
    - info
    - check
  pymdownx.blocks.details:
  pymdownx.blocks.tab:
    alternate_style: True

  # Other extensions

type any = interface{}

// comparable is an interface that is implemented by all comparable types
// (booleans, numbers, strings, pointers, channels, arrays of comparable types,
// structs whose fields are all comparable types).
// The comparable interface may only be used as a type parameter constraint,
// not as the type of a variable.
type comparable interface{ comparable }

package util

import (
	"context"
	"fmt"
	"net/netip"

	corev1 "k8s.io/api/core/v1"
	"k8s.io/apimachinery/pkg/api/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/types"
	"k8s.io/client-go/kubernetes"

	"istio.io/api/annotation"
	"istio.io/api/label"
	"istio.io/istio/pkg/config/constants"
)

var annotationPatch = []byte(fmt.Sprintf(
	`{"metadata":{"annotations":{"%s":"%s"}}}`,

    when (type) {
      // Special case types that have 0 or 1 flag.
      TYPE_SETTINGS, TYPE_PING -> return if (flags == FLAG_ACK) "ACK" else BINARY[flags]
      TYPE_PRIORITY, TYPE_RST_STREAM, TYPE_GOAWAY, TYPE_WINDOW_UPDATE -> return BINARY[flags]
    }
    val result = if (flags < FLAGS.size) FLAGS[flags]!! else BINARY[flags]
    // Special case types that have overlap flag values.
    return when {

  implementation("com.google.guava:guava:33.3.1-jre")

  // 2. Use Guava types in your public API:
  api("com.google.guava:guava:33.3.1-jre")

  // 3. Android - Use Guava in your implementation only:
  implementation("com.google.guava:guava:33.3.1-android")

  // 4. Android - Use Guava types in your public API:
  api("com.google.guava:guava:33.3.1-android")
}
```