@sitevision/api 2023.2.1 → 2023.2.2-beta.2

package/types/java/nio/channels/FileChannel.MapMode/index.d.ts

@@ -0,0 +1,33 @@
+import type { String } from "../../../lang/String";
+import type { Object } from "../../../lang/Object";
+
+/**
+ * A typesafe enumeration for file-mapping modes.
+ * @since 1.4
+ * @see java.nio.channels.FileChannel#map
+ */
+export type MapMode = Object & {
+  /**
+   * Returns a string describing this file-mapping mode.
+   * @return A descriptive string
+   */
+  toString(): string;
+
+  /**
+ * Mode for a read-only mapping.
+  
+    */
+  READ_ONLY: MapMode;
+
+  /**
+ * Mode for a read/write mapping.
+  
+    */
+  READ_WRITE: MapMode;
+
+  /**
+ * Mode for a private (copy-on-write) mapping.
+  
+    */
+  PRIVATE: MapMode;
+};

package/types/java/nio/channels/FileChannel.MapMode/index.js

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

package/types/java/nio/channels/FileLock/index.d.ts

@@ -0,0 +1,180 @@
+import type { FileChannel } from "../FileChannel";
+import type { Channel } from "../Channel";
+
+import type { String } from "../../../lang/String";
+import type { Object } from "../../../lang/Object";
+import type { AutoCloseable } from "../../../lang/AutoCloseable";
+
+/**
+ * A token representing a lock on a region of a file.
+ *
+ *  <p> A file-lock object is created each time a lock is acquired on a file via
+ *  one of the {@link FileChannel#lock(long,long,boolean) lock} or {@link
+ *  FileChannel#tryLock(long,long,boolean) tryLock} methods of the
+ *  {@link FileChannel} class, or the {@link
+ *  AsynchronousFileChannel#lock(long,long,boolean,Object,CompletionHandler) lock}
+ *  or {@link AsynchronousFileChannel#tryLock(long,long,boolean) tryLock}
+ *  methods of the {@link AsynchronousFileChannel} class.
+ *
+ *  <p> A file-lock object is initially valid.  It remains valid until the lock
+ *  is released by invoking the {@link #release release} method, by closing the
+ *  channel that was used to acquire it, or by the termination of the Java
+ *  virtual machine, whichever comes first.  The validity of a lock may be
+ *  tested by invoking its {@link #isValid isValid} method.
+ *
+ *  <p> A file lock is either <i>exclusive</i> or <i>shared</i>.  A shared lock
+ *  prevents other concurrently-running programs from acquiring an overlapping
+ *  exclusive lock, but does allow them to acquire overlapping shared locks.  An
+ *  exclusive lock prevents other programs from acquiring an overlapping lock of
+ *  either type.  Once it is released, a lock has no further effect on the locks
+ *  that may be acquired by other programs.
+ *
+ *  <p> Whether a lock is exclusive or shared may be determined by invoking its
+ *  {@link #isShared isShared} method.  Some platforms do not support shared
+ *  locks, in which case a request for a shared lock is automatically converted
+ *  into a request for an exclusive lock.
+ *
+ *  <p> The locks held on a particular file by a single Java virtual machine do
+ *  not overlap.  The {@link #overlaps overlaps} method may be used to test
+ *  whether a candidate lock range overlaps an existing lock.
+ *
+ *  <p> A file-lock object records the file channel upon whose file the lock is
+ *  held, the type and validity of the lock, and the position and size of the
+ *  locked region.  Only the validity of a lock is subject to change over time;
+ *  all other aspects of a lock's state are immutable.
+ *
+ *  <p> File locks are held on behalf of the entire Java virtual machine.
+ *  They are not suitable for controlling access to a file by multiple
+ *  threads within the same virtual machine.
+ *
+ *  <p> File-lock objects are safe for use by multiple concurrent threads.
+ *
+ *
+ *  <a name="pdep"></a><h2> Platform dependencies </h2>
+ *
+ *  <p> This file-locking API is intended to map directly to the native locking
+ *  facility of the underlying operating system.  Thus the locks held on a file
+ *  should be visible to all programs that have access to the file, regardless
+ *  of the language in which those programs are written.
+ *
+ *  <p> Whether or not a lock actually prevents another program from accessing
+ *  the content of the locked region is system-dependent and therefore
+ *  unspecified.  The native file-locking facilities of some systems are merely
+ *  <i>advisory</i>, meaning that programs must cooperatively observe a known
+ *  locking protocol in order to guarantee data integrity.  On other systems
+ *  native file locks are <i>mandatory</i>, meaning that if one program locks a
+ *  region of a file then other programs are actually prevented from accessing
+ *  that region in a way that would violate the lock.  On yet other systems,
+ *  whether native file locks are advisory or mandatory is configurable on a
+ *  per-file basis.  To ensure consistent and correct behavior across platforms,
+ *  it is strongly recommended that the locks provided by this API be used as if
+ *  they were advisory locks.
+ *
+ *  <p> On some systems, acquiring a mandatory lock on a region of a file
+ *  prevents that region from being {@link java.nio.channels.FileChannel#map
+ *  <i>mapped into memory</i>}, and vice versa.  Programs that combine
+ *  locking and mapping should be prepared for this combination to fail.
+ *
+ *  <p> On some systems, closing a channel releases all locks held by the Java
+ *  virtual machine on the underlying file regardless of whether the locks were
+ *  acquired via that channel or via another channel open on the same file.  It
+ *  is strongly recommended that, within a program, a unique channel be used to
+ *  acquire all locks on any given file.
+ *
+ *  <p> Some network filesystems permit file locking to be used with
+ *  memory-mapped files only when the locked regions are page-aligned and a
+ *  whole multiple of the underlying hardware's page size.  Some network
+ *  filesystems do not implement file locks on regions that extend past a
+ *  certain position, often 2<sup>30</sup> or 2<sup>31</sup>.  In general, great
+ *  care should be taken when locking files that reside on network filesystems.
+ * @author Mark Reinhold
+ * @author JSR-51 Expert Group
+ * @since 1.4
+ */
+export type FileLock = Object &
+  AutoCloseable & {
+    /**
+     * Returns the file channel upon whose file this lock was acquired.
+     *
+     *  <p> This method has been superseded by the {@link #acquiredBy acquiredBy}
+     *  method.
+     * @return The file channel, or {@code null} if the file lock was not&#xA; acquired by a file channel.
+     */
+    channel(): FileChannel;
+
+    /**
+     * Returns the channel upon whose file this lock was acquired.
+     * @return The channel upon whose file this lock was acquired.
+     * @since 1.7
+     */
+    acquiredBy(): Channel;
+
+    /**
+     * Returns the position within the file of the first byte of the locked
+     *  region.
+     *
+     *  <p> A locked region need not be contained within, or even overlap, the
+     *  actual underlying file, so the value returned by this method may exceed
+     *  the file's current size.  </p>
+     * @return The position
+     */
+    position(): number;
+
+    /**
+     * Returns the size of the locked region in bytes.
+     *
+     *  <p> A locked region need not be contained within, or even overlap, the
+     *  actual underlying file, so the value returned by this method may exceed
+     *  the file's current size.  </p>
+     * @return The size of the locked region
+     */
+    size(): number;
+
+    /**
+     * Tells whether this lock is shared.
+     * @return <tt>true</tt> if lock is shared,&#xA; <tt>false</tt> if it is exclusive
+     */
+    isShared(): boolean;
+
+    /**
+     * Tells whether or not this lock overlaps the given lock range.
+     * @param position&#xA; The starting position of the lock range
+     * @param size&#xA; The size of the lock range
+     * @return <tt>true</tt> if, and only if, this lock and the given lock&#xA; range overlap by at least one byte
+     */
+    overlaps(position: number, size: number): boolean;
+
+    /**
+     * Tells whether or not this lock is valid.
+     *
+     *  <p> A lock object remains valid until it is released or the associated
+     *  file channel is closed, whichever comes first.  </p>
+     * @return <tt>true</tt> if, and only if, this lock is valid
+     */
+    isValid(): boolean;
+
+    /**
+     * Releases this lock.
+     *
+     *  <p> If this lock object is valid then invoking this method releases the
+     *  lock and renders the object invalid.  If this lock object is invalid
+     *  then invoking this method has no effect.  </p>
+     * @throws ClosedChannelException&#xA; If the channel that was used to acquire this lock&#xA; is no longer open
+     * @throws IOException&#xA; If an I/O error occurs
+     */
+    release(): void;
+
+    /**
+     * This method invokes the {@link #release} method. It was added
+     *  to the class so that it could be used in conjunction with the
+     *  automatic resource management block construct.
+     * @since 1.7
+     */
+    close(): void;
+
+    /**
+     * Returns a string describing the range, type, and validity of this lock.
+     * @return A descriptive string
+     */
+    toString(): string;
+  };

