@sitevision/api 2023.2.1 → 2023.2.2-beta.1

package/types/java/io/File/index.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getName: function getName() {},
+  getParent: function getParent() {},
+  getParentFile: function getParentFile() {},
+  getPath: function getPath() {},
+  isAbsolute: function isAbsolute() {},
+  getAbsolutePath: function getAbsolutePath() {},
+  getAbsoluteFile: function getAbsoluteFile() {},
+  getCanonicalPath: function getCanonicalPath() {},
+  getCanonicalFile: function getCanonicalFile() {},
+  toURL: function toURL() {},
+  toURI: function toURI() {},
+  canRead: function canRead() {},
+  canWrite: function canWrite() {},
+  exists: function exists() {},
+  isDirectory: function isDirectory() {},
+  isFile: function isFile() {},
+  isHidden: function isHidden() {},
+  lastModified: function lastModified() {},
+  length: function length() {},
+  createNewFile: function createNewFile() {},
+  "delete": function _delete() {},
+  deleteOnExit: function deleteOnExit() {},
+  list: function list() {},
+  listFiles: function listFiles() {},
+  mkdir: function mkdir() {},
+  mkdirs: function mkdirs() {},
+  renameTo: function renameTo() {},
+  setLastModified: function setLastModified() {},
+  setReadOnly: function setReadOnly() {},
+  setWritable: function setWritable() {},
+  setReadable: function setReadable() {},
+  setExecutable: function setExecutable() {},
+  canExecute: function canExecute() {},
+  listRoots: function listRoots() {},
+  getTotalSpace: function getTotalSpace() {},
+  getFreeSpace: function getFreeSpace() {},
+  getUsableSpace: function getUsableSpace() {},
+  createTempFile: function createTempFile() {},
+  compareTo: function compareTo() {},
+  equals: function equals() {},
+  hashCode: function hashCode() {},
+  toString: function toString() {},
+  toPath: function toPath() {}
+};
+exports["default"] = _default;

package/types/java/io/FileFilter/index.d.ts

@@ -0,0 +1,19 @@
+import type { File } from "../File";
+
+/**
+ * A filter for abstract pathnames.
+ *
+ *  <p> Instances of this interface may be passed to the <code>{@link
+ *  File#listFiles(java.io.FileFilter) listFiles(FileFilter)}</code> method
+ *  of the <code>{@link java.io.File}</code> class.
+ * @since 1.2
+ */
+export type FileFilter = {
+  /**
+   * Tests whether or not the specified abstract pathname should be
+   *  included in a pathname list.
+   * @param pathname The abstract pathname to be tested
+   * @return <code>true</code> if and only if <code>pathname</code>&#xA; should be included
+   */
+  accept(pathname: File): boolean;
+};

package/types/java/io/FileFilter/index.js

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

package/types/java/io/FilenameFilter/index.d.ts

@@ -0,0 +1,25 @@
+import type { File } from "../File";
+import type { String } from "../../lang/String";
+
+/**
+ * Instances of classes that implement this interface are used to
+ *  filter filenames. These instances are used to filter directory
+ *  listings in the <code>list</code> method of class
+ *  <code>File</code>, and by the Abstract Window Toolkit's file
+ *  dialog component.
+ * @author Arthur van Hoff
+ * @author Jonathan Payne
+ * @see java.awt.FileDialog#setFilenameFilter(java.io.FilenameFilter)
+ * @see java.io.File
+ * @see java.io.File#list(java.io.FilenameFilter)
+ * @since JDK1.0
+ */
+export type FilenameFilter = {
+  /**
+   * Tests if a specified file should be included in a file list.
+   * @param dir the directory in which the file was found.
+   * @param name the name of the file.
+   * @return <code>true</code> if and only if the name should be&#xA; included in the file list; <code>false</code> otherwise.
+   */
+  accept(dir: File, name: String | string): boolean;
+};

package/types/java/io/FilenameFilter/index.js

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

package/types/java/io/FilterOutputStream/index.d.ts

