@sitevision/api 2023.2.1 → 2023.2.2-beta.1

package/types/java/lang/Package/index.d.ts

@@ -0,0 +1,216 @@
+import type { String } from "../String";
+
+import type { URL } from "../../net/URL";
+
+import type { Class } from "../Class";
+
+import type { Annotation } from "../annotation/Annotation";
+import type { Object } from "../Object";
+import type { AnnotatedElement } from "../reflect/AnnotatedElement";
+
+/**
+ * {@code Package} objects contain version information
+ *  about the implementation and specification of a Java package.
+ *  This versioning information is retrieved and made available
+ *  by the {@link ClassLoader} instance that
+ *  loaded the class(es).  Typically, it is stored in the manifest that is
+ *  distributed with the classes.
+ *
+ *  <p>The set of classes that make up the package may implement a
+ *  particular specification and if so the specification title, version number,
+ *  and vendor strings identify that specification.
+ *  An application can ask if the package is
+ *  compatible with a particular version, see the {@link
+ *  #isCompatibleWith isCompatibleWith}
+ *  method for details.
+ *
+ *  <p>Specification version numbers use a syntax that consists of nonnegative
+ *  decimal integers separated by periods ".", for example "2.0" or
+ *  "1.2.3.4.5.6.7".  This allows an extensible number to be used to represent
+ *  major, minor, micro, etc. versions.  The version specification is described
+ *  by the following formal grammar:
+ *  <blockquote>
+ *  <dl>
+ *  <dt><i>SpecificationVersion:</i>
+ *  <dd><i>Digits RefinedVersion<sub>opt</sub></i>
+ *
+ *  <dt><i>RefinedVersion:</i>
+ *  <dd>{@code .} <i>Digits</i>
+ *  <dd>{@code .} <i>Digits RefinedVersion</i>
+ *
+ *  <dt><i>Digits:</i>
+ *  <dd><i>Digit</i>
+ *  <dd><i>Digits</i>
+ *
+ *  <dt><i>Digit:</i>
+ *  <dd>any character for which {@link Character#isDigit} returns {@code true},
+ *  e.g. 0, 1, 2, ...
+ *  </dl>
+ *  </blockquote>
+ *
+ *  <p>The implementation title, version, and vendor strings identify an
+ *  implementation and are made available conveniently to enable accurate
+ *  reporting of the packages involved when a problem occurs. The contents
+ *  all three implementation strings are vendor specific. The
+ *  implementation version strings have no specified syntax and should
+ *  only be compared for equality with desired version identifiers.
+ *
+ *  <p>Within each {@code ClassLoader} instance all classes from the same
+ *  java package have the same Package object.  The static methods allow a package
+ *  to be found by name or the set of all packages known to the current class
+ *  loader to be found.
+ * @see ClassLoader#definePackage
+ */
+export type Package = Object &
+  AnnotatedElement & {
+    /**
+     * Return the name of this package.
+     * @return The fully-qualified name of this package as defined in section 6.5.3 of&#xA; <cite>The Java&trade; Language Specification</cite>,&#xA; for example, {@code java.lang}
+     */
+    getName(): string;
+
+    /**
+     * Return the title of the specification that this package implements.
+     * @return the specification title, null is returned if it is not known.
+     */
+    getSpecificationTitle(): string;
+
+    /**
+     * Returns the version number of the specification
+     *  that this package implements.
+     *  This version string must be a sequence of nonnegative decimal
+     *  integers separated by "."'s and may have leading zeros.
+     *  When version strings are compared the most significant
+     *  numbers are compared.
+     * @return the specification version, null is returned if it is not known.
+     */
+    getSpecificationVersion(): string;
+
+    /**
+     * Return the name of the organization, vendor,
+     *  or company that owns and maintains the specification
+     *  of the classes that implement this package.
+     * @return the specification vendor, null is returned if it is not known.
+     */
+    getSpecificationVendor(): string;
+
+    /**
+     * Return the title of this package.
+     * @return the title of the implementation, null is returned if it is not known.
+     */
+    getImplementationTitle(): string;
+
+    /**
+     * Return the version of this implementation. It consists of any string
+     *  assigned by the vendor of this implementation and does
+     *  not have any particular syntax specified or expected by the Java
+     *  runtime. It may be compared for equality with other
+     *  package version strings used for this implementation
+     *  by this vendor for this package.
+     * @return the version of the implementation, null is returned if it is not known.
+     */
+    getImplementationVersion(): string;
+
+    /**
+     * Returns the name of the organization,
+     *  vendor or company that provided this implementation.
+     * @return the vendor that implemented this package..
+     */
+    getImplementationVendor(): string;
+
+    /**
+     * Returns true if this package is sealed.
+     * @return true if the package is sealed, false otherwise
+     */
+    isSealed(): boolean;
+
+    /**
+     * Returns true if this package is sealed with respect to the specified
+     *  code source url.
+     * @param url the code source url
+     * @return true if this package is sealed with respect to url
+     */
+    isSealed(url: URL): boolean;
+
+    /**
+     * Compare this package's specification version with a
+     *  desired version. It returns true if
+     *  this packages specification version number is greater than or equal
+     *  to the desired version number. <p>
+     *
+     *  Version numbers are compared by sequentially comparing corresponding
+     *  components of the desired and specification strings.
+     *  Each component is converted as a decimal integer and the values
+     *  compared.
+     *  If the specification value is greater than the desired
+     *  value true is returned. If the value is less false is returned.
+     *  If the values are equal the period is skipped and the next pair of
+     *  components is compared.
+     * @param desired the version string of the desired version.
+     * @return true if this package's version number is greater&#xA; than or equal to the desired version number
+     * @throws NumberFormatException if the desired or current version&#xA; is not of the correct dotted form.
+     */
+    isCompatibleWith(desired: String | string): boolean;
+
+    /**
+     * Find a package by name in the callers {@code ClassLoader} instance.
+     *  The callers {@code ClassLoader} instance is used to find the package
+     *  instance corresponding to the named class. If the callers
+     *  {@code ClassLoader} instance is null then the set of packages loaded
+     *  by the system {@code ClassLoader} instance is searched to find the
+     *  named package. <p>
+     *
+     *  Packages have attributes for versions and specifications only if the class
+     *  loader created the package instance with the appropriate attributes. Typically,
+     *  those attributes are defined in the manifests that accompany the classes.
+     * @param name a package name, for example, java.lang.
+     * @return the package of the requested name. It may be null if no package&#xA; information is available from the archive or codebase.
+     */
+    getPackage(name: String | string): Package;
+
+    /**
+     * Get all the packages currently known for the caller's {@code ClassLoader}
+     *  instance.  Those packages correspond to classes loaded via or accessible by
+     *  name to that {@code ClassLoader} instance.  If the caller's
+     *  {@code ClassLoader} instance is the bootstrap {@code ClassLoader}
+     *  instance, which may be represented by {@code null} in some implementations,
+     *  only packages corresponding to classes loaded by the bootstrap
+     *  {@code ClassLoader} instance will be returned.
+     * @return a new array of packages known to the callers {@code ClassLoader}&#xA; instance. An zero length array is returned if none are known.
+     */
+    getPackages(): Package;
+
+    /**
+     * Return the hash code computed from the package name.
+     * @return the hash code computed from the package name.
+     */
+    hashCode(): number;
+
+    /**
+     * Returns the string representation of this Package.
+     *  Its value is the string "package " and the package name.
+     *  If the package title is defined it is appended.
+     *  If the package version is defined it is appended.
+     * @return the string representation of the package.
+     */
+    toString(): string;
+
+    getAnnotation(annotationClass: Class): unknown;
+
+    /**
+     * {@inheritDoc}
+     * @throws NullPointerException {@inheritDoc}
+     * @since 1.5
+     */
+    isAnnotationPresent(annotationClass: Class): boolean;
+
+    getAnnotationsByType(annotationClass: Class): unknown;
+
+    getAnnotations(): Annotation;
+
+    getDeclaredAnnotation(annotationClass: Class): unknown;
+
+    getDeclaredAnnotationsByType(annotationClass: Class): unknown;
+
+    getDeclaredAnnotations(): Annotation;
+  };

