@sitevision/api 2023.2.1 → 2023.2.2-beta.2

package/types/java/nio/file/PathMatcher/index.js

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

package/types/java/nio/file/WatchEvent.Kind/index.d.ts

@@ -0,0 +1,21 @@
+import type { String } from "../../../lang/String";
+import type { Class } from "../../../lang/Class";
+
+/**
+ * An event kind, for the purposes of identification.
+ * @since 1.7
+ * @see StandardWatchEventKinds
+ */
+export type Kind = {
+  /**
+   * Returns the name of the event kind.
+   * @return the name of the event kind
+   */
+  name(): string;
+
+  /**
+   * Returns the type of the {@link WatchEvent#context context} value.
+   * @return the type of the context value
+   */
+  type(): Class;
+};

package/types/java/nio/file/WatchEvent.Kind/index.js

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

package/types/java/nio/file/WatchEvent.Modifier/index.d.ts

@@ -0,0 +1,17 @@
+import type { String } from "../../../lang/String";
+
+/**
+ * An event modifier that qualifies how a {@link Watchable} is registered
+ *  with a {@link WatchService}.
+ *
+ *  <p> This release does not define any <em>standard</em> modifiers.
+ * @since 1.7
+ * @see Watchable#register
+ */
+export type Modifier = {
+  /**
+   * Returns the name of the modifier.
+   * @return the name of the modifier
+   */
+  name(): string;
+};

package/types/java/nio/file/WatchEvent.Modifier/index.js

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

package/types/java/nio/file/WatchKey/index.d.ts

@@ -0,0 +1,117 @@
+import type { List } from "../../../util/List";
+
+import type { Watchable } from "../Watchable";
+
+/**
+ * A token representing the registration of a {@link Watchable watchable} object
+ *  with a {@link WatchService}.
+ *
+ *  <p> A watch key is created when a watchable object is registered with a watch
+ *  service. The key remains {@link #isValid valid} until:
+ *  <ol>
+ *    <li> It is cancelled, explicitly, by invoking its {@link #cancel cancel}
+ *      method, or</li>
+ *    <li> Cancelled implicitly, because the object is no longer accessible,
+ *      or </li>
+ *    <li> By {@link WatchService#close closing} the watch service. </li>
+ *  </ol>
+ *
+ *  <p> A watch key has a state. When initially created the key is said to be
+ *  <em>ready</em>. When an event is detected then the key is <em>signalled</em>
+ *  and queued so that it can be retrieved by invoking the watch service's {@link
+ *  WatchService#poll() poll} or {@link WatchService#take() take} methods. Once
+ *  signalled, a key remains in this state until its {@link #reset reset} method
+ *  is invoked to return the key to the ready state. Events detected while the
+ *  key is in the signalled state are queued but do not cause the key to be
+ *  re-queued for retrieval from the watch service. Events are retrieved by
+ *  invoking the key's {@link #pollEvents pollEvents} method. This method
+ *  retrieves and removes all events accumulated for the object. When initially
+ *  created, a watch key has no pending events. Typically events are retrieved
+ *  when the key is in the signalled state leading to the following idiom:
+ *
+ *  <pre>
+ *      for (;;) {
+ *          // retrieve key
+ *          WatchKey key = watcher.take();
+ *
+ *          // process events
+ *          for (WatchEvent&lt;?&gt; event: key.pollEvents()) {
+ *              :
+ *          }
+ *
+ *          // reset the key
+ *          boolean valid = key.reset();
+ *          if (!valid) {
+ *              // object no longer registered
+ *          }
+ *      }
+ *  </pre>
+ *
+ *  <p> Watch keys are safe for use by multiple concurrent threads. Where there
+ *  are several threads retrieving signalled keys from a watch service then care
+ *  should be taken to ensure that the {@code reset} method is only invoked after
+ *  the events for the object have been processed. This ensures that one thread
+ *  is processing the events for an object at any time.
+ * @since 1.7
+ */
+export type WatchKey = {
+  /**
+   * Tells whether or not this watch key is valid.
+   *
+   *  <p> A watch key is valid upon creation and remains until it is cancelled,
+   *  or its watch service is closed.
+   * @return {@code true} if, and only if, this watch key is valid
+   */
+  isValid(): boolean;
+
+  /**
+   * Retrieves and removes all pending events for this watch key, returning
+   *  a {@code List} of the events that were retrieved.
+   *
+   *  <p> Note that this method does not wait if there are no events pending.
+   * @return the list of the events retrieved; may be empty
+   */
+  pollEvents(): List;
+
+  /**
+   * Resets this watch key.
+   *
+   *  <p> If this watch key has been cancelled or this watch key is already in
+   *  the ready state then invoking this method has no effect. Otherwise
+   *  if there are pending events for the object then this watch key is
+   *  immediately re-queued to the watch service. If there are no pending
+   *  events then the watch key is put into the ready state and will remain in
+   *  that state until an event is detected or the watch key is cancelled.
+   * @return {@code true} if the watch key is valid and has been reset, and&#xA; {@code false} if the watch key could not be reset because it is&#xA; no longer {@link #isValid valid}
+   */
+  reset(): boolean;
+
+  /**
+ * Cancels the registration with the watch service. Upon return the watch key
+ *  will be invalid. If the watch key is enqueued, waiting to be retrieved
+ *  from the watch service, then it will remain in the queue until it is
+ *  removed. Pending events, if any, remain pending and may be retrieved by
+ *  invoking the {@link #pollEvents pollEvents} method after the key is
+ *  cancelled.
+ * 
+ *  <p> If this watch key has already been cancelled then invoking this
+ *  method has no effect.  Once cancelled, a watch key remains forever invalid.
+  
+    */
+  cancel(): void;
+
+  /**
+   * Returns the object for which this watch key was created. This method will
+   *  continue to return the object even after the key is cancelled.
+   *
+   *  <p> As the {@code WatchService} is intended to map directly on to the
+   *  native file event notification facility (where available) then many of
+   *  details on how registered objects are watched is highly implementation
+   *  specific. When watching a directory for changes for example, and the
+   *  directory is moved or renamed in the file system, there is no guarantee
+   *  that the watch key will be cancelled and so the object returned by this
+   *  method may no longer be a valid path to the directory.
+   * @return the object for which this watch key was created
+   */
+  watchable(): Watchable;
+};

