@sitevision/api 2023.2.1 → 2023.2.2-beta.2

package/types/java/util/concurrent/ExecutorService/index.d.ts

@@ -0,0 +1,296 @@
+import type { List } from "../../List";
+
+import type { TimeUnit } from "../TimeUnit";
+import type { Callable } from "../Callable";
+import type { Future } from "../Future";
+import type { Runnable } from "../../../lang/Runnable";
+
+import type { Collection } from "../../Collection";
+import type { Executor } from "../Executor";
+
+/**
+ * An {@link Executor} that provides methods to manage termination and
+ *  methods that can produce a {@link Future} for tracking progress of
+ *  one or more asynchronous tasks.
+ *
+ *  <p>An {@code ExecutorService} can be shut down, which will cause
+ *  it to reject new tasks.  Two different methods are provided for
+ *  shutting down an {@code ExecutorService}. The {@link #shutdown}
+ *  method will allow previously submitted tasks to execute before
+ *  terminating, while the {@link #shutdownNow} method prevents waiting
+ *  tasks from starting and attempts to stop currently executing tasks.
+ *  Upon termination, an executor has no tasks actively executing, no
+ *  tasks awaiting execution, and no new tasks can be submitted.  An
+ *  unused {@code ExecutorService} should be shut down to allow
+ *  reclamation of its resources.
+ *
+ *  <p>Method {@code submit} extends base method {@link
+ *  Executor#execute(Runnable)} by creating and returning a {@link Future}
+ *  that can be used to cancel execution and/or wait for completion.
+ *  Methods {@code invokeAny} and {@code invokeAll} perform the most
+ *  commonly useful forms of bulk execution, executing a collection of
+ *  tasks and then waiting for at least one, or all, to
+ *  complete. (Class {@link ExecutorCompletionService} can be used to
+ *  write customized variants of these methods.)
+ *
+ *  <p>The {@link Executors} class provides factory methods for the
+ *  executor services provided in this package.
+ *
+ *  <h3>Usage Examples</h3>
+ *
+ *  Here is a sketch of a network service in which threads in a thread
+ *  pool service incoming requests. It uses the preconfigured {@link
+ *  Executors#newFixedThreadPool} factory method:
+ *
+ *   <pre> {@code
+ *  class NetworkService implements Runnable {
+ *    private final ServerSocket serverSocket;
+ *    private final ExecutorService pool;
+ *
+ *    public NetworkService(int port, int poolSize)
+ *        throws IOException {
+ *      serverSocket = new ServerSocket(port);
+ *      pool = Executors.newFixedThreadPool(poolSize);
+ *    }
+ *
+ *    public void run() { // run the service
+ *      try {
+ *        for (;;) {
+ *          pool.execute(new Handler(serverSocket.accept()));
+ *        }
+ *      } catch (IOException ex) {
+ *        pool.shutdown();
+ *      }
+ *    }
+ *  }
+ *
+ *  class Handler implements Runnable {
+ *    private final Socket socket;
+ *    Handler(Socket socket) { this.socket = socket; }
+ *    public void run() {
+ *      // read and service request on socket
+ *    }
+ *  }}</pre>
+ *
+ *  The following method shuts down an {@code ExecutorService} in two phases,
+ *  first by calling {@code shutdown} to reject incoming tasks, and then
+ *  calling {@code shutdownNow}, if necessary, to cancel any lingering tasks:
+ *
+ *   <pre> {@code
+ *  void shutdownAndAwaitTermination(ExecutorService pool) {
+ *    pool.shutdown(); // Disable new tasks from being submitted
+ *    try {
+ *      // Wait a while for existing tasks to terminate
+ *      if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
+ *        pool.shutdownNow(); // Cancel currently executing tasks
+ *        // Wait a while for tasks to respond to being cancelled
+ *        if (!pool.awaitTermination(60, TimeUnit.SECONDS))
+ *            System.err.println("Pool did not terminate");
+ *      }
+ *    } catch (InterruptedException ie) {
+ *      // (Re-)Cancel if current thread also interrupted
+ *      pool.shutdownNow();
+ *      // Preserve interrupt status
+ *      Thread.currentThread().interrupt();
+ *    }
+ *  }}</pre>
+ *
+ *  <p>Memory consistency effects: Actions in a thread prior to the
+ *  submission of a {@code Runnable} or {@code Callable} task to an
+ *  {@code ExecutorService}
+ *  <a href="package-summary.html#MemoryVisibility"><i>happen-before</i></a>
+ *  any actions taken by that task, which in turn <i>happen-before</i> the
+ *  result is retrieved via {@code Future.get()}.
+ * @since 1.5
+ * @author Doug Lea
+ */
+export type ExecutorService = Executor & {
+  /**
+   * Initiates an orderly shutdown in which previously submitted
+   *  tasks are executed, but no new tasks will be accepted.
+   *  Invocation has no additional effect if already shut down.
+   *
+   *  <p>This method does not wait for previously submitted tasks to
+   *  complete execution.  Use {@link #awaitTermination awaitTermination}
+   *  to do that.
+   * @throws SecurityException if a security manager exists and&#xA; shutting down this ExecutorService may manipulate&#xA; threads that the caller is not permitted to modify&#xA; because it does not hold {@link&#xA; java.lang.RuntimePermission}{@code ("modifyThread")},&#xA; or the security manager's {@code checkAccess} method&#xA; denies access.
+   */
+  shutdown(): void;
+
+  /**
+   * Attempts to stop all actively executing tasks, halts the
+   *  processing of waiting tasks, and returns a list of the tasks
+   *  that were awaiting execution.
+   *
+   *  <p>This method does not wait for actively executing tasks to
+   *  terminate.  Use {@link #awaitTermination awaitTermination} to
+   *  do that.
+   *
+   *  <p>There are no guarantees beyond best-effort attempts to stop
+   *  processing actively executing tasks.  For example, typical
+   *  implementations will cancel via {@link Thread#interrupt}, so any
+   *  task that fails to respond to interrupts may never terminate.
+   * @return list of tasks that never commenced execution
+   * @throws SecurityException if a security manager exists and&#xA; shutting down this ExecutorService may manipulate&#xA; threads that the caller is not permitted to modify&#xA; because it does not hold {@link&#xA; java.lang.RuntimePermission}{@code ("modifyThread")},&#xA; or the security manager's {@code checkAccess} method&#xA; denies access.
+   */
+  shutdownNow(): List;
+
+  /**
+   * Returns {@code true} if this executor has been shut down.
+   * @return {@code true} if this executor has been shut down
+   */
+  isShutdown(): boolean;
+
+  /**
+   * Returns {@code true} if all tasks have completed following shut down.
+   *  Note that {@code isTerminated} is never {@code true} unless
+   *  either {@code shutdown} or {@code shutdownNow} was called first.
+   * @return {@code true} if all tasks have completed following shut down
+   */
+  isTerminated(): boolean;
+
+  /**
+   * Blocks until all tasks have completed execution after a shutdown
+   *  request, or the timeout occurs, or the current thread is
+   *  interrupted, whichever happens first.
+   * @param timeout the maximum time to wait
+   * @param unit the time unit of the timeout argument
+   * @return {@code true} if this executor terminated and&#xA; {@code false} if the timeout elapsed before termination
+   * @throws InterruptedException if interrupted while waiting
+   */
+  awaitTermination(timeout: number, unit: TimeUnit): boolean;
+
+  /**
+   * Submits a value-returning task for execution and returns a
+   *  Future representing the pending results of the task. The
+   *  Future's {@code get} method will return the task's result upon
+   *  successful completion.
+   *
+   *  <p>
+   *  If you would like to immediately block waiting
+   *  for a task, you can use constructions of the form
+   *  {@code result = exec.submit(aCallable).get();}
+   *
+   *  <p>Note: The {@link Executors} class includes a set of methods
+   *  that can convert some other common closure-like objects,
+   *  for example, {@link java.security.PrivilegedAction} to
+   *  {@link Callable} form so they can be submitted.
+   * @param task the task to submit
+   * @param <T> the type of the task's result
+   * @return a Future representing pending completion of the task
+   * @throws RejectedExecutionException if the task cannot be&#xA; scheduled for execution
+   * @throws NullPointerException if the task is null
+   */
+  submit(task: Callable): Future;
+
+  /**
+   * Submits a Runnable task for execution and returns a Future
+   *  representing that task. The Future's {@code get} method will
+   *  return the given result upon successful completion.
+   * @param task the task to submit
+   * @param result the result to return
+   * @param <T> the type of the result
+   * @return a Future representing pending completion of the task
+   * @throws RejectedExecutionException if the task cannot be&#xA; scheduled for execution
+   * @throws NullPointerException if the task is null
+   */
+  submit(task: Runnable, result: unknown): Future;
+
+  /**
+   * Submits a Runnable task for execution and returns a Future
+   *  representing that task. The Future's {@code get} method will
+   *  return {@code null} upon <em>successful</em> completion.
+   * @param task the task to submit
+   * @return a Future representing pending completion of the task
+   * @throws RejectedExecutionException if the task cannot be&#xA; scheduled for execution
+   * @throws NullPointerException if the task is null
+   */
+  submit(task: Runnable): Future;
+
+  /**
+   * Executes the given tasks, returning a list of Futures holding
+   *  their status and results when all complete.
+   *  {@link Future#isDone} is {@code true} for each
+   *  element of the returned list.
+   *  Note that a <em>completed</em> task could have
+   *  terminated either normally or by throwing an exception.
+   *  The results of this method are undefined if the given
+   *  collection is modified while this operation is in progress.
+   * @param tasks the collection of tasks
+   * @param <T> the type of the values returned from the tasks
+   * @return a list of Futures representing the tasks, in the same&#xA; sequential order as produced by the iterator for the&#xA; given task list, each of which has completed
+   * @throws InterruptedException if interrupted while waiting, in&#xA; which case unfinished tasks are cancelled
+   * @throws NullPointerException if tasks or any of its elements are {@code null}
+   * @throws RejectedExecutionException if any task cannot be&#xA; scheduled for execution
+   */
+  invokeAll(tasks: Collection | unknown[]): List;
+
+  /**
+   * Executes the given tasks, returning a list of Futures holding
+   *  their status and results
+   *  when all complete or the timeout expires, whichever happens first.
+   *  {@link Future#isDone} is {@code true} for each
+   *  element of the returned list.
+   *  Upon return, tasks that have not completed are cancelled.
+   *  Note that a <em>completed</em> task could have
+   *  terminated either normally or by throwing an exception.
+   *  The results of this method are undefined if the given
+   *  collection is modified while this operation is in progress.
+   * @param tasks the collection of tasks
+   * @param timeout the maximum time to wait
+   * @param unit the time unit of the timeout argument
+   * @param <T> the type of the values returned from the tasks
+   * @return a list of Futures representing the tasks, in the same&#xA; sequential order as produced by the iterator for the&#xA; given task list. If the operation did not time out,&#xA; each task will have completed. If it did time out, some&#xA; of these tasks will not have completed.
+   * @throws InterruptedException if interrupted while waiting, in&#xA; which case unfinished tasks are cancelled
+   * @throws NullPointerException if tasks, any of its elements, or&#xA; unit are {@code null}
+   * @throws RejectedExecutionException if any task cannot be scheduled&#xA; for execution
+   */
+  invokeAll(
+    tasks: Collection | unknown[],
+    timeout: number,
+    unit: TimeUnit
+  ): List;
+
+  /**
+   * Executes the given tasks, returning the result
+   *  of one that has completed successfully (i.e., without throwing
+   *  an exception), if any do. Upon normal or exceptional return,
+   *  tasks that have not completed are cancelled.
+   *  The results of this method are undefined if the given
+   *  collection is modified while this operation is in progress.
+   * @param tasks the collection of tasks
+   * @param <T> the type of the values returned from the tasks
+   * @return the result returned by one of the tasks
+   * @throws InterruptedException if interrupted while waiting
+   * @throws NullPointerException if tasks or any element task&#xA; subject to execution is {@code null}
+   * @throws IllegalArgumentException if tasks is empty
+   * @throws ExecutionException if no task successfully completes
+   * @throws RejectedExecutionException if tasks cannot be scheduled&#xA; for execution
+   */
+  invokeAny(tasks: Collection | unknown[]): unknown;
+
+  /**
+   * Executes the given tasks, returning the result
+   *  of one that has completed successfully (i.e., without throwing
+   *  an exception), if any do before the given timeout elapses.
+   *  Upon normal or exceptional return, tasks that have not
+   *  completed are cancelled.
+   *  The results of this method are undefined if the given
+   *  collection is modified while this operation is in progress.
+   * @param tasks the collection of tasks
+   * @param timeout the maximum time to wait
+   * @param unit the time unit of the timeout argument
+   * @param <T> the type of the values returned from the tasks
+   * @return the result returned by one of the tasks
+   * @throws InterruptedException if interrupted while waiting
+   * @throws NullPointerException if tasks, or unit, or any element&#xA; task subject to execution is {@code null}
+   * @throws TimeoutException if the given timeout elapses before&#xA; any task successfully completes
+   * @throws ExecutionException if no task successfully completes
+   * @throws RejectedExecutionException if tasks cannot be scheduled&#xA; for execution
+   */
+  invokeAny(
+    tasks: Collection | unknown[],
+    timeout: number,
+    unit: TimeUnit
+  ): unknown;
+};

