@sitevision/api 2023.2.1 → 2023.2.2-beta.1

package/types/java/util/function/BiFunction/index.d.ts

@@ -0,0 +1,35 @@
+import type { Function } from "../Function";
+
+/**
+ * Represents a function that accepts two arguments and produces a result.
+ *  This is the two-arity specialization of {@link Function}.
+ *
+ *  <p>This is a <a href="package-summary.html">functional interface</a>
+ *  whose functional method is {@link #apply(Object, Object)}.
+ * @param <T> the type of the first argument to the function
+ * @param <U> the type of the second argument to the function
+ * @param <R> the type of the result of the function
+ * @see Function
+ * @since 1.8
+ */
+export type BiFunction = {
+  /**
+   * Applies this function to the given arguments.
+   * @param t the first function argument
+   * @param u the second function argument
+   * @return the function result
+   */
+  apply(t: unknown, u: unknown): unknown;
+
+  /**
+   * Returns a composed function that first applies this function to
+   *  its input, and then applies the {@code after} function to the result.
+   *  If evaluation of either function throws an exception, it is relayed to
+   *  the caller of the composed function.
+   * @param <V> the type of output of the {@code after} function, and of the&#xA; composed function
+   * @param after the function to apply after this function is applied
+   * @return a composed function that first applies this function and then&#xA; applies the {@code after} function
+   * @throws NullPointerException if after is null
+   */
+  andThen(after: Function): BiFunction;
+};

package/types/java/util/function/BiFunction/index.js

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

package/types/java/util/function/BinaryOperator/index.d.ts

@@ -0,0 +1,37 @@
+import type { Comparator } from "../../Comparator";
+import type { BiFunction } from "../BiFunction";
+
+/**
+ * Represents an operation upon two operands of the same type, producing a result
+ *  of the same type as the operands.  This is a specialization of
+ *  {@link BiFunction} for the case where the operands and the result are all of
+ *  the same type.
+ *
+ *  <p>This is a <a href="package-summary.html">functional interface</a>
+ *  whose functional method is {@link #apply(Object, Object)}.
+ * @param <T> the type of the operands and result of the operator
+ * @see BiFunction
+ * @see UnaryOperator
+ * @since 1.8
+ */
+export type BinaryOperator = BiFunction & {
+  /**
+   * Returns a {@link BinaryOperator} which returns the lesser of two elements
+   *  according to the specified {@code Comparator}.
+   * @param <T> the type of the input arguments of the comparator
+   * @param comparator a {@code Comparator} for comparing the two values
+   * @return a {@code BinaryOperator} which returns the lesser of its operands,&#xA; according to the supplied {@code Comparator}
+   * @throws NullPointerException if the argument is null
+   */
+  minBy(comparator: Comparator): BinaryOperator;
+
+  /**
+   * Returns a {@link BinaryOperator} which returns the greater of two elements
+   *  according to the specified {@code Comparator}.
+   * @param <T> the type of the input arguments of the comparator
+   * @param comparator a {@code Comparator} for comparing the two values
+   * @return a {@code BinaryOperator} which returns the greater of its operands,&#xA; according to the supplied {@code Comparator}
+   * @throws NullPointerException if the argument is null
+   */
+  maxBy(comparator: Comparator): BinaryOperator;
+};

package/types/java/util/function/BinaryOperator/index.js

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