package/types/java/nio/file/WatchKey/index.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  isValid: function isValid() {},
+  pollEvents: function pollEvents() {},
+  reset: function reset() {},
+  cancel: function cancel() {},
+  watchable: function watchable() {}
+};
+exports["default"] = _default;

package/types/java/nio/file/WatchService/index.d.ts

@@ -0,0 +1,121 @@
+import type { WatchKey } from "../WatchKey";
+
+import type { TimeUnit } from "../../../util/concurrent/TimeUnit";
+import type { Closeable } from "../../../io/Closeable";
+
+/**
+ * A watch service that <em>watches</em> registered objects for changes and
+ *  events. For example a file manager may use a watch service to monitor a
+ *  directory for changes so that it can update its display of the list of files
+ *  when files are created or deleted.
+ *
+ *  <p> A {@link Watchable} object is registered with a watch service by invoking
+ *  its {@link Watchable#register register} method, returning a {@link WatchKey}
+ *  to represent the registration. When an event for an object is detected the
+ *  key is <em>signalled</em>, and if not currently signalled, it is queued to
+ *  the watch service so that it can be retrieved by consumers that invoke the
+ *  {@link #poll() poll} or {@link #take() take} methods to retrieve keys
+ *  and process events. Once the events have been processed the consumer
+ *  invokes the key's {@link WatchKey#reset reset} method to reset the key which
+ *  allows the key to be signalled and re-queued with further events.
+ *
+ *  <p> Registration with a watch service is cancelled by invoking the key's
+ *  {@link WatchKey#cancel cancel} method. A key that is queued at the time that
+ *  it is cancelled remains in the queue until it is retrieved. Depending on the
+ *  object, a key may be cancelled automatically. For example, suppose a
+ *  directory is watched and the watch service detects that it has been deleted
+ *  or its file system is no longer accessible. When a key is cancelled in this
+ *  manner it is signalled and queued, if not currently signalled. To ensure
+ *  that the consumer is notified the return value from the {@code reset}
+ *  method indicates if the key is valid.
+ *
+ *  <p> A watch service is safe for use by multiple concurrent consumers. To
+ *  ensure that only one consumer processes the events for a particular object at
+ *  any time then care should be taken to ensure that the key's {@code reset}
+ *  method is only invoked after its events have been processed. The {@link
+ *  #close close} method may be invoked at any time to close the service causing
+ *  any threads waiting to retrieve keys, to throw {@code
+ *  ClosedWatchServiceException}.
+ *
+ *  <p> File systems may report events faster than they can be retrieved or
+ *  processed and an implementation may impose an unspecified limit on the number
+ *  of events that it may accumulate. Where an implementation <em>knowingly</em>
+ *  discards events then it arranges for the key's {@link WatchKey#pollEvents
+ *  pollEvents} method to return an element with an event type of {@link
+ *  StandardWatchEventKinds#OVERFLOW OVERFLOW}. This event can be used by the
+ *  consumer as a trigger to re-examine the state of the object.
+ *
+ *  <p> When an event is reported to indicate that a file in a watched directory
+ *  has been modified then there is no guarantee that the program (or programs)
+ *  that have modified the file have completed. Care should be taken to coordinate
+ *  access with other programs that may be updating the file.
+ *  The {@link java.nio.channels.FileChannel FileChannel} class defines methods
+ *  to lock regions of a file against access by other programs.
+ *
+ *  <h2>Platform dependencies</h2>
+ *
+ *  <p> The implementation that observes events from the file system is intended
+ *  to map directly on to the native file event notification facility where
+ *  available, or to use a primitive mechanism, such as polling, when a native
+ *  facility is not available. Consequently, many of the details on how events
+ *  are detected, their timeliness, and whether their ordering is preserved are
+ *  highly implementation specific. For example, when a file in a watched
+ *  directory is modified then it may result in a single {@link
+ *  StandardWatchEventKinds#ENTRY_MODIFY ENTRY_MODIFY} event in some
+ *  implementations but several events in other implementations. Short-lived
+ *  files (meaning files that are deleted very quickly after they are created)
+ *  may not be detected by primitive implementations that periodically poll the
+ *  file system to detect changes.
+ *
+ *  <p> If a watched file is not located on a local storage device then it is
+ *  implementation specific if changes to the file can be detected. In particular,
+ *  it is not required that changes to files carried out on remote systems be
+ *  detected.
+ * @since 1.7
+ * @see FileSystem#newWatchService
+ */
+export type WatchService = Closeable & {
+  /**
+   * Closes this watch service.
+   *
+   *  <p> If a thread is currently blocked in the {@link #take take} or {@link
+   *  #poll(long,TimeUnit) poll} methods waiting for a key to be queued then
+   *  it immediately receives a {@link ClosedWatchServiceException}. Any
+   *  valid keys associated with this watch service are {@link WatchKey#isValid
+   *  invalidated}.
+   *
+   *  <p> After a watch service is closed, any further attempt to invoke
+   *  operations upon it will throw {@link ClosedWatchServiceException}.
+   *  If this watch service is already closed then invoking this method
+   *  has no effect.
+   * @throws IOException&#xA; if an I/O error occurs
+   */
+  close(): void;
+
+  /**
+   * Retrieves and removes the next watch key, or {@code null} if none are
+   *  present.
+   * @return the next watch key, or {@code null}
+   * @throws ClosedWatchServiceException&#xA; if this watch service is closed
+   */
+  poll(): WatchKey;
+
+  /**
+   * Retrieves and removes the next watch key, waiting if necessary up to the
+   *  specified wait time if none are yet present.
+   * @param timeout&#xA; how to wait before giving up, in units of unit
+   * @param unit&#xA; a {@code TimeUnit} determining how to interpret the timeout&#xA; parameter
+   * @return the next watch key, or {@code null}
+   * @throws ClosedWatchServiceException&#xA; if this watch service is closed, or it is closed while waiting&#xA; for the next key
+   * @throws InterruptedException&#xA; if interrupted while waiting
+   */
+  poll(timeout: number, unit: TimeUnit): WatchKey;
+
+  /**
+   * Retrieves and removes next watch key, waiting if none are yet present.
+   * @return the next watch key
+   * @throws ClosedWatchServiceException&#xA; if this watch service is closed, or it is closed while waiting&#xA; for the next key
+   * @throws InterruptedException&#xA; if interrupted while waiting
+   */
+  take(): WatchKey;
+};