@@ -0,0 +1,93 @@
+import type { OutputStream } from "../OutputStream";
+
+/**
+ * This class is the superclass of all classes that filter output
+ *  streams. These streams sit on top of an already existing output
+ *  stream (the <i>underlying</i> output stream) which it uses as its
+ *  basic sink of data, but possibly transforming the data along the
+ *  way or providing additional functionality.
+ *  <p>
+ *  The class <code>FilterOutputStream</code> itself simply overrides
+ *  all methods of <code>OutputStream</code> with versions that pass
+ *  all requests to the underlying output stream. Subclasses of
+ *  <code>FilterOutputStream</code> may further override some of these
+ *  methods as well as provide additional methods and fields.
+ * @author Jonathan Payne
+ * @since JDK1.0
+ */
+export type FilterOutputStream = OutputStream & {
+  /**
+   * Writes the specified <code>byte</code> to this output stream.
+   *  <p>
+   *  The <code>write</code> method of <code>FilterOutputStream</code>
+   *  calls the <code>write</code> method of its underlying output stream,
+   *  that is, it performs <tt>out.write(b)</tt>.
+   *  <p>
+   *  Implements the abstract <tt>write</tt> method of <tt>OutputStream</tt>.
+   * @param b the <code>byte</code>.
+   * @throws IOException if an I/O error occurs.
+   */
+  write(b: number): void;
+
+  /**
+   * Writes <code>b.length</code> bytes to this output stream.
+   *  <p>
+   *  The <code>write</code> method of <code>FilterOutputStream</code>
+   *  calls its <code>write</code> method of three arguments with the
+   *  arguments <code>b</code>, <code>0</code>, and
+   *  <code>b.length</code>.
+   *  <p>
+   *  Note that this method does not call the one-argument
+   *  <code>write</code> method of its underlying stream with the single
+   *  argument <code>b</code>.
+   * @param b the data to be written.
+   * @throws IOException if an I/O error occurs.
+   * @see java.io.FilterOutputStream#write(byte[], int, int)
+   */
+  write(b: unknown[]): void;
+
+  /**
+   * Writes <code>len</code> bytes from the specified
+   *  <code>byte</code> array starting at offset <code>off</code> to
+   *  this output stream.
+   *  <p>
+   *  The <code>write</code> method of <code>FilterOutputStream</code>
+   *  calls the <code>write</code> method of one argument on each
+   *  <code>byte</code> to output.
+   *  <p>
+   *  Note that this method does not call the <code>write</code> method
+   *  of its underlying input stream with the same arguments. Subclasses
+   *  of <code>FilterOutputStream</code> should provide a more efficient
+   *  implementation of this method.
+   * @param b the data.
+   * @param off the start offset in the data.
+   * @param len the number of bytes to write.
+   * @throws IOException if an I/O error occurs.
+   * @see java.io.FilterOutputStream#write(int)
+   */
+  write(b: unknown[], off: number, len: number): void;
+
+  /**
+   * Flushes this output stream and forces any buffered output bytes
+   *  to be written out to the stream.
+   *  <p>
+   *  The <code>flush</code> method of <code>FilterOutputStream</code>
+   *  calls the <code>flush</code> method of its underlying output stream.
+   * @throws IOException if an I/O error occurs.
+   * @see java.io.FilterOutputStream#out
+   */
+  flush(): void;
+
+  /**
+   * Closes this output stream and releases any system resources
+   *  associated with the stream.
+   *  <p>
+   *  The <code>close</code> method of <code>FilterOutputStream</code>
+   *  calls its <code>flush</code> method, and then calls the
+   *  <code>close</code> method of its underlying output stream.
+   * @throws IOException if an I/O error occurs.
+   * @see java.io.FilterOutputStream#flush()
+   * @see java.io.FilterOutputStream#out
+   */
+  close(): void;
+};

package/types/java/io/FilterOutputStream/index.js

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

package/types/java/io/Flushable/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A <tt>Flushable</tt> is a destination of data that can be flushed.  The
+ *  flush method is invoked to write any buffered output to the underlying
+ *  stream.
+ * @since 1.5
+ */
+export type Flushable = {
+  /**
+   * Flushes this stream by writing any buffered output to the underlying
+   *  stream.
+   * @throws IOException If an I/O error occurs
+   */
+  flush(): void;
+};

package/types/java/io/Flushable/index.js

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

package/types/java/io/InputStream/index.d.ts

