@sitevision/api 2023.2.1 → 2023.2.2-beta.1

package/types/java/lang/reflect/Method/index.d.ts

@@ -0,0 +1,308 @@
+import type { Class } from "../../Class";
+import type { String } from "../../String";
+
+import type { TypeVariable } from "../TypeVariable";
+import type { Type } from "../Type";
+import type { Object } from "../../Object";
+
+import type { Annotation } from "../../annotation/Annotation";
+import type { AnnotatedType } from "../AnnotatedType";
+import type { Executable } from "../Executable";
+
+/**
+ * A {@code Method} provides information about, and access to, a single method
+ *  on a class or interface.  The reflected method may be a class method
+ *  or an instance method (including an abstract method).
+ *
+ *  <p>A {@code Method} permits widening conversions to occur when matching the
+ *  actual parameters to invoke with the underlying method's formal
+ *  parameters, but it throws an {@code IllegalArgumentException} if a
+ *  narrowing conversion would occur.
+ * @see Member
+ * @see java.lang.Class
+ * @see java.lang.Class#getMethods()
+ * @see java.lang.Class#getMethod(String, Class[])
+ * @see java.lang.Class#getDeclaredMethods()
+ * @see java.lang.Class#getDeclaredMethod(String, Class[])
+ * @author Kenneth Russell
+ * @author Nakul Saraiya
+ */
+export type Method = Executable & {
+  /**
+ * {@inheritDoc}
+  
+    */
+  getDeclaringClass(): Class;
+
+  /**
+ * Returns the name of the method represented by this {@code Method}
+ *  object, as a {@code String}.
+  
+    */
+  getName(): string;
+
+  /**
+ * {@inheritDoc}
+  
+    */
+  getModifiers(): number;
+
+  /**
+   * {@inheritDoc}
+   * @throws GenericSignatureFormatError {@inheritDoc}
+   * @since 1.5
+   */
+  getTypeParameters(): TypeVariable;
+
+  /**
+   * Returns a {@code Class} object that represents the formal return type
+   *  of the method represented by this {@code Method} object.
+   * @return the return type for the method this object represents
+   */
+  getReturnType(): Class;
+
+  /**
+   * Returns a {@code Type} object that represents the formal return
+   *  type of the method represented by this {@code Method} object.
+   *
+   *  <p>If the return type is a parameterized type,
+   *  the {@code Type} object returned must accurately reflect
+   *  the actual type parameters used in the source code.
+   *
+   *  <p>If the return type is a type variable or a parameterized type, it
+   *  is created. Otherwise, it is resolved.
+   * @return a {@code Type} object that represents the formal return&#xA; type of the underlying method
+   * @throws GenericSignatureFormatError&#xA; if the generic method signature does not conform to the format&#xA; specified in&#xA; <cite>The Java&trade; Virtual Machine Specification</cite>
+   * @throws TypeNotPresentException if the underlying method's&#xA; return type refers to a non-existent type declaration
+   * @throws MalformedParameterizedTypeException if the&#xA; underlying method's return typed refers to a parameterized&#xA; type that cannot be instantiated for any reason
+   * @since 1.5
+   */
+  getGenericReturnType(): Type;
+
+  /**
+ * {@inheritDoc}
+  
+    */
+  getParameterTypes(): Class;
+
+  /**
+   * {@inheritDoc}
+   * @since 1.8
+   */
+  getParameterCount(): number;
+
+  /**
+   * {@inheritDoc}
+   * @throws GenericSignatureFormatError {@inheritDoc}
+   * @throws TypeNotPresentException {@inheritDoc}
+   * @throws MalformedParameterizedTypeException {@inheritDoc}
+   * @since 1.5
+   */
+  getGenericParameterTypes(): Type;
+
+  /**
+ * {@inheritDoc}
+  
+    */
+  getExceptionTypes(): Class;
+
+  /**
+   * {@inheritDoc}
+   * @throws GenericSignatureFormatError {@inheritDoc}
+   * @throws TypeNotPresentException {@inheritDoc}
+   * @throws MalformedParameterizedTypeException {@inheritDoc}
+   * @since 1.5
+   */
+  getGenericExceptionTypes(): Type;
+
+  /**
+ * Compares this {@code Method} against the specified object.  Returns
+ *  true if the objects are the same.  Two {@code Methods} are the same if
+ *  they were declared by the same class and have the same name
+ *  and formal parameter types and return type.
+  
+    */
+  equals(obj: unknown): boolean;
+
+  /**
+ * Returns a hashcode for this {@code Method}.  The hashcode is computed
+ *  as the exclusive-or of the hashcodes for the underlying
+ *  method's declaring class name and the method's name.
+  
+    */
+  hashCode(): number;
+
+  /**
+   * Returns a string describing this {@code Method}.  The string is
+   *  formatted as the method access modifiers, if any, followed by
+   *  the method return type, followed by a space, followed by the
+   *  class declaring the method, followed by a period, followed by
+   *  the method name, followed by a parenthesized, comma-separated
+   *  list of the method's formal parameter types. If the method
+   *  throws checked exceptions, the parameter list is followed by a
+   *  space, followed by the word throws followed by a
+   *  comma-separated list of the thrown exception types.
+   *  For example:
+   *  <pre>
+   *     public boolean java.lang.Object.equals(java.lang.Object)
+   *  </pre>
+   *
+   *  <p>The access modifiers are placed in canonical order as
+   *  specified by "The Java Language Specification".  This is
+   *  {@code public}, {@code protected} or {@code private} first,
+   *  and then other modifiers in the following order:
+   *  {@code abstract}, {@code default}, {@code static}, {@code final},
+   *  {@code synchronized}, {@code native}, {@code strictfp}.
+   * @return a string describing this {@code Method}
+   * @jls 8.4.3 Method Modifiers
+   */
+  toString(): string;
+
+  /**
+   * Returns a string describing this {@code Method}, including
+   *  type parameters.  The string is formatted as the method access
+   *  modifiers, if any, followed by an angle-bracketed
+   *  comma-separated list of the method's type parameters, if any,
+   *  followed by the method's generic return type, followed by a
+   *  space, followed by the class declaring the method, followed by
+   *  a period, followed by the method name, followed by a
+   *  parenthesized, comma-separated list of the method's generic
+   *  formal parameter types.
+   *
+   *  If this method was declared to take a variable number of
+   *  arguments, instead of denoting the last parameter as
+   *  "<tt><i>Type</i>[]</tt>", it is denoted as
+   *  "<tt><i>Type</i>...</tt>".
+   *
+   *  A space is used to separate access modifiers from one another
+   *  and from the type parameters or return type.  If there are no
+   *  type parameters, the type parameter list is elided; if the type
+   *  parameter list is present, a space separates the list from the
+   *  class name.  If the method is declared to throw exceptions, the
+   *  parameter list is followed by a space, followed by the word
+   *  throws followed by a comma-separated list of the generic thrown
+   *  exception types.
+   *
+   *  <p>The access modifiers are placed in canonical order as
+   *  specified by "The Java Language Specification".  This is
+   *  {@code public}, {@code protected} or {@code private} first,
+   *  and then other modifiers in the following order:
+   *  {@code abstract}, {@code default}, {@code static}, {@code final},
+   *  {@code synchronized}, {@code native}, {@code strictfp}.
+   * @return a string describing this {@code Method},&#xA; include type parameters
+   * @since 1.5
+   * @jls 8.4.3 Method Modifiers
+   */
+  toGenericString(): string;
+
+  /**
+   * Invokes the underlying method represented by this {@code Method}
+   *  object, on the specified object with the specified parameters.
+   *  Individual parameters are automatically unwrapped to match
+   *  primitive formal parameters, and both primitive and reference
+   *  parameters are subject to method invocation conversions as
+   *  necessary.
+   *
+   *  <p>If the underlying method is static, then the specified {@code obj}
+   *  argument is ignored. It may be null.
+   *
+   *  <p>If the number of formal parameters required by the underlying method is
+   *  0, the supplied {@code args} array may be of length 0 or null.
+   *
+   *  <p>If the underlying method is an instance method, it is invoked
+   *  using dynamic method lookup as documented in The Java Language
+   *  Specification, Second Edition, section 15.12.4.4; in particular,
+   *  overriding based on the runtime type of the target object will occur.
+   *
+   *  <p>If the underlying method is static, the class that declared
+   *  the method is initialized if it has not already been initialized.
+   *
+   *  <p>If the method completes normally, the value it returns is
+   *  returned to the caller of invoke; if the value has a primitive
+   *  type, it is first appropriately wrapped in an object. However,
+   *  if the value has the type of an array of a primitive type, the
+   *  elements of the array are <i>not</i> wrapped in objects; in
+   *  other words, an array of primitive type is returned.  If the
+   *  underlying method return type is void, the invocation returns
+   *  null.
+   * @param obj the object the underlying method is invoked from
+   * @param args the arguments used for the method call
+   * @return the result of dispatching the method represented by&#xA; this object on {@code obj} with parameters&#xA; {@code args}
+   * @throws IllegalAccessException if this {@code Method} object&#xA; is enforcing Java language access control and the underlying&#xA; method is inaccessible.
+   * @throws IllegalArgumentException if the method is an&#xA; instance method and the specified object argument&#xA; is not an instance of the class or interface&#xA; declaring the underlying method (or of a subclass&#xA; or implementor thereof); if the number of actual&#xA; and formal parameters differ; if an unwrapping&#xA; conversion for primitive arguments fails; or if,&#xA; after possible unwrapping, a parameter value&#xA; cannot be converted to the corresponding formal&#xA; parameter type by a method invocation conversion.
+   * @throws InvocationTargetException if the underlying method&#xA; throws an exception.
+   * @throws NullPointerException if the specified object is null&#xA; and the method is an instance method.
+   * @throws ExceptionInInitializerError if the initialization&#xA; provoked by this method fails.
+   */
+  invoke(obj: unknown, args: unknown[]): unknown;
+
+  /**
+   * Returns {@code true} if this method is a bridge
+   *  method; returns {@code false} otherwise.
+   * @return true if and only if this method is a bridge&#xA; method as defined by the Java Language Specification.
+   * @since 1.5
+   */
+  isBridge(): boolean;
+
+  /**
+   * {@inheritDoc}
+   * @since 1.5
+   */
+  isVarArgs(): boolean;
+
+  /**
+   * {@inheritDoc}
+   * @jls 13.1 The Form of a Binary
+   * @since 1.5
+   */
+  isSynthetic(): boolean;
+
+  /**
+   * Returns {@code true} if this method is a default
+   *  method; returns {@code false} otherwise.
+   *
+   *  A default method is a public non-abstract instance method, that
+   *  is, a non-static method with a body, declared in an interface
+   *  type.
+   * @return true if and only if this method is a default&#xA; method as defined by the Java Language Specification.
+   * @since 1.8
+   */
+  isDefault(): boolean;
+
+  /**
+   * Returns the default value for the annotation member represented by
+   *  this {@code Method} instance.  If the member is of a primitive type,
+   *  an instance of the corresponding wrapper type is returned. Returns
+   *  null if no default is associated with the member, or if the method
+   *  instance does not represent a declared member of an annotation type.
+   * @return the default value for the annotation member represented&#xA; by this {@code Method} instance.
+   * @throws TypeNotPresentException if the annotation is of type&#xA; {@link Class} and no definition can be found for the&#xA; default class value.
+   * @since 1.5
+   */
+  getDefaultValue(): unknown;
+
+  /**
+   * {@inheritDoc}
+   * @throws NullPointerException {@inheritDoc}
+   * @since 1.5
+   */
+  getAnnotation(annotationClass: Class): unknown;
+
+  /**
+   * {@inheritDoc}
+   * @since 1.5
+   */
+  getDeclaredAnnotations(): Annotation;
+
+  /**
+   * {@inheritDoc}
+   * @since 1.5
+   */
+  getParameterAnnotations(): Annotation;
+
+  /**
+   * {@inheritDoc}
+   * @since 1.8
+   */
+  getAnnotatedReturnType(): AnnotatedType;
+};

