@sitevision/api 2023.2.1 → 2023.2.2-beta.1

package/types/java/time/format/DateTimeFormatter/index.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  ofPattern: function ofPattern() {},
+  ofLocalizedDate: function ofLocalizedDate() {},
+  ofLocalizedTime: function ofLocalizedTime() {},
+  ofLocalizedDateTime: function ofLocalizedDateTime() {},
+  parsedExcessDays: function parsedExcessDays() {},
+  parsedLeapSecond: function parsedLeapSecond() {},
+  getLocale: function getLocale() {},
+  withLocale: function withLocale() {},
+  getDecimalStyle: function getDecimalStyle() {},
+  withDecimalStyle: function withDecimalStyle() {},
+  getChronology: function getChronology() {},
+  withChronology: function withChronology() {},
+  getZone: function getZone() {},
+  withZone: function withZone() {},
+  getResolverStyle: function getResolverStyle() {},
+  withResolverStyle: function withResolverStyle() {},
+  getResolverFields: function getResolverFields() {},
+  withResolverFields: function withResolverFields() {},
+  format: function format() {},
+  formatTo: function formatTo() {},
+  parse: function parse() {},
+  parseBest: function parseBest() {},
+  parseUnresolved: function parseUnresolved() {},
+  toFormat: function toFormat() {},
+  toString: function toString() {}
+};
+exports["default"] = _default;

package/types/java/time/format/DecimalStyle/index.d.ts

@@ -0,0 +1,150 @@
+import type { Set } from "../../../util/Set";
+import type { Locale } from "../../../util/Locale";
+
+import type { Object } from "../../../lang/Object";
+
+import type { String } from "../../../lang/String";
+
+/**
+ * Localized decimal style used in date and time formatting.
+ *  <p>
+ *  A significant part of dealing with dates and times is the localization.
+ *  This class acts as a central point for accessing the information.
+ * @implSpec This class is immutable and thread-safe.
+ * @since 1.8
+ */
+export type DecimalStyle = Object & {
+  /**
+   * Lists all the locales that are supported.
+   *  <p>
+   *  The locale 'en_US' will always be present.
+   * @return a Set of Locales for which localization is supported
+   */
+  getAvailableLocales(): Set;
+
+  /**
+   * Obtains the DecimalStyle for the default
+   *  {@link java.util.Locale.Category#FORMAT FORMAT} locale.
+   *  <p>
+   *  This method provides access to locale sensitive decimal style symbols.
+   *  <p>
+   *  This is equivalent to calling
+   *  {@link #of(Locale)
+   *      of(Locale.getDefault(Locale.Category.FORMAT))}.
+   * @see java.util.Locale.Category#FORMAT
+   * @return the decimal style, not null
+   */
+  ofDefaultLocale(): DecimalStyle;
+
+  /**
+   * Obtains the DecimalStyle for the specified locale.
+   *  <p>
+   *  This method provides access to locale sensitive decimal style symbols.
+   * @param locale the locale, not null
+   * @return the decimal style, not null
+   */
+  of(locale: Locale): DecimalStyle;
+
+  /**
+   * Gets the character that represents zero.
+   *  <p>
+   *  The character used to represent digits may vary by culture.
+   *  This method specifies the zero character to use, which implies the characters for one to nine.
+   * @return the character for zero
+   */
+  getZeroDigit(): string;
+
+  /**
+   * Returns a copy of the info with a new character that represents zero.
+   *  <p>
+   *  The character used to represent digits may vary by culture.
+   *  This method specifies the zero character to use, which implies the characters for one to nine.
+   * @param zeroDigit the character for zero
+   * @return a copy with a new character that represents zero, not null
+   */
+  withZeroDigit(zeroDigit: string): DecimalStyle;
+
+  /**
+   * Gets the character that represents the positive sign.
+   *  <p>
+   *  The character used to represent a positive number may vary by culture.
+   *  This method specifies the character to use.
+   * @return the character for the positive sign
+   */
+  getPositiveSign(): string;
+
+  /**
+   * Returns a copy of the info with a new character that represents the positive sign.
+   *  <p>
+   *  The character used to represent a positive number may vary by culture.
+   *  This method specifies the character to use.
+   * @param positiveSign the character for the positive sign
+   * @return a copy with a new character that represents the positive sign, not null
+   */
+  withPositiveSign(positiveSign: string): DecimalStyle;
+
+  /**
+   * Gets the character that represents the negative sign.
+   *  <p>
+   *  The character used to represent a negative number may vary by culture.
+   *  This method specifies the character to use.
+   * @return the character for the negative sign
+   */
+  getNegativeSign(): string;
+
+  /**
+   * Returns a copy of the info with a new character that represents the negative sign.
+   *  <p>
+   *  The character used to represent a negative number may vary by culture.
+   *  This method specifies the character to use.
+   * @param negativeSign the character for the negative sign
+   * @return a copy with a new character that represents the negative sign, not null
+   */
+  withNegativeSign(negativeSign: string): DecimalStyle;
+
+  /**
+   * Gets the character that represents the decimal point.
+   *  <p>
+   *  The character used to represent a decimal point may vary by culture.
+   *  This method specifies the character to use.
+   * @return the character for the decimal point
+   */
+  getDecimalSeparator(): string;
+
+  /**
+   * Returns a copy of the info with a new character that represents the decimal point.
+   *  <p>
+   *  The character used to represent a decimal point may vary by culture.
+   *  This method specifies the character to use.
+   * @param decimalSeparator the character for the decimal point
+   * @return a copy with a new character that represents the decimal point, not null
+   */
+  withDecimalSeparator(decimalSeparator: string): DecimalStyle;
+
+  /**
+   * Checks if this DecimalStyle is equal to another DecimalStyle.
+   * @param obj the object to check, null returns false
+   * @return true if this is equal to the other date
+   */
+  equals(obj: unknown): boolean;
+
+  /**
+   * A hash code for this DecimalStyle.
+   * @return a suitable hash code
+   */
+  hashCode(): number;
+
+  /**
+   * Returns a string describing this DecimalStyle.
+   * @return a string description, not null
+   */
+  toString(): string;
+
+  /**
+ * The standard set of non-localized decimal style symbols.
+ *  <p>
+ *  This uses standard ASCII characters for zero, positive, negative and a dot for the decimal point.
+  
+    */
+  STANDARD: DecimalStyle;
+};

