@sitevision/api 2023.2.1 → 2023.2.2-beta.2

package/types/java/net/URLConnection/index.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  connect: function connect() {},
+  setConnectTimeout: function setConnectTimeout() {},
+  getConnectTimeout: function getConnectTimeout() {},
+  setReadTimeout: function setReadTimeout() {},
+  getReadTimeout: function getReadTimeout() {},
+  getURL: function getURL() {},
+  getContentLength: function getContentLength() {},
+  getContentLengthLong: function getContentLengthLong() {},
+  getContentType: function getContentType() {},
+  getContentEncoding: function getContentEncoding() {},
+  getExpiration: function getExpiration() {},
+  getDate: function getDate() {},
+  getLastModified: function getLastModified() {},
+  getHeaderField: function getHeaderField() {},
+  getHeaderFields: function getHeaderFields() {},
+  getHeaderFieldInt: function getHeaderFieldInt() {},
+  getHeaderFieldLong: function getHeaderFieldLong() {},
+  getHeaderFieldDate: function getHeaderFieldDate() {},
+  getHeaderFieldKey: function getHeaderFieldKey() {},
+  getContent: function getContent() {},
+  getPermission: function getPermission() {},
+  getInputStream: function getInputStream() {},
+  getOutputStream: function getOutputStream() {},
+  toString: function toString() {},
+  setDoInput: function setDoInput() {},
+  getDoInput: function getDoInput() {},
+  setDoOutput: function setDoOutput() {},
+  getDoOutput: function getDoOutput() {},
+  setAllowUserInteraction: function setAllowUserInteraction() {},
+  getAllowUserInteraction: function getAllowUserInteraction() {},
+  setUseCaches: function setUseCaches() {},
+  getUseCaches: function getUseCaches() {},
+  setIfModifiedSince: function setIfModifiedSince() {},
+  getIfModifiedSince: function getIfModifiedSince() {},
+  getDefaultUseCaches: function getDefaultUseCaches() {},
+  setDefaultUseCaches: function setDefaultUseCaches() {},
+  setRequestProperty: function setRequestProperty() {},
+  addRequestProperty: function addRequestProperty() {},
+  getRequestProperty: function getRequestProperty() {},
+  getRequestProperties: function getRequestProperties() {}
+};
+exports["default"] = _default;

package/types/java/nio/MappedByteBuffer/index.d.ts