package/types/java/lang/Package/index.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getName: function getName() {},
+  getSpecificationTitle: function getSpecificationTitle() {},
+  getSpecificationVersion: function getSpecificationVersion() {},
+  getSpecificationVendor: function getSpecificationVendor() {},
+  getImplementationTitle: function getImplementationTitle() {},
+  getImplementationVersion: function getImplementationVersion() {},
+  getImplementationVendor: function getImplementationVendor() {},
+  isSealed: function isSealed() {},
+  isCompatibleWith: function isCompatibleWith() {},
+  getPackage: function getPackage() {},
+  getPackages: function getPackages() {},
+  hashCode: function hashCode() {},
+  toString: function toString() {},
+  getAnnotation: function getAnnotation() {},
+  isAnnotationPresent: function isAnnotationPresent() {},
+  getAnnotationsByType: function getAnnotationsByType() {},
+  getAnnotations: function getAnnotations() {},
+  getDeclaredAnnotation: function getDeclaredAnnotation() {},
+  getDeclaredAnnotationsByType: function getDeclaredAnnotationsByType() {},
+  getDeclaredAnnotations: function getDeclaredAnnotations() {}
+};
+exports["default"] = _default;

package/types/java/lang/Readable/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A <tt>Readable</tt> is a source of characters. Characters from
+ *  a <tt>Readable</tt> are made available to callers of the read
+ *  method via a {@link java.nio.CharBuffer CharBuffer}.
+ * @since 1.5
+ */
+export type Readable = {
+  /**
+   * Attempts to read characters into the specified character buffer.
+   *  The buffer is used as a repository of characters as-is: the only
+   *  changes made are the results of a put operation. No flipping or
+   *  rewinding of the buffer is performed.
+   * @param cb the buffer to read characters into
+   * @return The number of {@code char} values added to the buffer,&#xA; or -1 if this source of characters is at its end
+   * @throws IOException if an I/O error occurs
+   * @throws NullPointerException if cb is null
+   * @throws java.nio.ReadOnlyBufferException if cb is a read only buffer
+   */
+  read(cb: unknown): number;
+};