package/types/java/lang/reflect/Method/index.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getDeclaringClass: function getDeclaringClass() {},
+  getName: function getName() {},
+  getModifiers: function getModifiers() {},
+  getTypeParameters: function getTypeParameters() {},
+  getReturnType: function getReturnType() {},
+  getGenericReturnType: function getGenericReturnType() {},
+  getParameterTypes: function getParameterTypes() {},
+  getParameterCount: function getParameterCount() {},
+  getGenericParameterTypes: function getGenericParameterTypes() {},
+  getExceptionTypes: function getExceptionTypes() {},
+  getGenericExceptionTypes: function getGenericExceptionTypes() {},
+  equals: function equals() {},
+  hashCode: function hashCode() {},
+  toString: function toString() {},
+  toGenericString: function toGenericString() {},
+  invoke: function invoke() {},
+  isBridge: function isBridge() {},
+  isVarArgs: function isVarArgs() {},
+  isSynthetic: function isSynthetic() {},
+  isDefault: function isDefault() {},
+  getDefaultValue: function getDefaultValue() {},
+  getAnnotation: function getAnnotation() {},
+  getDeclaredAnnotations: function getDeclaredAnnotations() {},
+  getParameterAnnotations: function getParameterAnnotations() {},
+  getAnnotatedReturnType: function getAnnotatedReturnType() {}
+};
+exports["default"] = _default;