package/types/java/util/concurrent/ExecutorService/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  shutdown: function shutdown() {},
+  shutdownNow: function shutdownNow() {},
+  isShutdown: function isShutdown() {},
+  isTerminated: function isTerminated() {},
+  awaitTermination: function awaitTermination() {},
+  submit: function submit() {},
+  invokeAll: function invokeAll() {},
+  invokeAny: function invokeAny() {}
+};
+exports["default"] = _default;

package/types/java/util/concurrent/Future/index.d.ts

@@ -0,0 +1,118 @@
+import type { TimeUnit } from "../TimeUnit";
+
+/**
+ * A {@code Future} represents the result of an asynchronous
+ *  computation.  Methods are provided to check if the computation is
+ *  complete, to wait for its completion, and to retrieve the result of
+ *  the computation.  The result can only be retrieved using method
+ *  {@code get} when the computation has completed, blocking if
+ *  necessary until it is ready.  Cancellation is performed by the
+ *  {@code cancel} method.  Additional methods are provided to
+ *  determine if the task completed normally or was cancelled. Once a
+ *  computation has completed, the computation cannot be cancelled.
+ *  If you would like to use a {@code Future} for the sake
+ *  of cancellability but not provide a usable result, you can
+ *  declare types of the form {@code Future<?>} and
+ *  return {@code null} as a result of the underlying task.
+ *
+ *  <p>
+ *  <b>Sample Usage</b> (Note that the following classes are all
+ *  made-up.)
+ *  <pre> {@code
+ *  interface ArchiveSearcher { String search(String target); }
+ *  class App {
+ *    ExecutorService executor = ...
+ *    ArchiveSearcher searcher = ...
+ *    void showSearch(final String target)
+ *        throws InterruptedException {
+ *      Future<String> future
+ *        = executor.submit(new Callable<String>() {
+ *          public String call() {
+ *              return searcher.search(target);
+ *          }});
+ *      displayOtherThings(); // do other things while searching
+ *      try {
+ *        displayText(future.get()); // use future
+ *      } catch (ExecutionException ex) { cleanup(); return; }
+ *    }
+ *  }}</pre>
+ *
+ *  The {@link FutureTask} class is an implementation of {@code Future} that
+ *  implements {@code Runnable}, and so may be executed by an {@code Executor}.
+ *  For example, the above construction with {@code submit} could be replaced by:
+ *   <pre> {@code
+ *  FutureTask<String> future =
+ *    new FutureTask<String>(new Callable<String>() {
+ *      public String call() {
+ *        return searcher.search(target);
+ *    }});
+ *  executor.execute(future);}</pre>
+ *
+ *  <p>Memory consistency effects: Actions taken by the asynchronous computation
+ *  <a href="package-summary.html#MemoryVisibility"> <i>happen-before</i></a>
+ *  actions following the corresponding {@code Future.get()} in another thread.
+ * @see FutureTask
+ * @see Executor
+ * @since 1.5
+ * @author Doug Lea
+ * @param <V> The result type returned by this Future's {@code get} method
+ */
+export type Future = {
+  /**
+   * Attempts to cancel execution of this task.  This attempt will
+   *  fail if the task has already completed, has already been cancelled,
+   *  or could not be cancelled for some other reason. If successful,
+   *  and this task has not started when {@code cancel} is called,
+   *  this task should never run.  If the task has already started,
+   *  then the {@code mayInterruptIfRunning} parameter determines
+   *  whether the thread executing this task should be interrupted in
+   *  an attempt to stop the task.
+   *
+   *  <p>After this method returns, subsequent calls to {@link #isDone} will
+   *  always return {@code true}.  Subsequent calls to {@link #isCancelled}
+   *  will always return {@code true} if this method returned {@code true}.
+   * @param mayInterruptIfRunning {@code true} if the thread executing this&#xA; task should be interrupted; otherwise, in-progress tasks are allowed&#xA; to complete
+   * @return {@code false} if the task could not be cancelled,&#xA; typically because it has already completed normally;&#xA; {@code true} otherwise
+   */
+  cancel(mayInterruptIfRunning: boolean): boolean;
+
+  /**
+   * Returns {@code true} if this task was cancelled before it completed
+   *  normally.
+   * @return {@code true} if this task was cancelled before it completed
+   */
+  isCancelled(): boolean;
+
+  /**
+   * Returns {@code true} if this task completed.
+   *
+   *  Completion may be due to normal termination, an exception, or
+   *  cancellation -- in all of these cases, this method will return
+   *  {@code true}.
+   * @return {@code true} if this task completed
+   */
+  isDone(): boolean;
+
+  /**
+   * Waits if necessary for the computation to complete, and then
+   *  retrieves its result.
+   * @return the computed result
+   * @throws CancellationException if the computation was cancelled
+   * @throws ExecutionException if the computation threw an&#xA; exception
+   * @throws InterruptedException if the current thread was interrupted&#xA; while waiting
+   */
+  get(): unknown;
+
+  /**
+   * Waits if necessary for at most the given time for the computation
+   *  to complete, and then retrieves its result, if available.
+   * @param timeout the maximum time to wait
+   * @param unit the time unit of the timeout argument
+   * @return the computed result
+   * @throws CancellationException if the computation was cancelled
+   * @throws ExecutionException if the computation threw an&#xA; exception
+   * @throws InterruptedException if the current thread was interrupted&#xA; while waiting
+   * @throws TimeoutException if the wait timed out
+   */
+  get(timeout: number, unit: TimeUnit): unknown;
+};