package/types/java/time/format/DecimalStyle/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getAvailableLocales: function getAvailableLocales() {},
+  ofDefaultLocale: function ofDefaultLocale() {},
+  of: function of() {},
+  getZeroDigit: function getZeroDigit() {},
+  withZeroDigit: function withZeroDigit() {},
+  getPositiveSign: function getPositiveSign() {},
+  withPositiveSign: function withPositiveSign() {},
+  getNegativeSign: function getNegativeSign() {},
+  withNegativeSign: function withNegativeSign() {},
+  getDecimalSeparator: function getDecimalSeparator() {},
+  withDecimalSeparator: function withDecimalSeparator() {},
+  equals: function equals() {},
+  hashCode: function hashCode() {},
+  toString: function toString() {}
+};
+exports["default"] = _default;

package/types/java/time/format/FormatStyle/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Enumeration of the style of a localized date, time or date-time formatter.
+ *  <p>
+ *  These styles are used when obtaining a date-time style from configuration.
+ *  See {@link DateTimeFormatter} and {@link DateTimeFormatterBuilder} for usage.
+ * @implSpec This is an immutable and thread-safe enum.
+ * @since 1.8
+ */
+export type FormatStyle = {
+  FULL: "FULL";
+  LONG: "LONG";
+  MEDIUM: "MEDIUM";
+  SHORT: "SHORT";
+};

package/types/java/time/format/FormatStyle/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  FULL: "FULL",
+  LONG: "LONG",
+  MEDIUM: "MEDIUM",
+  SHORT: "SHORT"
+};
+exports["default"] = _default;

