@sitevision/api 2023.2.1 → 2023.2.2-beta.2

package/types/java/util/Spliterator.OfLong/index.d.ts

@@ -0,0 +1,28 @@
+import type { LongConsumer } from "../function/LongConsumer";
+
+import type { Consumer } from "../function/Consumer";
+import type { OfPrimitive } from "../Spliterator.OfPrimitive";
+
+/**
+ * A Spliterator specialized for {@code long} values.
+ * @since 1.8
+ */
+export type OfLong = OfPrimitive & {
+  trySplit(): OfLong;
+
+  tryAdvance(action: LongConsumer): boolean;
+
+  forEachRemaining(action: LongConsumer): void;
+
+  /**
+   * {@inheritDoc}
+   * @implSpec If the action is an instance of {@code LongConsumer} then it is cast
 to {@code LongConsumer} and passed to
 {@link #tryAdvance(java.util.function.LongConsumer)}; otherwise
 the action is adapted to an instance of {@code LongConsumer}, by
 boxing the argument of {@code LongConsumer}, and then passed to
 {@link #tryAdvance(java.util.function.LongConsumer)}.
+   */
+  tryAdvance(action: Consumer): boolean;
+
+  /**
+   * {@inheritDoc}
+   * @implSpec If the action is an instance of {@code LongConsumer} then it is cast
 to {@code LongConsumer} and passed to
 {@link #forEachRemaining(java.util.function.LongConsumer)}; otherwise
 the action is adapted to an instance of {@code LongConsumer}, by
 boxing the argument of {@code LongConsumer}, and then passed to
 {@link #forEachRemaining(java.util.function.LongConsumer)}.
+   */
+  forEachRemaining(action: Consumer): void;
+};

package/types/java/util/Spliterator.OfLong/index.js

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

package/types/java/util/Spliterator.OfPrimitive/index.d.ts

@@ -0,0 +1,39 @@
+import type { Spliterator } from "../Spliterator";
+
+/**
+ * A Spliterator specialized for primitive values.
+ * @param <T> the type of elements returned by this Spliterator. The&#xA; type must be a wrapper type for a primitive type, such as {@code Integer}&#xA; for the primitive {@code int} type.
+ * @param <T_CONS> the type of primitive consumer. The type must be a&#xA; primitive specialization of {@link java.util.function.Consumer} for&#xA; {@code T}, such as {@link java.util.function.IntConsumer} for&#xA; {@code Integer}.
+ * @param <T_SPLITR> the type of primitive Spliterator. The type must be&#xA; a primitive specialization of Spliterator for {@code T}, such as&#xA; {@link Spliterator.OfInt} for {@code Integer}.
+ * @see Spliterator.OfInt
+ * @see Spliterator.OfLong
+ * @see Spliterator.OfDouble
+ * @since 1.8
+ */
+export type OfPrimitive = Spliterator & {
+  trySplit(): unknown;
+
+  /**
+   * If a remaining element exists, performs the given action on it,
+   *  returning {@code true}; else returns {@code false}.  If this
+   *  Spliterator is {@link #ORDERED} the action is performed on the
+   *  next element in encounter order.  Exceptions thrown by the
+   *  action are relayed to the caller.
+   * @param action The action
+   * @return {@code false} if no remaining elements existed&#xA; upon entry to this method, else {@code true}.
+   * @throws NullPointerException if the specified action is null
+   */
+  tryAdvance(action: unknown): boolean;
+
+  /**
+   * Performs the given action for each remaining element, sequentially in
+   *  the current thread, until all elements have been processed or the
+   *  action throws an exception.  If this Spliterator is {@link #ORDERED},
+   *  actions are performed in encounter order.  Exceptions thrown by the
+   *  action are relayed to the caller.
+   * @implSpec The default implementation repeatedly invokes {@link #tryAdvance}&#xA; until it returns {@code false}. It should be overridden whenever&#xA; possible.
+   * @param action The action
+   * @throws NullPointerException if the specified action is null
+   */
+  forEachRemaining(action: unknown): void;
+};

package/types/java/util/Spliterator.OfPrimitive/index.js

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

package/types/java/util/TimeZone/index.d.ts