package/types/java/nio/channels/FileLock/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  channel: function channel() {},
+  acquiredBy: function acquiredBy() {},
+  position: function position() {},
+  size: function size() {},
+  isShared: function isShared() {},
+  overlaps: function overlaps() {},
+  isValid: function isValid() {},
+  release: function release() {},
+  close: function close() {},
+  toString: function toString() {}
+};
+exports["default"] = _default;

package/types/java/nio/channels/GatheringByteChannel/index.d.ts

@@ -0,0 +1,83 @@
+import type { WritableByteChannel } from "../WritableByteChannel";
+
+/**
+ * A channel that can write bytes from a sequence of buffers.
+ *
+ *  <p> A <i>gathering</i> write operation writes, in a single invocation, a
+ *  sequence of bytes from one or more of a given sequence of buffers.
+ *  Gathering writes are often useful when implementing network protocols or
+ *  file formats that, for example, group data into segments consisting of one
+ *  or more fixed-length headers followed by a variable-length body.  Similar
+ *  <i>scattering</i> read operations are defined in the {@link
+ *  ScatteringByteChannel} interface.  </p>
+ * @author Mark Reinhold
+ * @author JSR-51 Expert Group
+ * @since 1.4
+ */
+export type GatheringByteChannel = WritableByteChannel & {
+  /**
+   * Writes a sequence of bytes to this channel from a subsequence of the
+   *  given buffers.
+   *
+   *  <p> An attempt is made to write up to <i>r</i> bytes to this channel,
+   *  where <i>r</i> is the total number of bytes remaining in the specified
+   *  subsequence of the given buffer array, that is,
+   *
+   *  <blockquote><pre>
+   *  srcs[offset].remaining()
+   *      + srcs[offset+1].remaining()
+   *      + ... + srcs[offset+length-1].remaining()</pre></blockquote>
+   *
+   *  at the moment that this method is invoked.
+   *
+   *  <p> Suppose that a byte sequence of length <i>n</i> is written, where
+   *  <tt>0</tt>&nbsp;<tt>&lt;=</tt>&nbsp;<i>n</i>&nbsp;<tt>&lt;=</tt>&nbsp;<i>r</i>.
+   *  Up to the first <tt>srcs[offset].remaining()</tt> bytes of this sequence
+   *  are written from buffer <tt>srcs[offset]</tt>, up to the next
+   *  <tt>srcs[offset+1].remaining()</tt> bytes are written from buffer
+   *  <tt>srcs[offset+1]</tt>, and so forth, until the entire byte sequence is
+   *  written.  As many bytes as possible are written from each buffer, hence
+   *  the final position of each updated buffer, except the last updated
+   *  buffer, is guaranteed to be equal to that buffer's limit.
+   *
+   *  <p> Unless otherwise specified, a write operation will return only after
+   *  writing all of the <i>r</i> requested bytes.  Some types of channels,
+   *  depending upon their state, may write only some of the bytes or possibly
+   *  none at all.  A socket channel in non-blocking mode, for example, cannot
+   *  write any more bytes than are free in the socket's output buffer.
+   *
+   *  <p> This method may be invoked at any time.  If another thread has
+   *  already initiated a write operation upon this channel, however, then an
+   *  invocation of this method will block until the first operation is
+   *  complete. </p>
+   * @param srcs&#xA; The buffers from which bytes are to be retrieved
+   * @param offset&#xA; The offset within the buffer array of the first buffer from&#xA; which bytes are to be retrieved; must be non-negative and no&#xA; larger than <tt>srcs.length</tt>
+   * @param length&#xA; The maximum number of buffers to be accessed; must be&#xA; non-negative and no larger than&#xA; <tt>srcs.length</tt>&nbsp;-&nbsp;<tt>offset</tt>
+   * @return The number of bytes written, possibly zero
+   * @throws IndexOutOfBoundsException&#xA; If the preconditions on the <tt>offset</tt> and <tt>length</tt>&#xA; parameters do not hold
+   * @throws NonWritableChannelException&#xA; If this channel was not opened for writing
+   * @throws ClosedChannelException&#xA; If this channel is closed
+   * @throws AsynchronousCloseException&#xA; If another thread closes this channel&#xA; while the write operation is in progress
+   * @throws ClosedByInterruptException&#xA; If another thread interrupts the current thread&#xA; while the write operation is in progress, thereby&#xA; closing the channel and setting the current thread's&#xA; interrupt status
+   * @throws IOException&#xA; If some other I/O error occurs
+   */
+  write(srcs: unknown[], offset: number, length: number): number;
+
+  /**
+   * Writes a sequence of bytes to this channel from the given buffers.
+   *
+   *  <p> An invocation of this method of the form <tt>c.write(srcs)</tt>
+   *  behaves in exactly the same manner as the invocation
+   *
+   *  <blockquote><pre>
+   *  c.write(srcs, 0, srcs.length);</pre></blockquote>
+   * @param srcs&#xA; The buffers from which bytes are to be retrieved
+   * @return The number of bytes written, possibly zero
+   * @throws NonWritableChannelException&#xA; If this channel was not opened for writing
+   * @throws ClosedChannelException&#xA; If this channel is closed
+   * @throws AsynchronousCloseException&#xA; If another thread closes this channel&#xA; while the write operation is in progress
+   * @throws ClosedByInterruptException&#xA; If another thread interrupts the current thread&#xA; while the write operation is in progress, thereby&#xA; closing the channel and setting the current thread's&#xA; interrupt status
+   * @throws IOException&#xA; If some other I/O error occurs
+   */
+  write(srcs: unknown[]): number;
+};