package/types/java/time/format/ResolverStyle/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Enumeration of different ways to resolve dates and times.
+ *  <p>
+ *  Parsing a text string occurs in two phases.
+ *  Phase 1 is a basic text parse according to the fields added to the builder.
+ *  Phase 2 resolves the parsed field-value pairs into date and/or time objects.
+ *  This style is used to control how phase 2, resolving, happens.
+ * @implSpec This is an immutable and thread-safe enum.
+ * @since 1.8
+ */
+export type ResolverStyle = {
+  STRICT: "STRICT";
+  SMART: "SMART";
+  LENIENT: "LENIENT";
+};

package/types/java/time/format/ResolverStyle/index.js

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

package/types/java/time/format/TextStyle/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Enumeration of the style of text formatting and parsing.
+ *  <p>
+ *  Text styles define three sizes for the formatted text - 'full', 'short' and 'narrow'.
+ *  Each of these three sizes is available in both 'standard' and 'stand-alone' variations.
+ *  <p>
+ *  The difference between the three sizes is obvious in most languages.
+ *  For example, in English the 'full' month is 'January', the 'short' month is 'Jan'
+ *  and the 'narrow' month is 'J'. Note that the narrow size is often not unique.
+ *  For example, 'January', 'June' and 'July' all have the 'narrow' text 'J'.
+ *  <p>
+ *  The difference between the 'standard' and 'stand-alone' forms is trickier to describe
+ *  as there is no difference in English. However, in other languages there is a difference
+ *  in the word used when the text is used alone, as opposed to in a complete date.
+ *  For example, the word used for a month when used alone in a date picker is different
+ *  to the word used for month in association with a day and year in a date.
+ * @implSpec This is immutable and thread-safe enum.
+ */
+export type TextStyle = {
+  FULL: "FULL";
+  FULL_STANDALONE: "FULL_STANDALONE";
+  SHORT: "SHORT";
+  SHORT_STANDALONE: "SHORT_STANDALONE";
+  NARROW: "NARROW";
+  NARROW_STANDALONE: "NARROW_STANDALONE";
+};

package/types/java/time/format/TextStyle/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  FULL: "FULL",
+  FULL_STANDALONE: "FULL_STANDALONE",
+  SHORT: "SHORT",
+  SHORT_STANDALONE: "SHORT_STANDALONE",
+  NARROW: "NARROW",
+  NARROW_STANDALONE: "NARROW_STANDALONE"
+};
+exports["default"] = _default;

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

