@sitevision/api 2023.2.1 → 2023.2.2-beta.1

package/types/java/security/Provider/index.d.ts

@@ -0,0 +1,383 @@
+import type { String } from "../../lang/String";
+
+import type { InputStream } from "../../io/InputStream";
+import type { Map } from "../../util/Map";
+import type { Set } from "../../util/Set";
+import type { Collection } from "../../util/Collection";
+import type { Object } from "../../lang/Object";
+
+import type { BiFunction } from "../../util/function/BiFunction";
+import type { Function } from "../../util/function/Function";
+import type { BiConsumer } from "../../util/function/BiConsumer";
+import type { Enumeration } from "../../util/Enumeration";
+import type { Service } from "../Provider.Service";
+import type { Properties } from "../../util/Properties";
+
+/**
+ * This class represents a "provider" for the
+ *  Java Security API, where a provider implements some or all parts of
+ *  Java Security. Services that a provider may implement include:
+ *
+ *  <ul>
+ *
+ *  <li>Algorithms (such as DSA, RSA, MD5 or SHA-1).
+ *
+ *  <li>Key generation, conversion, and management facilities (such as for
+ *  algorithm-specific keys).
+ *
+ * </ul>
+ *
+ *  <p>Each provider has a name and a version number, and is configured
+ *  in each runtime it is installed in.
+ *
+ *  <p>See <a href =
+ *  "../../../technotes/guides/security/crypto/CryptoSpec.html#Provider">The Provider Class</a>
+ *  in the "Java Cryptography Architecture API Specification &amp; Reference"
+ *  for information about how a particular type of provider, the
+ *  cryptographic service provider, works and is installed. However,
+ *  please note that a provider can be used to implement any security
+ *  service in Java that uses a pluggable architecture with a choice
+ *  of implementations that fit underneath.
+ *
+ *  <p>Some provider implementations may encounter unrecoverable internal
+ *  errors during their operation, for example a failure to communicate with a
+ *  security token. A {@link ProviderException} should be used to indicate
+ *  such errors.
+ *
+ *  <p>The service type {@code Provider} is reserved for use by the
+ *  security framework. Services of this type cannot be added, removed,
+ *  or modified by applications.
+ *  The following attributes are automatically placed in each Provider object:
+ *  <table cellspacing=4>
+ *  <caption><b>Attributes Automatically Placed in a Provider Object</b></caption>
+ *  <tr><th>Name</th><th>Value</th>
+ *  <tr><td>{@code Provider.id name}</td>
+ *     <td>{@code String.valueOf(provider.getName())}</td>
+ *  <tr><td>{@code Provider.id version}</td>
+ *      <td>{@code String.valueOf(provider.getVersion())}</td>
+ *  <tr><td>{@code Provider.id info}</td>
+ *        <td>{@code String.valueOf(provider.getInfo())}</td>
+ *  <tr><td>{@code Provider.id className}</td>
+ *      <td>{@code provider.getClass().getName()}</td>
+ *  </table>
+ * @author Benjamin Renaud
+ * @author Andreas Sterbenz
+ */
+export type Provider = Properties & {
+  /**
+   * Returns the name of this provider.
+   * @return the name of this provider.
+   */
+  getName(): string;
+
+  /**
+   * Returns the version number for this provider.
+   * @return the version number for this provider.
+   */
+  getVersion(): number;
+
+  /**
+   * Returns a human-readable description of the provider and its
+   *  services.  This may return an HTML page, with relevant links.
+   * @return a description of the provider and its services.
+   */
+  getInfo(): string;
+
+  /**
+   * Returns a string with the name and the version number
+   *  of this provider.
+   * @return the string with the name and the version number&#xA; for this provider.
+   */
+  toString(): string;
+
+  /**
+   * Clears this provider so that it no longer contains the properties
+   *  used to look up facilities implemented by the provider.
+   *
+   *  <p>If a security manager is enabled, its {@code checkSecurityAccess}
+   *  method is called with the string {@code "clearProviderProperties."+name}
+   *  (where {@code name} is the provider name) to see if it's ok to clear
+   *  this provider.
+   * @throws SecurityException&#xA; if a security manager exists and its {@link&#xA; java.lang.SecurityManager#checkSecurityAccess} method&#xA; denies access to clear this provider
+   * @since 1.2
+   */
+  clear(): void;
+
+  /**
+   * Reads a property list (key and element pairs) from the input stream.
+   * @param inStream the input stream.
+   * @throws IOException if an error occurred when reading from the&#xA; input stream.
+   * @see java.util.Properties#load
+   */
+  load(inStream: InputStream): void;
+
+  /**
+   * Copies all of the mappings from the specified Map to this provider.
+   *  These mappings will replace any properties that this provider had
+   *  for any of the keys currently in the specified Map.
+   * @since 1.2
+   */
+  putAll(t: Map | {}): void;
+
+  /**
+   * Returns an unmodifiable Set view of the property entries contained
+   *  in this Provider.
+   * @see java.util.Map.Entry
+   * @since 1.2
+   */
+  entrySet(): Set;
+
+  /**
+   * Returns an unmodifiable Set view of the property keys contained in
+   *  this provider.
+   * @since 1.2
+   */
+  keySet(): Set;
+
+  /**
+   * Returns an unmodifiable Collection view of the property values
+   *  contained in this provider.
+   * @since 1.2
+   */
+  values(): Collection;
+
+  /**
+   * Sets the {@code key} property to have the specified
+   *  {@code value}.
+   *
+   *  <p>If a security manager is enabled, its {@code checkSecurityAccess}
+   *  method is called with the string {@code "putProviderProperty."+name},
+   *  where {@code name} is the provider name, to see if it's ok to set this
+   *  provider's property values.
+   * @throws SecurityException&#xA; if a security manager exists and its {@link&#xA; java.lang.SecurityManager#checkSecurityAccess} method&#xA; denies access to set property values.
+   * @since 1.2
+   */
+  put(key: unknown, value: unknown): unknown;
+
+  /**
+   * If the specified key is not already associated with a value (or is mapped
+   *  to {@code null}) associates it with the given value and returns
+   *  {@code null}, else returns the current value.
+   *
+   *  <p>If a security manager is enabled, its {@code checkSecurityAccess}
+   *  method is called with the string {@code "putProviderProperty."+name},
+   *  where {@code name} is the provider name, to see if it's ok to set this
+   *  provider's property values.
+   * @throws SecurityException&#xA; if a security manager exists and its {@link&#xA; java.lang.SecurityManager#checkSecurityAccess} method&#xA; denies access to set property values.
+   * @since 1.8
+   */
+  putIfAbsent(key: unknown, value: unknown): unknown;
+
+  /**
+   * Removes the {@code key} property (and its corresponding
+   *  {@code value}).
+   *
+   *  <p>If a security manager is enabled, its {@code checkSecurityAccess}
+   *  method is called with the string {@code "removeProviderProperty."+name},
+   *  where {@code name} is the provider name, to see if it's ok to remove this
+   *  provider's properties.
+   * @throws SecurityException&#xA; if a security manager exists and its {@link&#xA; java.lang.SecurityManager#checkSecurityAccess} method&#xA; denies access to remove this provider's properties.
+   * @since 1.2
+   */
+  remove(key: unknown): unknown;
+
+  /**
+   * Removes the entry for the specified key only if it is currently
+   *  mapped to the specified value.
+   *
+   *  <p>If a security manager is enabled, its {@code checkSecurityAccess}
+   *  method is called with the string {@code "removeProviderProperty."+name},
+   *  where {@code name} is the provider name, to see if it's ok to remove this
+   *  provider's properties.
+   * @throws SecurityException&#xA; if a security manager exists and its {@link&#xA; java.lang.SecurityManager#checkSecurityAccess} method&#xA; denies access to remove this provider's properties.
+   * @since 1.8
+   */
+  remove(key: unknown, value: unknown): boolean;
+
+  /**
+   * Replaces the entry for the specified key only if currently
+   *  mapped to the specified value.
+   *
+   *  <p>If a security manager is enabled, its {@code checkSecurityAccess}
+   *  method is called with the string {@code "putProviderProperty."+name},
+   *  where {@code name} is the provider name, to see if it's ok to set this
+   *  provider's property values.
+   * @throws SecurityException&#xA; if a security manager exists and its {@link&#xA; java.lang.SecurityManager#checkSecurityAccess} method&#xA; denies access to set property values.
+   * @since 1.8
+   */
+  replace(key: unknown, oldValue: unknown, newValue: unknown): boolean;
+
+  /**
+   * Replaces the entry for the specified key only if it is
+   *  currently mapped to some value.
+   *
+   *  <p>If a security manager is enabled, its {@code checkSecurityAccess}
+   *  method is called with the string {@code "putProviderProperty."+name},
+   *  where {@code name} is the provider name, to see if it's ok to set this
+   *  provider's property values.
+   * @throws SecurityException&#xA; if a security manager exists and its {@link&#xA; java.lang.SecurityManager#checkSecurityAccess} method&#xA; denies access to set property values.
+   * @since 1.8
+   */
+  replace(key: unknown, value: unknown): unknown;
+
+  /**
+   * Replaces each entry's value with the result of invoking the given
+   *  function on that entry, in the order entries are returned by an entry
+   *  set iterator, until all entries have been processed or the function
+   *  throws an exception.
+   *
+   *  <p>If a security manager is enabled, its {@code checkSecurityAccess}
+   *  method is called with the string {@code "putProviderProperty."+name},
+   *  where {@code name} is the provider name, to see if it's ok to set this
+   *  provider's property values.
+   * @throws SecurityException&#xA; if a security manager exists and its {@link&#xA; java.lang.SecurityManager#checkSecurityAccess} method&#xA; denies access to set property values.
+   * @since 1.8
+   */
+  replaceAll(afunction: BiFunction): void;
+
+  /**
+   * Attempts to compute a mapping for the specified key and its
+   *  current mapped value (or {@code null} if there is no current
+   *  mapping).
+   *
+   *  <p>If a security manager is enabled, its {@code checkSecurityAccess}
+   *  method is called with the strings {@code "putProviderProperty."+name}
+   *  and {@code "removeProviderProperty."+name}, where {@code name} is the
+   *  provider name, to see if it's ok to set this provider's property values
+   *  and remove this provider's properties.
+   * @throws SecurityException&#xA; if a security manager exists and its {@link&#xA; java.lang.SecurityManager#checkSecurityAccess} method&#xA; denies access to set property values or remove properties.
+   * @since 1.8
+   */
+  compute(key: unknown, remappingFunction: BiFunction): unknown;
+
+  /**
+   * If the specified key is not already associated with a value (or
+   *  is mapped to {@code null}), attempts to compute its value using
+   *  the given mapping function and enters it into this map unless
+   *  {@code null}.
+   *
+   *  <p>If a security manager is enabled, its {@code checkSecurityAccess}
+   *  method is called with the strings {@code "putProviderProperty."+name}
+   *  and {@code "removeProviderProperty."+name}, where {@code name} is the
+   *  provider name, to see if it's ok to set this provider's property values
+   *  and remove this provider's properties.
+   * @throws SecurityException&#xA; if a security manager exists and its {@link&#xA; java.lang.SecurityManager#checkSecurityAccess} method&#xA; denies access to set property values and remove properties.
+   * @since 1.8
+   */
+  computeIfAbsent(key: unknown, mappingFunction: Function): unknown;
+
+  /**
+   * If the value for the specified key is present and non-null, attempts to
+   *  compute a new mapping given the key and its current mapped value.
+   *
+   *  <p>If a security manager is enabled, its {@code checkSecurityAccess}
+   *  method is called with the strings {@code "putProviderProperty."+name}
+   *  and {@code "removeProviderProperty."+name}, where {@code name} is the
+   *  provider name, to see if it's ok to set this provider's property values
+   *  and remove this provider's properties.
+   * @throws SecurityException&#xA; if a security manager exists and its {@link&#xA; java.lang.SecurityManager#checkSecurityAccess} method&#xA; denies access to set property values or remove properties.
+   * @since 1.8
+   */
+  computeIfPresent(key: unknown, remappingFunction: BiFunction): unknown;
+
+  /**
+   * If the specified key is not already associated with a value or is
+   *  associated with null, associates it with the given value. Otherwise,
+   *  replaces the value with the results of the given remapping function,
+   *  or removes if the result is null. This method may be of use when
+   *  combining multiple mapped values for a key.
+   *
+   *  <p>If a security manager is enabled, its {@code checkSecurityAccess}
+   *  method is called with the strings {@code "putProviderProperty."+name}
+   *  and {@code "removeProviderProperty."+name}, where {@code name} is the
+   *  provider name, to see if it's ok to set this provider's property values
+   *  and remove this provider's properties.
+   * @throws SecurityException&#xA; if a security manager exists and its {@link&#xA; java.lang.SecurityManager#checkSecurityAccess} method&#xA; denies access to set property values or remove properties.
+   * @since 1.8
+   */
+  merge(key: unknown, value: unknown, remappingFunction: BiFunction): unknown;
+
+  get(key: unknown): unknown;
+
+  getOrDefault(key: unknown, defaultValue: unknown): unknown;
+
+  forEach(action: BiConsumer): void;
+
+  keys(): Enumeration;
+
+  elements(): Enumeration;
+
+  getProperty(key: String | string): string;
+
+  /**
+   * Get the service describing this Provider's implementation of the
+   *  specified type of this algorithm or alias. If no such
+   *  implementation exists, this method returns null. If there are two
+   *  matching services, one added to this provider using
+   *  {@link #putService putService()} and one added via {@link #put put()},
+   *  the service added via {@link #putService putService()} is returned.
+   * @param type the type of {@link Service service} requested&#xA; (for example, {@code MessageDigest})
+   * @param algorithm the case insensitive algorithm name (or alternate&#xA; alias) of the service requested (for example, {@code SHA-1})
+   * @return the service describing this Provider's matching service&#xA; or null if no such service exists
+   * @throws NullPointerException if type or algorithm is null
+   * @since 1.5
+   */
+  getService(type: String | string, algorithm: String | string): Service;
+
+  /**
+   * Get an unmodifiable Set of all services supported by
+   *  this Provider.
+   * @return an unmodifiable Set of all services supported by&#xA; this Provider
+   * @since 1.5
+   */
+  getServices(): Set;
+
+  /**
+   * Add a service. If a service of the same type with the same algorithm
+   *  name exists and it was added using {@link #putService putService()},
+   *  it is replaced by the new service.
+   *  This method also places information about this service
+   *  in the provider's Hashtable values in the format described in the
+   *  <a href="../../../technotes/guides/security/crypto/CryptoSpec.html">
+   *  Java Cryptography Architecture API Specification &amp; Reference </a>.
+   *
+   *  <p>Also, if there is a security manager, its
+   *  {@code checkSecurityAccess} method is called with the string
+   *  {@code "putProviderProperty."+name}, where {@code name} is
+   *  the provider name, to see if it's ok to set this provider's property
+   *  values. If the default implementation of {@code checkSecurityAccess}
+   *  is used (that is, that method is not overriden), then this results in
+   *  a call to the security manager's {@code checkPermission} method with
+   *  a {@code SecurityPermission("putProviderProperty."+name)}
+   *  permission.
+   * @param s the Service to add
+   * @throws SecurityException&#xA; if a security manager exists and its {@link&#xA; java.lang.SecurityManager#checkSecurityAccess} method denies&#xA; access to set property values.
+   * @throws NullPointerException if s is null
+   * @since 1.5
+   */
+  putService(s: Service): void;
+
+  /**
+   * Remove a service previously added using
+   *  {@link #putService putService()}. The specified service is removed from
+   *  this provider. It will no longer be returned by
+   *  {@link #getService getService()} and its information will be removed
+   *  from this provider's Hashtable.
+   *
+   *  <p>Also, if there is a security manager, its
+   *  {@code checkSecurityAccess} method is called with the string
+   *  {@code "removeProviderProperty."+name}, where {@code name} is
+   *  the provider name, to see if it's ok to remove this provider's
+   *  properties. If the default implementation of
+   *  {@code checkSecurityAccess} is used (that is, that method is not
+   *  overriden), then this results in a call to the security manager's
+   *  {@code checkPermission} method with a
+   *  {@code SecurityPermission("removeProviderProperty."+name)}
+   *  permission.
+   * @param s the Service to be removed
+   * @throws SecurityException&#xA; if a security manager exists and its {@link&#xA; java.lang.SecurityManager#checkSecurityAccess} method denies&#xA; access to remove this provider's properties.
+   * @throws NullPointerException if s is null
+   * @since 1.5
+   */
+  removeService(s: Service): void;
+};

package/types/java/security/Provider/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getName: function getName() {},
+  getVersion: function getVersion() {},
+  getInfo: function getInfo() {},
+  toString: function toString() {},
+  clear: function clear() {},
+  load: function load() {},
+  putAll: function putAll() {},
+  entrySet: function entrySet() {},
+  keySet: function keySet() {},
+  values: function values() {},
+  put: function put() {},
+  putIfAbsent: function putIfAbsent() {},
+  remove: function remove() {},
+  replace: function replace() {},
+  replaceAll: function replaceAll() {},
+  compute: function compute() {},
+  computeIfAbsent: function computeIfAbsent() {},
+  computeIfPresent: function computeIfPresent() {},
+  merge: function merge() {},
+  get: function get() {},
+  getOrDefault: function getOrDefault() {},
+  forEach: function forEach() {},
+  keys: function keys() {},
+  elements: function elements() {},
+  getProperty: function getProperty() {},
+  getService: function getService() {},
+  getServices: function getServices() {},
+  putService: function putService() {},
+  removeService: function removeService() {}
+};
+exports["default"] = _default;

package/types/java/security/Provider.Service/index.d.ts

@@ -0,0 +1,116 @@
+import type { String } from "../../lang/String";
+import type { Provider } from "../Provider";
+import type { Object } from "../../lang/Object";
+
+/**
+ * The description of a security service. It encapsulates the properties
+ *  of a service and contains a factory method to obtain new implementation
+ *  instances of this service.
+ *
+ *  <p>Each service has a provider that offers the service, a type,
+ *  an algorithm name, and the name of the class that implements the
+ *  service. Optionally, it also includes a list of alternate algorithm
+ *  names for this service (aliases) and attributes, which are a map of
+ *  (name, value) String pairs.
+ *
+ *  <p>This class defines the methods {@link #supportsParameter
+ *  supportsParameter()} and {@link #newInstance newInstance()}
+ *  which are used by the Java security framework when it searches for
+ *  suitable services and instantiates them. The valid arguments to those
+ *  methods depend on the type of service. For the service types defined
+ *  within Java SE, see the
+ *  <a href="../../../technotes/guides/security/crypto/CryptoSpec.html">
+ *  Java Cryptography Architecture API Specification &amp; Reference </a>
+ *  for the valid values.
+ *  Note that components outside of Java SE can define additional types of
+ *  services and their behavior.
+ *
+ *  <p>Instances of this class are immutable.
+ * @since 1.5
+ */
+export type Service = Object & {
+  /**
+   * Get the type of this service. For example, {@code MessageDigest}.
+   * @return the type of this service
+   */
+  getType(): string;
+
+  /**
+   * Return the name of the algorithm of this service. For example,
+   *  {@code SHA-1}.
+   * @return the algorithm of this service
+   */
+  getAlgorithm(): string;
+
+  /**
+   * Return the Provider of this service.
+   * @return the Provider of this service
+   */
+  getProvider(): Provider;
+
+  /**
+   * Return the name of the class implementing this service.
+   * @return the name of the class implementing this service
+   */
+  getClassName(): string;
+
+  /**
+   * Return the value of the specified attribute or null if this
+   *  attribute is not set for this Service.
+   * @param name the name of the requested attribute
+   * @return the value of the specified attribute or null if the&#xA; attribute is not present
+   * @throws NullPointerException if name is null
+   */
+  getAttribute(name: String | string): string;
+
+  /**
+   * Return a new instance of the implementation described by this
+   *  service. The security provider framework uses this method to
+   *  construct implementations. Applications will typically not need
+   *  to call it.
+   *
+   *  <p>The default implementation uses reflection to invoke the
+   *  standard constructor for this type of service.
+   *  Security providers can override this method to implement
+   *  instantiation in a different way.
+   *  For details and the values of constructorParameter that are
+   *  valid for the various types of services see the
+   *  <a href="../../../technotes/guides/security/crypto/CryptoSpec.html">
+   *  Java Cryptography Architecture API Specification &amp;
+   *  Reference</a>.
+   * @param constructorParameter the value to pass to the constructor,&#xA; or null if this type of service does not use a constructorParameter.
+   * @return a new implementation of this service
+   * @throws InvalidParameterException if the value of&#xA; constructorParameter is invalid for this type of service.
+   * @throws NoSuchAlgorithmException if instantiation failed for&#xA; any other reason.
+   */
+  newInstance(constructorParameter: unknown): unknown;
+
+  /**
+   * Test whether this Service can use the specified parameter.
+   *  Returns false if this service cannot use the parameter. Returns
+   *  true if this service can use the parameter, if a fast test is
+   *  infeasible, or if the status is unknown.
+   *
+   *  <p>The security provider framework uses this method with
+   *  some types of services to quickly exclude non-matching
+   *  implementations for consideration.
+   *  Applications will typically not need to call it.
+   *
+   *  <p>For details and the values of parameter that are valid for the
+   *  various types of services see the top of this class and the
+   *  <a href="../../../technotes/guides/security/crypto/CryptoSpec.html">
+   *  Java Cryptography Architecture API Specification &amp;
+   *  Reference</a>.
+   *  Security providers can override it to implement their own test.
+   * @param parameter the parameter to test
+   * @return false if this this service cannot use the specified&#xA; parameter; true if it can possibly use the parameter
+   * @throws InvalidParameterException if the value of parameter is&#xA; invalid for this type of service or if this method cannot be&#xA; used with this type of service
+   */
+  supportsParameter(parameter: unknown): boolean;
+
+  /**
+   * Return a String representation of this service.
+   * @return a String representation of this service.
+   */
+  toString(): string;
+};