@@ -0,0 +1,370 @@
+import type { String } from "../../lang/String";
+import type { Locale } from "../Locale";
+
+import type { Date } from "../Date";
+import type { ZoneId } from "../../time/ZoneId";
+import type { Object } from "../../lang/Object";
+import type { Serializable } from "../../io/Serializable";
+import type { Cloneable } from "../../lang/Cloneable";
+
+/**
+ * <code>TimeZone</code> represents a time zone offset, and also figures out daylight
+ *  savings.
+ *
+ *  <p>
+ *  Typically, you get a <code>TimeZone</code> using <code>getDefault</code>
+ *  which creates a <code>TimeZone</code> based on the time zone where the program
+ *  is running. For example, for a program running in Japan, <code>getDefault</code>
+ *  creates a <code>TimeZone</code> object based on Japanese Standard Time.
+ *
+ *  <p>
+ *  You can also get a <code>TimeZone</code> using <code>getTimeZone</code>
+ *  along with a time zone ID. For instance, the time zone ID for the
+ *  U.S. Pacific Time zone is "America/Los_Angeles". So, you can get a
+ *  U.S. Pacific Time <code>TimeZone</code> object with:
+ *  <blockquote><pre>
+ *  TimeZone tz = TimeZone.getTimeZone("America/Los_Angeles");
+ *  </pre></blockquote>
+ *  You can use the <code>getAvailableIDs</code> method to iterate through
+ *  all the supported time zone IDs. You can then choose a
+ *  supported ID to get a <code>TimeZone</code>.
+ *  If the time zone you want is not represented by one of the
+ *  supported IDs, then a custom time zone ID can be specified to
+ *  produce a TimeZone. The syntax of a custom time zone ID is:
+ *
+ *  <blockquote><pre>
+ *  <a name="CustomID"><i>CustomID:</i></a>
+ *          <code>GMT</code> <i>Sign</i> <i>Hours</i> <code>:</code> <i>Minutes</i>
+ *          <code>GMT</code> <i>Sign</i> <i>Hours</i> <i>Minutes</i>
+ *          <code>GMT</code> <i>Sign</i> <i>Hours</i>
+ *  <i>Sign:</i> one of
+ *          <code>+ -</code>
+ *  <i>Hours:</i>
+ *          <i>Digit</i>
+ *          <i>Digit</i> <i>Digit</i>
+ *  <i>Minutes:</i>
+ *          <i>Digit</i> <i>Digit</i>
+ *  <i>Digit:</i> one of
+ *          <code>0 1 2 3 4 5 6 7 8 9</code>
+ *  </pre></blockquote>
+ *
+ *  <i>Hours</i> must be between 0 to 23 and <i>Minutes</i> must be
+ *  between 00 to 59.  For example, "GMT+10" and "GMT+0010" mean ten
+ *  hours and ten minutes ahead of GMT, respectively.
+ *  <p>
+ *  The format is locale independent and digits must be taken from the
+ *  Basic Latin block of the Unicode standard. No daylight saving time
+ *  transition schedule can be specified with a custom time zone ID. If
+ *  the specified string doesn't match the syntax, <code>"GMT"</code>
+ *  is used.
+ *  <p>
+ *  When creating a <code>TimeZone</code>, the specified custom time
+ *  zone ID is normalized in the following syntax:
+ *  <blockquote><pre>
+ *  <a name="NormalizedCustomID"><i>NormalizedCustomID:</i></a>
+ *          <code>GMT</code> <i>Sign</i> <i>TwoDigitHours</i> <code>:</code> <i>Minutes</i>
+ *  <i>Sign:</i> one of
+ *          <code>+ -</code>
+ *  <i>TwoDigitHours:</i>
+ *          <i>Digit</i> <i>Digit</i>
+ *  <i>Minutes:</i>
+ *          <i>Digit</i> <i>Digit</i>
+ *  <i>Digit:</i> one of
+ *          <code>0 1 2 3 4 5 6 7 8 9</code>
+ *  </pre></blockquote>
+ *  For example, TimeZone.getTimeZone("GMT-8").getID() returns "GMT-08:00".
+ *
+ *  <h3>Three-letter time zone IDs</h3>
+ *
+ *  For compatibility with JDK 1.1.x, some other three-letter time zone IDs
+ *  (such as "PST", "CTT", "AST") are also supported. However, <strong>their
+ *  use is deprecated</strong> because the same abbreviation is often used
+ *  for multiple time zones (for example, "CST" could be U.S. "Central Standard
+ *  Time" and "China Standard Time"), and the Java platform can then only
+ *  recognize one of them.
+ * @see Calendar
+ * @see GregorianCalendar
+ * @see SimpleTimeZone
+ * @author Mark Davis, David Goldsmith, Chen-Lieh Huang, Alan Liu
+ * @since JDK1.1
+ */
+export type TimeZone = Object &
+  Serializable &
+  Cloneable & {
+    /**
+     * Gets the time zone offset, for current date, modified in case of
+     *  daylight savings. This is the offset to add to UTC to get local time.
+     *  <p>
+     *  This method returns a historically correct offset if an
+     *  underlying <code>TimeZone</code> implementation subclass
+     *  supports historical Daylight Saving Time schedule and GMT
+     *  offset changes.
+     * @param era the era of the given date.
+     * @param year the year in the given date.
+     * @param month the month in the given date.&#xA; Month is 0-based. e.g., 0 for January.
+     * @param day the day-in-month of the given date.
+     * @param dayOfWeek the day-of-week of the given date.
+     * @param milliseconds the milliseconds in day in <em>standard</em>&#xA; local time.
+     * @return the offset in milliseconds to add to GMT to get local time.
+     * @see Calendar#ZONE_OFFSET
+     * @see Calendar#DST_OFFSET
+     */
+    getOffset(
+      era: number,
+      year: number,
+      month: number,
+      day: number,
+      dayOfWeek: number,
+      milliseconds: number
+    ): number;
+
+    /**
+     * Returns the offset of this time zone from UTC at the specified
+     *  date. If Daylight Saving Time is in effect at the specified
+     *  date, the offset value is adjusted with the amount of daylight
+     *  saving.
+     *  <p>
+     *  This method returns a historically correct offset value if an
+     *  underlying TimeZone implementation subclass supports historical
+     *  Daylight Saving Time schedule and GMT offset changes.
+     * @param date the date represented in milliseconds since January 1, 1970 00:00:00 GMT
+     * @return the amount of time in milliseconds to add to UTC to get local time.
+     * @see Calendar#ZONE_OFFSET
+     * @see Calendar#DST_OFFSET
+     * @since 1.4
+     */
+    getOffset(date: number): number;
+
+    /**
+     * Sets the base time zone offset to GMT.
+     *  This is the offset to add to UTC to get local time.
+     *  <p>
+     *  If an underlying <code>TimeZone</code> implementation subclass
+     *  supports historical GMT offset changes, the specified GMT
+     *  offset is set as the latest GMT offset and the difference from
+     *  the known latest GMT offset value is used to adjust all
+     *  historical GMT offset values.
+     * @param offsetMillis the given base time zone offset to GMT.
+     */
+    setRawOffset(offsetMillis: number): void;
+
+    /**
+     * Returns the amount of time in milliseconds to add to UTC to get
+     *  standard time in this time zone. Because this value is not
+     *  affected by daylight saving time, it is called <I>raw
+     *  offset</I>.
+     *  <p>
+     *  If an underlying <code>TimeZone</code> implementation subclass
+     *  supports historical GMT offset changes, the method returns the
+     *  raw offset value of the current date. In Honolulu, for example,
+     *  its raw offset changed from GMT-10:30 to GMT-10:00 in 1947, and
+     *  this method always returns -36000000 milliseconds (i.e., -10
+     *  hours).
+     * @return the amount of raw offset time in milliseconds to add to UTC.
+     * @see Calendar#ZONE_OFFSET
+     */
+    getRawOffset(): number;
+
+    /**
+     * Gets the ID of this time zone.
+     * @return the ID of this time zone.
+     */
+    getID(): string;
+
+    /**
+     * Sets the time zone ID. This does not change any other data in
+     *  the time zone object.
+     * @param ID the new time zone ID.
+     */
+    setID(ID: String | string): void;
+
+    /**
+     * Returns a long standard time name of this {@code TimeZone} suitable for
+     *  presentation to the user in the default locale.
+     *
+     *  <p>This method is equivalent to:
+     *  <blockquote><pre>
+     *  getDisplayName(false, {@link #LONG},
+     *                 Locale.getDefault({@link Locale.Category#DISPLAY}))
+     *  </pre></blockquote>
+     * @return the human-readable name of this time zone in the default locale.
+     * @since 1.2
+     * @see #getDisplayName(boolean, int, Locale)
+     * @see Locale#getDefault(Locale.Category)
+     * @see Locale.Category
+     */
+    getDisplayName(): string;
+
+    /**
+     * Returns a long standard time name of this {@code TimeZone} suitable for
+     *  presentation to the user in the specified {@code locale}.
+     *
+     *  <p>This method is equivalent to:
+     *  <blockquote><pre>
+     *  getDisplayName(false, {@link #LONG}, locale)
+     *  </pre></blockquote>
+     * @param locale the locale in which to supply the display name.
+     * @return the human-readable name of this time zone in the given locale.
+     * @throws NullPointerException if {@code locale} is {@code null}.
+     * @since 1.2
+     * @see #getDisplayName(boolean, int, Locale)
+     */
+    getDisplayName(locale: Locale): string;
+
+    /**
+     * Returns a name in the specified {@code style} of this {@code TimeZone}
+     *  suitable for presentation to the user in the default locale. If the
+     *  specified {@code daylight} is {@code true}, a Daylight Saving Time name
+     *  is returned (even if this {@code TimeZone} doesn't observe Daylight Saving
+     *  Time). Otherwise, a Standard Time name is returned.
+     *
+     *  <p>This method is equivalent to:
+     *  <blockquote><pre>
+     *  getDisplayName(daylight, style,
+     *                 Locale.getDefault({@link Locale.Category#DISPLAY}))
+     *  </pre></blockquote>
+     * @param daylight {@code true} specifying a Daylight Saving Time name, or&#xA; {@code false} specifying a Standard Time name
+     * @param style either {@link #LONG} or {@link #SHORT}
+     * @return the human-readable name of this time zone in the default locale.
+     * @throws IllegalArgumentException if {@code style} is invalid.
+     * @since 1.2
+     * @see #getDisplayName(boolean, int, Locale)
+     * @see Locale#getDefault(Locale.Category)
+     * @see Locale.Category
+     * @see java.text.DateFormatSymbols#getZoneStrings()
+     */
+    getDisplayName(daylight: boolean, style: number): string;
+
+    /**
+     * Returns a name in the specified {@code style} of this {@code TimeZone}
+     *  suitable for presentation to the user in the specified {@code
+     *  locale}. If the specified {@code daylight} is {@code true}, a Daylight
+     *  Saving Time name is returned (even if this {@code TimeZone} doesn't
+     *  observe Daylight Saving Time). Otherwise, a Standard Time name is
+     *  returned.
+     *
+     *  <p>When looking up a time zone name, the {@linkplain
+     *  ResourceBundle.Control#getCandidateLocales(String,Locale) default
+     *  <code>Locale</code> search path of <code>ResourceBundle</code>} derived
+     *  from the specified {@code locale} is used. (No {@linkplain
+     *  ResourceBundle.Control#getFallbackLocale(String,Locale) fallback
+     *  <code>Locale</code>} search is performed.) If a time zone name in any
+     *  {@code Locale} of the search path, including {@link Locale#ROOT}, is
+     *  found, the name is returned. Otherwise, a string in the
+     *  <a href="#NormalizedCustomID">normalized custom ID format</a> is returned.
+     * @param daylight {@code true} specifying a Daylight Saving Time name, or&#xA; {@code false} specifying a Standard Time name
+     * @param style either {@link #LONG} or {@link #SHORT}
+     * @param locale the locale in which to supply the display name.
+     * @return the human-readable name of this time zone in the given locale.
+     * @throws IllegalArgumentException if {@code style} is invalid.
+     * @throws NullPointerException if {@code locale} is {@code null}.
+     * @since 1.2
+     * @see java.text.DateFormatSymbols#getZoneStrings()
+     */
+    getDisplayName(daylight: boolean, style: number, locale: Locale): string;
+
+    /**
+     * Returns the amount of time to be added to local standard time
+     *  to get local wall clock time.
+     *
+     *  <p>The default implementation returns 3600000 milliseconds
+     *  (i.e., one hour) if a call to {@link #useDaylightTime()}
+     *  returns {@code true}. Otherwise, 0 (zero) is returned.
+     *
+     *  <p>If an underlying {@code TimeZone} implementation subclass
+     *  supports historical and future Daylight Saving Time schedule
+     *  changes, this method returns the amount of saving time of the
+     *  last known Daylight Saving Time rule that can be a future
+     *  prediction.
+     *
+     *  <p>If the amount of saving time at any given time stamp is
+     *  required, construct a {@link Calendar} with this {@code
+     *  TimeZone} and the time stamp, and call {@link Calendar#get(int)
+     *  Calendar.get}{@code (}{@link Calendar#DST_OFFSET}{@code )}.
+     * @return the amount of saving time in milliseconds
+     * @since 1.4
+     * @see #inDaylightTime(Date)
+     * @see #getOffset(long)
+     * @see #getOffset(int,int,int,int,int,int)
+     * @see Calendar#ZONE_OFFSET
+     */
+    getDSTSavings(): number;
+
+    /**
+     * Queries if this {@code TimeZone} uses Daylight Saving Time.
+     *
+     *  <p>If an underlying {@code TimeZone} implementation subclass
+     *  supports historical and future Daylight Saving Time schedule
+     *  changes, this method refers to the last known Daylight Saving Time
+     *  rule that can be a future prediction and may not be the same as
+     *  the current rule. Consider calling {@link #observesDaylightTime()}
+     *  if the current rule should also be taken into account.
+     * @return {@code true} if this {@code TimeZone} uses Daylight Saving Time,&#xA; {@code false}, otherwise.
+     * @see #inDaylightTime(Date)
+     * @see Calendar#DST_OFFSET
+     */
+    useDaylightTime(): boolean;
+
+    /**
+     * Returns {@code true} if this {@code TimeZone} is currently in
+     *  Daylight Saving Time, or if a transition from Standard Time to
+     *  Daylight Saving Time occurs at any future time.
+     *
+     *  <p>The default implementation returns {@code true} if
+     *  {@code useDaylightTime()} or {@code inDaylightTime(new Date())}
+     *  returns {@code true}.
+     * @return {@code true} if this {@code TimeZone} is currently in&#xA; Daylight Saving Time, or if a transition from Standard Time to&#xA; Daylight Saving Time occurs at any future time; {@code false}&#xA; otherwise.
+     * @since 1.7
+     * @see #useDaylightTime()
+     * @see #inDaylightTime(Date)
+     * @see Calendar#DST_OFFSET
+     */
+    observesDaylightTime(): boolean;
+
+    /**
+     * Queries if the given {@code date} is in Daylight Saving Time in
+     *  this time zone.
+     * @param date the given Date.
+     * @return {@code true} if the given date is in Daylight Saving Time,&#xA; {@code false}, otherwise.
+     */
+    inDaylightTime(date: Date): boolean;
+
+    /**
+     * Converts this {@code TimeZone} object to a {@code ZoneId}.
+     * @return a {@code ZoneId} representing the same time zone as this&#xA; {@code TimeZone}
+     * @since 1.8
+     */
+    toZoneId(): ZoneId;
+
+    /**
+     * Returns true if this zone has the same rule and offset as another zone.
+     *  That is, if this zone differs only in ID, if at all.  Returns false
+     *  if the other zone is null.
+     * @param other the <code>TimeZone</code> object to be compared with
+     * @return true if the other zone is not null and is the same as this one,&#xA; with the possible exception of the ID
+     * @since 1.2
+     */
+    hasSameRules(other: TimeZone): boolean;
+
+    /**
+     * Creates a copy of this <code>TimeZone</code>.
+     * @return a clone of this <code>TimeZone</code>
+     */
+    clone(): unknown;
+
+    /**
+     * A style specifier for <code>getDisplayName()</code> indicating
+     *  a short name, such as "PST."
+     * @see #LONG
+     * @since 1.2
+     */
+    SHORT: number;
+
+    /**
+     * A style specifier for <code>getDisplayName()</code> indicating
+     *  a long name, such as "Pacific Standard Time."
+     * @see #SHORT
+     * @since 1.2
+     */
+    LONG: number;
+  };

