@sitevision/api 2023.2.1 → 2023.2.2-beta.1

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

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getFileNameMap: function getFileNameMap() {},
+  setFileNameMap: function setFileNameMap() {},
+  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() {},
+  setDefaultAllowUserInteraction: function setDefaultAllowUserInteraction() {},
+  getDefaultAllowUserInteraction: function getDefaultAllowUserInteraction() {},
+  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() {},
+  setDefaultRequestProperty: function setDefaultRequestProperty() {},
+  getDefaultRequestProperty: function getDefaultRequestProperty() {},
+  setContentHandlerFactory: function setContentHandlerFactory() {},
+  guessContentTypeFromName: function guessContentTypeFromName() {},
+  guessContentTypeFromStream: function guessContentTypeFromStream() {}
+};
+exports["default"] = _default;

package/types/java/net/URLStreamHandler/index.d.ts

@@ -0,0 +1,199 @@
+import type { URL } from "../URL";
+import type { URLConnection } from "../URLConnection";
+import type { Proxy } from "../Proxy";
+import type { String } from "../../lang/String";
+
+import type { InetAddress } from "../InetAddress";
+import type { Object } from "../../lang/Object";
+
+/**
+ * The abstract class {@code URLStreamHandler} is the common
+ *  superclass for all stream protocol handlers. A stream protocol
+ *  handler knows how to make a connection for a particular protocol
+ *  type, such as {@code http} or {@code https}.
+ *  <p>
+ *  In most cases, an instance of a {@code URLStreamHandler}
+ *  subclass is not created directly by an application. Rather, the
+ *  first time a protocol name is encountered when constructing a
+ *  {@code URL}, the appropriate stream protocol handler is
+ *  automatically loaded.
+ * @author James Gosling
+ * @see java.net.URL#URL(java.lang.String, java.lang.String, int, java.lang.String)
+ * @since JDK1.0
+ */
+export type URLStreamHandler = Object & {
+  /**
+   * Opens a connection to the object referenced by the
+   *  {@code URL} argument.
+   *  This method should be overridden by a subclass.
+   *
+   *  <p>If for the handler's protocol (such as HTTP or JAR), there
+   *  exists a public, specialized URLConnection subclass belonging
+   *  to one of the following packages or one of their subpackages:
+   *  java.lang, java.io, java.util, java.net, the connection
+   *  returned will be of that subclass. For example, for HTTP an
+   *  HttpURLConnection will be returned, and for JAR a
+   *  JarURLConnection will be returned.
+   * @param u the URL that this connects to.
+   * @return a {@code URLConnection} object for the {@code URL}.
+   * @throws IOException if an I/O error occurs while opening the&#xA; connection.
+   */
+  openConnection(u: URL): URLConnection;
+
+  /**
+   * Same as openConnection(URL), except that the connection will be
+   *  made through the specified proxy; Protocol handlers that do not
+   *  support proxying will ignore the proxy parameter and make a
+   *  normal connection.
+   *
+   *  Calling this method preempts the system's default ProxySelector
+   *  settings.
+   * @param u the URL that this connects to.
+   * @param p the proxy through which the connection will be made.&#xA; If direct connection is desired, Proxy.NO_PROXY&#xA; should be specified.
+   * @return a {@code URLConnection} object for the {@code URL}.
+   * @throws IOException if an I/O error occurs while opening the&#xA; connection.
+   * @throws IllegalArgumentException if either u or p is null,&#xA; or p has the wrong type.
+   * @throws UnsupportedOperationException if the subclass that&#xA; implements the protocol doesn't support this method.
+   * @since 1.5
+   */
+  openConnection(u: URL, p: Proxy): URLConnection;
+
+  /**
+   * Parses the string representation of a {@code URL} into a
+   *  {@code URL} object.
+   *  <p>
+   *  If there is any inherited context, then it has already been
+   *  copied into the {@code URL} argument.
+   *  <p>
+   *  The {@code parseURL} method of {@code URLStreamHandler}
+   *  parses the string representation as if it were an
+   *  {@code http} specification. Most URL protocol families have a
+   *  similar parsing. A stream protocol handler for a protocol that has
+   *  a different syntax must override this routine.
+   * @param u the {@code URL} to receive the result of parsing&#xA; the spec.
+   * @param spec the {@code String} representing the URL that&#xA; must be parsed.
+   * @param start the character index at which to begin parsing. This is&#xA; just past the '{@code :}' (if there is one) that&#xA; specifies the determination of the protocol name.
+   * @param limit the character position to stop parsing at. This is the&#xA; end of the string or the position of the&#xA; "{@code #}" character, if present. All information&#xA; after the sharp sign indicates an anchor.
+   */
+  parseURL(u: URL, spec: String | string, start: number, limit: number): void;
+
+  /**
+   * Returns the default port for a URL parsed by this handler. This method
+   *  is meant to be overidden by handlers with default port numbers.
+   * @return the default port for a {@code URL} parsed by this handler.
+   * @since 1.3
+   */
+  getDefaultPort(): number;
+
+  /**
+   * Provides the default equals calculation. May be overidden by handlers
+   *  for other protocols that have different requirements for equals().
+   *  This method requires that none of its arguments is null. This is
+   *  guaranteed by the fact that it is only called by java.net.URL class.
+   * @param u1 a URL object
+   * @param u2 a URL object
+   * @return {@code true} if the two urls are&#xA; considered equal, ie. they refer to the same&#xA; fragment in the same file.
+   * @since 1.3
+   */
+  equals(u1: URL, u2: URL): boolean;
+
+  /**
+   * Provides the default hash calculation. May be overidden by handlers for
+   *  other protocols that have different requirements for hashCode
+   *  calculation.
+   * @param u a URL object
+   * @return an {@code int} suitable for hash table indexing
+   * @since 1.3
+   */
+  hashCode(u: URL): number;
+
+  /**
+   * Compare two urls to see whether they refer to the same file,
+   *  i.e., having the same protocol, host, port, and path.
+   *  This method requires that none of its arguments is null. This is
+   *  guaranteed by the fact that it is only called indirectly
+   *  by java.net.URL class.
+   * @param u1 a URL object
+   * @param u2 a URL object
+   * @return true if u1 and u2 refer to the same file
+   * @since 1.3
+   */
+  sameFile(u1: URL, u2: URL): boolean;
+
+  /**
+   * Get the IP address of our host. An empty host field or a DNS failure
+   *  will result in a null return.
+   * @param u a URL object
+   * @return an {@code InetAddress} representing the host&#xA; IP address.
+   * @since 1.3
+   */
+  getHostAddress(u: URL): InetAddress;
+
+  /**
+   * Compares the host components of two URLs.
+   * @param u1 the URL of the first host to compare
+   * @param u2 the URL of the second host to compare
+   * @return {@code true} if and only if they&#xA; are equal, {@code false} otherwise.
+   * @since 1.3
+   */
+  hostsEqual(u1: URL, u2: URL): boolean;
+
+  /**
+   * Converts a {@code URL} of a specific protocol to a
+   *  {@code String}.
+   * @param u the URL.
+   * @return a string representation of the {@code URL} argument.
+   */
+  toExternalForm(u: URL): string;
+
+  /**
+   * Sets the fields of the {@code URL} argument to the indicated values.
+   *  Only classes derived from URLStreamHandler are able
+   *  to use this method to set the values of the URL fields.
+   * @param u the URL to modify.
+   * @param protocol the protocol name.
+   * @param host the remote host value for the URL.
+   * @param port the port on the remote machine.
+   * @param authority the authority part for the URL.
+   * @param userInfo the userInfo part of the URL.
+   * @param path the path component of the URL.
+   * @param query the query part for the URL.
+   * @param ref the reference.
+   * @throws SecurityException if the protocol handler of the URL is&#xA; different from this one
+   * @see java.net.URL#set(java.lang.String, java.lang.String, int, java.lang.String, java.lang.String)
+   * @since 1.3
+   */
+  setURL(
+    u: URL,
+    protocol: String | string,
+    host: String | string,
+    port: number,
+    authority: String | string,
+    userInfo: String | string,
+    path: String | string,
+    query: String | string,
+    ref: String | string
+  ): void;
+
+  /**
+   * Sets the fields of the {@code URL} argument to the indicated values.
+   *  Only classes derived from URLStreamHandler are able
+   *  to use this method to set the values of the URL fields.
+   * @param u the URL to modify.
+   * @param protocol the protocol name. This value is ignored since 1.2.
+   * @param host the remote host value for the URL.
+   * @param port the port on the remote machine.
+   * @param file the file.
+   * @param ref the reference.
+   * @throws SecurityException if the protocol handler of the URL is&#xA; different from this one
+   * @deprecated Use setURL(URL, String, String, int, String, String, String,&#xA; String);
+   */
+  setURL(
+    u: URL,
+    protocol: String | string,
+    host: String | string,
+    port: number,
+    file: String | string,
+    ref: String | string
+  ): void;
+};

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

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  openConnection: function openConnection() {},
+  parseURL: function parseURL() {},
+  getDefaultPort: function getDefaultPort() {},
+  equals: function equals() {},
+  hashCode: function hashCode() {},
+  sameFile: function sameFile() {},
+  getHostAddress: function getHostAddress() {},
+  hostsEqual: function hostsEqual() {},
+  toExternalForm: function toExternalForm() {},
+  setURL: function setURL() {}
+};
+exports["default"] = _default;

package/types/java/net/URLStreamHandlerFactory/index.d.ts

@@ -0,0 +1,24 @@
+import type { String } from "../../lang/String";
+import type { URLStreamHandler } from "../URLStreamHandler";
+
+/**
+ * This interface defines a factory for {@code URL} stream
+ *  protocol handlers.
+ *  <p>
+ *  It is used by the {@code URL} class to create a
+ *  {@code URLStreamHandler} for a specific protocol.
+ * @author Arthur van Hoff
+ * @see java.net.URL
+ * @see java.net.URLStreamHandler
+ * @since JDK1.0
+ */
+export type URLStreamHandlerFactory = {
+  /**
+   * Creates a new {@code URLStreamHandler} instance with the specified
+   *  protocol.
+   * @param protocol the protocol ("{@code ftp}",&#xA; "{@code http}", "{@code nntp}", etc.).
+   * @return a {@code URLStreamHandler} for the specific protocol.
+   * @see java.net.URLStreamHandler
+   */
+  createURLStreamHandler(protocol: String | string): URLStreamHandler;
+};

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

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  createURLStreamHandler: function createURLStreamHandler() {}
+};
+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;