*/
    int getReceiveBufferSize ();


    /**
     * 
     * @return the transaction buffer size
     */
    int getTransactionBufferSize ();


    /**
     * 
     * @return number of initial credits the server grants
     */
    int getInitialCredits ();


    /**
     * @param tc
     * @param forceSigning
     * @return whether a connection can be reused for this config

    static Suggester suggester;

    static OpenSearchRunner runner;

    @BeforeClass
    public static void beforeClass() throws Exception {
        runner = new OpenSearchRunner();
        runner.onBuild((number, settingsBuilder) -> {
            settingsBuilder.put("http.cors.enabled", true);
            settingsBuilder.put("discovery.type", "single-node");
            // settingsBuilder.putList("discovery.seed_hosts", "127.0.0.1:9301");

  /** True if this web socket failed and the listener has been notified. */
  private var failed = false

  /** Total number of pings sent by this web socket. */
  private var sentPingCount = 0

  /** Total number of pings received by this web socket. */
  private var receivedPingCount = 0

  /** Total number of pongs received by this web socket. */
  private var receivedPongCount = 0

            return escapeValue(statsKey.getUrl());
        }
        if (keyObj instanceof final String key) {
            return escapeValue(key);
        }
        if (keyObj instanceof final Number key) {
            return key.toString();
        }
        return "-";
    }

    protected OptionalThing<String> getCacheKey(final Object keyObj) {
        if (keyObj instanceof final UrlQueue<?> urlQueue) {

  }

  /**
   * This test creates a long random sequence of inputs, then a lot of differently configured sinks
   * process it; all should produce the same answer, the only difference should be the number of
   * process()/processRemaining() invocations, due to alignment.
   */
  @AndroidIncompatible // slow. TODO(cpovirk): Maybe just reduce iterations under Android.
  public void testExhaustive() throws Exception {

 *
 * <p>As compared with {@link java.util.LinkedHashMap}, this structure places significantly reduced
 * load on the garbage collector by only using a constant number of internal objects.
 *
 * <p>This class should not be assumed to be universally superior to {@code
 * java.util.LinkedHashMap}. Generally speaking, this class reduces object allocation and memory

/** This class is for {@code com.google.common.base} use only! */
@J2ktIncompatible
@GwtIncompatible // java.time.Duration
@ElementTypesAreNonnullByDefault
final class Internal {

  /**
   * Returns the number of nanoseconds of the given duration without throwing or overflowing.
   *
   * <p>Instead of throwing {@link ArithmeticException}, this method silently saturates to either

 * iterator should return in order.
 *
 * <p>The items in {@code elementsToInsert} will be repeated if {@code steps} is larger than the
 * number of provided elements.
 *
 * @author Chris Povirk
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public abstract class ListIteratorTester<E extends @Nullable Object>

                            # TODO: remove when deprecating Pydantic v1
                            {
                                "title": "Process After",
                                "type": "number",
                                "format": "time-delta",
                            }
                        ),
                    },

                },
                "Subscription": {
                    "properties": {
                        "username": {"type": "string", "title": "Username"},
                        "monthly_fee": {"type": "number", "title": "Monthly Fee"},
                        "start_date": {
                            "type": "string",
                            "format": "date-time",
                            "title": "Start Date",