package/types/java/util/concurrent/Future/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  cancel: function cancel() {},
+  isCancelled: function isCancelled() {},
+  isDone: function isDone() {},
+  get: function get() {}
+};
+exports["default"] = _default;

package/types/java/util/concurrent/TimeUnit/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * A {@code TimeUnit} represents time durations at a given unit of
+ *  granularity and provides utility methods to convert across units,
+ *  and to perform timing and delay operations in these units.  A
+ *  {@code TimeUnit} does not maintain time information, but only
+ *  helps organize and use time representations that may be maintained
+ *  separately across various contexts.  A nanosecond is defined as one
+ *  thousandth of a microsecond, a microsecond as one thousandth of a
+ *  millisecond, a millisecond as one thousandth of a second, a minute
+ *  as sixty seconds, an hour as sixty minutes, and a day as twenty four
+ *  hours.
+ *
+ *  <p>A {@code TimeUnit} is mainly used to inform time-based methods
+ *  how a given timing parameter should be interpreted. For example,
+ *  the following code will timeout in 50 milliseconds if the {@link
+ *  java.util.concurrent.locks.Lock lock} is not available:
+ *
+ *   <pre> {@code
+ *  Lock lock = ...;
+ *  if (lock.tryLock(50L, TimeUnit.MILLISECONDS)) ...}</pre>
+ *
+ *  while this code will timeout in 50 seconds:
+ *   <pre> {@code
+ *  Lock lock = ...;
+ *  if (lock.tryLock(50L, TimeUnit.SECONDS)) ...}</pre>
+ *
+ *  Note however, that there is no guarantee that a particular timeout
+ *  implementation will be able to notice the passage of time at the
+ *  same granularity as the given {@code TimeUnit}.
+ * @since 1.5
+ * @author Doug Lea
+ */
+export type TimeUnit = {
+  NANOSECONDS: "NANOSECONDS";
+  MICROSECONDS: "MICROSECONDS";
+  MILLISECONDS: "MILLISECONDS";
+  SECONDS: "SECONDS";
+  MINUTES: "MINUTES";
+  HOURS: "HOURS";
+  DAYS: "DAYS";
+};

