@sitevision/api 2023.2.1 → 2023.2.2-beta.2

package/types/java/time/temporal/TemporalQuery/index.d.ts

@@ -0,0 +1,60 @@
+import type { TemporalAccessor } from "../TemporalAccessor";
+
+/**
+ * Strategy for querying a temporal object.
+ *  <p>
+ *  Queries are a key tool for extracting information from temporal objects.
+ *  They exist to externalize the process of querying, permitting different
+ *  approaches, as per the strategy design pattern.
+ *  Examples might be a query that checks if the date is the day before February 29th
+ *  in a leap year, or calculates the number of days to your next birthday.
+ *  <p>
+ *  The {@link TemporalField} interface provides another mechanism for querying
+ *  temporal objects. That interface is limited to returning a {@code long}.
+ *  By contrast, queries can return any type.
+ *  <p>
+ *  There are two equivalent ways of using a {@code TemporalQuery}.
+ *  The first is to invoke the method on this interface directly.
+ *  The second is to use {@link TemporalAccessor#query(TemporalQuery)}:
+ *  <pre>
+ *    // these two lines are equivalent, but the second approach is recommended
+ *    temporal = thisQuery.queryFrom(temporal);
+ *    temporal = temporal.query(thisQuery);
+ *  </pre>
+ *  It is recommended to use the second approach, {@code query(TemporalQuery)},
+ *  as it is a lot clearer to read in code.
+ *  <p>
+ *  The most common implementations are method references, such as
+ *  {@code LocalDate::from} and {@code ZoneId::from}.
+ *  Additional common queries are provided as static methods in {@link TemporalQueries}.
+ * @implSpec This interface places no restrictions on the mutability of implementations,&#xA; however immutability is strongly recommended.
+ * @param <R> the type returned from the query
+ * @since 1.8
+ */
+export type TemporalQuery = {
+  /**
+   * Queries the specified temporal object.
+   *  <p>
+   *  This queries the specified temporal object to return an object using the logic
+   *  encapsulated in the implementing class.
+   *  Examples might be a query that checks if the date is the day before February 29th
+   *  in a leap year, or calculates the number of days to your next birthday.
+   *  <p>
+   *  There are two equivalent ways of using this method.
+   *  The first is to invoke this method directly.
+   *  The second is to use {@link TemporalAccessor#query(TemporalQuery)}:
+   *  <pre>
+   *    // these two lines are equivalent, but the second approach is recommended
+   *    temporal = thisQuery.queryFrom(temporal);
+   *    temporal = temporal.query(thisQuery);
+   *  </pre>
+   *  It is recommended to use the second approach, {@code query(TemporalQuery)},
+   *  as it is a lot clearer to read in code.
+   * @implSpec The implementation must take the input object and query it.&#xA; The implementation defines the logic of the query and is responsible for&#xA; documenting that logic.&#xA; It may use any method on {@code TemporalAccessor} to determine the result.&#xA; The input object must not be altered.&#xA; <p>&#xA; The input temporal object may be in a calendar system other than ISO.&#xA; Implementations may choose to document compatibility with other calendar systems,&#xA; or reject non-ISO temporal objects by {@link TemporalQueries#chronology() querying the chronology}.&#xA; <p>&#xA; This method may be called from multiple threads in parallel.&#xA; It must be thread-safe when invoked.
+   * @param temporal the temporal object to query, not null
+   * @return the queried value, may return null to indicate not found
+   * @throws DateTimeException if unable to query
+   * @throws ArithmeticException if numeric overflow occurs
+   */
+  queryFrom(temporal: TemporalAccessor): unknown;
+};

package/types/java/time/temporal/TemporalQuery/index.js

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

package/types/java/time/temporal/TemporalUnit/index.d.ts