package/types/java/lang/Readable/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/lang/Runnable/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The <code>Runnable</code> interface should be implemented by any
+ *  class whose instances are intended to be executed by a thread. The
+ *  class must define a method of no arguments called <code>run</code>.
+ *  <p>
+ *  This interface is designed to provide a common protocol for objects that
+ *  wish to execute code while they are active. For example,
+ *  <code>Runnable</code> is implemented by class <code>Thread</code>.
+ *  Being active simply means that a thread has been started and has not
+ *  yet been stopped.
+ *  <p>
+ *  In addition, <code>Runnable</code> provides the means for a class to be
+ *  active while not subclassing <code>Thread</code>. A class that implements
+ *  <code>Runnable</code> can run without subclassing <code>Thread</code>
+ *  by instantiating a <code>Thread</code> instance and passing itself in
+ *  as the target.  In most cases, the <code>Runnable</code> interface should
+ *  be used if you are only planning to override the <code>run()</code>
+ *  method and no other <code>Thread</code> methods.
+ *  This is important because classes should not be subclassed
+ *  unless the programmer intends on modifying or enhancing the fundamental
+ *  behavior of the class.
+ * @author Arthur van Hoff
+ * @see java.lang.Thread
+ * @see java.util.concurrent.Callable
+ * @since JDK1.0
+ */
+export type Runnable = {
+  /**
+   * When an object implementing interface <code>Runnable</code> is used
+   *  to create a thread, starting the thread causes the object's
+   *  <code>run</code> method to be called in that separately executing
+   *  thread.
+   *  <p>
+   *  The general contract of the method <code>run</code> is that it may
+   *  take any action whatsoever.
+   * @see java.lang.Thread#run()
+   */
+  run(): void;
+};

package/types/java/lang/Runnable/index.js

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

package/types/java/lang/RuntimeException/index.d.ts

@@ -0,0 +1,17 @@
+import type { Exception } from "../Exception";
+
+/**
+ * {@code RuntimeException} is the superclass of those
+ *  exceptions that can be thrown during the normal operation of the
+ *  Java Virtual Machine.
+ *
+ *  <p>{@code RuntimeException} and its subclasses are <em>unchecked
+ *  exceptions</em>.  Unchecked exceptions do <em>not</em> need to be
+ *  declared in a method or constructor's {@code throws} clause if they
+ *  can be thrown by the execution of the method or constructor and
+ *  propagate outside the method or constructor boundary.
+ * @author Frank Yellin
+ * @jls 11.2 Compile-Time Checking of Exceptions
+ * @since JDK1.0
+ */
+export type RuntimeException = Exception & {};

package/types/java/lang/RuntimeException/index.js

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

package/types/java/lang/StackTraceElement/index.d.ts