package/types/java/nio/file/WatchService/index.js

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

package/types/java/nio/file/Watchable/index.d.ts

@@ -0,0 +1,71 @@
+import type { WatchService } from "../WatchService";
+import type { Kind } from "../WatchEvent.Kind";
+import type { Modifier } from "../WatchEvent.Modifier";
+import type { WatchKey } from "../WatchKey";
+
+/**
+ * An object that may be registered with a watch service so that it can be
+ *  <em>watched</em> for changes and events.
+ *
+ *  <p> This interface defines the {@link #register register} method to register
+ *  the object with a {@link WatchService} returning a {@link WatchKey} to
+ *  represent the registration. An object may be registered with more than one
+ *  watch service. Registration with a watch service is cancelled by invoking the
+ *  key's {@link WatchKey#cancel cancel} method.
+ * @since 1.7
+ * @see Path#register
+ */
+export type Watchable = {
+  /**
+   * Registers an object with a watch service.
+   *
+   *  <p> If the file system object identified by this object is currently
+   *  registered with the watch service then the watch key, representing that
+   *  registration, is returned after changing the event set or modifiers to
+   *  those specified by the {@code events} and {@code modifiers} parameters.
+   *  Changing the event set does not cause pending events for the object to be
+   *  discarded. Objects are automatically registered for the {@link
+   *  StandardWatchEventKinds#OVERFLOW OVERFLOW} event. This event is not
+   *  required to be present in the array of events.
+   *
+   *  <p> Otherwise the file system object has not yet been registered with the
+   *  given watch service, so it is registered and the resulting new key is
+   *  returned.
+   *
+   *  <p> Implementations of this interface should specify the events they
+   *  support.
+   * @param watcher&#xA; the watch service to which this object is to be registered
+   * @param events&#xA; the events for which this object should be registered
+   * @param modifiers&#xA; the modifiers, if any, that modify how the object is registered
+   * @return a key representing the registration of this object with the&#xA; given watch service
+   * @throws UnsupportedOperationException&#xA; if unsupported events or modifiers are specified
+   * @throws IllegalArgumentException&#xA; if an invalid of combination of events are modifiers are specified
+   * @throws ClosedWatchServiceException&#xA; if the watch service is closed
+   * @throws IOException&#xA; if an I/O error occurs
+   * @throws SecurityException&#xA; if a security manager is installed and it denies an unspecified&#xA; permission required to monitor this object. Implementations of&#xA; this interface should specify the permission checks.
+   */
+  register(
+    watcher: WatchService,
+    events: Kind[],
+    modifiers: Modifier[]
+  ): WatchKey;
+
+  /**
+   * Registers an object with a watch service.
+   *
+   *  <p> An invocation of this method behaves in exactly the same way as the
+   *  invocation
+   *  <pre>
+   *      watchable.{@link #register(WatchService,WatchEvent.Kind[],WatchEvent.Modifier[]) register}(watcher, events, new WatchEvent.Modifier[0]);
+   *  </pre>
+   * @param watcher&#xA; the watch service to which this object is to be registered
+   * @param events&#xA; the events for which this object should be registered
+   * @return a key representing the registration of this object with the&#xA; given watch service
+   * @throws UnsupportedOperationException&#xA; if unsupported events are specified
+   * @throws IllegalArgumentException&#xA; if an invalid of combination of events are specified
+   * @throws ClosedWatchServiceException&#xA; if the watch service is closed
+   * @throws IOException&#xA; if an I/O error occurs
+   * @throws SecurityException&#xA; if a security manager is installed and it denies an unspecified&#xA; permission required to monitor this object. Implementations of&#xA; this interface should specify the permission checks.
+   */
+  register(watcher: WatchService, events: Kind[]): WatchKey;
+};

