key="labels.web_api_json_enabled"/></span>
                                    <div class="form-inline col-sm-9">
                                        <la:errors property="webApiJson"/>
                                        <div class="form-check">

      return inline.invokeAll(tasks, timeout, unit);
    }

    // Define the invokeAny methods to invoke the first task
    @Override
    public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws ExecutionException, InterruptedException {
      assertTaskWrapped(tasks);
      lastMethodCalled = "invokeAny";
      return inline.submit(Iterables.get(tasks, 0)).get();
    }

@Suppress("NOTHING_TO_INLINE")
internal inline fun <T> List<T>.unmodifiable(): List<T> = Collections.unmodifiableList(this)

/** Returns an immutable wrap of this. */
@Suppress("NOTHING_TO_INLINE")
internal inline fun <T> Set<T>.unmodifiable(): Set<T> = Collections.unmodifiableSet(this)

/** Returns an immutable wrap of this. */
@Suppress("NOTHING_TO_INLINE")

          localDelegate.execute(this);
        }
      } finally {
        // Important to null this out here - if we did *not* execute inline, we might still
        // run() on the same thread that called execute() - such as in a thread pool, and think
        // that it was happening inline. As a side benefit, avoids holding on to the Thread object
        // longer than necessary.
        submitting = null;
      }
    }

  fun headers(name: String): List<String> = headers.values(name)

  /** Returns the tag attached with [T] as a key, or null if no tag is attached with that key. */
  @JvmName("reifiedTag")
  inline fun <reified T : Any> tag(): T? = tag(T::class)

  /** Returns the tag attached with [type] as a key, or null if no tag is attached with that key. */
  fun <T : Any> tag(type: KClass<T>): T? = type.java.cast(tags[type])

        for (final String id : ids) {
            bulkRequestBuilder.add(client.prepareUpdate()
                    .setIndex(index)
                    .setId(id)
                    .setScript(new Script(ScriptType.INLINE, scriptLang, scriptCode, params)));
        }
        if (bulkRequestBuilder.numberOfActions() > requestCacheSize) {
            flush();
        }
        return (long) ids.length;
    };

    /**

        LanguageHelper mockLanguageHelper = new LanguageHelper() {
            @Override
            public Script createScript(Map<String, Object> doc, String scriptString) {
                return new Script(ScriptType.INLINE, "painless", scriptString, new HashMap<>());
            }
        };
        ComponentUtil.register(mockLanguageHelper, "languageHelper");
    }

    // Test execute() method with successful processing

  }

  /*
   * If I understand correctly:
   *
   * This needs to be a @JsMethod so that J2CL knows to look for a JavaScript implemention of
   * it in Platform.native.js. (The JavaScript implementation inline below is visible to *GWT*, but
   * *J2CL* doesn't look at it.)
   *
   * However, once it's a @JsMethod, GWT produces a warning. That's because (a) the *other* purpose

     */
    public List<FacetQueryView> getFacetQueryViewList() {
        return facetQueryViewList;
    }

    /**
     * Adds a MIME type to the inline display set.
     *
     * @param mimeType the MIME type to display inline
     */
    public void addInlineMimeType(final String mimeType) {
        inlineMimeTypeSet.add(mimeType);
    }

    /**

      decodeException.initCause(e);
      throw decodeException;
    }
  }

  /*
   * We move the static constants into this class so ProGuard can inline UnsignedLongs entirely
   * unless the user is actually calling a parse method.
   */
  private static final class ParseOverflowDetection {
    private ParseOverflowDetection() {}