* returned by {@link CacheLoader#loadAll} will be stored in the cache, over-writing any
   * previously cached values. This method will throw an exception if {@link CacheLoader#loadAll}
   * returns {@code null}, returns a map containing null keys or values, or fails to return an entry
   * for each requested key.
   *
   * <p>Note that duplicate elements in {@code keys}, as determined by {@link Object#equals}, will
   * be ignored.
   *

        failureCounts.remove(handle.getDirectoryPath());
    }

    /**
     * Process change notification response
     *
     * @param handle notification handle
     * @param outputBuffer response buffer containing FILE_NOTIFY_INFORMATION structures
     */
    public void processChangeNotification(ChangeNotificationHandle handle, byte[] outputBuffer) {
        if (outputBuffer == null || outputBuffer.length == 0) {

    }

    @Override
    public String toString() {
        return binding.toString();
    }

    /**
     * Sends a DCERPC fragment to the remote endpoint
     * @param buf the buffer containing the fragment
     * @param off the offset into the buffer
     * @param length the length of data to send
     * @param isDirect whether to use direct transmission
     * @throws IOException if an I/O error occurs

 */
public class DataStoreFactory {
    /** Logger instance for this factory class. */
    private static final Logger logger = LogManager.getLogger(DataStoreFactory.class);

    /**
     * Map containing registered data store instances indexed by their names and class simple names.
     * All keys are stored in lowercase for case-insensitive lookup.
     */
    protected Map<String, DataStore> dataStoreMap = new LinkedHashMap<>();

        public ChatSource() {
        }

        /**
         * Creates a new chat source from a document map.
         *
         * @param index the source index
         * @param doc the document map containing source data
         */
        public ChatSource(final int index, final Map<String, Object> doc) {
            this.index = index;
            String titleValue = toStringOrNull(doc.get("title"));

     */
    public Set<String> getHighlightedQuerySet() {
        return highlightedQuerySet != null ? highlightedQuerySet : new HashSet<>();
    }

    /**
     * Gets the field log map containing field names and their associated query terms.
     * @return The field log map, or empty map if not initialized.
     */
    public Map<String, List<String>> getFieldLogMap() {

    return createMaybeNavigableAsMap();
  }

  /**
   * {@inheritDoc}
   *
   * <p>Creates an empty {@code TreeSet} for a collection of values for one key.
   *
   * @return a new {@code TreeSet} containing a collection of values for one key
   */
  @Override
  SortedSet<V> createCollection() {
    return new TreeSet<>(valueComparator);
  }

  @Override

        offset += 4;

        return offset - start;
    }

    /**
     * Decode directory lease context from buffer
     *
     * @param buffer the buffer containing the context data
     * @param offset offset in the buffer
     * @param length length of the context data
     */
    public void decode(byte[] buffer, int offset, int length) {

It receives a `dict`: the keys are status codes for each response (like `200`), and the values are other `dict`s with the information for each of them.

Each of those response `dict`s can have a key `model`, containing a Pydantic model, just like `response_model`.

**FastAPI** will take that model, generate its JSON Schema and include it in the correct place in OpenAPI.

    extends AbstractMultimap<K, V> implements ListMultimap<K, V>, Serializable {
  /*
   * Order is maintained using a linked list containing all key-value pairs. In
   * addition, a series of disjoint linked lists of "siblings", each containing
   * the values for a specific key, is used to implement {@link
   * ValueForKeyIterator} in constant time.
   */