@@ -0,0 +1,182 @@
+import type { Duration } from "../../Duration";
+
+import type { Temporal } from "../Temporal";
+
+import type { String } from "../../../lang/String";
+
+/**
+ * A unit of date-time, such as Days or Hours.
+ *  <p>
+ *  Measurement of time is built on units, such as years, months, days, hours, minutes and seconds.
+ *  Implementations of this interface represent those units.
+ *  <p>
+ *  An instance of this interface represents the unit itself, rather than an amount of the unit.
+ *  See {@link Period} for a class that represents an amount in terms of the common units.
+ *  <p>
+ *  The most commonly used units are defined in {@link ChronoUnit}.
+ *  Further units are supplied in {@link IsoFields}.
+ *  Units can also be written by application code by implementing this interface.
+ *  <p>
+ *  The unit works using double dispatch. Client code calls methods on a date-time like
+ *  {@code LocalDateTime} which check if the unit is a {@code ChronoUnit}.
+ *  If it is, then the date-time must handle it.
+ *  Otherwise, the method call is re-dispatched to the matching method in this interface.
+ * @implSpec This interface must be implemented with care to ensure other classes operate correctly.&#xA; All implementations that can be instantiated must be final, immutable and thread-safe.&#xA; It is recommended to use an enum where possible.
+ * @since 1.8
+ */
+export type TemporalUnit = {
+  /**
+   * Gets the duration of this unit, which may be an estimate.
+   *  <p>
+   *  All units return a duration measured in standard nanoseconds from this method.
+   *  The duration will be positive and non-zero.
+   *  For example, an hour has a duration of {@code 60 * 60 * 1,000,000,000ns}.
+   *  <p>
+   *  Some units may return an accurate duration while others return an estimate.
+   *  For example, days have an estimated duration due to the possibility of
+   *  daylight saving time changes.
+   *  To determine if the duration is an estimate, use {@link #isDurationEstimated()}.
+   * @return the duration of this unit, which may be an estimate, not null
+   */
+  getDuration(): Duration;
+
+  /**
+   * Checks if the duration of the unit is an estimate.
+   *  <p>
+   *  All units have a duration, however the duration is not always accurate.
+   *  For example, days have an estimated duration due to the possibility of
+   *  daylight saving time changes.
+   *  This method returns true if the duration is an estimate and false if it is
+   *  accurate. Note that accurate/estimated ignores leap seconds.
+   * @return true if the duration is estimated, false if accurate
+   */
+  isDurationEstimated(): boolean;
+
+  /**
+   * Checks if this unit represents a component of a date.
+   *  <p>
+   *  A date is time-based if it can be used to imply meaning from a date.
+   *  It must have a {@linkplain #getDuration() duration} that is an integral
+   *  multiple of the length of a standard day.
+   *  Note that it is valid for both {@code isDateBased()} and {@code isTimeBased()}
+   *  to return false, such as when representing a unit like 36 hours.
+   * @return true if this unit is a component of a date
+   */
+  isDateBased(): boolean;
+
+  /**
+   * Checks if this unit represents a component of a time.
+   *  <p>
+   *  A unit is time-based if it can be used to imply meaning from a time.
+   *  It must have a {@linkplain #getDuration() duration} that divides into
+   *  the length of a standard day without remainder.
+   *  Note that it is valid for both {@code isDateBased()} and {@code isTimeBased()}
+   *  to return false, such as when representing a unit like 36 hours.
+   * @return true if this unit is a component of a time
+   */
+  isTimeBased(): boolean;
+
+  /**
+   * Checks if this unit is supported by the specified temporal object.
+   *  <p>
+   *  This checks that the implementing date-time can add/subtract this unit.
+   *  This can be used to avoid throwing an exception.
+   *  <p>
+   *  This default implementation derives the value using
+   *  {@link Temporal#plus(long, TemporalUnit)}.
+   * @param temporal the temporal object to check, not null
+   * @return true if the unit is supported
+   */
+  isSupportedBy(temporal: Temporal): boolean;
+
+  /**
+   * Returns a copy of the specified temporal object with the specified period added.
+   *  <p>
+   *  The period added is a multiple of this unit. For example, this method
+   *  could be used to add "3 days" to a date by calling this method on the
+   *  instance representing "days", passing the date and the period "3".
+   *  The period to be added may be negative, which is equivalent to subtraction.
+   *  <p>
+   *  There are two equivalent ways of using this method.
+   *  The first is to invoke this method directly.
+   *  The second is to use {@link Temporal#plus(long, TemporalUnit)}:
+   *  <pre>
+   *    // these two lines are equivalent, but the second approach is recommended
+   *    temporal = thisUnit.addTo(temporal);
+   *    temporal = temporal.plus(thisUnit);
+   *  </pre>
+   *  It is recommended to use the second approach, {@code plus(TemporalUnit)},
+   *  as it is a lot clearer to read in code.
+   *  <p>
+   *  Implementations should perform any queries or calculations using the units
+   *  available in {@link ChronoUnit} or the fields available in {@link ChronoField}.
+   *  If the unit is not supported an {@code UnsupportedTemporalTypeException} must be thrown.
+   *  <p>
+   *  Implementations must not alter the specified temporal object.
+   *  Instead, an adjusted copy of the original must be returned.
+   *  This provides equivalent, safe behavior for immutable and mutable implementations.
+   * @param <R> the type of the Temporal object
+   * @param temporal the temporal object to adjust, not null
+   * @param amount the amount of this unit to add, positive or negative
+   * @return the adjusted temporal object, not null
+   * @throws DateTimeException if the amount cannot be added
+   * @throws UnsupportedTemporalTypeException if the unit is not supported by the temporal
+   */
+  addTo(temporal: unknown, amount: number): unknown;
+
+  /**
+   * Calculates the amount of time between two temporal objects.
+   *  <p>
+   *  This calculates the amount in terms of this unit. The start and end
+   *  points are supplied as temporal objects and must be of compatible types.
+   *  The implementation will convert the second type to be an instance of the
+   *  first type before the calculating the amount.
+   *  The result will be negative if the end is before the start.
+   *  For example, the amount in hours between two temporal objects can be
+   *  calculated using {@code HOURS.between(startTime, endTime)}.
+   *  <p>
+   *  The calculation returns a whole number, representing the number of
+   *  complete units between the two temporals.
+   *  For example, the amount in hours between the times 11:30 and 13:29
+   *  will only be one hour as it is one minute short of two hours.
+   *  <p>
+   *  There are two equivalent ways of using this method.
+   *  The first is to invoke this method directly.
+   *  The second is to use {@link Temporal#until(Temporal, TemporalUnit)}:
+   *  <pre>
+   *    // these two lines are equivalent
+   *    between = thisUnit.between(start, end);
+   *    between = start.until(end, thisUnit);
+   *  </pre>
+   *  The choice should be made based on which makes the code more readable.
+   *  <p>
+   *  For example, this method allows the number of days between two dates to
+   *  be calculated:
+   *  <pre>
+   *   long daysBetween = DAYS.between(start, end);
+   *   // or alternatively
+   *   long daysBetween = start.until(end, DAYS);
+   *  </pre>
+   *  <p>
+   *  Implementations should perform any queries or calculations using the units
+   *  available in {@link ChronoUnit} or the fields available in {@link ChronoField}.
+   *  If the unit is not supported an {@code UnsupportedTemporalTypeException} must be thrown.
+   *  Implementations must not alter the specified temporal objects.
+   * @implSpec Implementations must begin by checking to if the two temporals have the&#xA; same type using {@code getClass()}. If they do not, then the result must be&#xA; obtained by calling {@code temporal1Inclusive.until(temporal2Exclusive, this)}.
+   * @param temporal1Inclusive the base temporal object, not null
+   * @param temporal2Exclusive the other temporal object, exclusive, not null
+   * @return the amount of time between temporal1Inclusive and temporal2Exclusive&#xA; in terms of this unit; positive if temporal2Exclusive is later than&#xA; temporal1Inclusive, negative if earlier
+   * @throws DateTimeException if the amount cannot be calculated, or the end&#xA; temporal cannot be converted to the same type as the start temporal
+   * @throws UnsupportedTemporalTypeException if the unit is not supported by the temporal
+   * @throws ArithmeticException if numeric overflow occurs
+   */
+  between(temporal1Inclusive: Temporal, temporal2Exclusive: Temporal): number;
+
+  /**
+   * Gets a descriptive name for the unit.
+   *  <p>
+   *  This should be in the plural and upper-first camel case, such as 'Days' or 'Minutes'.
+   * @return the name of this unit, not null
+   */
+  toString(): string;
+};

