/**@class java.time.temporal.TemporalAmount
 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 java.time.temporal.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,
 however immutability is strongly recommended.

 @since 1.8
*/
var 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}.
@param {Object {TemporalUnit}} unit the {@code TemporalUnit} for which to return the value
@param unit the {@code TemporalUnit} for which to return the value
@return {Number} 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 : function(  ) {},

/**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
 state of the object without omissions, overlaps or duplication.
 The units are in order from longest duration to shortest.
@return {Object {java.util.List}} the List of {@code TemporalUnits}; not null
*/
getUnits : function(  ) {},

/**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 java.time.temporal.Temporal#plus(java.time.temporal.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.
@param {Object {Temporal}} temporal  the temporal object to add the amount to, not null
@param temporal  the temporal object to add the amount to, not null
@return {Object {java.time.temporal.Temporal}} 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 : function(  ) {},

/**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 java.time.temporal.Temporal#minus(java.time.temporal.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.
@param {Object {Temporal}} temporal  the temporal object to subtract the amount from, not null
@param temporal  the temporal object to subtract the amount from, not null
@return {Object {java.time.temporal.Temporal}} 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 : function(  ) {},


};