package/types/java/util/TimeZone/index.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getOffset: function getOffset() {},
+  setRawOffset: function setRawOffset() {},
+  getRawOffset: function getRawOffset() {},
+  getID: function getID() {},
+  setID: function setID() {},
+  getDisplayName: function getDisplayName() {},
+  getDSTSavings: function getDSTSavings() {},
+  useDaylightTime: function useDaylightTime() {},
+  observesDaylightTime: function observesDaylightTime() {},
+  inDaylightTime: function inDaylightTime() {},
+  toZoneId: function toZoneId() {},
+  hasSameRules: function hasSameRules() {},
+  clone: function clone() {}
+};
+exports["default"] = _default;

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

@@ -0,0 +1,26 @@
+/**
+ * A task that returns a result and may throw an exception.
+ *  Implementors define a single method with no arguments called
+ *  {@code call}.
+ *
+ *  <p>The {@code Callable} interface is similar to {@link
+ *  java.lang.Runnable}, in that both are designed for classes whose
+ *  instances are potentially executed by another thread.  A
+ *  {@code Runnable}, however, does not return a result and cannot
+ *  throw a checked exception.
+ *
+ *  <p>The {@link Executors} class contains utility methods to
+ *  convert from other common forms to {@code Callable} classes.
+ * @see Executor
+ * @since 1.5
+ * @author Doug Lea
+ * @param <V> the result type of method {@code call}
+ */
+export type Callable = {
+  /**
+   * Computes a result, or throws an exception if unable to do so.
+   * @return computed result
+   * @throws Exception if unable to compute a result
+   */
+  call(): unknown;
+};

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

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

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

