@sitevision/api 2023.2.1 → 2023.2.2-beta.2

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

@@ -0,0 +1,52 @@
+import type { CertPath } from "../cert/CertPath";
+import type { Timestamp } from "../Timestamp";
+
+import type { Object } from "../../lang/Object";
+
+import type { String } from "../../lang/String";
+import type { Serializable } from "../../io/Serializable";
+
+/**
+ * This class encapsulates information about a code signer.
+ *  It is immutable.
+ * @since 1.5
+ * @author Vincent Ryan
+ */
+export type CodeSigner = Object &
+  Serializable & {
+    /**
+     * Returns the signer's certificate path.
+     * @return A certificate path.
+     */
+    getSignerCertPath(): CertPath;
+
+    /**
+     * Returns the signature timestamp.
+     * @return The timestamp or {@code null} if none is present.
+     */
+    getTimestamp(): Timestamp;
+
+    /**
+     * Returns the hash code value for this code signer.
+     *  The hash code is generated using the signer's certificate path and the
+     *  timestamp, if present.
+     * @return a hash code value for this code signer.
+     */
+    hashCode(): number;
+
+    /**
+     * Tests for equality between the specified object and this
+     *  code signer. Two code signers are considered equal if their
+     *  signer certificate paths are equal and if their timestamps are equal,
+     *  if present in both.
+     * @param obj the object to test for equality with this object.
+     * @return true if the objects are considered equal, false otherwise.
+     */
+    equals(obj: unknown): boolean;
+
+    /**
+     * Returns a string describing this code signer.
+     * @return A string comprising the signer's certificate and a timestamp,
 if present.
+     */
+    toString(): string;
+  };

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

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

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

@@ -0,0 +1,143 @@
+import type { Object } from "../../lang/Object";
+
+import type { URL } from "../../net/URL";
+import type { Certificate } from "../cert/Certificate";
+import type { CodeSigner } from "../CodeSigner";
+import type { String } from "../../lang/String";
+import type { Serializable } from "../../io/Serializable";
+
+/**
+ * <p>This class extends the concept of a codebase to
+ *  encapsulate not only the location (URL) but also the certificate chains
+ *  that were used to verify signed code originating from that location.
+ * @author Li Gong
+ * @author Roland Schemers
+ */
+export type CodeSource = Object &
+  Serializable & {
+    /**
+     * Returns the hash code value for this object.
+     * @return a hash code value for this object.
+     */
+    hashCode(): number;
+
+    /**
+     * Tests for equality between the specified object and this
+     *  object. Two CodeSource objects are considered equal if their
+     *  locations are of identical value and if their signer certificate
+     *  chains are of identical value. It is not required that
+     *  the certificate chains be in the same order.
+     * @param obj the object to test for equality with this object.
+     * @return true if the objects are considered equal, false otherwise.
+     */
+    equals(obj: unknown): boolean;
+
+    /**
+     * Returns the location associated with this CodeSource.
+     * @return the location (URL).
+     */
+    getLocation(): URL;
+
+    /**
+     * Returns the certificates associated with this CodeSource.
+     *  <p>
+     *  If this CodeSource object was created using the
+     *  {@link #CodeSource(URL url, CodeSigner[] signers)}
+     *  constructor then its certificate chains are extracted and used to
+     *  create an array of Certificate objects. Each signer certificate is
+     *  followed by its supporting certificate chain (which may be empty).
+     *  Each signer certificate and its supporting certificate chain is ordered
+     *  bottom-to-top (i.e., with the signer certificate first and the (root)
+     *  certificate authority last).
+     * @return A copy of the certificates array, or null if there is none.
+     */
+    getCertificates(): Certificate;
+
+    /**
+     * Returns the code signers associated with this CodeSource.
+     *  <p>
+     *  If this CodeSource object was created using the
+     *  {@link #CodeSource(URL url, java.security.cert.Certificate[] certs)}
+     *  constructor then its certificate chains are extracted and used to
+     *  create an array of CodeSigner objects. Note that only X.509 certificates
+     *  are examined - all other certificate types are ignored.
+     * @return A copy of the code signer array, or null if there is none.
+     * @since 1.5
+     */
+    getCodeSigners(): CodeSigner;
+
+    /**
+     * Returns true if this CodeSource object "implies" the specified CodeSource.
+     *  <p>
+     *  More specifically, this method makes the following checks.
+     *  If any fail, it returns false. If they all succeed, it returns true.
+     *  <ul>
+     *  <li> <i>codesource</i> must not be null.
+     *  <li> If this object's certificates are not null, then all
+     *  of this object's certificates must be present in <i>codesource</i>'s
+     *  certificates.
+     *  <li> If this object's location (getLocation()) is not null, then the
+     *  following checks are made against this object's location and
+     *  <i>codesource</i>'s:
+     *    <ul>
+     *      <li>  <i>codesource</i>'s location must not be null.
+     *
+     *      <li>  If this object's location
+     *            equals <i>codesource</i>'s location, then return true.
+     *
+     *      <li>  This object's protocol (getLocation().getProtocol()) must be
+     *            equal to <i>codesource</i>'s protocol, ignoring case.
+     *
+     *      <li>  If this object's host (getLocation().getHost()) is not null,
+     *            then the SocketPermission
+     *            constructed with this object's host must imply the
+     *            SocketPermission constructed with <i>codesource</i>'s host.
+     *
+     *      <li>  If this object's port (getLocation().getPort()) is not
+     *            equal to -1 (that is, if a port is specified), it must equal
+     *            <i>codesource</i>'s port or default port
+     *            (codesource.getLocation().getDefaultPort()).
+     *
+     *      <li>  If this object's file (getLocation().getFile()) doesn't equal
+     *            <i>codesource</i>'s file, then the following checks are made:
+     *            If this object's file ends with "/-",
+     *            then <i>codesource</i>'s file must start with this object's
+     *            file (exclusive the trailing "-").
+     *            If this object's file ends with a "/*",
+     *            then <i>codesource</i>'s file must start with this object's
+     *            file and must not have any further "/" separators.
+     *            If this object's file doesn't end with a "/",
+     *            then <i>codesource</i>'s file must match this object's
+     *            file with a '/' appended.
+     *
+     *      <li>  If this object's reference (getLocation().getRef()) is
+     *            not null, it must equal <i>codesource</i>'s reference.
+     *
+     *    </ul>
+     *  </ul>
+     *  <p>
+     *  For example, the codesource objects with the following locations
+     *  and null certificates all imply
+     *  the codesource with the location "http://java.sun.com/classes/foo.jar"
+     *  and null certificates:
+     *  <pre>
+     *      http:
+     *      http://*.sun.com/classes/*
+     *      http://java.sun.com/classes/-
+     *      http://java.sun.com/classes/foo.jar
+     *  </pre>
+     *
+     *  Note that if this CodeSource has a null location and a null
+     *  certificate chain, then it implies every other CodeSource.
+     * @param codesource CodeSource to compare against.
+     * @return true if the specified codesource is implied by this codesource,&#xA; false if not.
+     */
+    implies(codesource: CodeSource): boolean;
+
+    /**
+     * Returns a string describing this CodeSource, telling its
+     *  URL and certificates.
+     * @return information about this CodeSource.
+     */
+    toString(): string;
+  };

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

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

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

