@sitevision/api 2023.2.1 → 2023.2.2-beta.2

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

@@ -0,0 +1,126 @@
+import type { TemporalField } from "../TemporalField";
+
+import type { ValueRange } from "../ValueRange";
+
+import type { TemporalQuery } from "../TemporalQuery";
+
+/**
+ * Framework-level interface defining read-only 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.
+ *  It is implemented by those classes that can provide information
+ *  as {@linkplain TemporalField fields} or {@linkplain TemporalQuery queries}.
+ *  <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 {@linkplain #query(TemporalQuery) queries} using
+ *  the static methods defined on {@link TemporalQuery}.
+ *  <p>
+ *  A sub-interface, {@link Temporal}, extends this definition to one that also
+ *  supports adjustment and manipulation on more complete temporal objects.
+ *  <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.
+ * @implSpec This interface places no restrictions on the mutability of implementations,&#xA; however immutability is strongly recommended.
+ * @since 1.8
+ */
+export type TemporalAccessor = {
+  /**
+   * Checks if the specified field is supported.
+   *  <p>
+   *  This checks if the date-time can be queried for the specified field.
+   *  If false, then calling the {@link #range(TemporalField) range} and {@link #get(TemporalField) get}
+   *  methods will throw an exception.
+   * @implSpec Implementations must check and handle all fields defined in {@link ChronoField}.&#xA; If the field is supported, then true must be returned, otherwise false must be returned.&#xA; <p>&#xA; If the field is not a {@code ChronoField}, then the result of this method&#xA; is obtained by invoking {@code TemporalField.isSupportedBy(TemporalAccessor)}&#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 field the field to check, null returns false
+   * @return true if this date-time can be queried for the field, false if not
+   */
+  isSupported(field: TemporalField): boolean;
+
+  /**
+   * Gets the range of valid values for the specified field.
+   *  <p>
+   *  All fields can be expressed as a {@code long} integer.
+   *  This method returns an object that describes the valid range for that value.
+   *  The value of this temporal object is used to enhance the accuracy of the returned range.
+   *  If the date-time cannot return the range, because the field is unsupported or for
+   *  some other reason, an exception will be thrown.
+   *  <p>
+   *  Note that the result only describes the minimum and maximum valid values
+   *  and it is important not to read too much into them. For example, there
+   *  could be values within the range that are invalid for the field.
+   * @implSpec Implementations must check and handle all fields defined in {@link ChronoField}.&#xA; If the field is supported, then the range of the field must be returned.&#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.rangeRefinedBy(TemporalAccessorl)}&#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.&#xA; <p>&#xA; The default implementation must behave equivalent to this code:&#xA; <pre>&#xA; if (field instanceof ChronoField) {&#xA; if (isSupported(field)) {&#xA; return field.range();&#xA; }&#xA; throw new UnsupportedTemporalTypeException("Unsupported field: " + field);&#xA; }&#xA; return field.rangeRefinedBy(this);&#xA; </pre>
+   * @param field the field to query the range for, not null
+   * @return the range of valid values for the field, not null
+   * @throws DateTimeException if the range for the field cannot be obtained
+   * @throws UnsupportedTemporalTypeException if the field is not supported
+   */
+  range(field: TemporalField): ValueRange;
+
+  /**
+   * Gets the value of the specified field as an {@code int}.
+   *  <p>
+   *  This queries the date-time for the value of the specified field.
+   *  The returned value will always be within the valid range of values for the field.
+   *  If the date-time cannot return the value, because the field is unsupported or for
+   *  some other reason, an exception will be thrown.
+   * @implSpec Implementations must check and handle all fields defined in {@link ChronoField}.&#xA; If the field is supported and has an {@code int} range, then the value of&#xA; the field must be returned.&#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.getFrom(TemporalAccessor)}&#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.&#xA; <p>&#xA; The default implementation must behave equivalent to this code:&#xA; <pre>&#xA; if (range(field).isIntValue()) {&#xA; return range(field).checkValidIntValue(getLong(field), field);&#xA; }&#xA; throw new UnsupportedTemporalTypeException("Invalid field " + field + " + for get() method, use getLong() instead");&#xA; </pre>
+   * @param field the field to get, not null
+   * @return the value for the field, within the valid range of values
+   * @throws DateTimeException if a value for the field cannot be obtained or&#xA; the value is outside the range of valid values for the field
+   * @throws UnsupportedTemporalTypeException if the field is not supported or&#xA; the range of values exceeds an {@code int}
+   * @throws ArithmeticException if numeric overflow occurs
+   */
+  get(field: TemporalField): number;
+
+  /**
+   * Gets the value of the specified field as a {@code long}.
+   *  <p>
+   *  This queries the date-time for the value of the specified field.
+   *  The returned value may be outside the valid range of values for the field.
+   *  If the date-time cannot return the value, because the field is unsupported or for
+   *  some other reason, an exception will be thrown.
+   * @implSpec Implementations must check and handle all fields defined in {@link ChronoField}.&#xA; If the field is supported, then the value of the field must be returned.&#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.getFrom(TemporalAccessor)}&#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 field the field to get, not null
+   * @return the value for the field
+   * @throws DateTimeException if a value for the field cannot be obtained
+   * @throws UnsupportedTemporalTypeException if the field is not supported
+   * @throws ArithmeticException if numeric overflow occurs
+   */
+  getLong(field: TemporalField): number;
+
+  /**
+   * Queries this date-time.
+   *  <p>
+   *  This queries this date-time using the specified query strategy object.
+   *  <p>
+   *  Queries are a key tool for extracting information from date-times.
+   *  They exists 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 most common query implementations are method references, such as
+   *  {@code LocalDate::from} and {@code ZoneId::from}.
+   *  Additional implementations are provided as static methods on {@link TemporalQuery}.
+   * @implSpec The default implementation must behave equivalent to this code:&#xA; <pre>&#xA; if (query == TemporalQueries.zoneId() ||&#xA; query == TemporalQueries.chronology() || query == TemporalQueries.precision()) {&#xA; return null;&#xA; }&#xA; return query.queryFrom(this);&#xA; </pre>&#xA; Future versions are permitted to add further queries to the if statement.&#xA; <p>&#xA; All classes implementing this interface and overriding this method must call&#xA; {@code TemporalAccessor.super.query(query)}. JDK classes may avoid calling&#xA; super if they provide behavior equivalent to the default behaviour, however&#xA; non-JDK classes may not utilize this optimization and must call {@code super}.&#xA; <p>&#xA; If the implementation can supply a value for one of the queries listed in the&#xA; if statement of the default implementation, then it must do so.&#xA; For example, an application-defined {@code HourMin} class storing the hour&#xA; and minute must override this method as follows:&#xA; <pre>&#xA; if (query == TemporalQueries.precision()) {&#xA; return MINUTES;&#xA; }&#xA; return TemporalAccessor.super.query(query);&#xA; </pre>&#xA; <p>&#xA; Implementations must ensure that no observable state is altered when this&#xA; read-only method is invoked.
+   * @param <R> the type of the result
+   * @param query the query to invoke, not null
+   * @return the query result, null may be returned (defined by the query)
+   * @throws DateTimeException if unable to query
+   * @throws ArithmeticException if numeric overflow occurs
+   */
+  query(query: TemporalQuery): unknown;
+};

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

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  isSupported: function isSupported() {},
+  range: function range() {},
+  get: function get() {},
+  getLong: function getLong() {},
+  query: function query() {}
+};
+exports["default"] = _default;

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

