@sitevision/api 2023.2.1 → 2023.2.2-beta.2

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

@@ -0,0 +1,132 @@
+import type { Permission } from "../Permission";
+
+import type { Enumeration } from "../../util/Enumeration";
+import type { String } from "../../lang/String";
+import type { Object } from "../../lang/Object";
+import type { Serializable } from "../../io/Serializable";
+
+/**
+ * Abstract class representing a collection of Permission objects.
+ *
+ *  <p>With a PermissionCollection, you can:
+ *  <UL>
+ *  <LI> add a permission to the collection using the {@code add} method.
+ *  <LI> check to see if a particular permission is implied in the
+ *       collection, using the {@code implies} method.
+ *  <LI> enumerate all the permissions, using the {@code elements} method.
+ *  </UL>
+ *
+ *  <p>When it is desirable to group together a number of Permission objects
+ *  of the same type, the {@code newPermissionCollection} method on that
+ *  particular type of Permission object should first be called. The default
+ *  behavior (from the Permission class) is to simply return null.
+ *  Subclasses of class Permission override the method 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 a non-null value is returned, that PermissionCollection must be used.
+ *  If null is returned, then the caller of {@code newPermissionCollection}
+ *  is free to store permissions of the
+ *  given type in any PermissionCollection they choose
+ *  (one that uses a Hashtable, one that uses a Vector, etc).
+ *
+ *  <p>The PermissionCollection returned by the
+ *  {@code Permission.newPermissionCollection}
+ *  method is a homogeneous collection, which stores only Permission objects
+ *  for a given Permission type.  A PermissionCollection may also be
+ *  heterogeneous.  For example, Permissions is a PermissionCollection
+ *  subclass that represents a collection of PermissionCollections.
+ *  That is, its members are each a homogeneous PermissionCollection.
+ *  For example, a Permissions object might have a FilePermissionCollection
+ *  for all the FilePermission objects, a SocketPermissionCollection for all the
+ *  SocketPermission objects, and so on. Its {@code add} method adds a
+ *  permission to the appropriate collection.
+ *
+ *  <p>Whenever a permission is added to a heterogeneous PermissionCollection
+ *  such as Permissions, and the PermissionCollection doesn't yet contain a
+ *  PermissionCollection of the specified permission's type, the
+ *  PermissionCollection should call
+ *  the {@code newPermissionCollection} method on the permission's class
+ *  to see if it requires a special PermissionCollection. If
+ *  {@code newPermissionCollection}
+ *  returns null, the PermissionCollection
+ *  is free to store the permission in any type of PermissionCollection it
+ *  desires (one using a Hashtable, one using a Vector, etc.). For example,
+ *  the Permissions object uses a default PermissionCollection implementation
+ *  that stores the permission objects in a Hashtable.
+ *
+ *  <p> Subclass implementations of PermissionCollection should assume
+ *  that they may be called simultaneously from multiple threads,
+ *  and therefore should be synchronized properly.  Furthermore,
+ *  Enumerations returned via the {@code elements} method are
+ *  not <em>fail-fast</em>.  Modifications to a collection should not be
+ *  performed while enumerating over that collection.
+ * @see Permission
+ * @see Permissions
+ * @author Roland Schemers
+ */
+export type PermissionCollection = Object &
+  Serializable & {
+    /**
+     * Adds a permission object to the current collection of permission objects.
+     * @param permission the Permission object to add.
+     * @throws SecurityException - if this PermissionCollection object&#xA; has been marked readonly
+     * @throws IllegalArgumentException - if this PermissionCollection&#xA; object is a homogeneous collection and the permission&#xA; is not of the correct type.
+     */
+    add(permission: Permission): void;
+
+    /**
+     * Checks to see if the specified permission is implied by
+     *  the collection of Permission objects held in this PermissionCollection.
+     * @param permission the Permission object to compare.
+     * @return true if "permission" is implied by the permissions in&#xA; the collection, false if not.
+     */
+    implies(permission: Permission): boolean;
+
+    /**
+     * Returns an enumeration of all the Permission objects in the collection.
+     * @return an enumeration of all the Permissions.
+     */
+    elements(): Enumeration;
+
+    /**
+ * Marks this PermissionCollection object as "readonly". After
+ *  a PermissionCollection object
+ *  is marked as readonly, no new Permission objects can be added to it
+ *  using {@code add}.
+  
+    */
+    setReadOnly(): void;
+
+    /**
+     * Returns true if this PermissionCollection object is marked as readonly.
+     *  If it is readonly, no new Permission objects can be added to it
+     *  using {@code add}.
+     *
+     *  <p>By default, the object is <i>not</i> readonly. It can be set to
+     *  readonly by a call to {@code setReadOnly}.
+     * @return true if this PermissionCollection object is marked as readonly,&#xA; false otherwise.
+     */
+    isReadOnly(): boolean;
+
+    /**
+     * Returns a string describing this PermissionCollection object,
+     *  providing information about all the permissions it contains.
+     *  The format is:
+     *  <pre>
+     *  super.toString() (
+     *    // enumerate all the Permission
+     *    // objects and call toString() on them,
+     *    // one per line..
+     *  )</pre>
+     *
+     *  {@code super.toString} is a call to the {@code toString}
+     *  method of this
+     *  object's superclass, which is Object. The result is
+     *  this PermissionCollection's type name followed by this object's
+     *  hashcode, thus enabling clients to differentiate different
+     *  PermissionCollections object, even if they contain the same permissions.
+     * @return information about this PermissionCollection object,&#xA; as described above.
+     */
+    toString(): string;
+  };

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  add: function add() {},
+  implies: function implies() {},
+  elements: function elements() {},
+  setReadOnly: function setReadOnly() {},
+  isReadOnly: function isReadOnly() {},
+  toString: function toString() {}
+};
+exports["default"] = _default;

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

@@ -0,0 +1,54 @@
+import type { Object } from "../../lang/Object";
+
+import type { String } from "../../lang/String";
+
+/**
+ * This interface represents the abstract notion of a principal, which
+ *  can be used to represent any entity, such as an individual, a
+ *  corporation, and a login id.
+ * @see java.security.cert.X509Certificate
+ * @author Li Gong
+ */
+export type Principal = {
+  /**
+   * Compares this principal to the specified object.  Returns true
+   *  if the object passed in matches the principal represented by
+   *  the implementation of this interface.
+   * @param another principal to compare with.
+   * @return true if the principal passed in is the same as that
 encapsulated by this principal, and false otherwise.
+   */
+  equals(another: unknown): boolean;
+
+  /**
+   * Returns a string representation of this principal.
+   * @return a string representation of this principal.
+   */
+  toString(): string;
+
+  /**
+   * Returns a hashcode for this principal.
+   * @return a hashcode for this principal.
+   */
+  hashCode(): number;
+
+  /**
+   * Returns the name of this principal.
+   * @return the name of this principal.
+   */
+  getName(): string;
+
+  /**
+   * Returns true if the specified subject is implied by this principal.
+   *
+   *  <p>The default implementation of this method returns true if
+   *  {@code subject} is non-null and contains at least one principal that
+   *  is equal to this principal.
+   *
+   *  <p>Subclasses may override this with a different implementation, if
+   *  necessary.
+   * @param subject the {@code Subject}
+   * @return true if {@code subject} is non-null and is&#xA; implied by this principal, or false otherwise.
+   * @since 1.8
+   */
+  implies(subject: unknown): boolean;
+};

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

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

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

@@ -0,0 +1,24 @@
+/**
+ * A computation to be performed with privileges enabled, that throws one or
+ *  more checked exceptions.  The computation is performed by invoking
+ *  {@code AccessController.doPrivileged} on the
+ *  {@code PrivilegedExceptionAction} object.  This interface is
+ *  used only for computations that throw checked exceptions;
+ *  computations that do not throw
+ *  checked exceptions should use {@code PrivilegedAction} instead.
+ * @see AccessController
+ * @see AccessController#doPrivileged(PrivilegedExceptionAction)
+ * @see AccessController#doPrivileged(PrivilegedExceptionAction,
 AccessControlContext)
+ * @see PrivilegedAction
+ */
+export type PrivilegedExceptionAction = {
+  /**
+   * Performs the computation.  This method will be called by
+   *  {@code AccessController.doPrivileged} after enabling privileges.
+   * @return a class-dependent value that may represent the results of the
 computation. Each class that implements
 {@code PrivilegedExceptionAction} should document what
 (if anything) this value represents.
+   * @throws Exception an exceptional condition has occurred. Each class
 that implements {@code PrivilegedExceptionAction} should
 document the exceptions that its run method can throw.
+   * @see AccessController#doPrivileged(PrivilegedExceptionAction)
+   * @see AccessController#doPrivileged(PrivilegedExceptionAction,AccessControlContext)
+   */
+  run(): unknown;
+};

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

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

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