@@ -0,0 +1,24 @@
+import type { Object } from "../../lang/Object";
+
+/**
+ * <p> This interface represents a guard, which is an object that is used
+ *  to protect access to another object.
+ *
+ *  <p>This interface contains a single method, {@code checkGuard},
+ *  with a single {@code object} argument. {@code checkGuard} is
+ *  invoked (by the GuardedObject {@code getObject} method)
+ *  to determine whether or not to allow access to the object.
+ * @see GuardedObject
+ * @author Roland Schemers
+ * @author Li Gong
+ */
+export type Guard = {
+  /**
+   * Determines whether or not to allow access to the guarded object
+   *  {@code object}. Returns silently if access is allowed.
+   *  Otherwise, throws a SecurityException.
+   * @param object the object being protected by the guard.
+   * @throws SecurityException if access is denied.
+   */
+  checkGuard(object: unknown): void;
+};

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

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

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

@@ -0,0 +1,120 @@
+import type { String } from "../../lang/String";
+
+import type { Serializable } from "../../io/Serializable";
+
+/**
+ * The Key interface is the top-level interface for all keys. It
+ *  defines the functionality shared by all key objects. All keys
+ *  have three characteristics:
+ *
+ *  <UL>
+ *
+ *  <LI>An Algorithm
+ *
+ *  <P>This is the key algorithm for that key. The key algorithm is usually
+ *  an encryption or asymmetric operation algorithm (such as DSA or
+ *  RSA), which will work with those algorithms and with related
+ *  algorithms (such as MD5 with RSA, SHA-1 with RSA, Raw DSA, etc.)
+ *  The name of the algorithm of a key is obtained using the
+ *  {@link #getAlgorithm() getAlgorithm} method.
+ *
+ *  <LI>An Encoded Form
+ *
+ *  <P>This is an external encoded form for the key used when a standard
+ *  representation of the key is needed outside the Java Virtual Machine,
+ *  as when transmitting the key to some other party. The key
+ *  is encoded according to a standard format (such as
+ *  X.509 {@code SubjectPublicKeyInfo} or PKCS#8), and
+ *  is returned using the {@link #getEncoded() getEncoded} method.
+ *  Note: The syntax of the ASN.1 type {@code SubjectPublicKeyInfo}
+ *  is defined as follows:
+ *
+ *  <pre>
+ *  SubjectPublicKeyInfo ::= SEQUENCE {
+ *    algorithm AlgorithmIdentifier,
+ *    subjectPublicKey BIT STRING }
+ *
+ *  AlgorithmIdentifier ::= SEQUENCE {
+ *    algorithm OBJECT IDENTIFIER,
+ *    parameters ANY DEFINED BY algorithm OPTIONAL }
+ *  </pre>
+ *
+ *  For more information, see
+ *  <a href="http://tools.ietf.org/html/rfc5280">RFC 5280:
+ *  Internet X.509 Public Key Infrastructure Certificate and CRL Profile</a>.
+ *
+ *  <LI>A Format
+ *
+ *  <P>This is the name of the format of the encoded key. It is returned
+ *  by the {@link #getFormat() getFormat} method.
+ *
+ *  </UL>
+ *
+ *  Keys are generally obtained through key generators, certificates,
+ *  or various Identity classes used to manage keys.
+ *  Keys may also be obtained from key specifications (transparent
+ *  representations of the underlying key material) through the use of a key
+ *  factory (see {@link KeyFactory}).
+ *
+ *  <p> A Key should use KeyRep as its serialized representation.
+ *  Note that a serialized Key may contain sensitive information
+ *  which should not be exposed in untrusted environments.  See the
+ *  <a href="../../../platform/serialization/spec/security.html">
+ *  Security Appendix</a>
+ *  of the Serialization Specification for more information.
+ * @see PublicKey
+ * @see PrivateKey
+ * @see KeyPair
+ * @see KeyPairGenerator
+ * @see KeyFactory
+ * @see KeyRep
+ * @see java.security.spec.KeySpec
+ * @see Identity
+ * @see Signer
+ * @author Benjamin Renaud
+ */
+export type Key = Serializable & {
+  /**
+   * Returns the standard algorithm name for this key. For
+   *  example, "DSA" would indicate that this key is a DSA key.
+   *  See Appendix A in the <a href=
+   *  "../../../technotes/guides/security/crypto/CryptoSpec.html#AppA">
+   *  Java Cryptography Architecture API Specification &amp; Reference </a>
+   *  for information about standard algorithm names.
+   * @return the name of the algorithm associated with this key.
+   */
+  getAlgorithm(): string;
+
+  /**
+   * Returns the name of the primary encoding format of this key,
+   *  or null if this key does not support encoding.
+   *  The primary encoding format is
+   *  named in terms of the appropriate ASN.1 data format, if an
+   *  ASN.1 specification for this key exists.
+   *  For example, the name of the ASN.1 data format for public
+   *  keys is <I>SubjectPublicKeyInfo</I>, as
+   *  defined by the X.509 standard; in this case, the returned format is
+   *  {@code "X.509"}. Similarly,
+   *  the name of the ASN.1 data format for private keys is
+   *  <I>PrivateKeyInfo</I>,
+   *  as defined by the PKCS #8 standard; in this case, the returned format is
+   *  {@code "PKCS#8"}.
+   * @return the primary encoding format of the key.
+   */
+  getFormat(): string;
+
+  /**
+   * Returns the key in its primary encoding format, or null
+   *  if this key does not support encoding.
+   * @return the encoded key, or null if the key does not support&#xA; encoding.
+   */
+  getEncoded(): unknown;
+
+  /**
+ * The class fingerprint that is set to indicate
+ *  serialization compatibility with a previous
+ *  version of the class.
+  
+    */
+  serialVersionUID: number;
+};

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

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

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

@@ -0,0 +1,153 @@
+import type { Object } from "../../lang/Object";
+
+import type { String } from "../../lang/String";
+import type { PermissionCollection } from "../PermissionCollection";
+import type { Guard } from "../Guard";
+import type { Serializable } from "../../io/Serializable";
+
+/**
+ * Abstract class for representing access to a system resource.
+ *  All permissions have a name (whose interpretation depends on the subclass),
+ *  as well as abstract functions for defining the semantics of the
+ *  particular Permission subclass.
+ *
+ *  <p>Most Permission objects also include an "actions" list that tells the actions
+ *  that are permitted for the object.  For example,
+ *  for a {@code java.io.FilePermission} object, the permission name is
+ *  the pathname of a file (or directory), and the actions list
+ *  (such as "read, write") specifies which actions are granted for the
+ *  specified file (or for files in the specified directory).
+ *  The actions list is optional for Permission objects, such as
+ *  {@code java.lang.RuntimePermission},
+ *  that don't need such a list; you either have the named permission (such
+ *  as "system.exit") or you don't.
+ *
+ *  <p>An important method that must be implemented by each subclass is
+ *  the {@code implies} method to compare Permissions. Basically,
+ *  "permission p1 implies permission p2" means that
+ *  if one is granted permission p1, one is naturally granted permission p2.
+ *  Thus, this is not an equality test, but rather more of a
+ *  subset test.
+ *
+ *  <P> Permission objects are similar to String objects in that they
+ *  are immutable once they have been created. Subclasses should not
+ *  provide methods that can change the state of a permission
+ *  once it has been created.
+ * @see Permissions
+ * @see PermissionCollection
+ * @author Marianne Mueller
+ * @author Roland Schemers
+ */
+export type Permission = Object &
+  Guard &
+  Serializable & {
+    /**
+     * Implements the guard interface for a permission. The
+     *  {@code SecurityManager.checkPermission} method is called,
+     *  passing this permission object as the permission to check.
+     *  Returns silently if access is granted. Otherwise, throws
+     *  a SecurityException.
+     * @param object the object being guarded (currently ignored).
+     * @throws SecurityException&#xA; if a security manager exists and its&#xA; {@code checkPermission} method doesn't allow access.
+     * @see Guard
+     * @see GuardedObject
+     * @see SecurityManager#checkPermission
+     */
+    checkGuard(object: unknown): void;
+
+    /**
+     * Checks if the specified permission's actions are "implied by"
+     *  this object's actions.
+     *  <P>
+     *  This must be implemented by subclasses of Permission, as they are the
+     *  only ones that can impose semantics on a Permission object.
+     *
+     *  <p>The {@code implies} method is used by the AccessController to determine
+     *  whether or not a requested permission is implied by another permission that
+     *  is known to be valid in the current execution context.
+     * @param permission the permission to check against.
+     * @return true if the specified permission is implied by this object,&#xA; false if not.
+     */
+    implies(permission: Permission): boolean;
+
+    /**
+     * Checks two Permission objects for equality.
+     *  <P>
+     *  Do not use the {@code equals} method for making access control
+     *  decisions; use the {@code implies} method.
+     * @param obj the object we are testing for equality with this object.
+     * @return true if both Permission objects are equivalent.
+     */
+    equals(obj: unknown): boolean;
+
+    /**
+     * Returns the hash code value for this Permission object.
+     *  <P>
+     *  The required {@code hashCode} behavior for Permission Objects is
+     *  the following:
+     *  <ul>
+     *  <li>Whenever it is invoked on the same Permission object more than
+     *      once during an execution of a Java application, the
+     *      {@code hashCode} method
+     *      must consistently return the same integer. This integer need not
+     *      remain consistent from one execution of an application to another
+     *      execution of the same application.
+     *  <li>If two Permission objects are equal according to the
+     *      {@code equals}
+     *      method, then calling the {@code hashCode} method on each of the
+     *      two Permission objects must produce the same integer result.
+     *  </ul>
+     * @return a hash code value for this object.
+     */
+    hashCode(): number;
+
+    /**
+     * Returns the name of this Permission.
+     *  For example, in the case of a {@code java.io.FilePermission},
+     *  the name will be a pathname.
+     * @return the name of this Permission.
+     */
+    getName(): string;
+
+    /**
+     * Returns the actions as a String. This is abstract
+     *  so subclasses can defer creating a String representation until
+     *  one is needed. Subclasses should always return actions in what they
+     *  consider to be their
+     *  canonical form. For example, two FilePermission objects created via
+     *  the following:
+     *
+     *  <pre>
+     *    perm1 = new FilePermission(p1,"read,write");
+     *    perm2 = new FilePermission(p2,"write,read");
+     *  </pre>
+     *
+     *  both return
+     *  "read,write" when the {@code getActions} method is invoked.
+     * @return the actions of this Permission.
+     */
+    getActions(): string;
+
+    /**
+     * Returns an empty PermissionCollection for a given Permission object, or null if
+     *  one is not defined. Subclasses of class Permission should
+     *  override this if they need to store their permissions in a particular
+     *  PermissionCollection object in order to provide the correct semantics
+     *  when the {@code PermissionCollection.implies} method is called.
+     *  If null is returned,
+     *  then the caller of this method is free to store permissions of this
+     *  type in any PermissionCollection they choose (one that uses a Hashtable,
+     *  one that uses a Vector, etc).
+     * @return a new PermissionCollection object for this type of Permission, or&#xA; null if one is not defined.
+     */
+    newPermissionCollection(): PermissionCollection;
+
+    /**
+     * Returns a string describing this Permission.  The convention is to
+     *  specify the class name, the permission name, and the actions in
+     *  the following format: '("ClassName" "name" "actions")', or
+     *  '("ClassName" "name")' if actions list is null or empty.
+     * @return information about this Permission.
+     */
+    toString(): string;
+  };

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

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