@@ -0,0 +1,45 @@
+/**
+ * A standard set of fields.
+ *  <p>
+ *  This set of fields provide field-based access to manipulate a date, time or date-time.
+ *  The standard set of fields can be extended by implementing {@link TemporalField}.
+ *  <p>
+ *  These fields are intended to be applicable in multiple calendar systems.
+ *  For example, most non-ISO calendar systems define dates as a year, month and day,
+ *  just with slightly different rules.
+ *  The documentation of each field explains how it operates.
+ * @implSpec This is a final, immutable and thread-safe enum.
+ * @since 1.8
+ */
+export type ChronoField = {
+  NANO_OF_SECOND: "NANO_OF_SECOND";
+  NANO_OF_DAY: "NANO_OF_DAY";
+  MICRO_OF_SECOND: "MICRO_OF_SECOND";
+  MICRO_OF_DAY: "MICRO_OF_DAY";
+  MILLI_OF_SECOND: "MILLI_OF_SECOND";
+  MILLI_OF_DAY: "MILLI_OF_DAY";
+  SECOND_OF_MINUTE: "SECOND_OF_MINUTE";
+  SECOND_OF_DAY: "SECOND_OF_DAY";
+  MINUTE_OF_HOUR: "MINUTE_OF_HOUR";
+  MINUTE_OF_DAY: "MINUTE_OF_DAY";
+  HOUR_OF_AMPM: "HOUR_OF_AMPM";
+  CLOCK_HOUR_OF_AMPM: "CLOCK_HOUR_OF_AMPM";
+  HOUR_OF_DAY: "HOUR_OF_DAY";
+  CLOCK_HOUR_OF_DAY: "CLOCK_HOUR_OF_DAY";
+  AMPM_OF_DAY: "AMPM_OF_DAY";
+  DAY_OF_WEEK: "DAY_OF_WEEK";
+  ALIGNED_DAY_OF_WEEK_IN_MONTH: "ALIGNED_DAY_OF_WEEK_IN_MONTH";
+  ALIGNED_DAY_OF_WEEK_IN_YEAR: "ALIGNED_DAY_OF_WEEK_IN_YEAR";
+  DAY_OF_MONTH: "DAY_OF_MONTH";
+  DAY_OF_YEAR: "DAY_OF_YEAR";
+  EPOCH_DAY: "EPOCH_DAY";
+  ALIGNED_WEEK_OF_MONTH: "ALIGNED_WEEK_OF_MONTH";
+  ALIGNED_WEEK_OF_YEAR: "ALIGNED_WEEK_OF_YEAR";
+  MONTH_OF_YEAR: "MONTH_OF_YEAR";
+  PROLEPTIC_MONTH: "PROLEPTIC_MONTH";
+  YEAR_OF_ERA: "YEAR_OF_ERA";
+  YEAR: "YEAR";
+  ERA: "ERA";
+  INSTANT_SECONDS: "INSTANT_SECONDS";
+  OFFSET_SECONDS: "OFFSET_SECONDS";
+};

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

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  NANO_OF_SECOND: "NANO_OF_SECOND",
+  NANO_OF_DAY: "NANO_OF_DAY",
+  MICRO_OF_SECOND: "MICRO_OF_SECOND",
+  MICRO_OF_DAY: "MICRO_OF_DAY",
+  MILLI_OF_SECOND: "MILLI_OF_SECOND",
+  MILLI_OF_DAY: "MILLI_OF_DAY",
+  SECOND_OF_MINUTE: "SECOND_OF_MINUTE",
+  SECOND_OF_DAY: "SECOND_OF_DAY",
+  MINUTE_OF_HOUR: "MINUTE_OF_HOUR",
+  MINUTE_OF_DAY: "MINUTE_OF_DAY",
+  HOUR_OF_AMPM: "HOUR_OF_AMPM",
+  CLOCK_HOUR_OF_AMPM: "CLOCK_HOUR_OF_AMPM",
+  HOUR_OF_DAY: "HOUR_OF_DAY",
+  CLOCK_HOUR_OF_DAY: "CLOCK_HOUR_OF_DAY",
+  AMPM_OF_DAY: "AMPM_OF_DAY",
+  DAY_OF_WEEK: "DAY_OF_WEEK",
+  ALIGNED_DAY_OF_WEEK_IN_MONTH: "ALIGNED_DAY_OF_WEEK_IN_MONTH",
+  ALIGNED_DAY_OF_WEEK_IN_YEAR: "ALIGNED_DAY_OF_WEEK_IN_YEAR",
+  DAY_OF_MONTH: "DAY_OF_MONTH",
+  DAY_OF_YEAR: "DAY_OF_YEAR",
+  EPOCH_DAY: "EPOCH_DAY",
+  ALIGNED_WEEK_OF_MONTH: "ALIGNED_WEEK_OF_MONTH",
+  ALIGNED_WEEK_OF_YEAR: "ALIGNED_WEEK_OF_YEAR",
+  MONTH_OF_YEAR: "MONTH_OF_YEAR",
+  PROLEPTIC_MONTH: "PROLEPTIC_MONTH",
+  YEAR_OF_ERA: "YEAR_OF_ERA",
+  YEAR: "YEAR",
+  ERA: "ERA",
+  INSTANT_SECONDS: "INSTANT_SECONDS",
+  OFFSET_SECONDS: "OFFSET_SECONDS"
+};
+exports["default"] = _default;

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