@@ -0,0 +1,64 @@
+import type { Temporal } from "../Temporal";
+
+/**
+ * Strategy for adjusting a temporal object.
+ *  <p>
+ *  Adjusters are a key tool for modifying temporal objects.
+ *  They exist to externalize the process of adjustment, permitting different
+ *  approaches, as per the strategy design pattern.
+ *  Examples might be an adjuster that sets the date avoiding weekends, or one that
+ *  sets the date to the last day of the month.
+ *  <p>
+ *  There are two equivalent ways of using a {@code TemporalAdjuster}.
+ *  The first is to invoke the method on this interface directly.
+ *  The second is to use {@link Temporal#with(TemporalAdjuster)}:
+ *  <pre>
+ *    // these two lines are equivalent, but the second approach is recommended
+ *    temporal = thisAdjuster.adjustInto(temporal);
+ *    temporal = temporal.with(thisAdjuster);
+ *  </pre>
+ *  It is recommended to use the second approach, {@code with(TemporalAdjuster)},
+ *  as it is a lot clearer to read in code.
+ *  <p>
+ *  The {@link TemporalAdjusters} class contains a standard set of adjusters,
+ *  available as static methods.
+ *  These include:
+ *  <ul>
+ *  <li>finding the first or last day of the month
+ *  <li>finding the first day of next month
+ *  <li>finding the first or last day of the year
+ *  <li>finding the first day of next year
+ *  <li>finding the first or last day-of-week within a month, such as "first Wednesday in June"
+ *  <li>finding the next or previous day-of-week, such as "next Thursday"
+ *  </ul>
+ * @implSpec This interface places no restrictions on the mutability of implementations,&#xA; however immutability is strongly recommended.
+ * @see TemporalAdjusters
+ * @since 1.8
+ */
+export type TemporalAdjuster = {
+  /**
+   * Adjusts the specified temporal object.
+   *  <p>
+   *  This adjusts the specified temporal object using the logic
+   *  encapsulated in the implementing class.
+   *  Examples might be an adjuster that sets the date avoiding weekends, or one that
+   *  sets the date to the last day of the month.
+   *  <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#with(TemporalAdjuster)}:
+   *  <pre>
+   *    // these two lines are equivalent, but the second approach is recommended
+   *    temporal = thisAdjuster.adjustInto(temporal);
+   *    temporal = temporal.with(thisAdjuster);
+   *  </pre>
+   *  It is recommended to use the second approach, {@code with(TemporalAdjuster)},
+   *  as it is a lot clearer to read in code.
+   * @implSpec The implementation must take the input object and adjust it.&#xA; The implementation defines the logic of the adjustment and is responsible for&#xA; documenting that logic. It may use any method on {@code Temporal} to&#xA; query the temporal object and perform the adjustment.&#xA; The returned object must have the same observable type as the input object&#xA; <p>&#xA; The input object must not be altered.&#xA; Instead, an adjusted copy of the original must be returned.&#xA; This provides equivalent, safe behavior for immutable and mutable temporal objects.&#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 adjust, not null
+   * @return an object of the same observable type with the adjustment made, not null
+   * @throws DateTimeException if unable to make the adjustment
+   * @throws ArithmeticException if numeric overflow occurs
+   */
+  adjustInto(temporal: Temporal): Temporal;
+};

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

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

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

