@sitevision/api 2023.2.1 → 2023.2.2-beta.1

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

@@ -0,0 +1,222 @@
+import type { String } from "../../lang/String";
+import type { Enumeration } from "../../util/Enumeration";
+import type { List } from "../../util/List";
+
+import type { InetAddress } from "../InetAddress";
+
+import type { Object } from "../../lang/Object";
+
+/**
+ * This class represents a Network Interface made up of a name,
+ *  and a list of IP addresses assigned to this interface.
+ *  It is used to identify the local interface on which a multicast group
+ *  is joined.
+ *
+ *  Interfaces are normally known by names such as "le0".
+ * @since 1.4
+ */
+export type NetworkInterface = Object & {
+  /**
+   * Get the name of this network interface.
+   * @return the name of this network interface
+   */
+  getName(): string;
+
+  /**
+   * Convenience method to return an Enumeration with all or a
+   *  subset of the InetAddresses bound to this network interface.
+   *  <p>
+   *  If there is a security manager, its {@code checkConnect}
+   *  method is called for each InetAddress. Only InetAddresses where
+   *  the {@code checkConnect} doesn't throw a SecurityException
+   *  will be returned in the Enumeration. However, if the caller has the
+   *  {@link NetPermission}("getNetworkInformation") permission, then all
+   *  InetAddresses are returned.
+   * @return an Enumeration object with all or a subset of the InetAddresses&#xA; bound to this network interface
+   */
+  getInetAddresses(): Enumeration;
+
+  /**
+   * Get a List of all or a subset of the {@code InterfaceAddresses}
+   *  of this network interface.
+   *  <p>
+   *  If there is a security manager, its {@code checkConnect}
+   *  method is called with the InetAddress for each InterfaceAddress.
+   *  Only InterfaceAddresses where the {@code checkConnect} doesn't throw
+   *  a SecurityException will be returned in the List.
+   * @return a {@code List} object with all or a subset of the&#xA; InterfaceAddresss of this network interface
+   * @since 1.6
+   */
+  getInterfaceAddresses(): List;
+
+  /**
+   * Get an Enumeration with all the subinterfaces (also known as virtual
+   *  interfaces) attached to this network interface.
+   *  <p>
+   *  For instance eth0:1 will be a subinterface to eth0.
+   * @return an Enumeration object with all of the subinterfaces&#xA; of this network interface
+   * @since 1.6
+   */
+  getSubInterfaces(): Enumeration;
+
+  /**
+   * Returns the parent NetworkInterface of this interface if this is
+   *  a subinterface, or {@code null} if it is a physical
+   *  (non virtual) interface or has no parent.
+   * @return The {@code NetworkInterface} this interface is attached to.
+   * @since 1.6
+   */
+  getParent(): NetworkInterface;
+
+  /**
+   * Returns the index of this network interface. The index is an integer greater
+   *  or equal to zero, or {@code -1} for unknown. This is a system specific value
+   *  and interfaces with the same name can have different indexes on different
+   *  machines.
+   * @return the index of this network interface or {@code -1} if the index is&#xA; unknown
+   * @see #getByIndex(int)
+   * @since 1.7
+   */
+  getIndex(): number;
+
+  /**
+   * Get the display name of this network interface.
+   *  A display name is a human readable String describing the network
+   *  device.
+   * @return a non-empty string representing the display name of this network&#xA; interface, or null if no display name is available.
+   */
+  getDisplayName(): string;
+
+  /**
+   * Searches for the network interface with the specified name.
+   * @param name&#xA; The name of the network interface.
+   * @return A {@code NetworkInterface} with the specified name,&#xA; or {@code null} if there is no network interface&#xA; with the specified name.
+   * @throws SocketException&#xA; If an I/O error occurs.
+   * @throws NullPointerException&#xA; If the specified name is {@code null}.
+   */
+  getByName(name: String | string): NetworkInterface;
+
+  /**
+   * Get a network interface given its index.
+   * @param index an integer, the index of the interface
+   * @return the NetworkInterface obtained from its index, or {@code null} if&#xA; there is no interface with such an index on the system
+   * @throws SocketException if an I/O error occurs.
+   * @throws IllegalArgumentException if index has a negative value
+   * @see #getIndex()
+   * @since 1.7
+   */
+  getByIndex(index: number): NetworkInterface;
+
+  /**
+   * Convenience method to search for a network interface that
+   *  has the specified Internet Protocol (IP) address bound to
+   *  it.
+   *  <p>
+   *  If the specified IP address is bound to multiple network
+   *  interfaces it is not defined which network interface is
+   *  returned.
+   * @param addr&#xA; The {@code InetAddress} to search with.
+   * @return A {@code NetworkInterface}&#xA; or {@code null} if there is no network interface&#xA; with the specified IP address.
+   * @throws SocketException&#xA; If an I/O error occurs.
+   * @throws NullPointerException&#xA; If the specified address is {@code null}.
+   */
+  getByInetAddress(addr: InetAddress): NetworkInterface;
+
+  /**
+   * Returns all the interfaces on this machine. The {@code Enumeration}
+   *  contains at least one element, possibly representing a loopback
+   *  interface that only supports communication between entities on
+   *  this machine.
+   *
+   *  NOTE: can use getNetworkInterfaces()+getInetAddresses()
+   *        to obtain all IP addresses for this node
+   * @return an Enumeration of NetworkInterfaces found on this machine
+   * @throws SocketException if an I/O error occurs.
+   */
+  getNetworkInterfaces(): Enumeration;
+
+  /**
+   * Returns whether a network interface is up and running.
+   * @return {@code true} if the interface is up and running.
+   * @throws SocketException if an I/O error occurs.
+   * @since 1.6
+   */
+  isUp(): boolean;
+
+  /**
+   * Returns whether a network interface is a loopback interface.
+   * @return {@code true} if the interface is a loopback interface.
+   * @throws SocketException if an I/O error occurs.
+   * @since 1.6
+   */
+  isLoopback(): boolean;
+
+  /**
+   * Returns whether a network interface is a point to point interface.
+   *  A typical point to point interface would be a PPP connection through
+   *  a modem.
+   * @return {@code true} if the interface is a point to point&#xA; interface.
+   * @throws SocketException if an I/O error occurs.
+   * @since 1.6
+   */
+  isPointToPoint(): boolean;
+
+  /**
+   * Returns whether a network interface supports multicasting or not.
+   * @return {@code true} if the interface supports Multicasting.
+   * @throws SocketException if an I/O error occurs.
+   * @since 1.6
+   */
+  supportsMulticast(): boolean;
+
+  /**
+   * Returns the hardware address (usually MAC) of the interface if it
+   *  has one and if it can be accessed given the current privileges.
+   *  If a security manager is set, then the caller must have
+   *  the permission {@link NetPermission}("getNetworkInformation").
+   * @return a byte array containing the address, or {@code null} if&#xA; the address doesn't exist, is not accessible or a security&#xA; manager is set and the caller does not have the permission&#xA; NetPermission("getNetworkInformation")
+   * @throws SocketException if an I/O error occurs.
+   * @since 1.6
+   */
+  getHardwareAddress(): unknown;
+
+  /**
+   * Returns the Maximum Transmission Unit (MTU) of this interface.
+   * @return the value of the MTU for that interface.
+   * @throws SocketException if an I/O error occurs.
+   * @since 1.6
+   */
+  getMTU(): number;
+
+  /**
+   * Returns whether this interface is a virtual interface (also called
+   *  subinterface).
+   *  Virtual interfaces are, on some systems, interfaces created as a child
+   *  of a physical interface and given different settings (like address or
+   *  MTU). Usually the name of the interface will the name of the parent
+   *  followed by a colon (:) and a number identifying the child since there
+   *  can be several virtual interfaces attached to a single physical
+   *  interface.
+   * @return {@code true} if this interface is a virtual interface.
+   * @since 1.6
+   */
+  isVirtual(): boolean;
+
+  /**
+   * Compares this object against the specified object.
+   *  The result is {@code true} if and only if the argument is
+   *  not {@code null} and it represents the same NetworkInterface
+   *  as this object.
+   *  <p>
+   *  Two instances of {@code NetworkInterface} represent the same
+   *  NetworkInterface if both name and addrs are the same for both.
+   * @param obj the object to compare against.
+   * @return {@code true} if the objects are the same;&#xA; {@code false} otherwise.
+   * @see java.net.InetAddress#getAddress()
+   */
+  equals(obj: unknown): boolean;
+
+  hashCode(): number;
+
+  toString(): string;
+};

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

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getName: function getName() {},
+  getInetAddresses: function getInetAddresses() {},
+  getInterfaceAddresses: function getInterfaceAddresses() {},
+  getSubInterfaces: function getSubInterfaces() {},
+  getParent: function getParent() {},
+  getIndex: function getIndex() {},
+  getDisplayName: function getDisplayName() {},
+  getByName: function getByName() {},
+  getByIndex: function getByIndex() {},
+  getByInetAddress: function getByInetAddress() {},
+  getNetworkInterfaces: function getNetworkInterfaces() {},
+  isUp: function isUp() {},
+  isLoopback: function isLoopback() {},
+  isPointToPoint: function isPointToPoint() {},
+  supportsMulticast: function supportsMulticast() {},
+  getHardwareAddress: function getHardwareAddress() {},
+  getMTU: function getMTU() {},
+  isVirtual: function isVirtual() {},
+  equals: function equals() {},
+  hashCode: function hashCode() {},
+  toString: function toString() {}
+};
+exports["default"] = _default;

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