package/types/java/util/concurrent/TimeUnit/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  NANOSECONDS: "NANOSECONDS",
+  MICROSECONDS: "MICROSECONDS",
+  MILLISECONDS: "MILLISECONDS",
+  SECONDS: "SECONDS",
+  MINUTES: "MINUTES",
+  HOURS: "HOURS",
+  DAYS: "DAYS"
+};
+exports["default"] = _default;

package/types/java/util/function/BiConsumer/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Represents an operation that accepts two input arguments and returns no
+ *  result.  This is the two-arity specialization of {@link Consumer}.
+ *  Unlike most other functional interfaces, {@code BiConsumer} is expected
+ *  to operate via side-effects.
+ *
+ *  <p>This is a <a href="package-summary.html">functional interface</a>
+ *  whose functional method is {@link #accept(Object, Object)}.
+ * @param <T> the type of the first argument to the operation
+ * @param <U> the type of the second argument to the operation
+ * @see Consumer
+ * @since 1.8
+ */
+export type BiConsumer = {
+  /**
+   * Performs this operation on the given arguments.
+   * @param t the first input argument
+   * @param u the second input argument
+   */
+  accept(t: unknown, u: unknown): void;
+
+  /**
+   * Returns a composed {@code BiConsumer} that performs, in sequence, this
+   *  operation followed by the {@code after} operation. If performing either
+   *  operation throws an exception, it is relayed to the caller of the
+   *  composed operation.  If performing this operation throws an exception,
+   *  the {@code after} operation will not be performed.
+   * @param after the operation to perform after this operation
+   * @return a composed {@code BiConsumer} that performs in sequence this&#xA; operation followed by the {@code after} operation
+   * @throws NullPointerException if {@code after} is null
+   */
+  andThen(after: BiConsumer): BiConsumer;
+};

package/types/java/util/function/BiConsumer/index.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  accept: function accept() {},
+  andThen: function andThen() {}
+};
+exports["default"] = _default;

