}
                }
            }
        }
    }
}
```

## Media types adicionais para o retorno principal { #additional-media-types-for-the-main-response }

Você pode utilizar o mesmo parâmetro `responses` para adicionar diferentes media types para o mesmo retorno principal.

pkg go/ast, func Preorder(Node) iter.Seq[Node] #66339
pkg go/types, method (*Alias) Origin() *Alias #67143
pkg go/types, method (*Alias) Rhs() Type #66559
pkg go/types, method (*Alias) SetTypeParams([]*TypeParam) #67143
pkg go/types, method (*Alias) TypeArgs() *TypeList #67143
pkg go/types, method (*Alias) TypeParams() *TypeParamList #67143
pkg go/types, method (*Func) Signature() *Signature #65772

    /**
     * Gets the packages/types to import from the parent realm.
     *
     * @return The modifiable list of packages/types to import from the parent realm, never {@code null}.
     */
    List<String> getParentImports();

    /**
     * Gets the packages/types to import from foreign realms.
     *
     * @return The modifiable map of packages/types to import from foreign realms, never {@code null}.
     */

     *
     * @return Array of arguments
     */
    public Object[] getMethodArgs() {
        return methodArgs;
    }

    /**
     * Returns the array of parameter types.
     *
     * @return Array of parameter types
     */
    public Class<?>[] getParamTypes() {
        return paramTypes;
    }

    private static String getSignature(final Object... methodArgs) {

		loadDriveMetrics)
}

func newCPUMetricsCache() *cachevalue.Cache[madmin.CPUMetrics] {
	loadCPUMetrics := func(ctx context.Context) (v madmin.CPUMetrics, err error) {
		types := madmin.MetricsCPU

		m := collectLocalMetrics(types, collectMetricsOpts{
			hosts: map[string]struct{}{
				globalLocalNodeName: {},
			},
		})

		for _, hm := range m.ByHost {
			if hm.CPU != nil {
				v = *hm.CPU

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.helper;

import org.lastaflute.web.util.LaRequestUtil;

/**
 * Helper class for detecting and categorizing user agent types from HTTP requests.
 * This class analyzes the User-Agent header to determine which browser type is being used
 * and caches the result in the request attribute for performance optimization.
 *
 */

	tb := t.current.Load()
	if tb != nil {
		tbb := *tb
		return tbb.Name()
	}
	return ""
}

func (t *testLogger) Endpoint() string {
	return ""
}

func (t *testLogger) Stats() types.TargetStats {
	return types.TargetStats{}
}

func (t *testLogger) Init(ctx context.Context) error {
	return nil
}

func (t *testLogger) IsOnline(ctx context.Context) bool {
	return t.current.Load() != nil
}

## Use `Annotated` no tipo do parâmetro `q` { #use-annotated-in-the-type-for-the-q-parameter }

Lembra que eu disse antes que `Annotated` pode ser usado para adicionar metadados aos seus parâmetros na [Introdução aos tipos do Python](../python-types.md#type-hints-with-metadata-annotations){.internal-link target=_blank}?

Agora é a hora de usá-lo com FastAPI. 🚀

Tínhamos esta anotação de tipo:

//// tab | Python 3.10+

```Python

If you need a 2 minute refresher of how to use Python types (even if you don't use FastAPI), check the short tutorial: [Python Types](python-types.md){.internal-link target=_blank}.

You write standard Python with types:

```Python
from datetime import date

from pydantic import BaseModel

# Declare a variable as a str

name: "Issue Labeler"
on:
  issues:
    types: [opened, edited, reopened]
  pull_request:
    types: [opened, edited, reopened]

jobs:
  triage:
    runs-on: ubuntu-latest
    name: Label issues and pull requests
    steps:
      - name: check out
        uses: actions/checkout@v4

      - name: labeler
        uses: jinzhu/super-labeler-action@develop
        with: