@sitevision/api 2023.2.1 → 2023.2.2-beta.2

package/types/java/security/cert/CertPath/index.d.ts

@@ -0,0 +1,181 @@
+import type { String } from "../../../lang/String";
+import type { Iterator } from "../../../util/Iterator";
+import type { Object } from "../../../lang/Object";
+
+import type { List } from "../../../util/List";
+import type { Serializable } from "../../../io/Serializable";
+
+/**
+ * An immutable sequence of certificates (a certification path).
+ *  <p>
+ *  This is an abstract class that defines the methods common to all
+ *  {@code CertPath}s. Subclasses can handle different kinds of
+ *  certificates (X.509, PGP, etc.).
+ *  <p>
+ *  All {@code CertPath} objects have a type, a list of
+ *  {@code Certificate}s, and one or more supported encodings. Because the
+ *  {@code CertPath} class is immutable, a {@code CertPath} cannot
+ *  change in any externally visible way after being constructed. This
+ *  stipulation applies to all public fields and methods of this class and any
+ *  added or overridden by subclasses.
+ *  <p>
+ *  The type is a {@code String} that identifies the type of
+ *  {@code Certificate}s in the certification path. For each
+ *  certificate {@code cert} in a certification path {@code certPath},
+ *  {@code cert.getType().equals(certPath.getType())} must be
+ *  {@code true}.
+ *  <p>
+ *  The list of {@code Certificate}s is an ordered {@code List} of
+ *  zero or more {@code Certificate}s. This {@code List} and all
+ *  of the {@code Certificate}s contained in it must be immutable.
+ *  <p>
+ *  Each {@code CertPath} object must support one or more encodings
+ *  so that the object can be translated into a byte array for storage or
+ *  transmission to other parties. Preferably, these encodings should be
+ *  well-documented standards (such as PKCS#7). One of the encodings supported
+ *  by a {@code CertPath} is considered the default encoding. This
+ *  encoding is used if no encoding is explicitly requested (for the
+ *  {@link #getEncoded() getEncoded()} method, for instance).
+ *  <p>
+ *  All {@code CertPath} objects are also {@code Serializable}.
+ *  {@code CertPath} objects are resolved into an alternate
+ *  {@link CertPathRep CertPathRep} object during serialization. This allows
+ *  a {@code CertPath} object to be serialized into an equivalent
+ *  representation regardless of its underlying implementation.
+ *  <p>
+ *  {@code CertPath} objects can be created with a
+ *  {@code CertificateFactory} or they can be returned by other classes,
+ *  such as a {@code CertPathBuilder}.
+ *  <p>
+ *  By convention, X.509 {@code CertPath}s (consisting of
+ *  {@code X509Certificate}s), are ordered starting with the target
+ *  certificate and ending with a certificate issued by the trust anchor. That
+ *  is, the issuer of one certificate is the subject of the following one. The
+ *  certificate representing the {@link TrustAnchor TrustAnchor} should not be
+ *  included in the certification path. Unvalidated X.509 {@code CertPath}s
+ *  may not follow these conventions. PKIX {@code CertPathValidator}s will
+ *  detect any departure from these conventions that cause the certification
+ *  path to be invalid and throw a {@code CertPathValidatorException}.
+ *
+ *  <p> Every implementation of the Java platform is required to support the
+ *  following standard {@code CertPath} encodings:
+ *  <ul>
+ *  <li>{@code PKCS7}</li>
+ *  <li>{@code PkiPath}</li>
+ *  </ul>
+ *  These encodings are described in the <a href=
+ *  "{@docRoot}/../technotes/guides/security/StandardNames.html#CertPathEncodings">
+ *  CertPath Encodings section</a> of the
+ *  Java Cryptography Architecture Standard Algorithm Name Documentation.
+ *  Consult the release documentation for your implementation to see if any
+ *  other encodings are supported.
+ *  <p>
+ *  <b>Concurrent Access</b>
+ *  <p>
+ *  All {@code CertPath} objects must be thread-safe. That is, multiple
+ *  threads may concurrently invoke the methods defined in this class on a
+ *  single {@code CertPath} object (or more than one) with no
+ *  ill effects. This is also true for the {@code List} returned by
+ *  {@code CertPath.getCertificates}.
+ *  <p>
+ *  Requiring {@code CertPath} objects to be immutable and thread-safe
+ *  allows them to be passed around to various pieces of code without worrying
+ *  about coordinating access.  Providing this thread-safety is
+ *  generally not difficult, since the {@code CertPath} and
+ *  {@code List} objects in question are immutable.
+ * @see CertificateFactory
+ * @see CertPathBuilder
+ * @author Yassir Elley
+ * @since 1.4
+ */
+export type CertPath = Object &
+  Serializable & {
+    /**
+     * Returns the type of {@code Certificate}s in this certification
+     *  path. This is the same string that would be returned by
+     *  {@link java.security.cert.Certificate#getType() cert.getType()}
+     *  for all {@code Certificate}s in the certification path.
+     * @return the type of {@code Certificate}s in this certification&#xA; path (never null)
+     */
+    getType(): string;
+
+    /**
+     * Returns an iteration of the encodings supported by this certification
+     *  path, with the default encoding first. Attempts to modify the returned
+     *  {@code Iterator} via its {@code remove} method result in an
+     *  {@code UnsupportedOperationException}.
+     * @return an {@code Iterator} over the names of the supported&#xA; encodings (as Strings)
+     */
+    getEncodings(): Iterator;
+
+    /**
+     * Compares this certification path for equality with the specified
+     *  object. Two {@code CertPath}s are equal if and only if their
+     *  types are equal and their certificate {@code List}s (and by
+     *  implication the {@code Certificate}s in those {@code List}s)
+     *  are equal. A {@code CertPath} is never equal to an object that is
+     *  not a {@code CertPath}.
+     *  <p>
+     *  This algorithm is implemented by this method. If it is overridden,
+     *  the behavior specified here must be maintained.
+     * @param other the object to test for equality with this certification path
+     * @return true if the specified object is equal to this certification path,&#xA; false otherwise
+     */
+    equals(other: unknown): boolean;
+
+    /**
+     * Returns the hashcode for this certification path. The hash code of
+     *  a certification path is defined to be the result of the following
+     *  calculation:
+     *  <pre>{@code
+     *   hashCode = path.getType().hashCode();
+     *   hashCode = 31*hashCode + path.getCertificates().hashCode();
+     *  }</pre>
+     *  This ensures that {@code path1.equals(path2)} implies that
+     *  {@code path1.hashCode()==path2.hashCode()} for any two certification
+     *  paths, {@code path1} and {@code path2}, as required by the
+     *  general contract of {@code Object.hashCode}.
+     * @return the hashcode value for this certification path
+     */
+    hashCode(): number;
+
+    /**
+     * Returns a string representation of this certification path.
+     *  This calls the {@code toString} method on each of the
+     *  {@code Certificate}s in the path.
+     * @return a string representation of this certification path
+     */
+    toString(): string;
+
+    /**
+     * Returns the encoded form of this certification path, using the default
+     *  encoding.
+     * @return the encoded bytes
+     * @throws CertificateEncodingException if an encoding error occurs
+     */
+    getEncoded(): unknown;
+
+    /**
+     * Returns the encoded form of this certification path, using the
+     *  specified encoding.
+     * @param encoding the name of the encoding to use
+     * @return the encoded bytes
+     * @throws CertificateEncodingException if an encoding error occurs or&#xA; the encoding requested is not supported
+     */
+    getEncoded(encoding: String | string): unknown;
+
+    /**
+     * Returns the list of certificates in this certification path.
+     *  The {@code List} returned must be immutable and thread-safe.
+     * @return an immutable {@code List} of {@code Certificate}s&#xA; (may be empty, but not null)
+     */
+    getCertificates(): List;
+
+    /**
+     * Replaces the {@code CertPath} to be serialized with a
+     *  {@code CertPathRep} object.
+     * @return the {@code CertPathRep} to be serialized
+     * @throws ObjectStreamException if a {@code CertPathRep} object&#xA; representing this certification path could not be created
+     */
+    writeReplace(): unknown;
+  };

package/types/java/security/cert/CertPath/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getType: function getType() {},
+  getEncodings: function getEncodings() {},
+  equals: function equals() {},
+  hashCode: function hashCode() {},
+  toString: function toString() {},
+  getEncoded: function getEncoded() {},
+  getCertificates: function getCertificates() {},
+  writeReplace: function writeReplace() {}
+};
+exports["default"] = _default;

package/types/java/security/cert/Certificate/index.d.ts

@@ -0,0 +1,133 @@
+import type { String } from "../../../lang/String";
+import type { Object } from "../../../lang/Object";
+
+import type { PublicKey } from "../../PublicKey";
+
+import type { Provider } from "../../Provider";
+import type { Serializable } from "../../../io/Serializable";
+
+/**
+ * <p>Abstract class for managing a variety of identity certificates.
+ *  An identity certificate is a binding of a principal to a public key which
+ *  is vouched for by another principal.  (A principal represents
+ *  an entity such as an individual user, a group, or a corporation.)
+ * <p>
+ *  This class is an abstraction for certificates that have different
+ *  formats but important common uses.  For example, different types of
+ *  certificates, such as X.509 and PGP, share general certificate
+ *  functionality (like encoding and verifying) and
+ *  some types of information (like a public key).
+ *  <p>
+ *  X.509, PGP, and SDSI certificates can all be implemented by
+ *  subclassing the Certificate class, even though they contain different
+ *  sets of information, and they store and retrieve the information in
+ *  different ways.
+ * @see X509Certificate
+ * @see CertificateFactory
+ * @author Hemma Prafullchandra
+ */
+export type Certificate = Object &
+  Serializable & {
+    /**
+     * Returns the type of this certificate.
+     * @return the type of this certificate.
+     */
+    getType(): string;
+
+    /**
+     * Compares this certificate for equality with the specified
+     *  object. If the {@code other} object is an
+     *  {@code instanceof} {@code Certificate}, then
+     *  its encoded form is retrieved and compared with the
+     *  encoded form of this certificate.
+     * @param other the object to test for equality with this certificate.
+     * @return true iff the encoded forms of the two certificates&#xA; match, false otherwise.
+     */
+    equals(other: unknown): boolean;
+
+    /**
+     * Returns a hashcode value for this certificate from its
+     *  encoded form.
+     * @return the hashcode value.
+     */
+    hashCode(): number;
+
+    /**
+     * Returns the encoded form of this certificate. It is
+     *  assumed that each certificate type would have only a single
+     *  form of encoding; for example, X.509 certificates would
+     *  be encoded as ASN.1 DER.
+     * @return the encoded form of this certificate
+     * @throws CertificateEncodingException if an encoding error occurs.
+     */
+    getEncoded(): unknown;
+
+    /**
+     * Verifies that this certificate was signed using the
+     *  private key that corresponds to the specified public key.
+     * @param key the PublicKey used to carry out the verification.
+     * @throws NoSuchAlgorithmException on unsupported signature&#xA; algorithms.
+     * @throws InvalidKeyException on incorrect key.
+     * @throws NoSuchProviderException if there's no default provider.
+     * @throws SignatureException on signature errors.
+     * @throws CertificateException on encoding errors.
+     */
+    verify(key: PublicKey): void;
+
+    /**
+     * Verifies that this certificate was signed using the
+     *  private key that corresponds to the specified public key.
+     *  This method uses the signature verification engine
+     *  supplied by the specified provider.
+     * @param key the PublicKey used to carry out the verification.
+     * @param sigProvider the name of the signature provider.
+     * @throws NoSuchAlgorithmException on unsupported signature&#xA; algorithms.
+     * @throws InvalidKeyException on incorrect key.
+     * @throws NoSuchProviderException on incorrect provider.
+     * @throws SignatureException on signature errors.
+     * @throws CertificateException on encoding errors.
+     */
+    verify(key: PublicKey, sigProvider: String | string): void;
+
+    /**
+     * Verifies that this certificate was signed using the
+     *  private key that corresponds to the specified public key.
+     *  This method uses the signature verification engine
+     *  supplied by the specified provider. Note that the specified
+     *  Provider object does not have to be registered in the provider list.
+     *
+     *  <p> This method was added to version 1.8 of the Java Platform
+     *  Standard Edition. In order to maintain backwards compatibility with
+     *  existing service providers, this method cannot be {@code abstract}
+     *  and by default throws an {@code UnsupportedOperationException}.
+     * @param key the PublicKey used to carry out the verification.
+     * @param sigProvider the signature provider.
+     * @throws NoSuchAlgorithmException on unsupported signature&#xA; algorithms.
+     * @throws InvalidKeyException on incorrect key.
+     * @throws SignatureException on signature errors.
+     * @throws CertificateException on encoding errors.
+     * @throws UnsupportedOperationException if the method is not supported
+     * @since 1.8
+     */
+    verify(key: PublicKey, sigProvider: Provider): void;
+
+    /**
+     * Returns a string representation of this certificate.
+     * @return a string representation of this certificate.
+     */
+    toString(): string;
+
+    /**
+     * Gets the public key from this certificate.
+     * @return the public key.
+     */
+    getPublicKey(): PublicKey;
+
+    /**
+     * Replace the Certificate to be serialized.
+     * @return the alternate Certificate object to be serialized
+     * @throws java.io.ObjectStreamException if a new object representing&#xA; this Certificate could not be created
+     * @since 1.3
+     */
+    writeReplace(): unknown;
+  };