package/types/java/lang/reflect/Parameter/index.d.ts

@@ -0,0 +1,155 @@
+import type { Object } from "../../Object";
+
+import type { String } from "../../String";
+import type { Executable } from "../Executable";
+import type { Type } from "../Type";
+import type { Class } from "../../Class";
+import type { AnnotatedType } from "../AnnotatedType";
+
+import type { Annotation } from "../../annotation/Annotation";
+import type { AnnotatedElement } from "../AnnotatedElement";
+
+/**
+ * Information about method parameters.
+ *
+ *  A {@code Parameter} provides information about method parameters,
+ *  including its name and modifiers.  It also provides an alternate
+ *  means of obtaining attributes for the parameter.
+ * @since 1.8
+ */
+export type Parameter = Object &
+  AnnotatedElement & {
+    /**
+     * Compares based on the executable and the index.
+     * @param obj The object to compare.
+     * @return Whether or not this is equal to the argument.
+     */
+    equals(obj: unknown): boolean;
+
+    /**
+     * Returns a hash code based on the executable's hash code and the
+     *  index.
+     * @return A hash code based on the executable's hash code.
+     */
+    hashCode(): number;
+
+    /**
+     * Returns true if the parameter has a name according to the class
+     *  file; returns false otherwise. Whether a parameter has a name
+     *  is determined by the {@literal MethodParameters} attribute of
+     *  the method which declares the parameter.
+     * @return true if and only if the parameter has a name according
 to the class file.
+     */
+    isNamePresent(): boolean;
+
+    /**
+     * Returns a string describing this parameter.  The format is the
+     *  modifiers for the parameter, if any, in canonical order as
+     *  recommended by <cite>The Java&trade; Language
+     *  Specification</cite>, followed by the fully- qualified type of
+     *  the parameter (excluding the last [] if the parameter is
+     *  variable arity), followed by "..." if the parameter is variable
+     *  arity, followed by a space, followed by the name of the
+     *  parameter.
+     * @return A string representation of the parameter and associated&#xA; information.
+     */
+    toString(): string;
+
+    /**
+     * Return the {@code Executable} which declares this parameter.
+     * @return The {@code Executable} declaring this parameter.
+     */
+    getDeclaringExecutable(): Executable;
+
+    /**
+     * Get the modifier flags for this the parameter represented by
+     *  this {@code Parameter} object.
+     * @return The modifier flags for this parameter.
+     */
+    getModifiers(): number;
+
+    /**
+     * Returns the name of the parameter.  If the parameter's name is
+     *  {@linkplain #isNamePresent() present}, then this method returns
+     *  the name provided by the class file. Otherwise, this method
+     *  synthesizes a name of the form argN, where N is the index of
+     *  the parameter in the descriptor of the method which declares
+     *  the parameter.
+     * @return The name of the parameter, either provided by the class&#xA; file or synthesized if the class file does not provide&#xA; a name.
+     */
+    getName(): string;
+
+    /**
+     * Returns a {@code Type} object that identifies the parameterized
+     *  type for the parameter represented by this {@code Parameter}
+     *  object.
+     * @return a {@code Type} object identifying the parameterized&#xA; type of the parameter represented by this object
+     */
+    getParameterizedType(): Type;
+
+    /**
+     * Returns a {@code Class} object that identifies the
+     *  declared type for the parameter represented by this
+     *  {@code Parameter} object.
+     * @return a {@code Class} object identifying the declared&#xA; type of the parameter represented by this object
+     */
+    getType(): Class;
+
+    /**
+     * Returns an AnnotatedType object that represents the use of a type to
+     *  specify the type of the formal parameter represented by this Parameter.
+     * @return an {@code AnnotatedType} object representing the use of a type&#xA; to specify the type of the formal parameter represented by this&#xA; Parameter
+     */
+    getAnnotatedType(): AnnotatedType;
+
+    /**
+     * Returns {@code true} if this parameter is implicitly declared
+     *  in source code; returns {@code false} otherwise.
+     * @return true if and only if this parameter is implicitly&#xA; declared as defined by <cite>The Java&trade; Language&#xA; Specification</cite>.
+     */
+    isImplicit(): boolean;
+
+    /**
+     * Returns {@code true} if this parameter is neither implicitly
+     *  nor explicitly declared in source code; returns {@code false}
+     *  otherwise.
+     * @jls 13.1 The Form of a Binary
+     * @return true if and only if this parameter is a synthetic&#xA; construct as defined by&#xA; <cite>The Java&trade; Language Specification</cite>.
+     */
+    isSynthetic(): boolean;
+
+    /**
+     * Returns {@code true} if this parameter represents a variable
+     *  argument list; returns {@code false} otherwise.
+     * @return {@code true} if an only if this parameter represents a&#xA; variable argument list.
+     */
+    isVarArgs(): boolean;
+
+    /**
+     * {@inheritDoc}
+     * @throws NullPointerException {@inheritDoc}
+     */
+    getAnnotation(annotationClass: Class): unknown;
+
+    /**
+     * {@inheritDoc}
+     * @throws NullPointerException {@inheritDoc}
+     */
+    getAnnotationsByType(annotationClass: Class): unknown;
+
+    /**
+ * {@inheritDoc}
+  
+    */
+    getDeclaredAnnotations(): Annotation;
+
+    getDeclaredAnnotation(annotationClass: Class): unknown;
+
+    getDeclaredAnnotationsByType(annotationClass: Class): unknown;
+
+    /**
+ * {@inheritDoc}
+  
+    */
+    getAnnotations(): Annotation;
+  };

