},
				VendorExtensible: spec.VendorExtensible{Extensions: map[string]interface{}{
					extListType: listTypeSet,
				}}},
			query:    map[string]interface{}{},
			expected: nil,
		},
		{
			name: "no keys",
			sts: &spec.Schema{
				SchemaProps: spec.SchemaProps{
					Type: []string{"array"},
				}},
			query:    map[string]interface{}{},
			expected: nil,
		},
		{
			name: "single key",

  void invalidate(@CompatibleWith("K") Object key);

  /**
   * Discards any cached values for keys {@code keys}.
   *
   * @since 11.0
   */
  // For discussion of <? extends Object>, see getAllPresent.
  void invalidateAll(Iterable<? extends Object> keys);

  /** Discards all entries in the cache. */
  void invalidateAll();

import java.util.SortedMap;
import java.util.SortedSet;
import javax.annotation.CheckForNull;

/**
 * Implementation of {@code Table} whose iteration ordering across row keys is sorted by their
 * natural ordering or by a supplied comparator. Note that iterations across the columns keys for a
 * single row key may or may not be ordered, depending on the implementation. When rows and columns

	Metric      string
	Aggregation string
	Labels      map[string]string
}

func (q Query) String() string {
	query := q.Metric + `{`

	keys := []string{}
	for k := range q.Labels {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	for _, k := range keys {
		v := q.Labels[k]
		query += fmt.Sprintf(`%s=%q,`, k, v)
	}
	query += "}"
	if q.Aggregation != "" {

// Registered enumerates the names of all registered plugins.
func (ps *Plugins) Registered() []string {
	ps.lock.Lock()
	defer ps.lock.Unlock()
	keys := []string{}
	for k := range ps.registry {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	return keys
}

// Register registers a plugin Factory by name. This
// is expected to happen during app startup.
func (ps *Plugins) Register(name string, plugin Factory) {

type OpenIDMetadataServer struct {
	configJSON []byte
	keysetJSON []byte
}

// NewOpenIDMetadataServer creates a new OpenIDMetadataServer.
// The issuer is the OIDC issuer; keys are the keys that may be used to sign
// KSA tokens.
func NewOpenIDMetadataServer(configJSON, keysetJSON []byte) *OpenIDMetadataServer {
	return &OpenIDMetadataServer{
		configJSON: configJSON,
		keysetJSON: keysetJSON,
	}
}

// GetByIP implements Index.
func (i *index) GetByIP(ip string) []*model.WorkloadInstance {
	i.mu.RLock()
	defer i.mu.RUnlock()

	keys := i.ipToKeys[ip]
	if len(keys) == 0 {
		return nil
	}
	instances := make([]*model.WorkloadInstance, 0, len(keys))
	for _, key := range sets.SortedList(keys) {
		if instance, exists := i.keyToInstance[key]; exists {
			instances = append(instances, instance)
		}
	}
	return instances

import java.util.SortedMap;
import java.util.SortedSet;
import javax.annotation.CheckForNull;

/**
 * Implementation of {@code Table} whose iteration ordering across row keys is sorted by their
 * natural ordering or by a supplied comparator. Note that iterations across the columns keys for a
 * single row key may or may not be ordered, depending on the implementation. When rows and columns

}

// lookupLabelValue returns the value of the first label in the supplied map that matches
// one of the supplied keys.
func lookupLabelValue(labels map[string]string, keys ...string) (string, bool) {
	for _, key := range keys {
		if value, ok := labels[key]; ok {
			return value, true
		}
	}
	return "", false
}

func HasCanonicalServiceName(labels map[string]string) bool {

You can also declare a body as a `dict` with keys of some type and values of some other type.

This way, you don't have to know beforehand what the valid field/attribute names are (as would be the case with Pydantic models).

This would be useful if you want to receive keys that you don't already know.

---

Another useful case is when you want to have keys of another type (e.g., `int`).