@@ -0,0 +1,80 @@
+/**
+ * A direct byte buffer whose content is a memory-mapped region of a file.
+ *
+ *  <p> Mapped byte buffers are created via the {@link
+ *  java.nio.channels.FileChannel#map FileChannel.map} method.  This class
+ *  extends the {@link ByteBuffer} class with operations that are specific to
+ *  memory-mapped file regions.
+ *
+ *  <p> A mapped byte buffer and the file mapping that it represents remain
+ *  valid until the buffer itself is garbage-collected.
+ *
+ *  <p> The content of a mapped byte buffer can change at any time, for example
+ *  if the content of the corresponding region of the mapped file is changed by
+ *  this program or another.  Whether or not such changes occur, and when they
+ *  occur, is operating-system dependent and therefore unspecified.
+ *
+ *  <a name="inaccess"></a><p> All or part of a mapped byte buffer may become
+ *  inaccessible at any time, for example if the mapped file is truncated.  An
+ *  attempt to access an inaccessible region of a mapped byte buffer will not
+ *  change the buffer's content and will cause an unspecified exception to be
+ *  thrown either at the time of the access or at some later time.  It is
+ *  therefore strongly recommended that appropriate precautions be taken to
+ *  avoid the manipulation of a mapped file by this program, or by a
+ *  concurrently running program, except to read or write the file's content.
+ *
+ *  <p> Mapped byte buffers otherwise behave no differently than ordinary direct
+ *  byte buffers. </p>
+ * @author Mark Reinhold
+ * @author JSR-51 Expert Group
+ * @since 1.4
+ */
+export type MappedByteBuffer = {
+  /**
+   * Tells whether or not this buffer's content is resident in physical
+   *  memory.
+   *
+   *  <p> A return value of <tt>true</tt> implies that it is highly likely
+   *  that all of the data in this buffer is resident in physical memory and
+   *  may therefore be accessed without incurring any virtual-memory page
+   *  faults or I/O operations.  A return value of <tt>false</tt> does not
+   *  necessarily imply that the buffer's content is not resident in physical
+   *  memory.
+   *
+   *  <p> The returned value is a hint, rather than a guarantee, because the
+   *  underlying operating system may have paged out some of the buffer's data
+   *  by the time that an invocation of this method returns.  </p>
+   * @return <tt>true</tt> if it is likely that this buffer's content&#xA; is resident in physical memory
+   */
+  isLoaded(): boolean;
+
+  /**
+   * Loads this buffer's content into physical memory.
+   *
+   *  <p> This method makes a best effort to ensure that, when it returns,
+   *  this buffer's content is resident in physical memory.  Invoking this
+   *  method may cause some number of page faults and I/O operations to
+   *  occur. </p>
+   * @return This buffer
+   */
+  load(): MappedByteBuffer;
+
+  /**
+   * Forces any changes made to this buffer's content to be written to the
+   *  storage device containing the mapped file.
+   *
+   *  <p> If the file mapped into this buffer resides on a local storage
+   *  device then when this method returns it is guaranteed that all changes
+   *  made to the buffer since it was created, or since this method was last
+   *  invoked, will have been written to that device.
+   *
+   *  <p> If the file does not reside on a local device then no such guarantee
+   *  is made.
+   *
+   *  <p> If this buffer was not mapped in read/write mode ({@link
+   *  java.nio.channels.FileChannel.MapMode#READ_WRITE}) then invoking this
+   *  method has no effect. </p>
+   * @return This buffer
+   */
+  force(): MappedByteBuffer;
+};

package/types/java/nio/MappedByteBuffer/index.js

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

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

@@ -0,0 +1,82 @@
+import type { Channel } from "../Channel";
+
+/**
+ * A channel that supports asynchronous I/O operations. Asynchronous I/O
+ *  operations will usually take one of two forms:
+ *
+ *  <ol>
+ *  <li><pre>{@link Future}&lt;V&gt; <em>operation</em>(<em>...</em>)</pre></li>
+ *  <li><pre>void <em>operation</em>(<em>...</em> A attachment, {@link
+ *    CompletionHandler}&lt;V,? super A&gt; handler)</pre></li>
+ *  </ol>
+ *
+ *  where <i>operation</i> is the name of the I/O operation (read or write for
+ *  example), <i>V</i> is the result type of the I/O operation, and <i>A</i> is
+ *  the type of an object attached to the I/O operation to provide context when
+ *  consuming the result. The attachment is important for cases where a
+ *  <em>state-less</em> {@code CompletionHandler} is used to consume the result
+ *  of many I/O operations.
+ *
+ *  <p> In the first form, the methods defined by the {@link Future Future}
+ *  interface may be used to check if the operation has completed, wait for its
+ *  completion, and to retrieve the result. In the second form, a {@link
+ *  CompletionHandler} is invoked to consume the result of the I/O operation when
+ *  it completes or fails.
+ *
+ *  <p> A channel that implements this interface is <em>asynchronously
+ *  closeable</em>: If an I/O operation is outstanding on the channel and the
+ *  channel's {@link #close close} method is invoked, then the I/O operation
+ *  fails with the exception {@link AsynchronousCloseException}.
+ *
+ *  <p> Asynchronous channels are safe for use by multiple concurrent threads.
+ *  Some channel implementations may support concurrent reading and writing, but
+ *  may not allow more than one read and one write operation to be outstanding at
+ *  any given time.
+ *
+ *  <h2>Cancellation</h2>
+ *
+ *  <p> The {@code Future} interface defines the {@link Future#cancel cancel}
+ *  method to cancel execution. This causes all threads waiting on the result of
+ *  the I/O operation to throw {@link java.util.concurrent.CancellationException}.
+ *  Whether the underlying I/O operation can be cancelled is highly implementation
+ *  specific and therefore not specified. Where cancellation leaves the channel,
+ *  or the entity to which it is connected, in an inconsistent state, then the
+ *  channel is put into an implementation specific <em>error state</em> that
+ *  prevents further attempts to initiate I/O operations that are <i>similar</i>
+ *  to the operation that was cancelled. For example, if a read operation is
+ *  cancelled but the implementation cannot guarantee that bytes have not been
+ *  read from the channel then it puts the channel into an error state; further
+ *  attempts to initiate a {@code read} operation cause an unspecified runtime
+ *  exception to be thrown. Similarly, if a write operation is cancelled but the
+ *  implementation cannot guarantee that bytes have not been written to the
+ *  channel then subsequent attempts to initiate a {@code write} will fail with
+ *  an unspecified runtime exception.
+ *
+ *  <p> Where the {@link Future#cancel cancel} method is invoked with the {@code
+ *  mayInterruptIfRunning} parameter set to {@code true} then the I/O operation
+ *  may be interrupted by closing the channel. In that case all threads waiting
+ *  on the result of the I/O operation throw {@code CancellationException} and
+ *  any other I/O operations outstanding on the channel complete with the
+ *  exception {@link AsynchronousCloseException}.
+ *
+ *  <p> Where the {@code cancel} method is invoked to cancel read or write
+ *  operations then it is recommended that all buffers used in the I/O operations
+ *  be discarded or care taken to ensure that the buffers are not accessed while
+ *  the channel remains open.
+ * @since 1.7
+ */
+export type AsynchronousChannel = Channel & {
+  /**
+   * Closes this channel.
+   *
+   *  <p> Any outstanding asynchronous operations upon this channel will
+   *  complete with the exception {@link AsynchronousCloseException}. After a
+   *  channel is closed, further attempts to initiate asynchronous I/O
+   *  operations complete immediately with cause {@link ClosedChannelException}.
+   *
+   *  <p>  This method otherwise behaves exactly as specified by the {@link
+   *  Channel} interface.
+   * @throws IOException&#xA; If an I/O error occurs
+   */
+  close(): void;
+};