package/types/java/lang/reflect/Parameter/index.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  equals: function equals() {},
+  hashCode: function hashCode() {},
+  isNamePresent: function isNamePresent() {},
+  toString: function toString() {},
+  getDeclaringExecutable: function getDeclaringExecutable() {},
+  getModifiers: function getModifiers() {},
+  getName: function getName() {},
+  getParameterizedType: function getParameterizedType() {},
+  getType: function getType() {},
+  getAnnotatedType: function getAnnotatedType() {},
+  isImplicit: function isImplicit() {},
+  isSynthetic: function isSynthetic() {},
+  isVarArgs: function isVarArgs() {},
+  getAnnotation: function getAnnotation() {},
+  getAnnotationsByType: function getAnnotationsByType() {},
+  getDeclaredAnnotations: function getDeclaredAnnotations() {},
+  getDeclaredAnnotation: function getDeclaredAnnotation() {},
+  getDeclaredAnnotationsByType: function getDeclaredAnnotationsByType() {},
+  getAnnotations: function getAnnotations() {}
+};
+exports["default"] = _default;

package/types/java/lang/reflect/Type/index.d.ts

@@ -0,0 +1,18 @@
+import type { String } from "../../String";
+
+/**
+ * Type is the common superinterface for all types in the Java
+ *  programming language. These include raw types, parameterized types,
+ *  array types, type variables and primitive types.
+ * @since 1.5
+ */
+export type Type = {
+  /**
+   * Returns a string describing this type, including information
+   *  about any type parameters.
+   * @implSpec The default implementation calls {@code toString}.
+   * @return a string describing this type
+   * @since 1.8
+   */
+  getTypeName(): string;
+};