package/types/java/nio/channels/GatheringByteChannel/index.js

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

package/types/java/nio/channels/InterruptibleChannel/index.d.ts

@@ -0,0 +1,43 @@
+import type { Channel } from "../Channel";
+
+/**
+ * A channel that can be asynchronously closed and interrupted.
+ *
+ *  <p> A channel that implements this interface is <i>asynchronously
+ *  closeable:</i> If a thread is blocked in an I/O operation on an
+ *  interruptible channel then another thread may invoke the channel's {@link
+ *  #close close} method.  This will cause the blocked thread to receive an
+ *  {@link AsynchronousCloseException}.
+ *
+ *  <p> A channel that implements this interface is also <i>interruptible:</i>
+ *  If a thread is blocked in an I/O operation on an interruptible channel then
+ *  another thread may invoke the blocked thread's {@link Thread#interrupt()
+ *  interrupt} method.  This will cause the channel to be closed, the blocked
+ *  thread to receive a {@link ClosedByInterruptException}, and the blocked
+ *  thread's interrupt status to be set.
+ *
+ *  <p> If a thread's interrupt status is already set and it invokes a blocking
+ *  I/O operation upon a channel then the channel will be closed and the thread
+ *  will immediately receive a {@link ClosedByInterruptException}; its interrupt
+ *  status will remain set.
+ *
+ *  <p> A channel supports asynchronous closing and interruption if, and only
+ *  if, it implements this interface.  This can be tested at runtime, if
+ *  necessary, via the <tt>instanceof</tt> operator.
+ * @author Mark Reinhold
+ * @author JSR-51 Expert Group
+ * @since 1.4
+ */
+export type InterruptibleChannel = Channel & {
+  /**
+   * Closes this channel.
+   *
+   *  <p> Any thread currently blocked in an I/O operation upon this channel
+   *  will receive an {@link AsynchronousCloseException}.
+   *
+   *  <p> This method otherwise behaves exactly as specified by the {@link
+   *  Channel#close Channel} interface.  </p>
+   * @throws IOException If an I/O error occurs
+   */
+  close(): void;
+};