package/types/java/security/Provider.Service/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getType: function getType() {},
+  getAlgorithm: function getAlgorithm() {},
+  getProvider: function getProvider() {},
+  getClassName: function getClassName() {},
+  getAttribute: function getAttribute() {},
+  newInstance: function newInstance() {},
+  supportsParameter: function supportsParameter() {},
+  toString: function toString() {}
+};
+exports["default"] = _default;

package/types/java/security/PublicKey/index.d.ts

@@ -0,0 +1,25 @@
+import type { Key } from "../Key";
+
+/**
+ * <p>A public key. This interface contains no methods or constants.
+ *  It merely serves to group (and provide type safety for) all public key
+ *  interfaces.
+ *
+ *  Note: The specialized public key interfaces extend this interface.
+ *  See, for example, the DSAPublicKey interface in
+ *  {@code java.security.interfaces}.
+ * @see Key
+ * @see PrivateKey
+ * @see Certificate
+ * @see Signature#initVerify
+ * @see java.security.interfaces.DSAPublicKey
+ * @see java.security.interfaces.RSAPublicKey
+ */
+export type PublicKey = Key & {
+  /**
+ * The class fingerprint that is set to indicate serialization
+ *  compatibility with a previous version of the class.
+  
+    */
+  serialVersionUID: number;
+};