@@ -0,0 +1,259 @@
+import type { TemporalUnit } from "../TemporalUnit";
+
+import type { TemporalAdjuster } from "../TemporalAdjuster";
+import type { TemporalField } from "../TemporalField";
+
+import type { TemporalAmount } from "../TemporalAmount";
+import type { TemporalAccessor } from "../TemporalAccessor";
+
+/**
+ * Framework-level interface defining read-write access to a temporal object,
+ *  such as a date, time, offset or some combination of these.
+ *  <p>
+ *  This is the base interface type for date, time and offset objects that
+ *  are complete enough to be manipulated using plus and minus.
+ *  It is implemented by those classes that can provide and manipulate information
+ *  as {@linkplain TemporalField fields} or {@linkplain TemporalQuery queries}.
+ *  See {@link TemporalAccessor} for the read-only version of this interface.
+ *  <p>
+ *  Most date and time information can be represented as a number.
+ *  These are modeled using {@code TemporalField} with the number held using
+ *  a {@code long} to handle large values. Year, month and day-of-month are
+ *  simple examples of fields, but they also include instant and offsets.
+ *  See {@link ChronoField} for the standard set of fields.
+ *  <p>
+ *  Two pieces of date/time information cannot be represented by numbers,
+ *  the {@linkplain java.time.chrono.Chronology chronology} and the
+ *  {@linkplain java.time.ZoneId time-zone}.
+ *  These can be accessed via {@link #query(TemporalQuery) queries} using
+ *  the static methods defined on {@link TemporalQuery}.
+ *  <p>
+ *  This interface is a framework-level interface that should not be widely
+ *  used in application code. Instead, applications should create and pass
+ *  around instances of concrete types, such as {@code LocalDate}.
+ *  There are many reasons for this, part of which is that implementations
+ *  of this interface may be in calendar systems other than ISO.
+ *  See {@link java.time.chrono.ChronoLocalDate} for a fuller discussion of the issues.
+ *
+ *  <h3>When to implement</h3>
+ *  <p>
+ *  A class should implement this interface if it meets three criteria:
+ *  <ul>
+ *  <li>it provides access to date/time/offset information, as per {@code TemporalAccessor}
+ *  <li>the set of fields are contiguous from the largest to the smallest
+ *  <li>the set of fields are complete, such that no other field is needed to define the
+ *   valid range of values for the fields that are represented
+ *  </ul>
+ *  <p>
+ *  Four examples make this clear:
+ *  <ul>
+ *  <li>{@code LocalDate} implements this interface as it represents a set of fields
+ *   that are contiguous from days to forever and require no external information to determine
+ *   the validity of each date. It is therefore able to implement plus/minus correctly.
+ *  <li>{@code LocalTime} implements this interface as it represents a set of fields
+ *   that are contiguous from nanos to within days and require no external information to determine
+ *   validity. It is able to implement plus/minus correctly, by wrapping around the day.
+ *  <li>{@code MonthDay}, the combination of month-of-year and day-of-month, does not implement
+ *   this interface.  While the combination is contiguous, from days to months within years,
+ *   the combination does not have sufficient information to define the valid range of values
+ *   for day-of-month.  As such, it is unable to implement plus/minus correctly.
+ *  <li>The combination day-of-week and day-of-month ("Friday the 13th") should not implement
+ *   this interface. It does not represent a contiguous set of fields, as days to weeks overlaps
+ *   days to months.
+ *  </ul>
+ * @implSpec This interface places no restrictions on the mutability of implementations,&#xA; however immutability is strongly recommended.&#xA; All implementations must be {@link Comparable}.
+ * @since 1.8
+ */
+export type Temporal = TemporalAccessor & {
+  /**
+   * Checks if the specified unit is supported.
+   *  <p>
+   *  This checks if the specified unit can be added to, or subtracted from, this date-time.
+   *  If false, then calling the {@link #plus(long, TemporalUnit)} and
+   *  {@link #minus(long, TemporalUnit) minus} methods will throw an exception.
+   * @implSpec Implementations must check and handle all units defined in {@link ChronoUnit}.&#xA; If the unit is supported, then true must be returned, otherwise false must be returned.&#xA; <p>&#xA; If the field is not a {@code ChronoUnit}, then the result of this method&#xA; is obtained by invoking {@code TemporalUnit.isSupportedBy(Temporal)}&#xA; passing {@code this} as the argument.&#xA; <p>&#xA; Implementations must ensure that no observable state is altered when this&#xA; read-only method is invoked.
+   * @param unit the unit to check, null returns false
+   * @return true if the unit can be added/subtracted, false if not
+   */
+  isSupported(unit: TemporalUnit): boolean;
+
+  /**
+   * Returns an adjusted object of the same type as this object with the adjustment made.
+   *  <p>
+   *  This adjusts this date-time according to the rules of the specified adjuster.
+   *  A simple adjuster might simply set the one of the fields, such as the year field.
+   *  A more complex adjuster might set the date to the last day of the month.
+   *  A selection of common adjustments is provided in
+   *  {@link java.time.temporal.TemporalAdjusters TemporalAdjusters}.
+   *  These include finding the "last day of the month" and "next Wednesday".
+   *  The adjuster is responsible for handling special cases, such as the varying
+   *  lengths of month and leap years.
+   *  <p>
+   *  Some example code indicating how and why this method is used:
+   *  <pre>
+   *   date = date.with(Month.JULY);        // most key classes implement TemporalAdjuster
+   *   date = date.with(lastDayOfMonth());  // static import from Adjusters
+   *   date = date.with(next(WEDNESDAY));   // static import from Adjusters and DayOfWeek
+   *  </pre>
+   * @implSpec <p>&#xA; Implementations must not alter either this object or the specified temporal object.&#xA; Instead, an adjusted copy of the original must be returned.&#xA; This provides equivalent, safe behavior for immutable and mutable implementations.&#xA; <p>&#xA; The default implementation must behave equivalent to this code:&#xA; <pre>&#xA; return adjuster.adjustInto(this);&#xA; </pre>
+   * @param adjuster the adjuster to use, not null
+   * @return an object of the same type with the specified adjustment made, not null
+   * @throws DateTimeException if unable to make the adjustment
+   * @throws ArithmeticException if numeric overflow occurs
+   */
+  with(adjuster: TemporalAdjuster): Temporal;
+
+  /**
+   * Returns an object of the same type as this object with the specified field altered.
+   *  <p>
+   *  This returns a new object based on this one with the value for the specified field changed.
+   *  For example, on a {@code LocalDate}, this could be used to set the year, month or day-of-month.
+   *  The returned object will have the same observable type as this object.
+   *  <p>
+   *  In some cases, changing a field is not fully defined. For example, if the target object is
+   *  a date representing the 31st January, then changing the month to February would be unclear.
+   *  In cases like this, the field is responsible for resolving the result. Typically it will choose
+   *  the previous valid date, which would be the last valid day of February in this example.
+   * @implSpec Implementations must check and handle all fields defined in {@link ChronoField}.&#xA; If the field is supported, then the adjustment must be performed.&#xA; If unsupported, then an {@code UnsupportedTemporalTypeException} must be thrown.&#xA; <p>&#xA; If the field is not a {@code ChronoField}, then the result of this method&#xA; is obtained by invoking {@code TemporalField.adjustInto(Temporal, long)}&#xA; passing {@code this} as the first argument.&#xA; <p>&#xA; Implementations must not alter this object.&#xA; Instead, an adjusted copy of the original must be returned.&#xA; This provides equivalent, safe behavior for immutable and mutable implementations.
+   * @param field the field to set in the result, not null
+   * @param newValue the new value of the field in the result
+   * @return an object of the same type with the specified field set, not null
+   * @throws DateTimeException if the field cannot be set
+   * @throws UnsupportedTemporalTypeException if the field is not supported
+   * @throws ArithmeticException if numeric overflow occurs
+   */
+  with(field: TemporalField, newValue: number): Temporal;
+
+  /**
+   * Returns an object of the same type as this object with an amount added.
+   *  <p>
+   *  This adjusts this temporal, adding according to the rules of the specified amount.
+   *  The amount is typically a {@link java.time.Period} but may be any other type implementing
+   *  the {@link TemporalAmount} interface, such as {@link java.time.Duration}.
+   *  <p>
+   *  Some example code indicating how and why this method is used:
+   *  <pre>
+   *   date = date.plus(period);                // add a Period instance
+   *   date = date.plus(duration);              // add a Duration instance
+   *   date = date.plus(workingDays(6));        // example user-written workingDays method
+   *  </pre>
+   *  <p>
+   *  Note that calling {@code plus} followed by {@code minus} is not guaranteed to
+   *  return the same date-time.
+   * @implSpec <p>&#xA; Implementations must not alter either this object or the specified temporal object.&#xA; Instead, an adjusted copy of the original must be returned.&#xA; This provides equivalent, safe behavior for immutable and mutable implementations.&#xA; <p>&#xA; The default implementation must behave equivalent to this code:&#xA; <pre>&#xA; return amount.addTo(this);&#xA; </pre>
+   * @param amount the amount to add, not null
+   * @return an object of the same type with the specified adjustment made, not null
+   * @throws DateTimeException if the addition cannot be made
+   * @throws ArithmeticException if numeric overflow occurs
+   */
+  plus(amount: TemporalAmount): Temporal;
+
+  /**
+   * Returns an object of the same type as this object with the specified period added.
+   *  <p>
+   *  This method returns a new object based on this one with the specified period added.
+   *  For example, on a {@code LocalDate}, this could be used to add a number of years, months or days.
+   *  The returned object will have the same observable type as this object.
+   *  <p>
+   *  In some cases, changing a field is not fully defined. For example, if the target object is
+   *  a date representing the 31st January, then adding one month would be unclear.
+   *  In cases like this, the field is responsible for resolving the result. Typically it will choose
+   *  the previous valid date, which would be the last valid day of February in this example.
+   * @implSpec Implementations must check and handle all units defined in {@link ChronoUnit}.&#xA; If the unit is supported, then the addition must be performed.&#xA; If unsupported, then an {@code UnsupportedTemporalTypeException} must be thrown.&#xA; <p>&#xA; If the unit is not a {@code ChronoUnit}, then the result of this method&#xA; is obtained by invoking {@code TemporalUnit.addTo(Temporal, long)}&#xA; passing {@code this} as the first argument.&#xA; <p>&#xA; Implementations must not alter this object.&#xA; Instead, an adjusted copy of the original must be returned.&#xA; This provides equivalent, safe behavior for immutable and mutable implementations.
+   * @param amountToAdd the amount of the specified unit to add, may be negative
+   * @param unit the unit of the amount to add, not null
+   * @return an object of the same type with the specified period added, not null
+   * @throws DateTimeException if the unit cannot be added
+   * @throws UnsupportedTemporalTypeException if the unit is not supported
+   * @throws ArithmeticException if numeric overflow occurs
+   */
+  plus(amountToAdd: number, unit: TemporalUnit): Temporal;
+
+  /**
+   * Returns an object of the same type as this object with an amount subtracted.
+   *  <p>
+   *  This adjusts this temporal, subtracting according to the rules of the specified amount.
+   *  The amount is typically a {@link java.time.Period} but may be any other type implementing
+   *  the {@link TemporalAmount} interface, such as {@link java.time.Duration}.
+   *  <p>
+   *  Some example code indicating how and why this method is used:
+   *  <pre>
+   *   date = date.minus(period);               // subtract a Period instance
+   *   date = date.minus(duration);             // subtract a Duration instance
+   *   date = date.minus(workingDays(6));       // example user-written workingDays method
+   *  </pre>
+   *  <p>
+   *  Note that calling {@code plus} followed by {@code minus} is not guaranteed to
+   *  return the same date-time.
+   * @implSpec <p>&#xA; Implementations must not alter either this object or the specified temporal object.&#xA; Instead, an adjusted copy of the original must be returned.&#xA; This provides equivalent, safe behavior for immutable and mutable implementations.&#xA; <p>&#xA; The default implementation must behave equivalent to this code:&#xA; <pre>&#xA; return amount.subtractFrom(this);&#xA; </pre>
+   * @param amount the amount to subtract, not null
+   * @return an object of the same type with the specified adjustment made, not null
+   * @throws DateTimeException if the subtraction cannot be made
+   * @throws ArithmeticException if numeric overflow occurs
+   */
+  minus(amount: TemporalAmount): Temporal;
+
+  /**
+   * Returns an object of the same type as this object with the specified period subtracted.
+   *  <p>
+   *  This method returns a new object based on this one with the specified period subtracted.
+   *  For example, on a {@code LocalDate}, this could be used to subtract a number of years, months or days.
+   *  The returned object will have the same observable type as this object.
+   *  <p>
+   *  In some cases, changing a field is not fully defined. For example, if the target object is
+   *  a date representing the 31st March, then subtracting one month would be unclear.
+   *  In cases like this, the field is responsible for resolving the result. Typically it will choose
+   *  the previous valid date, which would be the last valid day of February in this example.
+   * @implSpec Implementations must behave in a manor equivalent to the default method behavior.&#xA; <p>&#xA; Implementations must not alter this object.&#xA; Instead, an adjusted copy of the original must be returned.&#xA; This provides equivalent, safe behavior for immutable and mutable implementations.&#xA; <p>&#xA; The default implementation must behave equivalent to this code:&#xA; <pre>&#xA; return (amountToSubtract == Long.MIN_VALUE ?&#xA; plus(Long.MAX_VALUE, unit).plus(1, unit) : plus(-amountToSubtract, unit));&#xA; </pre>
+   * @param amountToSubtract the amount of the specified unit to subtract, may be negative
+   * @param unit the unit of the amount to subtract, not null
+   * @return an object of the same type with the specified period subtracted, not null
+   * @throws DateTimeException if the unit cannot be subtracted
+   * @throws UnsupportedTemporalTypeException if the unit is not supported
+   * @throws ArithmeticException if numeric overflow occurs
+   */
+  minus(amountToSubtract: number, unit: TemporalUnit): Temporal;
+
+  /**
+   * Calculates the amount of time until another temporal in terms of the specified unit.
+   *  <p>
+   *  This calculates the amount of time between two temporal objects
+   *  in terms of a single {@code TemporalUnit}.
+   *  The start and end points are {@code this} and the specified temporal.
+   *  The end point is converted to be of the same type as the start point if different.
+   *  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 startTime.until(endTime, HOURS)}.
+   *  <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 TemporalUnit#between(Temporal, Temporal)}:
+   *  <pre>
+   *    // these two lines are equivalent
+   *    temporal = start.until(end, unit);
+   *    temporal = unit.between(start, end);
+   *  </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 = start.until(end, DAYS);
+   *   // or alternatively
+   *   long daysBetween = DAYS.between(start, end);
+   *  </pre>
+   * @implSpec Implementations must begin by checking to ensure that the input temporal&#xA; object is of the same observable type as the implementation.&#xA; They must then perform the calculation for all instances of {@link ChronoUnit}.&#xA; An {@code UnsupportedTemporalTypeException} must be thrown for {@code ChronoUnit}&#xA; instances that are unsupported.&#xA; <p>&#xA; If the unit is not a {@code ChronoUnit}, then the result of this method&#xA; is obtained by invoking {@code TemporalUnit.between(Temporal, Temporal)}&#xA; passing {@code this} as the first argument and the converted input temporal as&#xA; the second argument.&#xA; <p>&#xA; In summary, implementations must behave in a manner equivalent to this pseudo-code:&#xA; <pre>&#xA; // convert the end temporal to the same type as this class&#xA; if (unit instanceof ChronoUnit) {&#xA; // if unit is supported, then calculate and return result&#xA; // else throw UnsupportedTemporalTypeException for unsupported units&#xA; }&#xA; return unit.between(this, convertedEndTemporal);&#xA; </pre>&#xA; <p>&#xA; Note that the unit's {@code between} method must only be invoked if the&#xA; two temporal objects have exactly the same type evaluated by {@code getClass()}.&#xA; <p>&#xA; Implementations must ensure that no observable state is altered when this&#xA; read-only method is invoked.
+   * @param endExclusive the end temporal, exclusive, converted to be of the&#xA; same type as this object, not null
+   * @param unit the unit to measure the amount in, not null
+   * @return the amount of time between this temporal object and the specified one&#xA; in terms of the unit; positive if the specified object is later than this one,&#xA; negative if it is earlier than this one
+   * @throws DateTimeException if the amount cannot be calculated, or the end&#xA; temporal cannot be converted to the same type as this temporal
+   * @throws UnsupportedTemporalTypeException if the unit is not supported
+   * @throws ArithmeticException if numeric overflow occurs
+   */
+  until(endExclusive: Temporal, unit: TemporalUnit): number;
+};