package/types/java/nio/channels/AsynchronousChannel/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/AsynchronousFileChannel/index.d.ts

@@ -0,0 +1,410 @@
+import type { CompletionHandler } from "../CompletionHandler";
+import type { Future } from "../../../util/concurrent/Future";
+import type { FileLock } from "../FileLock";
+
+import type { Object } from "../../../lang/Object";
+import type { AsynchronousChannel } from "../AsynchronousChannel";
+
+/**
+ * An asynchronous channel for reading, writing, and manipulating a file.
+ *
+ *  <p> An asynchronous file channel is created when a file is opened by invoking
+ *  one of the {@link #open open} methods defined by this class. The file contains
+ *  a variable-length sequence of bytes that can be read and written and whose
+ *  current size can be {@link #size() queried}. The size of the file increases
+ *  when bytes are written beyond its  current size; the size of the file decreases
+ *  when it is {@link #truncate truncated}.
+ *
+ *  <p> An asynchronous file channel does not have a <i>current position</i>
+ *  within the file. Instead, the file position is specified to each read and
+ *  write method that initiates asynchronous operations. A {@link CompletionHandler}
+ *  is specified as a parameter and is invoked to consume the result of the I/O
+ *  operation. This class also defines read and write methods that initiate
+ *  asynchronous operations, returning a {@link Future} to represent the pending
+ *  result of the operation. The {@code Future} may be used to check if the
+ *  operation has completed, wait for its completion, and retrieve the result.
+ *
+ *  <p> In addition to read and write operations, this class defines the
+ *  following operations: </p>
+ *
+ *  <ul>
+ *
+ *    <li><p> Updates made to a file may be {@link #force <i>forced
+ *    out</i>} to the underlying storage device, ensuring that data are not
+ *    lost in the event of a system crash.  </p></li>
+ *
+ *    <li><p> A region of a file may be {@link #lock <i>locked</i>} against
+ *    access by other programs.  </p></li>
+ *
+ *  </ul>
+ *
+ *  <p> An {@code AsynchronousFileChannel} is associated with a thread pool to
+ *  which tasks are submitted to handle I/O events and dispatch to completion
+ *  handlers that consume the results of I/O operations on the channel. The
+ *  completion handler for an I/O operation initiated on a channel is guaranteed
+ *  to be invoked by one of the threads in the thread pool (This ensures that the
+ *  completion handler is run by a thread with the expected <em>identity</em>).
+ *  Where an I/O operation completes immediately, and the initiating thread is
+ *  itself a thread in the thread pool, then the completion handler may be invoked
+ *  directly by the initiating thread. When an {@code AsynchronousFileChannel} is
+ *  created without specifying a thread pool then the channel is associated with
+ *  a system-dependent default thread pool that may be shared with other
+ *  channels. The default thread pool is configured by the system properties
+ *  defined by the {@link AsynchronousChannelGroup} class.
+ *
+ *  <p> Channels of this type are safe for use by multiple concurrent threads. The
+ *  {@link Channel#close close} method may be invoked at any time, as specified
+ *  by the {@link Channel} interface. This causes all outstanding asynchronous
+ *  operations on the channel to complete with the exception {@link
+ *  AsynchronousCloseException}. Multiple read and write operations may be
+ *  outstanding at the same time. When multiple read and write operations are
+ *  outstanding then the ordering of the I/O operations, and the order that the
+ *  completion handlers are invoked, is not specified; they are not, in particular,
+ *  guaranteed to execute in the order that the operations were initiated. The
+ *  {@link java.nio.ByteBuffer ByteBuffers} used when reading or writing are not
+ *  safe for use by multiple concurrent I/O operations. Furthermore, after an I/O
+ *  operation is initiated then care should be taken to ensure that the buffer is
+ *  not accessed until after the operation has completed.
+ *
+ *  <p> As with {@link FileChannel}, the view of a file provided by an instance of
+ *  this class is guaranteed to be consistent with other views of the same file
+ *  provided by other instances in the same program.  The view provided by an
+ *  instance of this class may or may not, however, be consistent with the views
+ *  seen by other concurrently-running programs due to caching performed by the
+ *  underlying operating system and delays induced by network-filesystem protocols.
+ *  This is true regardless of the language in which these other programs are
+ *  written, and whether they are running on the same machine or on some other
+ *  machine.  The exact nature of any such inconsistencies are system-dependent
+ *  and are therefore unspecified.
+ * @since 1.7
+ */
+export type AsynchronousFileChannel = Object &
+  AsynchronousChannel & {
+    /**
+     * Returns the current size of this channel's file.
+     * @return The current size of this channel's file, measured in bytes
+     * @throws ClosedChannelException&#xA; If this channel is closed
+     * @throws IOException&#xA; If some other I/O error occurs
+     */
+    size(): number;
+
+    /**
+     * Truncates this channel's file to the given size.
+     *
+     *  <p> If the given size is less than the file's current size then the file
+     *  is truncated, discarding any bytes beyond the new end of the file.  If
+     *  the given size is greater than or equal to the file's current size then
+     *  the file is not modified. </p>
+     * @param size&#xA; The new size, a non-negative byte count
+     * @return This file 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): AsynchronousFileChannel;
+
+    /**
+     * Forces any updates to this channel's file to be written to the storage
+     *  device that contains it.
+     *
+     *  <p> If this channel's file resides on a local storage device then when
+     *  this method returns it is guaranteed that all changes made to the file
+     *  since this channel was created, or since this method was last invoked,
+     *  will have been written to that device.  This is useful for ensuring that
+     *  critical information is not lost in the event of a system crash.
+     *
+     *  <p> If the file does not reside on a local device then no such guarantee
+     *  is made.
+     *
+     *  <p> The {@code metaData} parameter can be used to limit the number of
+     *  I/O operations that this method is required to perform.  Passing
+     *  {@code false} for this parameter indicates that only updates to the
+     *  file's content need be written to storage; passing {@code true}
+     *  indicates that updates to both the file's content and metadata must be
+     *  written, which generally requires at least one more I/O operation.
+     *  Whether this parameter actually has any effect is dependent upon the
+     *  underlying operating system and is therefore unspecified.
+     *
+     *  <p> Invoking this method may cause an I/O operation to occur even if the
+     *  channel was only opened for reading.  Some operating systems, for
+     *  example, maintain a last-access time as part of a file's metadata, and
+     *  this time is updated whenever the file is read.  Whether or not this is
+     *  actually done is system-dependent and is therefore unspecified.
+     *
+     *  <p> This method is only guaranteed to force changes that were made to
+     *  this channel's file via the methods defined in this class.
+     * @param metaData&#xA; If {@code true} then this method is required to force changes&#xA; to both the file's content and metadata to be written to&#xA; storage; otherwise, it need only force content changes to be&#xA; written
+     * @throws ClosedChannelException&#xA; If this channel is closed
+     * @throws IOException&#xA; If some other I/O error occurs
+     */
+    force(metaData: boolean): void;
+
+    /**
+     * Acquires a lock on the given region of this channel's file.
+     *
+     *  <p> This method initiates an operation to acquire a lock on the given
+     *  region of this channel's file. The {@code handler} parameter is a
+     *  completion handler that is invoked when the lock is acquired (or the
+     *  operation fails). The result passed to the completion handler is the
+     *  resulting {@code FileLock}.
+     *
+     *  <p> The region specified by the {@code position} and {@code size}
+     *  parameters need not be contained within, or even overlap, the actual
+     *  underlying file.  Lock regions are fixed in size; if a locked region
+     *  initially contains the end of the file and the file grows beyond the
+     *  region then the new portion of the file will not be covered by the lock.
+     *  If a file is expected to grow in size and a lock on the entire file is
+     *  required then a region starting at zero, and no smaller than the
+     *  expected maximum size of the file, should be locked.  The two-argument
+     *  {@link #lock(Object,CompletionHandler)} method simply locks a region
+     *  of size {@link Long#MAX_VALUE}. If a lock that overlaps the requested
+     *  region is already held by this Java virtual machine, or this method has
+     *  been invoked to lock an overlapping region and that operation has not
+     *  completed, then this method throws {@link OverlappingFileLockException}.
+     *
+     *  <p> Some operating systems do not support a mechanism to acquire a file
+     *  lock in an asynchronous manner. Consequently an implementation may
+     *  acquire the file lock in a background thread or from a task executed by
+     *  a thread in the associated thread pool. If there are many lock operations
+     *  outstanding then it may consume threads in the Java virtual machine for
+     *  indefinite periods.
+     *
+     *  <p> Some operating systems do not support shared locks, in which case a
+     *  request for a shared lock is automatically converted into a request for
+     *  an exclusive lock.  Whether the newly-acquired lock is shared or
+     *  exclusive may be tested by invoking the resulting lock object's {@link
+     *  FileLock#isShared() isShared} method.
+     *
+     *  <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.
+     * @param <A>&#xA; The type of the attachment
+     * @param position&#xA; The position at which the locked region is to start; must be&#xA; non-negative
+     * @param size&#xA; The size of the locked region; must be non-negative, and the sum&#xA; {@code position}&nbsp;+&nbsp;{@code size} must be non-negative
+     * @param shared&#xA; {@code true} to request a shared lock, in which case this&#xA; channel must be open for reading (and possibly writing);&#xA; {@code false} to request an exclusive lock, in which case this&#xA; channel must be open for writing (and possibly reading)
+     * @param attachment&#xA; The object to attach to the I/O operation; can be {@code null}
+     * @param handler&#xA; The handler for consuming the result
+     * @throws OverlappingFileLockException&#xA; If a lock that overlaps the requested region is already held by&#xA; this Java virtual machine, or there is already a pending attempt&#xA; to lock an overlapping region
+     * @throws IllegalArgumentException&#xA; If the preconditions on the parameters do not hold
+     * @throws NonReadableChannelException&#xA; If {@code shared} is true but this channel was not opened for reading
+     * @throws NonWritableChannelException&#xA; If {@code shared} is false but this channel was not opened for writing
+     */
+    lock(
+      position: number,
+      size: number,
+      shared: boolean,
+      attachment: unknown,
+      handler: CompletionHandler
+    ): void;
+
+    /**
+     * Acquires an exclusive lock on this channel's file.
+     *
+     *  <p> This method initiates an operation to acquire a lock on the given
+     *  region of this channel's file. The {@code handler} parameter is a
+     *  completion handler that is invoked when the lock is acquired (or the
+     *  operation fails). The result passed to the completion handler is the
+     *  resulting {@code FileLock}.
+     *
+     *  <p> An invocation of this method of the form {@code ch.lock(att,handler)}
+     *  behaves in exactly the same way as the invocation
+     *  <pre>
+     *      ch.{@link #lock(long,long,boolean,Object,CompletionHandler) lock}(0L, Long.MAX_VALUE, false, att, handler)
+     *  </pre>
+     * @param <A>&#xA; The type of the attachment
+     * @param attachment&#xA; The object to attach to the I/O operation; can be {@code null}
+     * @param handler&#xA; The handler for consuming the result
+     * @throws OverlappingFileLockException&#xA; If a lock is already held by this Java virtual machine, or there&#xA; is already a pending attempt to lock a region
+     * @throws NonWritableChannelException&#xA; If this channel was not opened for writing
+     */
+    lock(attachment: unknown, handler: CompletionHandler): void;
+
+    /**
+     * Acquires a lock on the given region of this channel's file.
+     *
+     *  <p> This method initiates an operation to acquire a lock on the given
+     *  region of this channel's file.  The method behaves in exactly the same
+     *  manner as the {@link #lock(long, long, boolean, Object, CompletionHandler)}
+     *  method except that instead of specifying a completion handler, this
+     *  method returns a {@code Future} representing the pending result. The
+     *  {@code Future}'s {@link Future#get() get} method returns the {@link
+     *  FileLock} on successful completion.
+     * @param position&#xA; The position at which the locked region is to start; must be&#xA; non-negative
+     * @param size&#xA; The size of the locked region; must be non-negative, and the sum&#xA; {@code position}&nbsp;+&nbsp;{@code size} must be non-negative
+     * @param shared&#xA; {@code true} to request a shared lock, in which case this&#xA; channel must be open for reading (and possibly writing);&#xA; {@code false} to request an exclusive lock, in which case this&#xA; channel must be open for writing (and possibly reading)
+     * @return a {@code Future} object representing the pending result
+     * @throws OverlappingFileLockException&#xA; If a lock is already held by this Java virtual machine, or there&#xA; is already a pending attempt to lock a region
+     * @throws IllegalArgumentException&#xA; If the preconditions on the parameters do not hold
+     * @throws NonReadableChannelException&#xA; If {@code shared} is true but this channel was not opened for reading
+     * @throws NonWritableChannelException&#xA; If {@code shared} is false but this channel was not opened for writing
+     */
+    lock(position: number, size: number, shared: boolean): Future;
+
+    /**
+     * Acquires an exclusive lock on this channel's file.
+     *
+     *  <p> This method initiates an operation to acquire an exclusive lock on this
+     *  channel's file. The method returns a {@code Future} representing the
+     *  pending result of the operation. The {@code Future}'s {@link Future#get()
+     *  get} method returns the {@link FileLock} on successful completion.
+     *
+     *  <p> An invocation of this method behaves in exactly the same way as the
+     *  invocation
+     *  <pre>
+     *      ch.{@link #lock(long,long,boolean) lock}(0L, Long.MAX_VALUE, false)
+     *  </pre>
+     * @return a {@code Future} object representing the pending result
+     * @throws OverlappingFileLockException&#xA; If a lock is already held by this Java virtual machine, or there&#xA; is already a pending attempt to lock a region
+     * @throws NonWritableChannelException&#xA; If this channel was not opened for writing
+     */
+    lock(): Future;
+
+    /**
+     * Attempts to acquire a lock on the given region of this channel's file.
+     *
+     *  <p> This method does not block. An invocation always returns immediately,
+     *  either having acquired a lock on the requested region or having failed to
+     *  do so.  If it fails to acquire a lock because an overlapping lock is held
+     *  by another program then it returns {@code null}.  If it fails to acquire
+     *  a lock for any other reason then an appropriate exception is thrown.
+     * @param position&#xA; The position at which the locked region is to start; must be&#xA; non-negative
+     * @param size&#xA; The size of the locked region; must be non-negative, and the sum&#xA; {@code position}&nbsp;+&nbsp;{@code size} must be non-negative
+     * @param shared&#xA; {@code true} to request a shared lock,&#xA; {@code false} to request an exclusive lock
+     * @return A lock object representing the newly-acquired lock,&#xA; or {@code null} if the lock could not be acquired&#xA; because another program holds an overlapping lock
+     * @throws IllegalArgumentException&#xA; If the preconditions on the parameters do not hold
+     * @throws ClosedChannelException&#xA; If this channel is closed
+     * @throws OverlappingFileLockException&#xA; If a lock that overlaps the requested region is already held by&#xA; this Java virtual machine, or if another thread is already&#xA; blocked in this method and is attempting to lock an overlapping&#xA; region of the same file
+     * @throws NonReadableChannelException&#xA; If {@code shared} is true but this channel was not opened for reading
+     * @throws NonWritableChannelException&#xA; If {@code shared} is false but this channel was not opened for writing
+     * @throws IOException&#xA; If some other I/O error occurs
+     * @see #lock(Object,CompletionHandler)
+     * @see #lock(long,long,boolean,Object,CompletionHandler)
+     * @see #tryLock()
+     */
+    tryLock(position: number, size: number, shared: boolean): FileLock;
+
+    /**
+     * Attempts to acquire an exclusive lock on this channel's file.
+     *
+     *  <p> An invocation of this method of the form {@code ch.tryLock()}
+     *  behaves in exactly the same way as the invocation
+     *
+     *  <pre>
+     *      ch.{@link #tryLock(long,long,boolean) tryLock}(0L, Long.MAX_VALUE, false) </pre>
+     * @return A lock object representing the newly-acquired lock,&#xA; or {@code null} if the lock could not be acquired&#xA; because another program holds an overlapping lock
+     * @throws ClosedChannelException&#xA; If this channel is closed
+     * @throws OverlappingFileLockException&#xA; If a lock that overlaps the requested region is already held by&#xA; this Java virtual machine, or if another thread is already&#xA; blocked in this method and is attempting to lock an overlapping&#xA; region
+     * @throws NonWritableChannelException&#xA; If {@code shared} is false but this channel was not opened for writing
+     * @throws IOException&#xA; If some other I/O error occurs
+     * @see #lock(Object,CompletionHandler)
+     * @see #lock(long,long,boolean,Object,CompletionHandler)
+     * @see #tryLock(long,long,boolean)
+     */
+    tryLock(): FileLock;
+
+    /**
+     * Reads a sequence of bytes from this channel into the given buffer,
+     *  starting at the given file position.
+     *
+     *  <p> This method initiates the reading of a sequence of bytes from this
+     *  channel into the given buffer, starting at the given file position. The
+     *  result of the read is the number of bytes read or {@code -1} if the given
+     *  position is greater than or equal to the file's size at the time that the
+     *  read is attempted.
+     *
+     *  <p> This method works in the same manner as the {@link
+     *  AsynchronousByteChannel#read(ByteBuffer,Object,CompletionHandler)}
+     *  method, except that bytes are read starting at the given file position.
+     *  If the given file position is greater than the file's size at the time
+     *  that the read is attempted then no bytes are read.
+     * @param <A>&#xA; The type of the attachment
+     * @param dst&#xA; The buffer into which bytes are to be transferred
+     * @param position&#xA; The file position at which the transfer is to begin;&#xA; must be non-negative
+     * @param attachment&#xA; The object to attach to the I/O operation; can be {@code null}
+     * @param handler&#xA; The handler for consuming the result
+     * @throws IllegalArgumentException&#xA; If the position is negative or the buffer is read-only
+     * @throws NonReadableChannelException&#xA; If this channel was not opened for reading
+     */
+    read(
+      dst: unknown,
+      position: number,
+      attachment: unknown,
+      handler: CompletionHandler
+    ): void;
+
+    /**
+     * Reads a sequence of bytes from this channel into the given buffer,
+     *  starting at the given file position.
+     *
+     *  <p> This method initiates the reading of a sequence of bytes from this
+     *  channel into the given buffer, starting at the given file position. This
+     *  method returns a {@code Future} representing the pending result of the
+     *  operation. The {@code Future}'s {@link Future#get() get} method returns
+     *  the number of bytes read or {@code -1} if the given position is greater
+     *  than or equal to the file's size at the time that the read is attempted.
+     *
+     *  <p> This method works in the same manner as the {@link
+     *  AsynchronousByteChannel#read(ByteBuffer)} method, except that bytes are
+     *  read starting at the given file position. If the given file position is
+     *  greater than the file's size at the time that the read is attempted then
+     *  no bytes are read.
+     * @param dst&#xA; The buffer into which bytes are to be transferred
+     * @param position&#xA; The file position at which the transfer is to begin;&#xA; must be non-negative
+     * @return A {@code Future} object representing the pending result
+     * @throws IllegalArgumentException&#xA; If the position is negative or the buffer is read-only
+     * @throws NonReadableChannelException&#xA; If this channel was not opened for reading
+     */
+    read(dst: unknown, position: number): Future;
+
+    /**
+     * Writes a sequence of bytes to this channel from the given buffer, starting
+     *  at the given file position.
+     *
+     *  <p> This method works in the same manner as the {@link
+     *  AsynchronousByteChannel#write(ByteBuffer,Object,CompletionHandler)}
+     *  method, except that bytes are written starting at the given file position.
+     *  If the given position is greater than the file's size, at the time that
+     *  the write is attempted, then the file will be grown to accommodate the new
+     *  bytes; the values of any bytes between the previous end-of-file and the
+     *  newly-written bytes are unspecified.
+     * @param <A>&#xA; The type of the attachment
+     * @param src&#xA; The buffer from which bytes are to be transferred
+     * @param position&#xA; The file position at which the transfer is to begin;&#xA; must be non-negative
+     * @param attachment&#xA; The object to attach to the I/O operation; can be {@code null}
+     * @param handler&#xA; The handler for consuming the result
+     * @throws IllegalArgumentException&#xA; If the position is negative
+     * @throws NonWritableChannelException&#xA; If this channel was not opened for writing
+     */
+    write(
+      src: unknown,
+      position: number,
+      attachment: unknown,
+      handler: CompletionHandler
+    ): void;
+
+    /**
+     * Writes a sequence of bytes to this channel from the given buffer, starting
+     *  at the given file position.
+     *
+     *  <p> This method initiates the writing of a sequence of bytes to this
+     *  channel from the given buffer, starting at the given file position. The
+     *  method returns a {@code Future} representing the pending result of the
+     *  write operation. The {@code Future}'s {@link Future#get() get} method
+     *  returns the number of bytes written.
+     *
+     *  <p> This method works in the same manner as the {@link
+     *  AsynchronousByteChannel#write(ByteBuffer)} method, except that bytes are
+     *  written starting at the given file position. If the given position is
+     *  greater than the file's size, at the time that the write is attempted,
+     *  then the file will be grown to accommodate the new bytes; the values of
+     *  any bytes between the previous end-of-file and the newly-written bytes
+     *  are unspecified.
+     * @param src&#xA; The buffer from which bytes are to be transferred
+     * @param position&#xA; The file position at which the transfer is to begin;&#xA; must be non-negative
+     * @return A {@code Future} object representing the pending result
+     * @throws IllegalArgumentException&#xA; If the position is negative
+     * @throws NonWritableChannelException&#xA; If this channel was not opened for writing
+     */
+    write(src: unknown, position: number): Future;
+  };

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

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  size: function size() {},
+  truncate: function truncate() {},
+  force: function force() {},
+  lock: function lock() {},
+  tryLock: function tryLock() {},
+  read: function read() {},
+  write: function write() {}
+};
+exports["default"] = _default;