@sitevision/api 2023.2.1 → 2023.2.2-beta.1

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

@@ -0,0 +1,55 @@
+/**
+ * Represents a predicate (boolean-valued function) of one {@code int}-valued
+ *  argument. This is the {@code int}-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(int)}.
+ * @see Predicate
+ * @since 1.8
+ */
+export type IntPredicate = {
+  /**
+   * 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: IntPredicate): IntPredicate;
+
+  /**
+   * Returns a predicate that represents the logical negation of this
+   *  predicate.
+   * @return a predicate that represents the logical negation of this&#xA; predicate
+   */
+  negate(): IntPredicate;
+
+  /**
+   * 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: IntPredicate): IntPredicate;
+};

package/types/java/util/function/IntPredicate/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/IntSupplier/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Represents a supplier of {@code int}-valued results.  This is the
+ *  {@code int}-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 #getAsInt()}.
+ * @see Supplier
+ * @since 1.8
+ */
+export type IntSupplier = {
+  /**
+   * Gets a result.
+   * @return a result
+   */
+  getAsInt(): number;
+};

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

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

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

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

package/types/java/util/function/IntToDoubleFunction/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/IntToLongFunction/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Represents a function that accepts an int-valued argument and produces a
+ *  long-valued result.  This is the {@code int}-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(int)}.
+ * @see Function
+ * @since 1.8
+ */
+export type IntToLongFunction = {
+  /**
+   * 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/IntToLongFunction/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/IntUnaryOperator/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Represents an operation on a single {@code int}-valued operand that produces
+ *  an {@code int}-valued result.  This is the primitive type specialization of
+ *  {@link UnaryOperator} for {@code int}.
+ *
+ *  <p>This is a <a href="package-summary.html">functional interface</a>
+ *  whose functional method is {@link #applyAsInt(int)}.
+ * @see UnaryOperator
+ * @since 1.8
+ */
+export type IntUnaryOperator = {
+  /**
+   * Applies this operator to the given operand.
+   * @param operand the operand
+   * @return the operator result
+   */
+  applyAsInt(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(IntUnaryOperator)
+   */
+  compose(before: IntUnaryOperator): IntUnaryOperator;
+
+  /**
+   * 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(IntUnaryOperator)
+   */
+  andThen(after: IntUnaryOperator): IntUnaryOperator;
+
+  /**
+   * Returns a unary operator that always returns its input argument.
+   * @return a unary operator that always returns its input argument
+   */
+  identity(): IntUnaryOperator;
+};

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

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

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

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

package/types/java/util/function/LongBinaryOperator/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/LongConsumer/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Represents an operation that accepts a single {@code long}-valued argument and
+ *  returns no result.  This is the primitive type specialization of
+ *  {@link Consumer} for {@code long}.  Unlike most other functional interfaces,
+ *  {@code LongConsumer} 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(long)}.
+ * @see Consumer
+ * @since 1.8
+ */
+export type LongConsumer = {
+  /**
+   * Performs this operation on the given argument.
+   * @param value the input argument
+   */
+  accept(value: number): void;
+
+  /**
+   * Returns a composed {@code LongConsumer} 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 LongConsumer} that performs in sequence this&#xA; operation followed by the {@code after} operation
+   * @throws NullPointerException if {@code after} is null
+   */
+  andThen(after: LongConsumer): LongConsumer;
+};

package/types/java/util/function/LongConsumer/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/LongFunction/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Represents a function that accepts a long-valued argument and produces a
+ *  result.  This is the {@code long}-consuming primitive specialization for
+ *  {@link Function}.
+ *
+ *  <p>This is a <a href="package-summary.html">functional interface</a>
+ *  whose functional method is {@link #apply(long)}.
+ * @param <R> the type of the result of the function
+ * @see Function
+ * @since 1.8
+ */
+export type LongFunction = {
+  /**
+   * 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/LongFunction/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/LongPredicate/index.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Represents a predicate (boolean-valued function) of one {@code long}-valued
+ *  argument. This is the {@code long}-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(long)}.
+ * @see Predicate
+ * @since 1.8
+ */
+export type LongPredicate = {
+  /**
+   * 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: LongPredicate): LongPredicate;
+
+  /**
+   * Returns a predicate that represents the logical negation of this
+   *  predicate.
+   * @return a predicate that represents the logical negation of this&#xA; predicate
+   */
+  negate(): LongPredicate;
+
+  /**
+   * 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: LongPredicate): LongPredicate;
+};

package/types/java/util/function/LongPredicate/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/LongSupplier/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Represents a supplier of {@code long}-valued results.  This is the
+ *  {@code long}-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 #getAsLong()}.
+ * @see Supplier
+ * @since 1.8
+ */
+export type LongSupplier = {
+  /**
+   * Gets a result.
+   * @return a result
+   */
+  getAsLong(): number;
+};

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

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

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

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

package/types/java/util/function/LongToDoubleFunction/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/LongToIntFunction/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Represents a function that accepts a long-valued argument and produces an
+ *  int-valued result.  This is the {@code long}-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(long)}.
+ * @see Function
+ * @since 1.8
+ */
+export type LongToIntFunction = {
+  /**
+   * 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/LongToIntFunction/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/LongUnaryOperator/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Represents an operation on a single {@code long}-valued operand that produces
+ *  a {@code long}-valued result.  This is the primitive type specialization of
+ *  {@link UnaryOperator} for {@code long}.
+ *
+ *  <p>This is a <a href="package-summary.html">functional interface</a>
+ *  whose functional method is {@link #applyAsLong(long)}.
+ * @see UnaryOperator
+ * @since 1.8
+ */
+export type LongUnaryOperator = {
+  /**
+   * Applies this operator to the given operand.
+   * @param operand the operand
+   * @return the operator result
+   */
+  applyAsLong(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(LongUnaryOperator)
+   */
+  compose(before: LongUnaryOperator): LongUnaryOperator;
+
+  /**
+   * 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(LongUnaryOperator)
+   */
+  andThen(after: LongUnaryOperator): LongUnaryOperator;
+
+  /**
+   * Returns a unary operator that always returns its input argument.
+   * @return a unary operator that always returns its input argument
+   */
+  identity(): LongUnaryOperator;
+};

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

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

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

@@ -0,0 +1,21 @@
+/**
+ * Represents an operation that accepts an object-valued and a
+ *  {@code double}-valued argument, and returns no result.  This is the
+ *  {@code (reference, double)} specialization of {@link BiConsumer}.
+ *  Unlike most other functional interfaces, {@code ObjDoubleConsumer} 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, double)}.
+ * @param <T> the type of the object argument to the operation
+ * @see BiConsumer
+ * @since 1.8
+ */
+export type ObjDoubleConsumer = {
+  /**
+   * Performs this operation on the given arguments.
+   * @param t the first input argument
+   * @param value the second input argument
+   */
+  accept(t: unknown, value: number): void;
+};

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

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

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

@@ -0,0 +1,21 @@
+/**
+ * Represents an operation that accepts an object-valued and a
+ *  {@code int}-valued argument, and returns no result.  This is the
+ *  {@code (reference, int)} specialization of {@link BiConsumer}.
+ *  Unlike most other functional interfaces, {@code ObjIntConsumer} 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, int)}.
+ * @param <T> the type of the object argument to the operation
+ * @see BiConsumer
+ * @since 1.8
+ */
+export type ObjIntConsumer = {
+  /**
+   * Performs this operation on the given arguments.
+   * @param t the first input argument
+   * @param value the second input argument
+   */
+  accept(t: unknown, value: number): void;
+};

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

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

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

@@ -0,0 +1,21 @@
+/**
+ * Represents an operation that accepts an object-valued and a
+ *  {@code long}-valued argument, and returns no result.  This is the
+ *  {@code (reference, long)} specialization of {@link BiConsumer}.
+ *  Unlike most other functional interfaces, {@code ObjLongConsumer} 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, long)}.
+ * @param <T> the type of the object argument to the operation
+ * @see BiConsumer
+ * @since 1.8
+ */
+export type ObjLongConsumer = {
+  /**
+   * Performs this operation on the given arguments.
+   * @param t the first input argument
+   * @param value the second input argument
+   */
+  accept(t: unknown, value: number): void;
+};