package/types/java/time/temporal/TemporalUnit/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getDuration: function getDuration() {},
+  isDurationEstimated: function isDurationEstimated() {},
+  isDateBased: function isDateBased() {},
+  isTimeBased: function isTimeBased() {},
+  isSupportedBy: function isSupportedBy() {},
+  addTo: function addTo() {},
+  between: function between() {},
+  toString: function toString() {}
+};
+exports["default"] = _default;

package/types/java/time/temporal/ValueRange/index.d.ts

@@ -0,0 +1,155 @@
+import type { TemporalField } from "../TemporalField";
+
+import type { Object } from "../../../lang/Object";
+import type { String } from "../../../lang/String";
+import type { Serializable } from "../../../io/Serializable";
+
+/**
+ * The range of valid values for a date-time field.
+ *  <p>
+ *  All {@link TemporalField} instances have a valid range of values.
+ *  For example, the ISO day-of-month runs from 1 to somewhere between 28 and 31.
+ *  This class captures that valid range.
+ *  <p>
+ *  It is important to be aware of the limitations of this class.
+ *  Only the minimum and maximum values are provided.
+ *  It is possible for there to be invalid values within the outer range.
+ *  For example, a weird field may have valid values of 1, 2, 4, 6, 7, thus
+ *  have a range of '1 - 7', despite that fact that values 3 and 5 are invalid.
+ *  <p>
+ *  Instances of this class are not tied to a specific field.
+ * @implSpec This class is immutable and thread-safe.
+ * @since 1.8
+ */
+export type ValueRange = Object &
+  Serializable & {
+    /**
+     * Is the value range fixed and fully known.
+     *  <p>
+     *  For example, the ISO day-of-month runs from 1 to between 28 and 31.
+     *  Since there is uncertainty about the maximum value, the range is not fixed.
+     *  However, for the month of January, the range is always 1 to 31, thus it is fixed.
+     * @return true if the set of values is fixed
+     */
+    isFixed(): boolean;
+
+    /**
+     * Gets the minimum value that the field can take.
+     *  <p>
+     *  For example, the ISO day-of-month always starts at 1.
+     *  The minimum is therefore 1.
+     * @return the minimum value for this field
+     */
+    getMinimum(): number;
+
+    /**
+     * Gets the largest possible minimum value that the field can take.
+     *  <p>
+     *  For example, the ISO day-of-month always starts at 1.
+     *  The largest minimum is therefore 1.
+     * @return the largest possible minimum value for this field
+     */
+    getLargestMinimum(): number;
+
+    /**
+     * Gets the smallest possible maximum value that the field can take.
+     *  <p>
+     *  For example, the ISO day-of-month runs to between 28 and 31 days.
+     *  The smallest maximum is therefore 28.
+     * @return the smallest possible maximum value for this field
+     */
+    getSmallestMaximum(): number;
+
+    /**
+     * Gets the maximum value that the field can take.
+     *  <p>
+     *  For example, the ISO day-of-month runs to between 28 and 31 days.
+     *  The maximum is therefore 31.
+     * @return the maximum value for this field
+     */
+    getMaximum(): number;
+
+    /**
+     * Checks if all values in the range fit in an {@code int}.
+     *  <p>
+     *  This checks that all valid values are within the bounds of an {@code int}.
+     *  <p>
+     *  For example, the ISO month-of-year has values from 1 to 12, which fits in an {@code int}.
+     *  By comparison, ISO nano-of-day runs from 1 to 86,400,000,000,000 which does not fit in an {@code int}.
+     *  <p>
+     *  This implementation uses {@link #getMinimum()} and {@link #getMaximum()}.
+     * @return true if a valid value always fits in an {@code int}
+     */
+    isIntValue(): boolean;
+
+    /**
+     * Checks if the value is within the valid range.
+     *  <p>
+     *  This checks that the value is within the stored range of values.
+     * @param value the value to check
+     * @return true if the value is valid
+     */
+    isValidValue(value: number): boolean;
+
+    /**
+     * Checks if the value is within the valid range and that all values
+     *  in the range fit in an {@code int}.
+     *  <p>
+     *  This method combines {@link #isIntValue()} and {@link #isValidValue(long)}.
+     * @param value the value to check
+     * @return true if the value is valid and fits in an {@code int}
+     */
+    isValidIntValue(value: number): boolean;
+
+    /**
+     * Checks that the specified value is valid.
+     *  <p>
+     *  This validates that the value is within the valid range of values.
+     *  The field is only used to improve the error message.
+     * @param value the value to check
+     * @param field the field being checked, may be null
+     * @return the value that was passed in
+     * @see #isValidValue(long)
+     */
+    checkValidValue(value: number, field: TemporalField): number;
+
+    /**
+     * Checks that the specified value is valid and fits in an {@code int}.
+     *  <p>
+     *  This validates that the value is within the valid range of values and that
+     *  all valid values are within the bounds of an {@code int}.
+     *  The field is only used to improve the error message.
+     * @param value the value to check
+     * @param field the field being checked, may be null
+     * @return the value that was passed in
+     * @see #isValidIntValue(long)
+     */
+    checkValidIntValue(value: number, field: TemporalField): number;
+
+    /**
+     * Checks if this range is equal to another range.
+     *  <p>
+     *  The comparison is based on the four values, minimum, largest minimum,
+     *  smallest maximum and maximum.
+     *  Only objects of type {@code ValueRange} are compared, other types return false.
+     * @param obj the object to check, null returns false
+     * @return true if this is equal to the other range
+     */
+    equals(obj: unknown): boolean;
+
+    /**
+     * A hash code for this range.
+     * @return a suitable hash code
+     */
+    hashCode(): number;
+
+    /**
+     * Outputs this range as a {@code String}.
+     *  <p>
+     *  The format will be '{min}/{largestMin} - {smallestMax}/{max}',
+     *  where the largestMin or smallestMax sections may be omitted, together
+     *  with associated slash, if they are the same as the min or max.
+     * @return a string representation of this range, not null
+     */
+    toString(): string;
+  };