@@ -0,0 +1,68 @@
+import type { Type } from "../Proxy.Type";
+import type { SocketAddress } from "../SocketAddress";
+import type { String } from "../../lang/String";
+import type { Object } from "../../lang/Object";
+
+/**
+ * This class represents a proxy setting, typically a type (http, socks) and
+ *  a socket address.
+ *  A {@code Proxy} is an immutable object.
+ * @see java.net.ProxySelector
+ * @author Yingxian Wang
+ * @author Jean-Christophe Collet
+ * @since 1.5
+ */
+export type Proxy = Object & {
+  /**
+   * Returns the proxy type.
+   * @return a Type representing the proxy type
+   */
+  type(): Type;
+
+  /**
+   * Returns the socket address of the proxy, or
+   *  {@code null} if its a direct connection.
+   * @return a {@code SocketAddress} representing the socket end
 point of the proxy
+   */
+  address(): SocketAddress;
+
+  /**
+   * Constructs a string representation of this Proxy.
+   *  This String is constructed by calling toString() on its type
+   *  and concatenating " @ " and the toString() result from its address
+   *  if its type is not {@code DIRECT}.
+   * @return a string representation of this object.
+   */
+  toString(): string;
+
+  /**
+   * Compares this object against the specified object.
+   *  The result is {@code true} if and only if the argument is
+   *  not {@code null} and it represents the same proxy as
+   *  this object.
+   *  <p>
+   *  Two instances of {@code Proxy} represent the same
+   *  address if both the SocketAddresses and type are equal.
+   * @param obj the object to compare against.
+   * @return {@code true} if the objects are the same;&#xA; {@code false} otherwise.
+   * @see java.net.InetSocketAddress#equals(java.lang.Object)
+   */
+  equals(obj: unknown): boolean;
+
+  /**
+   * Returns a hashcode for this Proxy.
+   * @return a hash code value for this Proxy.
+   */
+  hashCode(): number;
+
+  /**
+ * A proxy setting that represents a {@code DIRECT} connection,
+ *  basically telling the protocol handler not to use any proxying.
+ *  Used, for instance, to create sockets bypassing any other global
+ *  proxy settings (like SOCKS):
+ *  <P>
+ *  {@code Socket s = new Socket(Proxy.NO_PROXY);}
+  
+    */
+  NO_PROXY: Proxy;
+};

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

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

package/types/java/net/Proxy.Type/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Represents the proxy type.
+ * @since 1.5
+ */
+export type Type = {
+  DIRECT: "DIRECT";
+  HTTP: "HTTP";
+  SOCKS: "SOCKS";
+};

package/types/java/net/Proxy.Type/index.js

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

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

@@ -0,0 +1,15 @@
+import type { Object } from "../../lang/Object";
+import type { Serializable } from "../../io/Serializable";
+
+/**
+ * This class represents a Socket Address with no protocol attachment.
+ *  As an abstract class, it is meant to be subclassed with a specific,
+ *  protocol dependent, implementation.
+ *  <p>
+ *  It provides an immutable object used by sockets for binding, connecting, or
+ *  as returned values.
+ * @see java.net.Socket
+ * @see java.net.ServerSocket
+ * @since 1.4
+ */
+export type SocketAddress = Object & Serializable & {};

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

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