package/types/java/lang/reflect/Type/index.js

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

package/types/java/lang/reflect/TypeVariable/index.d.ts

@@ -0,0 +1,70 @@
+import type { Type } from "../Type";
+
+import type { String } from "../../String";
+import type { AnnotatedType } from "../AnnotatedType";
+import type { AnnotatedElement } from "../AnnotatedElement";
+
+/**
+ * TypeVariable is the common superinterface for type variables of kinds.
+ *  A type variable is created the first time it is needed by a reflective
+ *  method, as specified in this package.  If a type variable t is referenced
+ *  by a type (i.e, class, interface or annotation type) T, and T is declared
+ *  by the nth enclosing class of T (see JLS 8.1.2), then the creation of t
+ *  requires the resolution (see JVMS 5) of the ith enclosing class of T,
+ *  for i = 0 to n, inclusive. Creating a type variable must not cause the
+ *  creation of its bounds. Repeated creation of a type variable has no effect.
+ *
+ *  <p>Multiple objects may be instantiated at run-time to
+ *  represent a given type variable. Even though a type variable is
+ *  created only once, this does not imply any requirement to cache
+ *  instances representing the type variable. However, all instances
+ *  representing a type variable must be equal() to each other.
+ *  As a consequence, users of type variables must not rely on the identity
+ *  of instances of classes implementing this interface.
+ * @param <D> the type of generic declaration that declared the&#xA; underlying type variable.
+ * @since 1.5
+ */
+export type TypeVariable = Type &
+  AnnotatedElement & {
+    /**
+     * Returns an array of {@code Type} objects representing the
+     *  upper bound(s) of this type variable.  Note that if no upper bound is
+     *  explicitly declared, the upper bound is {@code Object}.
+     *
+     *  <p>For each upper bound B: <ul> <li>if B is a parameterized
+     *  type or a type variable, it is created, (see {@link
+     *  java.lang.reflect.ParameterizedType ParameterizedType} for the
+     *  details of the creation process for parameterized types).
+     *  <li>Otherwise, B is resolved.  </ul>
+     * @throws TypeNotPresentException if any of the&#xA; bounds refers to a non-existent type declaration
+     * @throws MalformedParameterizedTypeException if any of the&#xA; bounds refer to a parameterized type that cannot be instantiated&#xA; for any reason
+     * @return an array of {@code Type}s representing the upper&#xA; bound(s) of this type variable
+     */
+    getBounds(): Type;
+
+    /**
+     * Returns the {@code GenericDeclaration} object representing the
+     *  generic declaration declared this type variable.
+     * @return the generic declaration declared for this type variable.
+     * @since 1.5
+     */
+    getGenericDeclaration(): unknown;
+
+    /**
+     * Returns the name of this type variable, as it occurs in the source code.
+     * @return the name of this type variable, as it appears in the source code
+     */
+    getName(): string;
+
+    /**
+     * Returns an array of AnnotatedType objects that represent the use of
+     *  types to denote the upper bounds of the type parameter represented by
+     *  this TypeVariable. The order of the objects in the array corresponds to
+     *  the order of the bounds in the declaration of the type parameter.
+     *
+     *  Returns an array of length 0 if the type parameter declares no bounds.
+     * @return an array of objects representing the upper bounds of the type variable
+     * @since 1.8
+     */
+    getAnnotatedBounds(): AnnotatedType;
+  };

package/types/java/lang/reflect/TypeVariable/index.js

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