package/types/java/nio/channels/InterruptibleChannel/index.js

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

package/types/java/nio/channels/ReadableByteChannel/index.d.ts

@@ -0,0 +1,56 @@
+import type { Channel } from "../Channel";
+
+/**
+ * A channel that can read bytes.
+ *
+ *  <p> Only one read operation upon a readable channel may be in progress at
+ *  any given time.  If one thread initiates a read operation upon a channel
+ *  then any other thread that attempts to initiate another read operation will
+ *  block until the first operation is complete.  Whether or not other kinds of
+ *  I/O operations may proceed concurrently with a read operation depends upon
+ *  the type of the channel. </p>
+ * @author Mark Reinhold
+ * @author JSR-51 Expert Group
+ * @since 1.4
+ */
+export type ReadableByteChannel = Channel & {
+  /**
+   * Reads a sequence of bytes from this channel into the given buffer.
+   *
+   *  <p> An attempt is made to read up to <i>r</i> bytes from the channel,
+   *  where <i>r</i> is the number of bytes remaining in the buffer, that is,
+   *  <tt>dst.remaining()</tt>, at the moment this method is invoked.
+   *
+   *  <p> Suppose that a byte sequence of length <i>n</i> is read, where
+   *  <tt>0</tt>&nbsp;<tt>&lt;=</tt>&nbsp;<i>n</i>&nbsp;<tt>&lt;=</tt>&nbsp;<i>r</i>.
+   *  This byte sequence will be transferred into the buffer so that the first
+   *  byte in the sequence is at index <i>p</i> and the last byte is at index
+   *  <i>p</i>&nbsp;<tt>+</tt>&nbsp;<i>n</i>&nbsp;<tt>-</tt>&nbsp;<tt>1</tt>,
+   *  where <i>p</i> is the buffer's position at the moment this method is
+   *  invoked.  Upon return the buffer's position will be equal to
+   *  <i>p</i>&nbsp;<tt>+</tt>&nbsp;<i>n</i>; its limit will not have changed.
+   *
+   *  <p> A read operation might not fill the buffer, and in fact it might not
+   *  read any bytes at all.  Whether or not it does so depends upon the
+   *  nature and state of the channel.  A socket channel in non-blocking mode,
+   *  for example, cannot read any more bytes than are immediately available
+   *  from the socket's input buffer; similarly, a file channel cannot read
+   *  any more bytes than remain in the file.  It is guaranteed, however, that
+   *  if a channel is in blocking mode and there is at least one byte
+   *  remaining in the buffer then this method will block until at least one
+   *  byte is read.
+   *
+   *  <p> This method may be invoked at any time.  If another thread has
+   *  already initiated a read operation upon this channel, however, then an
+   *  invocation of this method will block until the first operation is
+   *  complete. </p>
+   * @param dst&#xA; The buffer into which bytes are to be transferred
+   * @return The number of bytes read, possibly zero, or <tt>-1</tt> if the&#xA; channel has reached end-of-stream
+   * @throws NonReadableChannelException&#xA; If this channel was not opened for reading
+   * @throws ClosedChannelException&#xA; If this channel is closed
+   * @throws AsynchronousCloseException&#xA; If another thread closes this channel&#xA; while the read operation is in progress
+   * @throws ClosedByInterruptException&#xA; If another thread interrupts the current thread&#xA; while the read operation is in progress, thereby&#xA; closing the channel and setting the current thread's&#xA; interrupt status
+   * @throws IOException&#xA; If some other I/O error occurs
+   */
+  read(dst: unknown): number;
+};