package/types/java/nio/file/Watchable/index.js

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

package/types/java/nio/file/attribute/FileAttribute/index.d.ts

@@ -0,0 +1,24 @@
+import type { String } from "../../../../lang/String";
+
+/**
+ * An object that encapsulates the value of a file attribute that can be set
+ *  atomically when creating a new file or directory by invoking the {@link
+ *  java.nio.file.Files#createFile createFile} or {@link
+ *  java.nio.file.Files#createDirectory createDirectory} methods.
+ * @param <T> The type of the file attribute value
+ * @since 1.7
+ * @see PosixFilePermissions#asFileAttribute
+ */
+export type FileAttribute = {
+  /**
+   * Returns the attribute name.
+   * @return The attribute name
+   */
+  name(): string;
+
+  /**
+   * Returns the attribute value.
+   * @return The attribute value
+   */
+  value(): unknown;
+};

package/types/java/nio/file/attribute/FileAttribute/index.js

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

package/types/java/nio/file/attribute/GroupPrincipal/index.d.ts

@@ -0,0 +1,14 @@
+import type { UserPrincipal } from "../UserPrincipal";
+
+/**
+ * A {@code UserPrincipal} representing a <em>group identity</em>, used to
+ *  determine access rights to objects in a file system. The exact definition of
+ *  a group is implementation specific, but typically, it represents an identity
+ *  created for administrative purposes so as to determine the access rights for
+ *  the members of the group. Whether an entity can be a member of multiple
+ *  groups, and whether groups can be nested, are implementation specified and
+ *  therefore not specified.
+ * @since 1.7
+ * @see UserPrincipalLookupService#lookupPrincipalByGroupName
+ */
+export type GroupPrincipal = UserPrincipal & {};