package/types/java/util/function/BiFunction/index.d.ts

@@ -0,0 +1,35 @@
+import type { Function } from "../Function";
+
+/**
+ * Represents a function that accepts two arguments and produces a result.
+ *  This is the two-arity specialization of {@link Function}.
+ *
+ *  <p>This is a <a href="package-summary.html">functional interface</a>
+ *  whose functional method is {@link #apply(Object, Object)}.
+ * @param <T> the type of the first argument to the function
+ * @param <U> the type of the second argument to the function
+ * @param <R> the type of the result of the function
+ * @see Function
+ * @since 1.8
+ */
+export type BiFunction = {
+  /**
+   * Applies this function to the given arguments.
+   * @param t the first function argument
+   * @param u the second function argument
+   * @return the function result
+   */
+  apply(t: unknown, u: unknown): unknown;
+
+  /**
+   * Returns a composed function that first applies this function to
+   *  its input, and then applies the {@code after} function to the result.
+   *  If evaluation of either function throws an exception, it is relayed to
+   *  the caller of the composed function.
+   * @param <V> the type of output of the {@code after} function, and of the&#xA; composed function
+   * @param after the function to apply after this function is applied
+   * @return a composed function that first applies this function and then&#xA; applies the {@code after} function
+   * @throws NullPointerException if after is null
+   */
+  andThen(after: Function): BiFunction;
+};