package/types/java/util/function/Consumer/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Represents an operation that accepts a single input argument and returns no
+ *  result. Unlike most other functional interfaces, {@code Consumer} is expected
+ *  to operate via side-effects.
+ *
+ *  <p>This is a <a href="package-summary.html">functional interface</a>
+ *  whose functional method is {@link #accept(Object)}.
+ * @param <T> the type of the input to the operation
+ * @since 1.8
+ */
+export type Consumer = {
+  /**
+   * Performs this operation on the given argument.
+   * @param t the input argument
+   */
+  accept(t: unknown): void;
+
+  /**
+   * Returns a composed {@code Consumer} that performs, in sequence, this
+   *  operation followed by the {@code after} operation. If performing either
+   *  operation throws an exception, it is relayed to the caller of the
+   *  composed operation.  If performing this operation throws an exception,
+   *  the {@code after} operation will not be performed.
+   * @param after the operation to perform after this operation
+   * @return a composed {@code Consumer} that performs in sequence this&#xA; operation followed by the {@code after} operation
+   * @throws NullPointerException if {@code after} is null
+   */
+  andThen(after: Consumer): Consumer;
+};

package/types/java/util/function/Consumer/index.js

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

package/types/java/util/function/DoubleBinaryOperator/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Represents an operation upon two {@code double}-valued operands and producing a
+ *  {@code double}-valued result.   This is the primitive type specialization of
+ *  {@link BinaryOperator} for {@code double}.
+ *
+ *  <p>This is a <a href="package-summary.html">functional interface</a>
+ *  whose functional method is {@link #applyAsDouble(double, double)}.
+ * @see BinaryOperator
+ * @see DoubleUnaryOperator
+ * @since 1.8
+ */
+export type DoubleBinaryOperator = {
+  /**
+   * Applies this operator to the given operands.
+   * @param left the first operand
+   * @param right the second operand
+   * @return the operator result
+   */
+  applyAsDouble(left: number, right: number): number;
+};

package/types/java/util/function/DoubleBinaryOperator/index.js

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

package/types/java/util/function/DoubleConsumer/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Represents an operation that accepts a single {@code double}-valued argument and
+ *  returns no result.  This is the primitive type specialization of
+ *  {@link Consumer} for {@code double}.  Unlike most other functional interfaces,
+ *  {@code DoubleConsumer} is expected to operate via side-effects.
+ *
+ *  <p>This is a <a href="package-summary.html">functional interface</a>
+ *  whose functional method is {@link #accept(double)}.
+ * @see Consumer
+ * @since 1.8
+ */
+export type DoubleConsumer = {
+  /**
+   * Performs this operation on the given argument.
+   * @param value the input argument
+   */
+  accept(value: number): void;
+
+  /**
+   * Returns a composed {@code DoubleConsumer} that performs, in sequence, this
+   *  operation followed by the {@code after} operation. If performing either
+   *  operation throws an exception, it is relayed to the caller of the
+   *  composed operation.  If performing this operation throws an exception,
+   *  the {@code after} operation will not be performed.
+   * @param after the operation to perform after this operation
+   * @return a composed {@code DoubleConsumer} that performs in sequence this&#xA; operation followed by the {@code after} operation
+   * @throws NullPointerException if {@code after} is null
+   */
+  andThen(after: DoubleConsumer): DoubleConsumer;
+};

package/types/java/util/function/DoubleConsumer/index.js

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

package/types/java/util/function/DoubleFunction/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Represents a function that accepts a double-valued argument and produces a
+ *  result.  This is the {@code double}-consuming primitive specialization for
+ *  {@link Function}.
+ *
+ *  <p>This is a <a href="package-summary.html">functional interface</a>
+ *  whose functional method is {@link #apply(double)}.
+ * @param <R> the type of the result of the function
+ * @see Function
+ * @since 1.8
+ */
+export type DoubleFunction = {
+  /**
+   * Applies this function to the given argument.
+   * @param value the function argument
+   * @return the function result
+   */
+  apply(value: number): unknown;
+};

package/types/java/util/function/DoubleFunction/index.js

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

package/types/java/util/function/DoublePredicate/index.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Represents a predicate (boolean-valued function) of one {@code double}-valued
+ *  argument. This is the {@code double}-consuming primitive type specialization
+ *  of {@link Predicate}.
+ *
+ *  <p>This is a <a href="package-summary.html">functional interface</a>
+ *  whose functional method is {@link #test(double)}.
+ * @see Predicate
+ * @since 1.8
+ */
+export type DoublePredicate = {
+  /**
+   * Evaluates this predicate on the given argument.
+   * @param value the input argument
+   * @return {@code true} if the input argument matches the predicate,&#xA; otherwise {@code false}
+   */
+  test(value: number): boolean;
+
+  /**
+   * Returns a composed predicate that represents a short-circuiting logical
+   *  AND of this predicate and another.  When evaluating the composed
+   *  predicate, if this predicate is {@code false}, then the {@code other}
+   *  predicate is not evaluated.
+   *
+   *  <p>Any exceptions thrown during evaluation of either predicate are relayed
+   *  to the caller; if evaluation of this predicate throws an exception, the
+   *  {@code other} predicate will not be evaluated.
+   * @param other a predicate that will be logically-ANDed with this&#xA; predicate
+   * @return a composed predicate that represents the short-circuiting logical&#xA; AND of this predicate and the {@code other} predicate
+   * @throws NullPointerException if other is null
+   */
+  and(other: DoublePredicate): DoublePredicate;
+
+  /**
+   * Returns a predicate that represents the logical negation of this
+   *  predicate.
+   * @return a predicate that represents the logical negation of this&#xA; predicate
+   */
+  negate(): DoublePredicate;
+
+  /**
+   * Returns a composed predicate that represents a short-circuiting logical
+   *  OR of this predicate and another.  When evaluating the composed
+   *  predicate, if this predicate is {@code true}, then the {@code other}
+   *  predicate is not evaluated.
+   *
+   *  <p>Any exceptions thrown during evaluation of either predicate are relayed
+   *  to the caller; if evaluation of this predicate throws an exception, the
+   *  {@code other} predicate will not be evaluated.
+   * @param other a predicate that will be logically-ORed with this&#xA; predicate
+   * @return a composed predicate that represents the short-circuiting logical&#xA; OR of this predicate and the {@code other} predicate
+   * @throws NullPointerException if other is null
+   */
+  or(other: DoublePredicate): DoublePredicate;
+};

package/types/java/util/function/DoublePredicate/index.js

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

package/types/java/util/function/DoubleSupplier/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Represents a supplier of {@code double}-valued results.  This is the
+ *  {@code double}-producing primitive specialization of {@link Supplier}.
+ *
+ *  <p>There is no requirement that a distinct result be returned each
+ *  time the supplier is invoked.
+ *
+ *  <p>This is a <a href="package-summary.html">functional interface</a>
+ *  whose functional method is {@link #getAsDouble()}.
+ * @see Supplier
+ * @since 1.8
+ */
+export type DoubleSupplier = {
+  /**
+   * Gets a result.
+   * @return a result
+   */
+  getAsDouble(): number;
+};

package/types/java/util/function/DoubleSupplier/index.js

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

package/types/java/util/function/DoubleToIntFunction/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Represents a function that accepts a double-valued argument and produces an
+ *  int-valued result.  This is the {@code double}-to-{@code int} primitive
+ *  specialization for {@link Function}.
+ *
+ *  <p>This is a <a href="package-summary.html">functional interface</a>
+ *  whose functional method is {@link #applyAsInt(double)}.
+ * @see Function
+ * @since 1.8
+ */
+export type DoubleToIntFunction = {
+  /**
+   * Applies this function to the given argument.
+   * @param value the function argument
+   * @return the function result
+   */
+  applyAsInt(value: number): number;
+};

package/types/java/util/function/DoubleToIntFunction/index.js

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

package/types/java/util/function/DoubleToLongFunction/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Represents a function that accepts a double-valued argument and produces a
+ *  long-valued result.  This is the {@code double}-to-{@code long} primitive
+ *  specialization for {@link Function}.
+ *
+ *  <p>This is a <a href="package-summary.html">functional interface</a>
+ *  whose functional method is {@link #applyAsLong(double)}.
+ * @see Function
+ * @since 1.8
+ */
+export type DoubleToLongFunction = {
+  /**
+   * Applies this function to the given argument.
+   * @param value the function argument
+   * @return the function result
+   */
+  applyAsLong(value: number): number;
+};

package/types/java/util/function/DoubleToLongFunction/index.js

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

package/types/java/util/function/DoubleUnaryOperator/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Represents an operation on a single {@code double}-valued operand that produces
+ *  a {@code double}-valued result.  This is the primitive type specialization of
+ *  {@link UnaryOperator} for {@code double}.
+ *
+ *  <p>This is a <a href="package-summary.html">functional interface</a>
+ *  whose functional method is {@link #applyAsDouble(double)}.
+ * @see UnaryOperator
+ * @since 1.8
+ */
+export type DoubleUnaryOperator = {
+  /**
+   * Applies this operator to the given operand.
+   * @param operand the operand
+   * @return the operator result
+   */
+  applyAsDouble(operand: number): number;
+
+  /**
+   * Returns a composed operator that first applies the {@code before}
+   *  operator to its input, and then applies this operator to the result.
+   *  If evaluation of either operator throws an exception, it is relayed to
+   *  the caller of the composed operator.
+   * @param before the operator to apply before this operator is applied
+   * @return a composed operator that first applies the {@code before}&#xA; operator and then applies this operator
+   * @throws NullPointerException if before is null
+   * @see #andThen(DoubleUnaryOperator)
+   */
+  compose(before: DoubleUnaryOperator): DoubleUnaryOperator;
+
+  /**
+   * Returns a composed operator that first applies this operator to
+   *  its input, and then applies the {@code after} operator to the result.
+   *  If evaluation of either operator throws an exception, it is relayed to
+   *  the caller of the composed operator.
+   * @param after the operator to apply after this operator is applied
+   * @return a composed operator that first applies this operator and then&#xA; applies the {@code after} operator
+   * @throws NullPointerException if after is null
+   * @see #compose(DoubleUnaryOperator)
+   */
+  andThen(after: DoubleUnaryOperator): DoubleUnaryOperator;
+
+  /**
+   * Returns a unary operator that always returns its input argument.
+   * @return a unary operator that always returns its input argument
+   */
+  identity(): DoubleUnaryOperator;
+};

package/types/java/util/function/DoubleUnaryOperator/index.js

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

package/types/java/util/function/Function/index.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Represents a function that accepts one argument and produces a result.
+ *
+ *  <p>This is a <a href="package-summary.html">functional interface</a>
+ *  whose functional method is {@link #apply(Object)}.
+ * @param <T> the type of the input to the function
+ * @param <R> the type of the result of the function
+ * @since 1.8
+ */
+export type Function = {
+  /**
+   * Applies this function to the given argument.
+   * @param t the function argument
+   * @return the function result
+   */
+  apply(t: unknown): unknown;
+
+  /**
+   * Returns a composed function that first applies the {@code before}
+   *  function to its input, and then applies this function to the result.
+   *  If evaluation of either function throws an exception, it is relayed to
+   *  the caller of the composed function.
+   * @param <V> the type of input to the {@code before} function, and to the&#xA; composed function
+   * @param before the function to apply before this function is applied
+   * @return a composed function that first applies the {@code before}&#xA; function and then applies this function
+   * @throws NullPointerException if before is null
+   * @see #andThen(Function)
+   */
+  compose(before: Function): Function;
+
+  /**
+   * Returns a composed function that first applies this function to
+   *  its input, and then applies the {@code after} function to the result.
+   *  If evaluation of either function throws an exception, it is relayed to
+   *  the caller of the composed function.
+   * @param <V> the type of output of the {@code after} function, and of the&#xA; composed function
+   * @param after the function to apply after this function is applied
+   * @return a composed function that first applies this function and then&#xA; applies the {@code after} function
+   * @throws NullPointerException if after is null
+   * @see #compose(Function)
+   */
+  andThen(after: Function): Function;
+
+  /**
+   * Returns a function that always returns its input argument.
+   * @param <T> the type of the input and output objects to the function
+   * @return a function that always returns its input argument
+   */
+  identity(): Function;
+};

package/types/java/util/function/Function/index.js

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

package/types/java/util/function/IntBinaryOperator/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Represents an operation upon two {@code int}-valued operands and producing an
+ *  {@code int}-valued result.   This is the primitive type specialization of
+ *  {@link BinaryOperator} for {@code int}.
+ *
+ *  <p>This is a <a href="package-summary.html">functional interface</a>
+ *  whose functional method is {@link #applyAsInt(int, int)}.
+ * @see BinaryOperator
+ * @see IntUnaryOperator
+ * @since 1.8
+ */
+export type IntBinaryOperator = {
+  /**
+   * Applies this operator to the given operands.
+   * @param left the first operand
+   * @param right the second operand
+   * @return the operator result
+   */
+  applyAsInt(left: number, right: number): number;
+};

package/types/java/util/function/IntBinaryOperator/index.js

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

package/types/java/util/function/IntConsumer/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Represents an operation that accepts a single {@code int}-valued argument and
+ *  returns no result.  This is the primitive type specialization of
+ *  {@link Consumer} for {@code int}.  Unlike most other functional interfaces,
+ *  {@code IntConsumer} is expected to operate via side-effects.
+ *
+ *  <p>This is a <a href="package-summary.html">functional interface</a>
+ *  whose functional method is {@link #accept(int)}.
+ * @see Consumer
+ * @since 1.8
+ */
+export type IntConsumer = {
+  /**
+   * Performs this operation on the given argument.
+   * @param value the input argument
+   */
+  accept(value: number): void;
+
+  /**
+   * Returns a composed {@code IntConsumer} that performs, in sequence, this
+   *  operation followed by the {@code after} operation. If performing either
+   *  operation throws an exception, it is relayed to the caller of the
+   *  composed operation.  If performing this operation throws an exception,
+   *  the {@code after} operation will not be performed.
+   * @param after the operation to perform after this operation
+   * @return a composed {@code IntConsumer} that performs in sequence this&#xA; operation followed by the {@code after} operation
+   * @throws NullPointerException if {@code after} is null
+   */
+  andThen(after: IntConsumer): IntConsumer;
+};

package/types/java/util/function/IntConsumer/index.js

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

package/types/java/util/function/IntFunction/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Represents a function that accepts an int-valued argument and produces a
+ *  result.  This is the {@code int}-consuming primitive specialization for
+ *  {@link Function}.
+ *
+ *  <p>This is a <a href="package-summary.html">functional interface</a>
+ *  whose functional method is {@link #apply(int)}.
+ * @param <R> the type of the result of the function
+ * @see Function
+ * @since 1.8
+ */
+export type IntFunction = {
+  /**
+   * Applies this function to the given argument.
+   * @param value the function argument
+   * @return the function result
+   */
+  apply(value: number): unknown;
+};

package/types/java/util/function/IntFunction/index.js

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