@@ -0,0 +1,88 @@
+import type { CodeSource } from "../CodeSource";
+import type { ClassLoader } from "../../lang/ClassLoader";
+import type { Principal } from "../Principal";
+import type { PermissionCollection } from "../PermissionCollection";
+import type { Permission } from "../Permission";
+
+import type { String } from "../../lang/String";
+import type { Object } from "../../lang/Object";
+
+/**
+ * The ProtectionDomain class encapsulates the characteristics of a domain,
+ *  which encloses a set of classes whose instances are granted a set
+ *  of permissions when being executed on behalf of a given set of Principals.
+ *  <p>
+ *  A static set of permissions can be bound to a ProtectionDomain when it is
+ *  constructed; such permissions are granted to the domain regardless of the
+ *  Policy in force. However, to support dynamic security policies, a
+ *  ProtectionDomain can also be constructed such that it is dynamically
+ *  mapped to a set of permissions by the current Policy whenever a permission
+ *  is checked.
+ *  <p>
+ * @author Li Gong
+ * @author Roland Schemers
+ * @author Gary Ellison
+ */
+export type ProtectionDomain = Object & {
+  /**
+   * Returns the CodeSource of this domain.
+   * @return the CodeSource of this domain which may be null.
+   * @since 1.2
+   */
+  getCodeSource(): CodeSource;
+
+  /**
+   * Returns the ClassLoader of this domain.
+   * @return the ClassLoader of this domain which may be null.
+   * @since 1.4
+   */
+  getClassLoader(): ClassLoader;
+
+  /**
+   * Returns an array of principals for this domain.
+   * @return a non-null array of principals for this domain.&#xA; Returns a new array each time this method is called.
+   * @since 1.4
+   */
+  getPrincipals(): Principal;
+
+  /**
+   * Returns the static permissions granted to this domain.
+   * @return the static set of permissions for this domain which may be null.
+   * @see Policy#refresh
+   * @see Policy#getPermissions(ProtectionDomain)
+   */
+  getPermissions(): PermissionCollection;
+
+  /**
+   * Check and see if this ProtectionDomain implies the permissions
+   *  expressed in the Permission object.
+   *  <p>
+   *  The set of permissions evaluated is a function of whether the
+   *  ProtectionDomain was constructed with a static set of permissions
+   *  or it was bound to a dynamically mapped set of permissions.
+   *  <p>
+   *  If the ProtectionDomain was constructed to a
+   *  {@link #ProtectionDomain(CodeSource, PermissionCollection)
+   *  statically bound} PermissionCollection then the permission will
+   *  only be checked against the PermissionCollection supplied at
+   *  construction.
+   *  <p>
+   *  However, if the ProtectionDomain was constructed with
+   *  the constructor variant which supports
+   *  {@link #ProtectionDomain(CodeSource, PermissionCollection,
+   *  ClassLoader, java.security.Principal[]) dynamically binding}
+   *  permissions, then the permission will be checked against the
+   *  combination of the PermissionCollection supplied at construction and
+   *  the current Policy binding.
+   *  <p>
+   * @param permission the Permission object to check.
+   * @return true if "permission" is implicit to this ProtectionDomain.
+   */
+  implies(permission: Permission): boolean;
+
+  /**
+ * Convert a ProtectionDomain to a String.
+  
+    */
+  toString(): string;
+};

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getCodeSource: function getCodeSource() {},
+  getClassLoader: function getClassLoader() {},
+  getPrincipals: function getPrincipals() {},
+  getPermissions: function getPermissions() {},
+  implies: function implies() {},
+  toString: function toString() {}
+};
+exports["default"] = _default;