package/types/java/security/cert/Certificate/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getType: function getType() {},
+  equals: function equals() {},
+  hashCode: function hashCode() {},
+  getEncoded: function getEncoded() {},
+  verify: function verify() {},
+  toString: function toString() {},
+  getPublicKey: function getPublicKey() {},
+  writeReplace: function writeReplace() {}
+};
+exports["default"] = _default;

package/types/java/text/AttributedCharacterIterator/index.d.ts

@@ -0,0 +1,127 @@
+import type { Attribute } from "../AttributedCharacterIterator.Attribute";
+import type { Set } from "../../util/Set";
+import type { Map } from "../../util/Map";
+import type { Object } from "../../lang/Object";
+import type { CharacterIterator } from "../CharacterIterator";
+
+/**
+ * An {@code AttributedCharacterIterator} allows iteration through both text and
+ *  related attribute information.
+ *
+ *  <p>
+ *  An attribute is a key/value pair, identified by the key.  No two
+ *  attributes on a given character can have the same key.
+ *
+ *  <p>The values for an attribute are immutable, or must not be mutated
+ *  by clients or storage.  They are always passed by reference, and not
+ *  cloned.
+ *
+ *  <p>A <em>run with respect to an attribute</em> is a maximum text range for
+ *  which:
+ *  <ul>
+ *  <li>the attribute is undefined or {@code null} for the entire range, or
+ *  <li>the attribute value is defined and has the same non-{@code null} value for the
+ *      entire range.
+ *  </ul>
+ *
+ *  <p>A <em>run with respect to a set of attributes</em> is a maximum text range for
+ *  which this condition is met for each member attribute.
+ *
+ *  <p>When getting a run with no explicit attributes specified (i.e.,
+ *  calling {@link #getRunStart()} and {@link #getRunLimit()}), any
+ *  contiguous text segments having the same attributes (the same set
+ *  of attribute/value pairs) are treated as separate runs if the
+ *  attributes have been given to those text segments separately.
+ *
+ *  <p>The returned indexes are limited to the range of the iterator.
+ *
+ *  <p>The returned attribute information is limited to runs that contain
+ *  the current character.
+ *
+ *  <p>
+ *  Attribute keys are instances of {@link AttributedCharacterIterator.Attribute} and its
+ *  subclasses, such as {@link java.awt.font.TextAttribute}.
+ * @see AttributedCharacterIterator.Attribute
+ * @see java.awt.font.TextAttribute
+ * @see AttributedString
+ * @see Annotation
+ * @since 1.2
+ */
+export type AttributedCharacterIterator = CharacterIterator & {
+  /**
+   * Returns the index of the first character of the run
+   *  with respect to all attributes containing the current character.
+   *
+   *  <p>Any contiguous text segments having the same attributes (the
+   *  same set of attribute/value pairs) are treated as separate runs
+   *  if the attributes have been given to those text segments separately.
+   * @return the index of the first character of the run
+   */
+  getRunStart(): number;
+
+  /**
+   * Returns the index of the first character of the run
+   *  with respect to the given {@code attribute} containing the current character.
+   * @param attribute the desired attribute.
+   * @return the index of the first character of the run
+   */
+  getRunStart(attribute: Attribute): number;
+
+  /**
+   * Returns the index of the first character of the run
+   *  with respect to the given {@code attributes} containing the current character.
+   * @param attributes a set of the desired attributes.
+   * @return the index of the first character of the run
+   */
+  getRunStart(attributes: Set | unknown[]): number;
+
+  /**
+   * Returns the index of the first character following the run
+   *  with respect to all attributes containing the current character.
+   *
+   *  <p>Any contiguous text segments having the same attributes (the
+   *  same set of attribute/value pairs) are treated as separate runs
+   *  if the attributes have been given to those text segments separately.
+   * @return the index of the first character following the run
+   */
+  getRunLimit(): number;
+
+  /**
+   * Returns the index of the first character following the run
+   *  with respect to the given {@code attribute} containing the current character.
+   * @param attribute the desired attribute
+   * @return the index of the first character following the run
+   */
+  getRunLimit(attribute: Attribute): number;
+
+  /**
+   * Returns the index of the first character following the run
+   *  with respect to the given {@code attributes} containing the current character.
+   * @param attributes a set of the desired attributes
+   * @return the index of the first character following the run
+   */
+  getRunLimit(attributes: Set | unknown[]): number;
+
+  /**
+   * Returns a map with the attributes defined on the current
+   *  character.
+   * @return a map with the attributes defined on the current character
+   */
+  getAttributes(): Map;
+
+  /**
+   * Returns the value of the named {@code attribute} for the current character.
+   *  Returns {@code null} if the {@code attribute} is not defined.
+   * @param attribute the desired attribute
+   * @return the value of the named {@code attribute} or {@code null}
+   */
+  getAttribute(attribute: Attribute): unknown;
+
+  /**
+   * Returns the keys of all attributes defined on the
+   *  iterator's text range. The set is empty if no
+   *  attributes are defined.
+   * @return the keys of all attributes
+   */
+  getAllAttributeKeys(): Set;
+};