package/types/java/security/PublicKey/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/security/Timestamp/index.d.ts

@@ -0,0 +1,53 @@
+import type { Date } from "../../util/Date";
+import type { CertPath } from "../cert/CertPath";
+
+import type { Object } from "../../lang/Object";
+
+import type { String } from "../../lang/String";
+import type { Serializable } from "../../io/Serializable";
+
+/**
+ * This class encapsulates information about a signed timestamp.
+ *  It is immutable.
+ *  It includes the timestamp's date and time as well as information about the
+ *  Timestamping Authority (TSA) which generated and signed the timestamp.
+ * @since 1.5
+ * @author Vincent Ryan
+ */
+export type Timestamp = Object &
+  Serializable & {
+    /**
+     * Returns the date and time when the timestamp was generated.
+     * @return The timestamp's date and time.
+     */
+    getTimestamp(): Date;
+
+    /**
+     * Returns the certificate path for the Timestamping Authority.
+     * @return The TSA's certificate path.
+     */
+    getSignerCertPath(): CertPath;
+
+    /**
+     * Returns the hash code value for this timestamp.
+     *  The hash code is generated using the date and time of the timestamp
+     *  and the TSA's certificate path.
+     * @return a hash code value for this timestamp.
+     */
+    hashCode(): number;
+
+    /**
+     * Tests for equality between the specified object and this
+     *  timestamp. Two timestamps are considered equal if the date and time of
+     *  their timestamp's and their signer's certificate paths are equal.
+     * @param obj the object to test for equality with this timestamp.
+     * @return true if the timestamp are considered equal, false otherwise.
+     */
+    equals(obj: unknown): boolean;
+
+    /**
+     * Returns a string describing this timestamp.
+     * @return A string comprising the date and time of the timestamp and
 its signer's certificate.
+     */
+    toString(): string;
+  };

package/types/java/security/Timestamp/index.js

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