package/types/java/nio/channels/ReadableByteChannel/index.js

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

package/types/java/nio/channels/ScatteringByteChannel/index.d.ts

@@ -0,0 +1,78 @@
+import type { ReadableByteChannel } from "../ReadableByteChannel";
+
+/**
+ * A channel that can read bytes into a sequence of buffers.
+ *
+ *  <p> A <i>scattering</i> read operation reads, in a single invocation, a
+ *  sequence of bytes into one or more of a given sequence of buffers.
+ *  Scattering reads are often useful when implementing network protocols or
+ *  file formats that, for example, group data into segments consisting of one
+ *  or more fixed-length headers followed by a variable-length body.  Similar
+ *  <i>gathering</i> write operations are defined in the {@link
+ *  GatheringByteChannel} interface.  </p>
+ * @author Mark Reinhold
+ * @author JSR-51 Expert Group
+ * @since 1.4
+ */
+export type ScatteringByteChannel = ReadableByteChannel & {
+  /**
+   * Reads a sequence of bytes from this channel into a subsequence of the
+   *  given buffers.
+   *
+   *  <p> An invocation of this method attempts to read up to <i>r</i> bytes
+   *  from this channel, where <i>r</i> is the total number of bytes remaining
+   *  the specified subsequence of the given buffer array, that is,
+   *
+   *  <blockquote><pre>
+   *  dsts[offset].remaining()
+   *      + dsts[offset+1].remaining()
+   *      + ... + dsts[offset+length-1].remaining()</pre></blockquote>
+   *
+   *  at the moment that this method is invoked.
+   *
+   *  <p> Suppose that a byte sequence of length <i>n</i> is read, where
+   *  <tt>0</tt>&nbsp;<tt>&lt;=</tt>&nbsp;<i>n</i>&nbsp;<tt>&lt;=</tt>&nbsp;<i>r</i>.
+   *  Up to the first <tt>dsts[offset].remaining()</tt> bytes of this sequence
+   *  are transferred into buffer <tt>dsts[offset]</tt>, up to the next
+   *  <tt>dsts[offset+1].remaining()</tt> bytes are transferred into buffer
+   *  <tt>dsts[offset+1]</tt>, and so forth, until the entire byte sequence
+   *  is transferred into the given buffers.  As many bytes as possible are
+   *  transferred into each buffer, hence the final position of each updated
+   *  buffer, except the last updated buffer, is guaranteed to be equal to
+   *  that buffer's limit.
+   *
+   *  <p> This method may be invoked at any time.  If another thread has
+   *  already initiated a read operation upon this channel, however, then an
+   *  invocation of this method will block until the first operation is
+   *  complete. </p>
+   * @param dsts&#xA; The buffers into which bytes are to be transferred
+   * @param offset&#xA; The offset within the buffer array of the first buffer into&#xA; which bytes are to be transferred; must be non-negative and no&#xA; larger than <tt>dsts.length</tt>
+   * @param length&#xA; The maximum number of buffers to be accessed; must be&#xA; non-negative and no larger than&#xA; <tt>dsts.length</tt>&nbsp;-&nbsp;<tt>offset</tt>
+   * @return The number of bytes read, possibly zero,&#xA; or <tt>-1</tt> if the channel has reached end-of-stream
+   * @throws IndexOutOfBoundsException&#xA; If the preconditions on the <tt>offset</tt> and <tt>length</tt>&#xA; parameters do not hold
+   * @throws NonReadableChannelException&#xA; If this channel was not opened for reading
+   * @throws ClosedChannelException&#xA; If this channel is closed
+   * @throws AsynchronousCloseException&#xA; If another thread closes this channel&#xA; while the read operation is in progress
+   * @throws ClosedByInterruptException&#xA; If another thread interrupts the current thread&#xA; while the read operation is in progress, thereby&#xA; closing the channel and setting the current thread's&#xA; interrupt status
+   * @throws IOException&#xA; If some other I/O error occurs
+   */
+  read(dsts: unknown[], offset: number, length: number): number;
+
+  /**
+   * Reads a sequence of bytes from this channel into the given buffers.
+   *
+   *  <p> An invocation of this method of the form <tt>c.read(dsts)</tt>
+   *  behaves in exactly the same manner as the invocation
+   *
+   *  <blockquote><pre>
+   *  c.read(dsts, 0, dsts.length);</pre></blockquote>
+   * @param dsts&#xA; The buffers into which bytes are to be transferred
+   * @return The number of bytes read, possibly zero,&#xA; or <tt>-1</tt> if the channel has reached end-of-stream
+   * @throws NonReadableChannelException&#xA; If this channel was not opened for reading
+   * @throws ClosedChannelException&#xA; If this channel is closed
+   * @throws AsynchronousCloseException&#xA; If another thread closes this channel&#xA; while the read operation is in progress
+   * @throws ClosedByInterruptException&#xA; If another thread interrupts the current thread&#xA; while the read operation is in progress, thereby&#xA; closing the channel and setting the current thread's&#xA; interrupt status
+   * @throws IOException&#xA; If some other I/O error occurs
+   */
+  read(dsts: unknown[]): number;
+};