@@ -0,0 +1,105 @@
+import type { TemporalUnit } from "../TemporalUnit";
+
+import type { List } from "../../../util/List";
+import type { Temporal } from "../Temporal";
+
+/**
+ * Framework-level interface defining an amount of time, such as
+ *  "6 hours", "8 days" or "2 years and 3 months".
+ *  <p>
+ *  This is the base interface type for amounts of time.
+ *  An amount is distinct from a date or time-of-day in that it is not tied
+ *  to any specific point on the time-line.
+ *  <p>
+ *  The amount can be thought of as a {@code Map} of {@link TemporalUnit} to
+ *  {@code long}, exposed via {@link #getUnits()} and {@link #get(TemporalUnit)}.
+ *  A simple case might have a single unit-value pair, such as "6 hours".
+ *  A more complex case may have multiple unit-value pairs, such as
+ *  "7 years, 3 months and 5 days".
+ *  <p>
+ *  There are two common implementations.
+ *  {@link Period} is a date-based implementation, storing years, months and days.
+ *  {@link Duration} is a time-based implementation, storing seconds and nanoseconds,
+ *  but providing some access using other duration based units such as minutes,
+ *  hours and fixed 24-hour days.
+ *  <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 Period} and {@code Duration}.
+ * @implSpec This interface places no restrictions on the mutability of implementations,&#xA; however immutability is strongly recommended.
+ * @since 1.8
+ */
+export type TemporalAmount = {
+  /**
+   * Returns the value of the requested unit.
+   *  The units returned from {@link #getUnits()} uniquely define the
+   *  value of the {@code TemporalAmount}.  A value must be returned
+   *  for each unit listed in {@code getUnits}.
+   * @implSpec Implementations may declare support for units not listed by {@link #getUnits()}.&#xA; Typically, the implementation would define additional units&#xA; as conversions for the convenience of developers.
+   * @param unit the {@code TemporalUnit} for which to return the value
+   * @return the long value of the unit
+   * @throws DateTimeException if a value for the unit cannot be obtained
+   * @throws UnsupportedTemporalTypeException if the {@code unit} is not supported
+   */
+  get(unit: TemporalUnit): number;
+
+  /**
+   * Returns the list of units uniquely defining the value of this TemporalAmount.
+   *  The list of {@code TemporalUnits} is defined by the implementation class.
+   *  The list is a snapshot of the units at the time {@code getUnits}
+   *  is called and is not mutable.
+   *  The units are ordered from longest duration to the shortest duration
+   *  of the unit.
+   * @implSpec The list of units completely and uniquely represents the&#xA; state of the object without omissions, overlaps or duplication.&#xA; The units are in order from longest duration to shortest.
+   * @return the List of {@code TemporalUnits}; not null
+   */
+  getUnits(): List;
+
+  /**
+   * Adds to the specified temporal object.
+   *  <p>
+   *  Adds the amount to the specified temporal object using the logic
+   *  encapsulated in the implementing class.
+   *  <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(TemporalAmount)}:
+   *  <pre>
+   *    // These two lines are equivalent, but the second approach is recommended
+   *    dateTime = amount.addTo(dateTime);
+   *    dateTime = dateTime.plus(adder);
+   *  </pre>
+   *  It is recommended to use the second approach, {@code plus(TemporalAmount)},
+   *  as it is a lot clearer to read in code.
+   * @implSpec The implementation must take the input object and add to it.&#xA; The implementation defines the logic of the addition and is responsible for&#xA; documenting that logic. It may use any method on {@code Temporal} to&#xA; query the temporal object and perform the addition.&#xA; The returned object must have the same observable type as the input object&#xA; <p>&#xA; The input object must not be altered.&#xA; Instead, an adjusted copy of the original must be returned.&#xA; This provides equivalent, safe behavior for immutable and mutable temporal objects.&#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 add the amount to, not null
+   * @return an object of the same observable type with the addition made, not null
+   * @throws DateTimeException if unable to add
+   * @throws ArithmeticException if numeric overflow occurs
+   */
+  addTo(temporal: Temporal): Temporal;
+
+  /**
+   * Subtracts this object from the specified temporal object.
+   *  <p>
+   *  Subtracts the amount from the specified temporal object using the logic
+   *  encapsulated in the implementing class.
+   *  <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#minus(TemporalAmount)}:
+   *  <pre>
+   *    // these two lines are equivalent, but the second approach is recommended
+   *    dateTime = amount.subtractFrom(dateTime);
+   *    dateTime = dateTime.minus(amount);
+   *  </pre>
+   *  It is recommended to use the second approach, {@code minus(TemporalAmount)},
+   *  as it is a lot clearer to read in code.
+   * @implSpec The implementation must take the input object and subtract from it.&#xA; The implementation defines the logic of the subtraction and is responsible for&#xA; documenting that logic. It may use any method on {@code Temporal} to&#xA; query the temporal object and perform the subtraction.&#xA; The returned object must have the same observable type as the input object&#xA; <p>&#xA; The input object must not be altered.&#xA; Instead, an adjusted copy of the original must be returned.&#xA; This provides equivalent, safe behavior for immutable and mutable temporal objects.&#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 subtract the amount from, not null
+   * @return an object of the same observable type with the subtraction made, not null
+   * @throws DateTimeException if unable to subtract
+   * @throws ArithmeticException if numeric overflow occurs
+   */
+  subtractFrom(temporal: Temporal): Temporal;
+};

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

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

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