package/types/java/text/AttributedCharacterIterator/index.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getRunStart: function getRunStart() {},
+  getRunLimit: function getRunLimit() {},
+  getAttributes: function getAttributes() {},
+  getAttribute: function getAttribute() {},
+  getAllAttributeKeys: function getAllAttributeKeys() {}
+};
+exports["default"] = _default;

package/types/java/text/AttributedCharacterIterator.Attribute/index.d.ts

@@ -0,0 +1,76 @@
+import type { Object } from "../../lang/Object";
+
+import type { String } from "../../lang/String";
+import type { Serializable } from "../../io/Serializable";
+
+/**
+ * Defines attribute keys that are used to identify text attributes. These
+ *  keys are used in {@code AttributedCharacterIterator} and {@code AttributedString}.
+ * @see AttributedCharacterIterator
+ * @see AttributedString
+ * @since 1.2
+ */
+export type Attribute = Object &
+  Serializable & {
+    /**
+ * Compares two objects for equality. This version only returns true
+ *  for {@code x.equals(y)} if {@code x} and {@code y} refer
+ *  to the same object, and guarantees this for all subclasses.
+  
+    */
+    equals(obj: unknown): boolean;
+
+    /**
+ * Returns a hash code value for the object. This version is identical to
+ *  the one in {@code Object}, but is also final.
+  
+    */
+    hashCode(): number;
+
+    /**
+ * Returns a string representation of the object. This version returns the
+ *  concatenation of class name, {@code "("}, a name identifying the attribute
+ *  and {@code ")"}.
+  
+    */
+    toString(): string;
+
+    /**
+     * Returns the name of the attribute.
+     * @return the name of {@code Attribute}
+     */
+    getName(): string;
+
+    /**
+     * Resolves instances being deserialized to the predefined constants.
+     * @return the resolved {@code Attribute} object
+     * @throws InvalidObjectException if the object to resolve is not
 an instance of {@code Attribute}
+     */
+    readResolve(): unknown;
+
+    /**
+     * Attribute key for the language of some text.
+     *  <p> Values are instances of {@link java.util.Locale Locale}.
+     * @see java.util.Locale
+     */
+    LANGUAGE: Attribute;
+
+    /**
+     * Attribute key for the reading of some text. In languages where the written form
+     *  and the pronunciation of a word are only loosely related (such as Japanese),
+     *  it is often necessary to store the reading (pronunciation) along with the
+     *  written form.
+     *  <p>Values are instances of {@link Annotation} holding instances of {@link String}.
+     * @see Annotation
+     * @see java.lang.String
+     */
+    READING: Attribute;
+
+    /**
+     * Attribute key for input method segments. Input methods often break
+     *  up text into segments, which usually correspond to words.
+     *  <p>Values are instances of {@link Annotation} holding a {@code null} reference.
+     * @see Annotation
+     */
+    INPUT_METHOD_SEGMENT: Attribute;
+  };

package/types/java/text/AttributedCharacterIterator.Attribute/index.js

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