package/types/java/nio/channels/ScatteringByteChannel/index.js

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

package/types/java/nio/channels/SeekableByteChannel/index.d.ts

@@ -0,0 +1,110 @@
+import type { ByteChannel } from "../ByteChannel";
+
+/**
+ * A byte channel that maintains a current <i>position</i> and allows the
+ *  position to be changed.
+ *
+ *  <p> A seekable byte channel is connected to an entity, typically a file,
+ *  that contains a variable-length sequence of bytes that can be read and
+ *  written. The current position can be {@link #position() <i>queried</i>} and
+ *  {@link #position(long) <i>modified</i>}. The channel also provides access to
+ *  the current <i>size</i> of the entity to which the channel is connected. The
+ *  size increases when bytes are written beyond its current size; the size
+ *  decreases when it is {@link #truncate <i>truncated</i>}.
+ *
+ *  <p> The {@link #position(long) position} and {@link #truncate truncate} methods
+ *  which do not otherwise have a value to return are specified to return the
+ *  channel upon which they are invoked. This allows method invocations to be
+ *  chained. Implementations of this interface should specialize the return type
+ *  so that method invocations on the implementation class can be chained.
+ * @since 1.7
+ * @see java.nio.file.Files#newByteChannel
+ */
+export type SeekableByteChannel = ByteChannel & {
+  /**
+ * Reads a sequence of bytes from this channel into the given buffer.
+ * 
+ *  <p> Bytes are read starting at this channel's current position, and
+ *  then the position is updated with the number of bytes actually read.
+ *  Otherwise this method behaves exactly as specified in the {@link
+ *  ReadableByteChannel} interface.
+  
+    */
+  read(dst: unknown): number;
+
+  /**
+ * Writes a sequence of bytes to this channel from the given buffer.
+ * 
+ *  <p> Bytes are written starting at this channel's current position, unless
+ *  the channel is connected to an entity such as a file that is opened with
+ *  the {@link java.nio.file.StandardOpenOption#APPEND APPEND} option, in
+ *  which case the position is first advanced to the end. The entity to which
+ *  the channel is connected is grown, if necessary, to accommodate the
+ *  written bytes, and then the position is updated with the number of bytes
+ *  actually written. Otherwise this method behaves exactly as specified by
+ *  the {@link WritableByteChannel} interface.
+  
+    */
+  write(src: unknown): number;
+
+  /**
+   * Returns this channel's position.
+   * @return This channel's position,&#xA; a non-negative integer counting the number of bytes&#xA; from the beginning of the entity to the current position
+   * @throws ClosedChannelException&#xA; If this channel is closed
+   * @throws IOException&#xA; If some other I/O error occurs
+   */
+  position(): number;
+
+  /**
+   * Sets this channel's position.
+   *
+   *  <p> Setting the position to a value that is greater than the current size
+   *  is legal but does not change the size of the entity.  A later attempt to
+   *  read bytes at such a position will immediately return an end-of-file
+   *  indication.  A later attempt to write bytes at such a position will cause
+   *  the entity to grow to accommodate the new bytes; the values of any bytes
+   *  between the previous end-of-file and the newly-written bytes are
+   *  unspecified.
+   *
+   *  <p> Setting the channel's position is not recommended when connected to
+   *  an entity, typically a file, that is opened with the {@link
+   *  java.nio.file.StandardOpenOption#APPEND APPEND} option. When opened for
+   *  append, the position is first advanced to the end before writing.
+   * @param newPosition&#xA; The new position, a non-negative integer counting&#xA; the number of bytes from the beginning of the entity
+   * @return This channel
+   * @throws ClosedChannelException&#xA; If this channel is closed
+   * @throws IllegalArgumentException&#xA; If the new position is negative
+   * @throws IOException&#xA; If some other I/O error occurs
+   */
+  position(newPosition: number): SeekableByteChannel;
+
+  /**
+   * Returns the current size of entity to which this channel is connected.
+   * @return The current size, measured in bytes
+   * @throws ClosedChannelException&#xA; If this channel is closed
+   * @throws IOException&#xA; If some other I/O error occurs
+   */
+  size(): number;
+
+  /**
+   * Truncates the entity, to which this channel is connected, to the given
+   *  size.
+   *
+   *  <p> If the given size is less than the current size then the entity is
+   *  truncated, discarding any bytes beyond the new end. If the given size is
+   *  greater than or equal to the current size then the entity is not modified.
+   *  In either case, if the current position is greater than the given size
+   *  then it is set to that size.
+   *
+   *  <p> An implementation of this interface may prohibit truncation when
+   *  connected to an entity, typically a file, opened with the {@link
+   *  java.nio.file.StandardOpenOption#APPEND APPEND} option.
+   * @param size&#xA; The new size, a non-negative byte count
+   * @return This channel
+   * @throws NonWritableChannelException&#xA; If this channel was not opened for writing
+   * @throws ClosedChannelException&#xA; If this channel is closed
+   * @throws IllegalArgumentException&#xA; If the new size is negative
+   * @throws IOException&#xA; If some other I/O error occurs
+   */
+  truncate(size: number): SeekableByteChannel;
+};