package/types/java/util/function/BiFunction/index.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  apply: function apply() {},
+  andThen: function andThen() {}
+};
+exports["default"] = _default;

package/types/java/util/function/BinaryOperator/index.d.ts

@@ -0,0 +1,37 @@
+import type { Comparator } from "../../Comparator";
+import type { BiFunction } from "../BiFunction";
+
+/**
+ * Represents an operation upon two operands of the same type, producing a result
+ *  of the same type as the operands.  This is a specialization of
+ *  {@link BiFunction} for the case where the operands and the result are all of
+ *  the same type.
+ *
+ *  <p>This is a <a href="package-summary.html">functional interface</a>
+ *  whose functional method is {@link #apply(Object, Object)}.
+ * @param <T> the type of the operands and result of the operator
+ * @see BiFunction
+ * @see UnaryOperator
+ * @since 1.8
+ */
+export type BinaryOperator = BiFunction & {
+  /**
+   * Returns a {@link BinaryOperator} which returns the lesser of two elements
+   *  according to the specified {@code Comparator}.
+   * @param <T> the type of the input arguments of the comparator
+   * @param comparator a {@code Comparator} for comparing the two values
+   * @return a {@code BinaryOperator} which returns the lesser of its operands,&#xA; according to the supplied {@code Comparator}
+   * @throws NullPointerException if the argument is null
+   */
+  minBy(comparator: Comparator): BinaryOperator;
+
+  /**
+   * Returns a {@link BinaryOperator} which returns the greater of two elements
+   *  according to the specified {@code Comparator}.
+   * @param <T> the type of the input arguments of the comparator
+   * @param comparator a {@code Comparator} for comparing the two values
+   * @return a {@code BinaryOperator} which returns the greater of its operands,&#xA; according to the supplied {@code Comparator}
+   * @throws NullPointerException if the argument is null
+   */
+  maxBy(comparator: Comparator): BinaryOperator;
+};

package/types/java/util/function/BinaryOperator/index.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  minBy: function minBy() {},
+  maxBy: function maxBy() {}
+};
+exports["default"] = _default;