package/types/java/time/temporal/ValueRange/index.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  isFixed: function isFixed() {},
+  getMinimum: function getMinimum() {},
+  getLargestMinimum: function getLargestMinimum() {},
+  getSmallestMaximum: function getSmallestMaximum() {},
+  getMaximum: function getMaximum() {},
+  isIntValue: function isIntValue() {},
+  isValidValue: function isValidValue() {},
+  isValidIntValue: function isValidIntValue() {},
+  checkValidValue: function checkValidValue() {},
+  checkValidIntValue: function checkValidIntValue() {},
+  equals: function equals() {},
+  hashCode: function hashCode() {},
+  toString: function toString() {}
+};
+exports["default"] = _default;

package/types/java/time/zone/ZoneOffsetTransition/index.d.ts

@@ -0,0 +1,161 @@
+import type { Instant } from "../../Instant";
+
+import type { LocalDateTime } from "../../LocalDateTime";
+import type { ZoneOffset } from "../../ZoneOffset";
+import type { Duration } from "../../Duration";
+
+import type { Object } from "../../../lang/Object";
+import type { String } from "../../../lang/String";
+import type { Comparable } from "../../../lang/Comparable";
+import type { Serializable } from "../../../io/Serializable";
+
+/**
+ * A transition between two offsets caused by a discontinuity in the local time-line.
+ *  <p>
+ *  A transition between two offsets is normally the result of a daylight savings cutover.
+ *  The discontinuity is normally a gap in spring and an overlap in autumn.
+ *  {@code ZoneOffsetTransition} models the transition between the two offsets.
+ *  <p>
+ *  Gaps occur where there are local date-times that simply do not exist.
+ *  An example would be when the offset changes from {@code +03:00} to {@code +04:00}.
+ *  This might be described as 'the clocks will move forward one hour tonight at 1am'.
+ *  <p>
+ *  Overlaps occur where there are local date-times that exist twice.
+ *  An example would be when the offset changes from {@code +04:00} to {@code +03:00}.
+ *  This might be described as 'the clocks will move back one hour tonight at 2am'.
+ * @implSpec This class is immutable and thread-safe.
+ * @since 1.8
+ */
+export type ZoneOffsetTransition = Object &
+  Comparable &
+  Serializable & {
+    /**
+     * Gets the transition instant.
+     *  <p>
+     *  This is the instant of the discontinuity, which is defined as the first
+     *  instant that the 'after' offset applies.
+     *  <p>
+     *  The methods {@link #getInstant()}, {@link #getDateTimeBefore()} and {@link #getDateTimeAfter()}
+     *  all represent the same instant.
+     * @return the transition instant, not null
+     */
+    getInstant(): Instant;
+
+    /**
+     * Gets the transition instant as an epoch second.
+     * @return the transition epoch second
+     */
+    toEpochSecond(): number;
+
+    /**
+     * Gets the local transition date-time, as would be expressed with the 'before' offset.
+     *  <p>
+     *  This is the date-time where the discontinuity begins expressed with the 'before' offset.
+     *  At this instant, the 'after' offset is actually used, therefore the combination of this
+     *  date-time and the 'before' offset will never occur.
+     *  <p>
+     *  The combination of the 'before' date-time and offset represents the same instant
+     *  as the 'after' date-time and offset.
+     * @return the transition date-time expressed with the before offset, not null
+     */
+    getDateTimeBefore(): LocalDateTime;
+
+    /**
+     * Gets the local transition date-time, as would be expressed with the 'after' offset.
+     *  <p>
+     *  This is the first date-time after the discontinuity, when the new offset applies.
+     *  <p>
+     *  The combination of the 'before' date-time and offset represents the same instant
+     *  as the 'after' date-time and offset.
+     * @return the transition date-time expressed with the after offset, not null
+     */
+    getDateTimeAfter(): LocalDateTime;
+
+    /**
+     * Gets the offset before the transition.
+     *  <p>
+     *  This is the offset in use before the instant of the transition.
+     * @return the offset before the transition, not null
+     */
+    getOffsetBefore(): ZoneOffset;
+
+    /**
+     * Gets the offset after the transition.
+     *  <p>
+     *  This is the offset in use on and after the instant of the transition.
+     * @return the offset after the transition, not null
+     */
+    getOffsetAfter(): ZoneOffset;
+
+    /**
+     * Gets the duration of the transition.
+     *  <p>
+     *  In most cases, the transition duration is one hour, however this is not always the case.
+     *  The duration will be positive for a gap and negative for an overlap.
+     *  Time-zones are second-based, so the nanosecond part of the duration will be zero.
+     * @return the duration of the transition, positive for gaps, negative for overlaps
+     */
+    getDuration(): Duration;
+
+    /**
+     * Does this transition represent a gap in the local time-line.
+     *  <p>
+     *  Gaps occur where there are local date-times that simply do not exist.
+     *  An example would be when the offset changes from {@code +01:00} to {@code +02:00}.
+     *  This might be described as 'the clocks will move forward one hour tonight at 1am'.
+     * @return true if this transition is a gap, false if it is an overlap
+     */
+    isGap(): boolean;
+
+    /**
+     * Does this transition represent an overlap in the local time-line.
+     *  <p>
+     *  Overlaps occur where there are local date-times that exist twice.
+     *  An example would be when the offset changes from {@code +02:00} to {@code +01:00}.
+     *  This might be described as 'the clocks will move back one hour tonight at 2am'.
+     * @return true if this transition is an overlap, false if it is a gap
+     */
+    isOverlap(): boolean;
+
+    /**
+     * Checks if the specified offset is valid during this transition.
+     *  <p>
+     *  This checks to see if the given offset will be valid at some point in the transition.
+     *  A gap will always return false.
+     *  An overlap will return true if the offset is either the before or after offset.
+     * @param offset the offset to check, null returns false
+     * @return true if the offset is valid during the transition
+     */
+    isValidOffset(offset: ZoneOffset): boolean;
+
+    /**
+     * Compares this transition to another based on the transition instant.
+     *  <p>
+     *  This compares the instants of each transition.
+     *  The offsets are ignored, making this order inconsistent with equals.
+     * @param transition the transition to compare to, not null
+     * @return the comparator value, negative if less, positive if greater
+     */
+    compareTo(transition: ZoneOffsetTransition): number;
+
+    /**
+     * Checks if this object equals another.
+     *  <p>
+     *  The entire state of the object is compared.
+     * @param other the other object to compare to, null returns false
+     * @return true if equal
+     */
+    equals(other: unknown): boolean;
+
+    /**
+     * Returns a suitable hash code.
+     * @return the hash code
+     */
+    hashCode(): number;
+
+    /**
+     * Returns a string describing this object.
+     * @return a string for debugging, not null
+     */
+    toString(): string;
+  };

package/types/java/time/zone/ZoneOffsetTransition/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getInstant: function getInstant() {},
+  toEpochSecond: function toEpochSecond() {},
+  getDateTimeBefore: function getDateTimeBefore() {},
+  getDateTimeAfter: function getDateTimeAfter() {},
+  getOffsetBefore: function getOffsetBefore() {},
+  getOffsetAfter: function getOffsetAfter() {},
+  getDuration: function getDuration() {},
+  isGap: function isGap() {},
+  isOverlap: function isOverlap() {},
+  isValidOffset: function isValidOffset() {},
+  compareTo: function compareTo() {},
+  equals: function equals() {},
+  hashCode: function hashCode() {},
+  toString: function toString() {}
+};
+exports["default"] = _default;