package/types/java/nio/file/attribute/GroupPrincipal/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/nio/file/attribute/UserPrincipal/index.d.ts

@@ -0,0 +1,25 @@
+import type { Principal } from "../../../../security/Principal";
+
+/**
+ * A {@code Principal} representing an identity used to determine access rights
+ *  to objects in a file system.
+ *
+ *  <p> On many platforms and file systems an entity requires appropriate access
+ *  rights or permissions in order to access objects in a file system. The
+ *  access rights are generally performed by checking the identity of the entity.
+ *  For example, on implementations that use Access Control Lists (ACLs) to
+ *  enforce privilege separation then a file in the file system may have an
+ *  associated ACL that determines the access rights of identities specified in
+ *  the ACL.
+ *
+ *  <p> A {@code UserPrincipal} object is an abstract representation of an
+ *  identity. It has a {@link #getName() name} that is typically the username or
+ *  account name that it represents. User principal objects may be obtained using
+ *  a {@link UserPrincipalLookupService}, or returned by {@link
+ *  FileAttributeView} implementations that provide access to identity related
+ *  attributes. For example, the {@link AclFileAttributeView} and {@link
+ *  PosixFileAttributeView} provide access to a file's {@link
+ *  PosixFileAttributes#owner owner}.
+ * @since 1.7
+ */
+export type UserPrincipal = Principal & {};

package/types/java/nio/file/attribute/UserPrincipal/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/nio/file/attribute/UserPrincipalLookupService/index.d.ts

@@ -0,0 +1,52 @@
+import type { String } from "../../../../lang/String";
+import type { UserPrincipal } from "../UserPrincipal";
+import type { GroupPrincipal } from "../GroupPrincipal";
+import type { Object } from "../../../../lang/Object";
+
+/**
+ * An object to lookup user and group principals by name. A {@link UserPrincipal}
+ *  represents an identity that may be used to determine access rights to objects
+ *  in a file system. A {@link GroupPrincipal} represents a <em>group identity</em>.
+ *  A {@code UserPrincipalLookupService} defines methods to lookup identities by
+ *  name or group name (which are typically user or account names). Whether names
+ *  and group names are case sensitive or not depends on the implementation.
+ *  The exact definition of a group is implementation specific but typically a
+ *  group represents an identity created for administrative purposes so as to
+ *  determine the access rights for the members of the group. In particular it is
+ *  implementation specific if the <em>namespace</em> for names and groups is the
+ *  same or is distinct. To ensure consistent and correct behavior across
+ *  platforms it is recommended that this API be used as if the namespaces are
+ *  distinct. In other words, the {@link #lookupPrincipalByName
+ *  lookupPrincipalByName} should be used to lookup users, and {@link
+ *  #lookupPrincipalByGroupName lookupPrincipalByGroupName} should be used to
+ *  lookup groups.
+ * @since 1.7
+ * @see java.nio.file.FileSystem#getUserPrincipalLookupService
+ */
+export type UserPrincipalLookupService = Object & {
+  /**
+   * Lookup a user principal by name.
+   * @param name&#xA; the string representation of the user principal to lookup
+   * @return a user principal
+   * @throws UserPrincipalNotFoundException&#xA; the principal does not exist
+   * @throws IOException&#xA; if an I/O error occurs
+   * @throws SecurityException&#xA; In the case of the default provider, and a security manager is&#xA; installed, it checks {@link RuntimePermission}<tt>("lookupUserInformation")</tt>
+   */
+  lookupPrincipalByName(name: String | string): UserPrincipal;
+
+  /**
+   * Lookup a group principal by group name.
+   *
+   *  <p> Where an implementation does not support any notion of group then
+   *  this method always throws {@link UserPrincipalNotFoundException}. Where
+   *  the namespace for user accounts and groups is the same, then this method
+   *  is identical to invoking {@link #lookupPrincipalByName
+   *  lookupPrincipalByName}.
+   * @param group&#xA; the string representation of the group to lookup
+   * @return a group principal
+   * @throws UserPrincipalNotFoundException&#xA; the principal does not exist or is not a group
+   * @throws IOException&#xA; if an I/O error occurs
+   * @throws SecurityException&#xA; In the case of the default provider, and a security manager is&#xA; installed, it checks {@link RuntimePermission}<tt>("lookupUserInformation")</tt>
+   */
+  lookupPrincipalByGroupName(group: String | string): GroupPrincipal;
+};

package/types/java/nio/file/attribute/UserPrincipalLookupService/index.js

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