@@ -0,0 +1,255 @@
+import type { Object } from "../../lang/Object";
+import type { Closeable } from "../Closeable";
+
+/**
+ * This abstract class is the superclass of all classes representing
+ *  an input stream of bytes.
+ *
+ *  <p> Applications that need to define a subclass of <code>InputStream</code>
+ *  must always provide a method that returns the next byte of input.
+ * @author Arthur van Hoff
+ * @see java.io.BufferedInputStream
+ * @see java.io.ByteArrayInputStream
+ * @see java.io.DataInputStream
+ * @see java.io.FilterInputStream
+ * @see java.io.InputStream#read()
+ * @see java.io.OutputStream
+ * @see java.io.PushbackInputStream
+ * @since JDK1.0
+ */
+export type InputStream = Object &
+  Closeable & {
+    /**
+     * Reads the next byte of data from the input stream. The value byte is
+     *  returned as an <code>int</code> in the range <code>0</code> to
+     *  <code>255</code>. If no byte is available because the end of the stream
+     *  has been reached, the value <code>-1</code> is returned. This method
+     *  blocks until input data is available, the end of the stream is detected,
+     *  or an exception is thrown.
+     *
+     *  <p> A subclass must provide an implementation of this method.
+     * @return the next byte of data, or <code>-1</code> if the end of the&#xA; stream is reached.
+     * @throws IOException if an I/O error occurs.
+     */
+    read(): number;
+
+    /**
+     * Reads some number of bytes from the input stream and stores them into
+     *  the buffer array <code>b</code>. The number of bytes actually read is
+     *  returned as an integer.  This method blocks until input data is
+     *  available, end of file is detected, or an exception is thrown.
+     *
+     *  <p> If the length of <code>b</code> is zero, then no bytes are read and
+     *  <code>0</code> is returned; otherwise, there is an attempt to read at
+     *  least one byte. If no byte is available because the stream is at the
+     *  end of the file, the value <code>-1</code> is returned; otherwise, at
+     *  least one byte is read and stored into <code>b</code>.
+     *
+     *  <p> The first byte read is stored into element <code>b[0]</code>, the
+     *  next one into <code>b[1]</code>, and so on. The number of bytes read is,
+     *  at most, equal to the length of <code>b</code>. Let <i>k</i> be the
+     *  number of bytes actually read; these bytes will be stored in elements
+     *  <code>b[0]</code> through <code>b[</code><i>k</i><code>-1]</code>,
+     *  leaving elements <code>b[</code><i>k</i><code>]</code> through
+     *  <code>b[b.length-1]</code> unaffected.
+     *
+     *  <p> The <code>read(b)</code> method for class <code>InputStream</code>
+     *  has the same effect as: <pre><code> read(b, 0, b.length) </code></pre>
+     * @param b the buffer into which the data is read.
+     * @return the total number of bytes read into the buffer, or&#xA; <code>-1</code> if there is no more data because the end of&#xA; the stream has been reached.
+     * @throws IOException If the first byte cannot be read for any reason&#xA; other than the end of the file, if the input stream has been closed, or&#xA; if some other I/O error occurs.
+     * @throws NullPointerException if <code>b</code> is <code>null</code>.
+     * @see java.io.InputStream#read(byte[], int, int)
+     */
+    read(b: unknown[]): number;
+
+    /**
+     * Reads up to <code>len</code> bytes of data from the input stream into
+     *  an array of bytes.  An attempt is made to read as many as
+     *  <code>len</code> bytes, but a smaller number may be read.
+     *  The number of bytes actually read is returned as an integer.
+     *
+     *  <p> This method blocks until input data is available, end of file is
+     *  detected, or an exception is thrown.
+     *
+     *  <p> If <code>len</code> is zero, then no bytes are read and
+     *  <code>0</code> is returned; otherwise, there is an attempt to read at
+     *  least one byte. If no byte is available because the stream is at end of
+     *  file, the value <code>-1</code> is returned; otherwise, at least one
+     *  byte is read and stored into <code>b</code>.
+     *
+     *  <p> The first byte read is stored into element <code>b[off]</code>, the
+     *  next one into <code>b[off+1]</code>, and so on. The number of bytes read
+     *  is, at most, equal to <code>len</code>. Let <i>k</i> be the number of
+     *  bytes actually read; these bytes will be stored in elements
+     *  <code>b[off]</code> through <code>b[off+</code><i>k</i><code>-1]</code>,
+     *  leaving elements <code>b[off+</code><i>k</i><code>]</code> through
+     *  <code>b[off+len-1]</code> unaffected.
+     *
+     *  <p> In every case, elements <code>b[0]</code> through
+     *  <code>b[off]</code> and elements <code>b[off+len]</code> through
+     *  <code>b[b.length-1]</code> are unaffected.
+     *
+     *  <p> The <code>read(b,</code> <code>off,</code> <code>len)</code> method
+     *  for class <code>InputStream</code> simply calls the method
+     *  <code>read()</code> repeatedly. If the first such call results in an
+     *  <code>IOException</code>, that exception is returned from the call to
+     *  the <code>read(b,</code> <code>off,</code> <code>len)</code> method.  If
+     *  any subsequent call to <code>read()</code> results in a
+     *  <code>IOException</code>, the exception is caught and treated as if it
+     *  were end of file; the bytes read up to that point are stored into
+     *  <code>b</code> and the number of bytes read before the exception
+     *  occurred is returned. The default implementation of this method blocks
+     *  until the requested amount of input data <code>len</code> has been read,
+     *  end of file is detected, or an exception is thrown. Subclasses are encouraged
+     *  to provide a more efficient implementation of this method.
+     * @param b the buffer into which the data is read.
+     * @param off the start offset in array <code>b</code>&#xA; at which the data is written.
+     * @param len the maximum number of bytes to read.
+     * @return the total number of bytes read into the buffer, or&#xA; <code>-1</code> if there is no more data because the end of&#xA; the stream has been reached.
+     * @throws IOException If the first byte cannot be read for any reason&#xA; other than end of file, or if the input stream has been closed, or if&#xA; some other I/O error occurs.
+     * @throws NullPointerException If <code>b</code> is <code>null</code>.
+     * @throws IndexOutOfBoundsException If <code>off</code> is negative,&#xA; <code>len</code> is negative, or <code>len</code> is greater than&#xA; <code>b.length - off</code>
+     * @see java.io.InputStream#read()
+     */
+    read(b: unknown[], off: number, len: number): number;
+
+    /**
+     * Skips over and discards <code>n</code> bytes of data from this input
+     *  stream. The <code>skip</code> method may, for a variety of reasons, end
+     *  up skipping over some smaller number of bytes, possibly <code>0</code>.
+     *  This may result from any of a number of conditions; reaching end of file
+     *  before <code>n</code> bytes have been skipped is only one possibility.
+     *  The actual number of bytes skipped is returned. If {@code n} is
+     *  negative, the {@code skip} method for class {@code InputStream} always
+     *  returns 0, and no bytes are skipped. Subclasses may handle the negative
+     *  value differently.
+     *
+     *  <p> The <code>skip</code> method of this class creates a
+     *  byte array and then repeatedly reads into it until <code>n</code> bytes
+     *  have been read or the end of the stream has been reached. Subclasses are
+     *  encouraged to provide a more efficient implementation of this method.
+     *  For instance, the implementation may depend on the ability to seek.
+     * @param n the number of bytes to be skipped.
+     * @return the actual number of bytes skipped.
+     * @throws IOException if the stream does not support seek,&#xA; or if some other I/O error occurs.
+     */
+    skip(n: number): number;
+
+    /**
+     * Returns an estimate of the number of bytes that can be read (or
+     *  skipped over) from this input stream without blocking by the next
+     *  invocation of a method for this input stream. The next invocation
+     *  might be the same thread or another thread.  A single read or skip of this
+     *  many bytes will not block, but may read or skip fewer bytes.
+     *
+     *  <p> Note that while some implementations of {@code InputStream} will return
+     *  the total number of bytes in the stream, many will not.  It is
+     *  never correct to use the return value of this method to allocate
+     *  a buffer intended to hold all data in this stream.
+     *
+     *  <p> A subclass' implementation of this method may choose to throw an
+     *  {@link IOException} if this input stream has been closed by
+     *  invoking the {@link #close()} method.
+     *
+     *  <p> The {@code available} method for class {@code InputStream} always
+     *  returns {@code 0}.
+     *
+     *  <p> This method should be overridden by subclasses.
+     * @return an estimate of the number of bytes that can be read (or skipped&#xA; over) from this input stream without blocking or {@code 0} when&#xA; it reaches the end of the input stream.
+     * @throws IOException if an I/O error occurs.
+     */
+    available(): number;
+
+    /**
+     * Closes this input stream and releases any system resources associated
+     *  with the stream.
+     *
+     *  <p> The <code>close</code> method of <code>InputStream</code> does
+     *  nothing.
+     * @throws IOException if an I/O error occurs.
+     */
+    close(): void;
+
+    /**
+     * Marks the current position in this input stream. A subsequent call to
+     *  the <code>reset</code> method repositions this stream at the last marked
+     *  position so that subsequent reads re-read the same bytes.
+     *
+     *  <p> The <code>readlimit</code> arguments tells this input stream to
+     *  allow that many bytes to be read before the mark position gets
+     *  invalidated.
+     *
+     *  <p> The general contract of <code>mark</code> is that, if the method
+     *  <code>markSupported</code> returns <code>true</code>, the stream somehow
+     *  remembers all the bytes read after the call to <code>mark</code> and
+     *  stands ready to supply those same bytes again if and whenever the method
+     *  <code>reset</code> is called.  However, the stream is not required to
+     *  remember any data at all if more than <code>readlimit</code> bytes are
+     *  read from the stream before <code>reset</code> is called.
+     *
+     *  <p> Marking a closed stream should not have any effect on the stream.
+     *
+     *  <p> The <code>mark</code> method of <code>InputStream</code> does
+     *  nothing.
+     * @param readlimit the maximum limit of bytes that can be read before&#xA; the mark position becomes invalid.
+     * @see java.io.InputStream#reset()
+     */
+    mark(readlimit: number): void;
+
+    /**
+     * Repositions this stream to the position at the time the
+     *  <code>mark</code> method was last called on this input stream.
+     *
+     *  <p> The general contract of <code>reset</code> is:
+     *
+     *  <ul>
+     *  <li> If the method <code>markSupported</code> returns
+     *  <code>true</code>, then:
+     *
+     *      <ul><li> If the method <code>mark</code> has not been called since
+     *      the stream was created, or the number of bytes read from the stream
+     *      since <code>mark</code> was last called is larger than the argument
+     *      to <code>mark</code> at that last call, then an
+     *      <code>IOException</code> might be thrown.
+     *
+     *      <li> If such an <code>IOException</code> is not thrown, then the
+     *      stream is reset to a state such that all the bytes read since the
+     *      most recent call to <code>mark</code> (or since the start of the
+     *      file, if <code>mark</code> has not been called) will be resupplied
+     *      to subsequent callers of the <code>read</code> method, followed by
+     *      any bytes that otherwise would have been the next input data as of
+     *      the time of the call to <code>reset</code>. </ul>
+     *
+     *  <li> If the method <code>markSupported</code> returns
+     *  <code>false</code>, then:
+     *
+     *      <ul><li> The call to <code>reset</code> may throw an
+     *      <code>IOException</code>.
+     *
+     *      <li> If an <code>IOException</code> is not thrown, then the stream
+     *      is reset to a fixed state that depends on the particular type of the
+     *      input stream and how it was created. The bytes that will be supplied
+     *      to subsequent callers of the <code>read</code> method depend on the
+     *      particular type of the input stream. </ul></ul>
+     *
+     *  <p>The method <code>reset</code> for class <code>InputStream</code>
+     *  does nothing except throw an <code>IOException</code>.
+     * @throws IOException if this stream has not been marked or if the&#xA; mark has been invalidated.
+     * @see java.io.InputStream#mark(int)
+     * @see java.io.IOException
+     */
+    reset(): void;
+
+    /**
+     * Tests if this input stream supports the <code>mark</code> and
+     *  <code>reset</code> methods. Whether or not <code>mark</code> and
+     *  <code>reset</code> are supported is an invariant property of a
+     *  particular input stream instance. The <code>markSupported</code> method
+     *  of <code>InputStream</code> returns <code>false</code>.
+     * @return <code>true</code> if this stream instance supports the mark&#xA; and reset methods; <code>false</code> otherwise.
+     * @see java.io.InputStream#mark(int)
+     * @see java.io.InputStream#reset()
+     */
+    markSupported(): boolean;
+  };