@@ -0,0 +1,116 @@
+import type { String } from "../String";
+
+import type { Object } from "../Object";
+import type { Serializable } from "../../io/Serializable";
+
+/**
+ * An element in a stack trace, as returned by {@link
+ *  Throwable#getStackTrace()}.  Each element represents a single stack frame.
+ *  All stack frames except for the one at the top of the stack represent
+ *  a method invocation.  The frame at the top of the stack represents the
+ *  execution point at which the stack trace was generated.  Typically,
+ *  this is the point at which the throwable corresponding to the stack trace
+ *  was created.
+ * @since 1.4
+ * @author Josh Bloch
+ */
+export type StackTraceElement = Object &
+  Serializable & {
+    /**
+     * Returns the name of the source file containing the execution point
+     *  represented by this stack trace element.  Generally, this corresponds
+     *  to the {@code SourceFile} attribute of the relevant {@code class}
+     *  file (as per <i>The Java Virtual Machine Specification</i>, Section
+     *  4.7.7).  In some systems, the name may refer to some source code unit
+     *  other than a file, such as an entry in source repository.
+     * @return the name of the file containing the execution point&#xA; represented by this stack trace element, or {@code null} if&#xA; this information is unavailable.
+     */
+    getFileName(): string;
+
+    /**
+     * Returns the line number of the source line containing the execution
+     *  point represented by this stack trace element.  Generally, this is
+     *  derived from the {@code LineNumberTable} attribute of the relevant
+     *  {@code class} file (as per <i>The Java Virtual Machine
+     *  Specification</i>, Section 4.7.8).
+     * @return the line number of the source line containing the execution&#xA; point represented by this stack trace element, or a negative&#xA; number if this information is unavailable.
+     */
+    getLineNumber(): number;
+
+    /**
+     * Returns the fully qualified name of the class containing the
+     *  execution point represented by this stack trace element.
+     * @return the fully qualified name of the {@code Class} containing&#xA; the execution point represented by this stack trace element.
+     */
+    getClassName(): string;
+
+    /**
+     * Returns the name of the method containing the execution point
+     *  represented by this stack trace element.  If the execution point is
+     *  contained in an instance or class initializer, this method will return
+     *  the appropriate <i>special method name</i>, {@code <init>} or
+     *  {@code <clinit>}, as per Section 3.9 of <i>The Java Virtual
+     *  Machine Specification</i>.
+     * @return the name of the method containing the execution point&#xA; represented by this stack trace element.
+     */
+    getMethodName(): string;
+
+    /**
+     * Returns true if the method containing the execution point
+     *  represented by this stack trace element is a native method.
+     * @return {@code true} if the method containing the execution point&#xA; represented by this stack trace element is a native method.
+     */
+    isNativeMethod(): boolean;
+
+    /**
+     * Returns a string representation of this stack trace element.  The
+     *  format of this string depends on the implementation, but the following
+     *  examples may be regarded as typical:
+     *  <ul>
+     *  <li>
+     *    {@code "MyClass.mash(MyClass.java:9)"} - Here, {@code "MyClass"}
+     *    is the <i>fully-qualified name</i> of the class containing the
+     *    execution point represented by this stack trace element,
+     *    {@code "mash"} is the name of the method containing the execution
+     *    point, {@code "MyClass.java"} is the source file containing the
+     *    execution point, and {@code "9"} is the line number of the source
+     *    line containing the execution point.
+     *  <li>
+     *    {@code "MyClass.mash(MyClass.java)"} - As above, but the line
+     *    number is unavailable.
+     *  <li>
+     *    {@code "MyClass.mash(Unknown Source)"} - As above, but neither
+     *    the file name nor the line  number are available.
+     *  <li>
+     *    {@code "MyClass.mash(Native Method)"} - As above, but neither
+     *    the file name nor the line  number are available, and the method
+     *    containing the execution point is known to be a native method.
+     *  </ul>
+     * @see Throwable#printStackTrace()
+     */
+    toString(): string;
+
+    /**
+     * Returns true if the specified object is another
+     *  {@code StackTraceElement} instance representing the same execution
+     *  point as this instance.  Two stack trace elements {@code a} and
+     *  {@code b} are equal if and only if:
+     *  <pre>{@code
+     *      equals(a.getFileName(), b.getFileName()) &&
+     *      a.getLineNumber() == b.getLineNumber()) &&
+     *      equals(a.getClassName(), b.getClassName()) &&
+     *      equals(a.getMethodName(), b.getMethodName())
+     *  }</pre>
+     *  where {@code equals} has the semantics of {@link
+     *  java.util.Objects#equals(Object, Object) Objects.equals}.
+     * @param obj the object to be compared with this stack trace element.
+     * @return true if the specified object is another&#xA; {@code StackTraceElement} instance representing the same&#xA; execution point as this instance.
+     */
+    equals(obj: unknown): boolean;
+
+    /**
+ * Returns a hash code value for this stack trace element.
+  
+    */
+    hashCode(): number;
+  };

package/types/java/lang/StackTraceElement/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getFileName: function getFileName() {},
+  getLineNumber: function getLineNumber() {},
+  getClassName: function getClassName() {},
+  getMethodName: function getMethodName() {},
+  isNativeMethod: function isNativeMethod() {},
+  toString: function toString() {},
+  equals: function equals() {},
+  hashCode: function hashCode() {}
+};
+exports["default"] = _default;