@@ -0,0 +1,102 @@
+import type { Runnable } from "../../../lang/Runnable";
+
+/**
+ * An object that executes submitted {@link Runnable} tasks. This
+ *  interface provides a way of decoupling task submission from the
+ *  mechanics of how each task will be run, including details of thread
+ *  use, scheduling, etc.  An {@code Executor} is normally used
+ *  instead of explicitly creating threads. For example, rather than
+ *  invoking {@code new Thread(new(RunnableTask())).start()} for each
+ *  of a set of tasks, you might use:
+ *
+ *  <pre>
+ *  Executor executor = <em>anExecutor</em>;
+ *  executor.execute(new RunnableTask1());
+ *  executor.execute(new RunnableTask2());
+ *  ...
+ *  </pre>
+ *
+ *  However, the {@code Executor} interface does not strictly
+ *  require that execution be asynchronous. In the simplest case, an
+ *  executor can run the submitted task immediately in the caller's
+ *  thread:
+ *
+ *   <pre> {@code
+ *  class DirectExecutor implements Executor {
+ *    public void execute(Runnable r) {
+ *      r.run();
+ *    }
+ *  }}</pre>
+ *
+ *  More typically, tasks are executed in some thread other
+ *  than the caller's thread.  The executor below spawns a new thread
+ *  for each task.
+ *
+ *   <pre> {@code
+ *  class ThreadPerTaskExecutor implements Executor {
+ *    public void execute(Runnable r) {
+ *      new Thread(r).start();
+ *    }
+ *  }}</pre>
+ *
+ *  Many {@code Executor} implementations impose some sort of
+ *  limitation on how and when tasks are scheduled.  The executor below
+ *  serializes the submission of tasks to a second executor,
+ *  illustrating a composite executor.
+ *
+ *   <pre> {@code
+ *  class SerialExecutor implements Executor {
+ *    final Queue<Runnable> tasks = new ArrayDeque<Runnable>();
+ *    final Executor executor;
+ *    Runnable active;
+ *
+ *    SerialExecutor(Executor executor) {
+ *      this.executor = executor;
+ *    }
+ *
+ *    public synchronized void execute(final Runnable r) {
+ *      tasks.offer(new Runnable() {
+ *        public void run() {
+ *          try {
+ *            r.run();
+ *          } finally {
+ *            scheduleNext();
+ *          }
+ *        }
+ *      });
+ *      if (active == null) {
+ *        scheduleNext();
+ *      }
+ *    }
+ *
+ *    protected synchronized void scheduleNext() {
+ *      if ((active = tasks.poll()) != null) {
+ *        executor.execute(active);
+ *      }
+ *    }
+ *  }}</pre>
+ *
+ *  The {@code Executor} implementations provided in this package
+ *  implement {@link ExecutorService}, which is a more extensive
+ *  interface.  The {@link ThreadPoolExecutor} class provides an
+ *  extensible thread pool implementation. The {@link Executors} class
+ *  provides convenient factory methods for these Executors.
+ *
+ *  <p>Memory consistency effects: Actions in a thread prior to
+ *  submitting a {@code Runnable} object to an {@code Executor}
+ *  <a href="package-summary.html#MemoryVisibility"><i>happen-before</i></a>
+ *  its execution begins, perhaps in another thread.
+ * @since 1.5
+ * @author Doug Lea
+ */
+export type Executor = {
+  /**
+   * Executes the given command at some time in the future.  The command
+   *  may execute in a new thread, in a pooled thread, or in the calling
+   *  thread, at the discretion of the {@code Executor} implementation.
+   * @param command the runnable task
+   * @throws RejectedExecutionException if this task cannot be&#xA; accepted for execution
+   * @throws NullPointerException if command is null
+   */
+  execute(command: Runnable): void;
+};

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

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