package/types/java/io/InputStream/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  read: function read() {},
+  skip: function skip() {},
+  available: function available() {},
+  close: function close() {},
+  mark: function mark() {},
+  reset: function reset() {},
+  markSupported: function markSupported() {}
+};
+exports["default"] = _default;

package/types/java/io/OutputStream/index.d.ts

@@ -0,0 +1,106 @@
+import type { Object } from "../../lang/Object";
+import type { Closeable } from "../Closeable";
+import type { Flushable } from "../Flushable";
+
+/**
+ * This abstract class is the superclass of all classes representing
+ *  an output stream of bytes. An output stream accepts output bytes
+ *  and sends them to some sink.
+ *  <p>
+ *  Applications that need to define a subclass of
+ *  <code>OutputStream</code> must always provide at least a method
+ *  that writes one byte of output.
+ * @author Arthur van Hoff
+ * @see java.io.BufferedOutputStream
+ * @see java.io.ByteArrayOutputStream
+ * @see java.io.DataOutputStream
+ * @see java.io.FilterOutputStream
+ * @see java.io.InputStream
+ * @see java.io.OutputStream#write(int)
+ * @since JDK1.0
+ */
+export type OutputStream = Object &
+  Closeable &
+  Flushable & {
+    /**
+     * Writes the specified byte to this output stream. The general
+     *  contract for <code>write</code> is that one byte is written
+     *  to the output stream. The byte to be written is the eight
+     *  low-order bits of the argument <code>b</code>. The 24
+     *  high-order bits of <code>b</code> are ignored.
+     *  <p>
+     *  Subclasses of <code>OutputStream</code> must provide an
+     *  implementation for this method.
+     * @param b the <code>byte</code>.
+     * @throws IOException if an I/O error occurs. In particular,&#xA; an <code>IOException</code> may be thrown if the&#xA; output stream has been closed.
+     */
+    write(b: number): void;
+
+    /**
+     * Writes <code>b.length</code> bytes from the specified byte array
+     *  to this output stream. The general contract for <code>write(b)</code>
+     *  is that it should have exactly the same effect as the call
+     *  <code>write(b, 0, b.length)</code>.
+     * @param b the data.
+     * @throws IOException if an I/O error occurs.
+     * @see java.io.OutputStream#write(byte[], int, int)
+     */
+    write(b: unknown[]): void;
+
+    /**
+     * Writes <code>len</code> bytes from the specified byte array
+     *  starting at offset <code>off</code> to this output stream.
+     *  The general contract for <code>write(b, off, len)</code> is that
+     *  some of the bytes in the array <code>b</code> are written to the
+     *  output stream in order; element <code>b[off]</code> is the first
+     *  byte written and <code>b[off+len-1]</code> is the last byte written
+     *  by this operation.
+     *  <p>
+     *  The <code>write</code> method of <code>OutputStream</code> calls
+     *  the write method of one argument on each of the bytes to be
+     *  written out. Subclasses are encouraged to override this method and
+     *  provide a more efficient implementation.
+     *  <p>
+     *  If <code>b</code> is <code>null</code>, a
+     *  <code>NullPointerException</code> is thrown.
+     *  <p>
+     *  If <code>off</code> is negative, or <code>len</code> is negative, or
+     *  <code>off+len</code> is greater than the length of the array
+     *  <code>b</code>, then an <tt>IndexOutOfBoundsException</tt> is thrown.
+     * @param b the data.
+     * @param off the start offset in the data.
+     * @param len the number of bytes to write.
+     * @throws IOException if an I/O error occurs. In particular,&#xA; an <code>IOException</code> is thrown if the output&#xA; stream is closed.
+     */
+    write(b: unknown[], off: number, len: number): void;
+
+    /**
+     * Flushes this output stream and forces any buffered output bytes
+     *  to be written out. The general contract of <code>flush</code> is
+     *  that calling it is an indication that, if any bytes previously
+     *  written have been buffered by the implementation of the output
+     *  stream, such bytes should immediately be written to their
+     *  intended destination.
+     *  <p>
+     *  If the intended destination of this stream is an abstraction provided by
+     *  the underlying operating system, for example a file, then flushing the
+     *  stream guarantees only that bytes previously written to the stream are
+     *  passed to the operating system for writing; it does not guarantee that
+     *  they are actually written to a physical device such as a disk drive.
+     *  <p>
+     *  The <code>flush</code> method of <code>OutputStream</code> does nothing.
+     * @throws IOException if an I/O error occurs.
+     */
+    flush(): void;
+
+    /**
+     * Closes this output stream and releases any system resources
+     *  associated with this stream. The general contract of <code>close</code>
+     *  is that it closes the output stream. A closed stream cannot perform
+     *  output operations and cannot be reopened.
+     *  <p>
+     *  The <code>close</code> method of <code>OutputStream</code> does nothing.
+     * @throws IOException if an I/O error occurs.
+     */
+    close(): void;
+  };

package/types/java/io/OutputStream/index.js

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