@@ -0,0 +1,257 @@
+import type { Locale } from "../../../util/Locale";
+import type { String } from "../../../lang/String";
+import type { TemporalUnit } from "../TemporalUnit";
+import type { ValueRange } from "../ValueRange";
+
+import type { TemporalAccessor } from "../TemporalAccessor";
+
+import type { Map } from "../../../util/Map";
+import type { ResolverStyle } from "../../format/ResolverStyle";
+
+/**
+ * A field of date-time, such as month-of-year or hour-of-minute.
+ *  <p>
+ *  Date and time is expressed using fields which partition the time-line into something
+ *  meaningful for humans. Implementations of this interface represent those fields.
+ *  <p>
+ *  The most commonly used units are defined in {@link ChronoField}.
+ *  Further fields are supplied in {@link IsoFields}, {@link WeekFields} and {@link JulianFields}.
+ *  Fields can also be written by application code by implementing this interface.
+ *  <p>
+ *  The field works using double dispatch. Client code calls methods on a date-time like
+ *  {@code LocalDateTime} which check if the field is a {@code ChronoField}.
+ *  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; Implementations should be {@code Serializable} where possible.&#xA; An enum is as effective implementation choice.
+ * @since 1.8
+ */
+export type TemporalField = {
+  /**
+   * Gets the display name for the field in the requested locale.
+   *  <p>
+   *  If there is no display name for the locale then a suitable default must be returned.
+   *  <p>
+   *  The default implementation must check the locale is not null
+   *  and return {@code toString()}.
+   * @param locale the locale to use, not null
+   * @return the display name for the locale or a suitable default, not null
+   */
+  getDisplayName(locale: Locale): string;
+
+  /**
+   * Gets the unit that the field is measured in.
+   *  <p>
+   *  The unit of the field is the period that varies within the range.
+   *  For example, in the field 'MonthOfYear', the unit is 'Months'.
+   *  See also {@link #getRangeUnit()}.
+   * @return the unit defining the base unit of the field, not null
+   */
+  getBaseUnit(): TemporalUnit;
+
+  /**
+   * Gets the range that the field is bound by.
+   *  <p>
+   *  The range of the field is the period that the field varies within.
+   *  For example, in the field 'MonthOfYear', the range is 'Years'.
+   *  See also {@link #getBaseUnit()}.
+   *  <p>
+   *  The range is never null. For example, the 'Year' field is shorthand for
+   *  'YearOfForever'. It therefore has a unit of 'Years' and a range of 'Forever'.
+   * @return the unit defining the range of the field, not null
+   */
+  getRangeUnit(): TemporalUnit;
+
+  /**
+   * Gets the range of valid values for the field.
+   *  <p>
+   *  All fields can be expressed as a {@code long} integer.
+   *  This method returns an object that describes the valid range for that value.
+   *  This method is generally only applicable to the ISO-8601 calendar system.
+   *  <p>
+   *  Note that the result only describes the minimum and maximum valid values
+   *  and it is important not to read too much into them. For example, there
+   *  could be values within the range that are invalid for the field.
+   * @return the range of valid values for the field, not null
+   */
+  range(): ValueRange;
+
+  /**
+   * Checks if this field represents a component of a date.
+   *  <p>
+   *  A field is date-based if it can be derived from
+   *  {@link ChronoField#EPOCH_DAY EPOCH_DAY}.
+   *  Note that it is valid for both {@code isDateBased()} and {@code isTimeBased()}
+   *  to return false, such as when representing a field like minute-of-week.
+   * @return true if this field is a component of a date
+   */
+  isDateBased(): boolean;
+
+  /**
+   * Checks if this field represents a component of a time.
+   *  <p>
+   *  A field is time-based if it can be derived from
+   *  {@link ChronoField#NANO_OF_DAY NANO_OF_DAY}.
+   *  Note that it is valid for both {@code isDateBased()} and {@code isTimeBased()}
+   *  to return false, such as when representing a field like minute-of-week.
+   * @return true if this field is a component of a time
+   */
+  isTimeBased(): boolean;
+
+  /**
+   * Checks if this field is supported by the temporal object.
+   *  <p>
+   *  This determines whether the temporal accessor supports this field.
+   *  If this returns false, then the temporal cannot be queried for this field.
+   *  <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#isSupported(TemporalField)}:
+   *  <pre>
+   *    // these two lines are equivalent, but the second approach is recommended
+   *    temporal = thisField.isSupportedBy(temporal);
+   *    temporal = temporal.isSupported(thisField);
+   *  </pre>
+   *  It is recommended to use the second approach, {@code isSupported(TemporalField)},
+   *  as it is a lot clearer to read in code.
+   *  <p>
+   *  Implementations should determine whether they are supported using the fields
+   *  available in {@link ChronoField}.
+   * @param temporal the temporal object to query, not null
+   * @return true if the date-time can be queried for this field, false if not
+   */
+  isSupportedBy(temporal: TemporalAccessor): boolean;
+
+  /**
+   * Get the range of valid values for this field using the temporal object to
+   *  refine the result.
+   *  <p>
+   *  This uses the temporal object to find the range of valid values for the field.
+   *  This is similar to {@link #range()}, however this method refines the result
+   *  using the temporal. For example, if the field is {@code DAY_OF_MONTH} the
+   *  {@code range} method is not accurate as there are four possible month lengths,
+   *  28, 29, 30 and 31 days. Using this method with a date allows the range to be
+   *  accurate, returning just one of those four options.
+   *  <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#range(TemporalField)}:
+   *  <pre>
+   *    // these two lines are equivalent, but the second approach is recommended
+   *    temporal = thisField.rangeRefinedBy(temporal);
+   *    temporal = temporal.range(thisField);
+   *  </pre>
+   *  It is recommended to use the second approach, {@code range(TemporalField)},
+   *  as it is a lot clearer to read in code.
+   *  <p>
+   *  Implementations should perform any queries or calculations using the fields
+   *  available in {@link ChronoField}.
+   *  If the field is not supported an {@code UnsupportedTemporalTypeException} must be thrown.
+   * @param temporal the temporal object used to refine the result, not null
+   * @return the range of valid values for this field, not null
+   * @throws DateTimeException if the range for the field cannot be obtained
+   * @throws UnsupportedTemporalTypeException if the field is not supported by the temporal
+   */
+  rangeRefinedBy(temporal: TemporalAccessor): ValueRange;
+
+  /**
+   * Gets the value of this field from the specified temporal object.
+   *  <p>
+   *  This queries the temporal object for the value of this field.
+   *  <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#getLong(TemporalField)}
+   *  (or {@link TemporalAccessor#get(TemporalField)}):
+   *  <pre>
+   *    // these two lines are equivalent, but the second approach is recommended
+   *    temporal = thisField.getFrom(temporal);
+   *    temporal = temporal.getLong(thisField);
+   *  </pre>
+   *  It is recommended to use the second approach, {@code getLong(TemporalField)},
+   *  as it is a lot clearer to read in code.
+   *  <p>
+   *  Implementations should perform any queries or calculations using the fields
+   *  available in {@link ChronoField}.
+   *  If the field is not supported an {@code UnsupportedTemporalTypeException} must be thrown.
+   * @param temporal the temporal object to query, not null
+   * @return the value of this field, not null
+   * @throws DateTimeException if a value for the field cannot be obtained
+   * @throws UnsupportedTemporalTypeException if the field is not supported by the temporal
+   * @throws ArithmeticException if numeric overflow occurs
+   */
+  getFrom(temporal: TemporalAccessor): number;
+
+  /**
+   * Returns a copy of the specified temporal object with the value of this field set.
+   *  <p>
+   *  This returns a new temporal object based on the specified one with the value for
+   *  this field changed. For example, on a {@code LocalDate}, this could be used to
+   *  set the year, month or day-of-month.
+   *  The returned object has the same observable type as the specified 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 implementation 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.
+   *  <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#with(TemporalField, long)}:
+   *  <pre>
+   *    // these two lines are equivalent, but the second approach is recommended
+   *    temporal = thisField.adjustInto(temporal);
+   *    temporal = temporal.with(thisField);
+   *  </pre>
+   *  It is recommended to use the second approach, {@code with(TemporalField)},
+   *  as it is a lot clearer to read in code.
+   *  <p>
+   *  Implementations should perform any queries or calculations using the fields
+   *  available in {@link ChronoField}.
+   *  If the field 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 newValue the new value of the field
+   * @return the adjusted temporal object, not null
+   * @throws DateTimeException if the field cannot be set
+   * @throws UnsupportedTemporalTypeException if the field is not supported by the temporal
+   * @throws ArithmeticException if numeric overflow occurs
+   */
+  adjustInto(temporal: unknown, newValue: number): unknown;
+
+  /**
+   * Resolves this field to provide a simpler alternative or a date.
+   *  <p>
+   *  This method is invoked during the resolve phase of parsing.
+   *  It is designed to allow application defined fields to be simplified into
+   *  more standard fields, such as those on {@code ChronoField}, or into a date.
+   *  <p>
+   *  Applications should not normally invoke this method directly.
+   * @implSpec If an implementation represents a field that can be simplified, or&#xA; combined with others, then this method must be implemented.&#xA; <p>&#xA; The specified map contains the current state of the parse.&#xA; The map is mutable and must be mutated to resolve the field and&#xA; any related fields. This method will only be invoked during parsing&#xA; if the map contains this field, and implementations should therefore&#xA; assume this field is present.&#xA; <p>&#xA; Resolving a field will consist of looking at the value of this field,&#xA; and potentially other fields, and either updating the map with a&#xA; simpler value, such as a {@code ChronoField}, or returning a&#xA; complete {@code ChronoLocalDate}. If a resolve is successful,&#xA; the code must remove all the fields that were resolved from the map,&#xA; including this field.&#xA; <p>&#xA; For example, the {@code IsoFields} class contains the quarter-of-year&#xA; and day-of-quarter fields. The implementation of this method in that class&#xA; resolves the two fields plus the {@link ChronoField#YEAR YEAR} into a&#xA; complete {@code LocalDate}. The resolve method will remove all three&#xA; fields from the map before returning the {@code LocalDate}.&#xA; <p>&#xA; A partially complete temporal is used to allow the chronology and zone&#xA; to be queried. In general, only the chronology will be needed.&#xA; Querying items other than the zone or chronology is undefined and&#xA; must not be relied on.&#xA; The behavior of other methods such as {@code get}, {@code getLong},&#xA; {@code range} and {@code isSupported} is unpredictable and the results undefined.&#xA; <p>&#xA; If resolution should be possible, but the data is invalid, the resolver&#xA; style should be used to determine an appropriate level of leniency, which&#xA; may require throwing a {@code DateTimeException} or {@code ArithmeticException}.&#xA; If no resolution is possible, the resolve method must return null.&#xA; <p>&#xA; When resolving time fields, the map will be altered and null returned.&#xA; When resolving date fields, the date is normally returned from the method,&#xA; with the map altered to remove the resolved fields. However, it would also&#xA; be acceptable for the date fields to be resolved into other {@code ChronoField}&#xA; instances that can produce a date, such as {@code EPOCH_DAY}.&#xA; <p>&#xA; Not all {@code TemporalAccessor} implementations are accepted as return values.&#xA; Implementations that call this method must accept {@code ChronoLocalDate},&#xA; {@code ChronoLocalDateTime}, {@code ChronoZonedDateTime} and {@code LocalTime}.&#xA; <p>&#xA; The default implementation must return null.
+   * @param fieldValues the map of fields to values, which can be updated, not null
+   * @param partialTemporal the partially complete temporal to query for zone and&#xA; chronology; querying for other things is undefined and not recommended, not null
+   * @param resolverStyle the requested type of resolve, not null
+   * @return the resolved temporal object; null if resolving only&#xA; changed the map, or no resolve occurred
+   * @throws ArithmeticException if numeric overflow occurs
+   * @throws DateTimeException if resolving results in an error. This must not be thrown&#xA; by querying a field on the temporal without first checking if it is supported
+   */
+  resolve(
+    fieldValues: Map | {},
+    partialTemporal: TemporalAccessor,
+    resolverStyle: ResolverStyle
+  ): TemporalAccessor;
+
+  /**
+   * Gets a descriptive name for the field.
+   *  <p>
+   *  The should be of the format 'BaseOfRange', such as 'MonthOfYear',
+   *  unless the field has a range of {@code FOREVER}, when only
+   *  the base unit is mentioned, such as 'Year' or 'Era'.
+   * @return the name of the field, not null
+   */
+  toString(): string;
+};

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

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getDisplayName: function getDisplayName() {},
+  getBaseUnit: function getBaseUnit() {},
+  getRangeUnit: function getRangeUnit() {},
+  range: function range() {},
+  isDateBased: function isDateBased() {},
+  isTimeBased: function isTimeBased() {},
+  isSupportedBy: function isSupportedBy() {},
+  rangeRefinedBy: function rangeRefinedBy() {},
+  getFrom: function getFrom() {},
+  adjustInto: function adjustInto() {},
+  resolve: function resolve() {},
+  toString: function toString() {}
+};
+exports["default"] = _default;