KaPsiBasedSymbolPointer.createForSymbolFromSource<KaDestructuringDeclarationSymbol>(this)?.let { return it }
        throw CanNotCreateSymbolPointerForLocalLibraryDeclarationException(SpecialNames.DESTRUCT.asString())
    }

    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        return other is KaFe10PsiDestructuringDeclarationSymbol && other.psi == this.psi
    }

}

// IncomparableField returns an incomparable Field of struct Type t, if any.
func IncomparableField(t *Type) *Field {
	for _, f := range t.Fields() {
		if !IsComparable(f.Type) {
			return f
		}
	}
	return nil
}

// IsPaddedField reports whether the i'th field of struct type t is followed
// by padding.
func IsPaddedField(t *Type, i int) bool {
	if !t.IsStruct() {
		base.Fatalf("IsPaddedField called non-struct %v", t)

} t_my_union;
typedef enum my_enum {
	e1 = 1,
	e2 = 2,
	e3 = -5,
	e4 = 1000000000000000LL,
} t_my_enum;

typedef struct list t_my_list;
struct list {
	short val;
	t_my_list *next;
};

typedef struct tree {
	struct tree *left, *right;
	unsigned long long val;
} t_my_tree;

t_ptr_volatile_int *a2;
t_ptr_const_char **a3a;
t_long *a4;
t_ushort *a5;
t_func_int_of_float_double *a6;

            return type?.toKtType(analysisContext) ?: createErrorType()
        }

    override val name: Name
        get() = withValidityAssertion {
            if (psi.destructuringDeclaration != null) SpecialNames.DESTRUCT
            else psi.nameAsSafeName
        }

    override fun createPointer(): KaSymbolPointer<KaValueParameterSymbol> = withValidityAssertion {

If you declare it as is, because it is a singular value, **FastAPI** will assume that it is a query parameter.

But you can instruct **FastAPI** to treat it as another body key using `Body`:

=== "Python 3.10+"

    ```Python hl_lines="23"
    {!> ../../../docs_src/body_multiple_params/tutorial003_an_py310.py!}
    ```

	_If          // if
	_Import      // import
	_Interface   // interface
	_Map         // map
	_Package     // package
	_Range       // range
	_Return      // return
	_Select      // select
	_Struct      // struct
	_Switch      // switch
	_Type        // type
	_Var         // var

	// empty line comment to exclude it from .String
	tokenCount //
)

const (
	// for BranchStmt
	Break       = _Break

 *
 * In short, we want TeamCity to be aware of the test execution data (which tests are executed and how long they are),
 * even when the Test task is `FROM-CACHE` or `UP-TO-DATE`. This build service will output a service message to instruct TeamCity to read JUnit test result XMLs.
 *
 * See https://www.jetbrains.com/help/teamcity/service-messages.html#Importing+XML+Reports
 */
@DisableCachingByDefault(because = "It outputs a TeamCity service message")

}

// IsSlice reports whether value is a slice type.
func IsSlice(value any) bool {
	return kindOf(value) == reflect.Slice
}

// IsStruct reports whether value is a struct type
func IsStruct(value any) bool {
	return kindOf(value) == reflect.Struct
}

// IsSlicePtr reports whether v is a slice ptr type.
func IsSlicePtr(v any) bool {

   * doesn't work: Because nullness analyses typically infer the nullness of local variables,
   * there's no way to assign a {@code @Nullable T} to a field {@code T foo;} and instruct the
   * analysis that that means "plain {@code T}" rather than the inferred type {@code @Nullable T}.
   * (Even if supported added {@code @NonNull}, that would not help, since the problem case

		Config: adsc.Config{
			Meta: model.NodeMetadata{
				Generator:      "event",
				ServiceAccount: serviceAccount,
				Namespace:      ns,
				CloudrunAddr:   opts.IstiodAddr,
			}.ToStruct(),
			CertDir:            opts.CertDir,
			InsecureSkipVerify: opts.InsecureSkipVerify,
			XDSSAN:             opts.XDSSAN,
			GrpcOpts:           grpcOpts,
		},
	}, nil)
	if err != nil {