// shutdown in progress
		return http.ErrServerClosed
	}

	// Close underneath HTTP listener.
	srv.listenerMutex.Lock()
	err := srv.listener.Close()
	srv.listenerMutex.Unlock()
	if err != nil {
		return err
	}

	// Wait for opened connection to be closed up to Shutdown timeout.
	return nil
}

// UseIdleTimeout configure idle connection timeout

            }
        }
    }

    /**
     * Closes the underlying CrawlerClient and releases any resources associated with it.
     *
     * @throws Exception if an error occurs during the close operation
     */
    @Override
    public void close() throws Exception {
        client.close();
    }

    /**
     * Returns the underlying CrawlerClient.

	// Stores any error while removing a target or while sending an event.
	Err error
}

// Remove - closes and removes targets by given target IDs.
func (list *TargetList) Remove(targetIDSet TargetIDSet) {
	list.Lock()
	defer list.Unlock()

	for id := range targetIDSet {
		target, ok := list.targets[id]
		if ok {
			target.Close()
			delete(list.targets, id)
		}
	}
}

// Targets - list all targets

    }

    /**
     * Closes the Zip file.
     * <p>
     * If {@link ZipFile#close()} throws an exception, an error message is logged. The exception is not rethrown.
     * </p>
     *
     * @param zipFile
     *            Zip file. Must not be {@literal null}.
     */
    public static void close(final ZipFile zipFile) {
        assertArgumentNotNull("zipFile", zipFile);

	// Cache the Stmt object with the associated key.
	s.Set(key, cacheStmt)
	// Unlock after completing initialization to prevent deadlocks.
	locker.Unlock()

	// Ensure the prepared channel is closed after the function execution completes.
	defer close(cacheStmt.prepared)

	// Prepare the SQL statement using the provided connection.
	cacheStmt.Stmt, err = conn.PrepareContext(ctx, key)
	if err != nil {

        if (rpc.retval != 0) {
            throw new SmbException(rpc.retval, false);
        }
    }

    /**
     * Closes this SAM alias handle.
     *
     * @throws IOException if an I/O error occurs during handle closure
     */
    public void close() throws IOException {
        final MsrpcSamrCloseHandle rpc = new MsrpcSamrCloseHandle(this);
        handle.sendrecv(rpc);
        if (rpc.retval != 0) {

     * @throws SmbException if account is locked out
     */
    public boolean checkAttempt(String username, String sourceIp) throws SmbException {
        if (closed.get()) {
            throw new IllegalStateException("Rate limiter is closed");
        }

        // Check global rate limit
        if (!checkGlobalRateLimit()) {
            totalAttemptsBlocked.incrementAndGet();

     */
    ResponseData execute(RequestData data);

    /**
     * Closes the crawler client and releases any resources associated with it.
     * This default implementation does nothing.
     *
     * @throws Exception if an error occurs during closing
     */
    @Override
    default void close() throws Exception {
        // nothing
    }

   * should return immediately. Responses returned after shutdown will not be transmitted: their
   * socket connections have already been closed.
   */
  public open override fun close() {}

func clear[T ~[]Type | ~map[Type]Type1](t T)

// The close built-in function closes a channel, which must be either
// bidirectional or send-only. It should be executed only by the sender,
// never the receiver, and has the effect of shutting down the channel after
// the last sent value is received. After the last value has been received
// from a closed channel c, any receive from c will succeed without