Returns the absolute value of a temporal amount:

(abs (negate x)) == (abs x)

True if this interval abut with the other one

Adjusts the temporal `entity` using the provided `adjuster` with optional `args`.

The adjuster should either be a keyword which resolves to one of the
predefined adjusters (see `java-time.repl/show-adjusters`) an instance of
`TemporalAdjuster` or a function which returns another temporal entity when
applied to the given one:

  (adjust (local-date 2015 1 1) :next-working-day)
  => #<LocalDate 2015-1-2>

  (adjust (local-date 2015 1 1) :first-in-month :monday)
  => #<LocalDate 2015-1-5>

  (adjust (local-date 2015 1 1) plus (days 1))
  => #<LocalDate 2015-1-2>

Returns non-nil if time entities are ordered from the earliest to the latest
(same semantics as `>`):

  (after? (local-date 2011) (local-date 2010) (local-date 2009))
  => truthy...

  (after? (instant 99999999)
          (interval (instant 10000) (instant 1000000)))
  => truthy...

Returns the `AmPm` for the given keyword name (`:am` or `:pm`),
ordinal or entity. Current AM/PM if no arguments given.

Values of property/unit identified by keys/objects `ks` of the temporal
entity `o`, e.g.

  (as (duration 1 :hour) :minutes)
  => 60

  (as (local-date 2015 9) :year :month-of-year)
  => [2015 9]

Converts a time entity to a map of property key -> value as defined by the
passed in `value-fn`. By default the actual value of the unit/field is
produced.

  (as-map (duration))
  => {:nanos 0, :seconds 0}

  (as-map (local-date 2015 1 1))
  => {:year 2015, :month-of-year 1, :day-of-month 1, ...}

Returns non-nil if time entities are ordered from the earliest to the latest
(same semantics as `<`):

  (before? (local-date 2009) (local-date 2010) (local-date 2011))
  => truthy...

  (before? (interval (instant 10000) (instant 1000000))
           (instant 99999999))
  => truthy...

The `Chronology` of the entity

True if the interval contains the given instant or interval

Converts an amount from one unit to another. Returns a map of:
  * `:whole` - the whole part of the conversion in the `to` unit
  * `:remainder` - the remainder in the `from` unit

Arguments may be keywords or instances of `TemporalUnit`.

Converts between precise units - nanos up to weeks, treating days as exact
multiples of 24 hours. Also converts between imprecise units - months up to
millenia. See `ChronoUnit` and `IsoFields` for all of the supported units.
Does not convert between precise and imprecise units.

Throws `ArithmeticException` if long overflow occurs during computation.

  (convert-amount 10000 :seconds :hours)
  => {:remainder 2800 :whole 2}

Returns the `DayOfMonth` for the given entity, clock, zone or day of month.
Current day of month if no arguments given.

Returns the `DayOfWeek` for the given day keyword name (e.g. `:monday`),
ordinal or entity. Current day if no arguments given.

Returns the `DayOfYear` for the given entity, clock, zone or day of year.
Current day of year if no arguments given.

Creates a duration - a temporal entity representing standard days, hours,
minutes, millis, micros and nanos. The duration itself contains only seconds
and nanos as properties.

Given one argument will
  * interpret as millis if a number
  * try to parse from the standard format if a string
  * extract supported units from another `TemporalAmount`
  * convert from a Joda Period/Duration

Given two arguments will
  * get a duration between two `Temporal`s
  * get a duration of a specified unit, e.g. `(duration 100 :seconds)`

True if an instance of Duration.

Gets the end instant of the interval

Returns a `TemporalField` for the given key `k` or extracts the field from
the given temporal `entity`.

You can see predefined fields via `java-time.repl/show-fields`.

If you want to make your own custom TemporalFields resolvable, you need to rebind the
`java-time.properties/*fields*` to a custom `java-time.properties.FieldGroup`.

True if this is a `TemporalField`.

Fields present in this temporal entity

Creates a fixed clock either at the current instant or at the supplied
instant/instant + zone.

Formats the given time entity as a string.

Accepts something that can be converted to a `DateTimeFormatter` as a first
argument. Given one argument uses the default format.

Constructs a DateTimeFormatter out of a

* format string - "YYYY/mm/DD", "YYY HH:MM", etc.
* formatter name - :iso-date, :iso-time, etc.
   - More examples can be found here

Accepts a map of options as an optional second argument:

* `resolver-style` - either `:strict`, `:smart `or `:lenient`

Returns true if the given time entity with the
`day-of-week` property falls on a friday.

Gets the gap between this interval and the other one or `nil`

Duration of a specified number of hours.

Creates an `Instant`. The following arguments are supported:

* no arguments - current instant
* one argument
  + clock
  + java.util.Date/Calendar
  + another temporal entity
  + string representation
  + millis from epoch
* two arguments
  + formatter (format) and a string

True if an instance of Instant.

Constructs an interval out of a string, start and end instants or a start
+ duration:

(j/interval "2010-01-01T00:00:00Z/2013-01-01T00:00:00Z")
=> #<Interval 2010-01-01T00:00:00Z/2013-01-01T00:00:00Z>

(j/interval (j/instant 100000) (j/instant 1000000))
=> #<Interval 1970-01-01T00:01:40Z/1970-01-01T00:16:40Z>

(j/interval (j/instant 100000) (j/duration 15 :minutes))
=> #<Interval 1970-01-01T00:01:40Z/1970-01-01T00:16:40Z>

True if `Interval`

Returns a lazy sequence of `initial` , `(apply f initial v vs)`, etc.

Useful when you want to produce a sequence of temporal entities, for
example:

  (iterate plus (days 0) 1)
  => (#<Period P0D> #<Period P1D> #<Period P2D> ...)

  (iterate plus (local-date 2010 1 1) (years 1))
  => (#<LocalDate 2010-01-01> #<LocalDate 2011-01-01> ...)

  (iterate adjust (local-date 2010 1 1) :next-working-day)
  => (#<LocalDate 2010-01-01> #<LocalDate 2010-01-04> ...)

Creates a `java.util.Date` out of any combination of arguments valid for
`java-time/instant` or the Instant itself.

A `java.util.Date` represents an instant in time. It's a direct analog of the
`java.time.Instant` type introduced in the JSR-310. Please consider using the
`java.time.Instant` (through `java-time/instant`) directly.

Largest minimum value of this property

True if the year of this entity is a leap year.

Creates a `LocalDate`. The following arguments are supported:

* no arguments - current local-date
* one argument
  + clock
  + another temporal entity
  + string representation
  + year
* two arguments
  + formatter (format) and a string
  + an instant and a zone id
  + another temporal entity and an offset (preserves local time)
  + year and month
* three arguments
  + year, month and date

Creates a `LocalDateTime`. The following arguments are supported:

* no arguments - current local date-time
* one argument
  + clock
  + another temporal entity
  + string representation
  + year
* two arguments
  + local date and local time
  + an instant and a zone id
  + formatter (format) and a string
  + year and month

three and more arguments - year/month/day/...

True if an instance of LocalDateTime.

True if an instance of LocalDate.

Creates a `LocalTime`. The following arguments are supported:

* no arguments - current local time
* one argument
  + clock
  + another temporal entity
  + string representation
  + hours
* two arguments
  + formatter (format) and a string
  + an instant and a zone id
  + hours and minutes
* three/four arguments - hour, minute, second, nanos

True if an instance of LocalTime.

Latest/longest of the given time entities. Entities should be of the same
type

Maximum value of this property, e.g. 29th of February for months

Duration of a specified number of microseconds.

Duration of a specified number of millis.

Earliest/shortest of the given time entities. Entities should be of the same
type

Minimum value of this property

Subtracts all of the `os` from the time entity `o`

(j/minus (j/local-date 2015) (j/years 1))
=> <java.time.LocalDate "2014-01-01">

Duration of a specified number of minutes.

Returns true if the given time entity with the
`day-of-week` property falls on a monday.

Returns the `Month` for the given month keyword name (e.g. `:january`),
ordinal or entity. Current month if no arguments given.

Returns the `MonthDay` for the given entity, string, clock, zone or
month/day combination. Current month-day if no arguments given.

Moves the end instant of the interval by the sum of given
periods/durations/numbers of milliseconds.

  (move-start-by (interval 0 10000) (millis 1000) (seconds 1))
  => #<Interval ...:00Z/...:12Z>

Fails if the new end instant falls before the start instant.

  (move-end-by (interval 0 10000) (millis -11000))
  => DateTimeException...

Moves the end of the interval to the given instant (or something
 convertible to an instant):

 (move-end-to (interval 0 10000) (instant 15000))
 => #<Interval ...:00Z/...:15Z>

Fails if the new end instant falls before the start instant:

 (move-end-to (interval 0 10000) (millis -1))
 => DateTimeException...

Moves the start instant of the interval by the sum of given
periods/durations/numbers of milliseconds:

  (move-start-by (interval 0 10000) (millis 1000) (seconds 1))
  => #<Interval ...:02Z/...:10Z>

Fails if the new start instant falls after the end instant.

  (move-start-by (interval 0 10000) (millis 11000))
  ; => DateTimeException...

Moves the start instant of the interval to the given instant (or something
 convertible to an instant):

 (move-start-to (interval 0 10000) (instant 5000))
 => #<Interval ...:05Z/...:10Z>

Fails if the new start instant falls after the end instant:

 (move-start-to (interval 0 10000) (millis 15000))
 => DateTimeException...

Entity `o` mutlitplied by the value `v`

Duration of a specified number of nanos.

Negates a temporal amount:

(negate (negate x)) == x

True if the amount is negative

Creates a clock offset from the current/provided clock by a given
`duration`.

Creates an `OffsetDateTime`. The following arguments are supported:

  * no arguments - current date-time with the default offset
  * one argument
    + clock
    + another temporal entity
    + string representation
    + year
  * two arguments
    + formatter (format) and a string
    + local date-time and an offset
    + another temporal entity and an offset (preserves local time)
    + year and month
  * three arguments
    + local date, local time and an offset
    + year, month and date
  * four up to seven arguments - position date-time constructors
  * eight arguments - time fields up to nanoseconds and a zone offset

If zone offset is not specified, default will be used. You can check the
default offset by invoking `(zone-offset)`.

True if an instance of OffsetDateTime.

Creates an `OffsetTime`. The following arguments are supported:

  * no arguments - current time with the default offset
  * one argument
    + clock
    + zone id
    + another temporal entity
    + string representation
    + hour
  * two arguments
    + formatter (format) and a string
    + local time and an offset
    + instant and an offset
    + hour and minutes
  * three arguments - hours, minutes, seconds
  * four arguments - hours, minutes, seconds, nanos
  * five arguments - last is the offset

If zone offset is not specified, default will be used. You can check the
default offset by invoking `(zone-offset)`.

True if an instance of OffsetTime.

Gets the overlap between this interval and the other one or `nil`

True if this interval overlaps the other one

Creates a period - a temporal entity consisting of years, months and days.

Given one argument will
  * interpret as years if a number
  * try to parse from the standard format if a string
  * extract supported units from another `TemporalAmount`
  * convert from a Joda Period

Given two arguments will
  * get a period of a specified unit, e.g. `(period 10 :months)`
  * get a period between two temporals by converting them to local dates
  * get a period of a specified number of years and months

Given three arguments will create a year/month/day period.

True if an instance of Period.

Adds all of the `os` to the time entity `o`

(j/plus (j/local-date 2015) (j/years 1))
=> <java.time.LocalDate "2016-01-01">

Map of properties present in this temporal entity

Property of this temporal entity under key `k`

Returns the `Quarter` for the given quarter keyword name (e.g. `:q1`),
ordinal or entity. Current quarter if no arguments given.

Range of values for this property

Returns true if the given time entity with the
`day-of-week` property falls on a saturday.

Duration of a specified number of seconds.

Smallest maximum value of this property, e.g. 28th of February for months

Creates a `java.sql.Date` out of any combination of arguments valid for
`java-time/local-date` or the LocalDate itself.

Please consider using the JSR-310 Java Time types instead of `java.sql.Date`
if your drivers support them.

Even though `java.sql.Date` extends a `java.util.Date`, it's supposed to be
used as a local date (no time component or timezone) for the purposes of
conversion from/to native JDBC driver DATE types.

Creates a `java.sql.Time` out of any combination of arguments valid for
`java-time/local-time` (except the nanos constructor) or the LocalTime
itself.

Please consider using the JSR-310 Java Time types instead of `java.sql.Time`
if your drivers support them.

Even though `java.sql.Time` extends a `java.util.Date`, it's supposed to be
used as a local time (no date component or timezone) for the purposes of
conversion from/to native JDBC driver TIME types.

Creates a `java.sql.Timestamp` out of any combination of arguments valid for
`java-time/local-date-time` or the LocalDateTime itself.

Please consider using the JSR-310 Java Time types instead of
`java.sql.Timestamp` if your drivers support them.

`java.sql.Timestamp` is a version of a `java.util.Date` supposed to be used
as a local date-time (no timezone) for the purposes of conversion from/to native
JDBC driver TIMESTAMP types.

Duration of a specified number of days.

Gets the start instant of the interval

Returns true if the given time entity with the
`day-of-week` property falls on a sunday.

True if the `o` entity supports the `p` property

Creates a system clock. In the default timezone if called without arguments,
otherwise accepts a Zone Id.

Returns true if the given time entity with the
`day-of-week` property falls on a thursday.

Creates a clock wrapping system/provided clock that only ticks as per
specified duration.

Time between temporal entities `o` and `e` in unit `u`.

(j/time-between (j/local-date 2015) (j/local-date 2016) :days)
=> 365

(j/time-between :days (j/local-date 2015) (j/local-date 2016))
=> 365

Converts a date entity to a `java.util.Date`.

*Deprecated*:
This function only has a single arity and works for entities directly
convertible to `java.time.Instant`. Please consider using `java-date`
instead.

Converts a date entity to a `long` representing the number of milliseconds
from epoch.

Converts a local date entity to a `java.sql.Date`.

*Deprecated*:
This function only has a single arity and works for entities directly
convertible to `java.time.LocalDate`. Please consider using `sql-date`
instead.

Converts a date entity to a `java.sql.Timestamp`.

*Deprecated*:
This function only has a single arity and works for entities directly
convertible to `java.time.Instant`. Please consider using `sql-timestamp`
instead.

Truncates this entity to the specified time unit. Only works for units that
divide into the length of standard day without remainder (up to `:days`).

Returns true if the given time entity with the
`day-of-week` property falls on a tuesday.

Returns a `TemporalUnit` for the given key `k` or extracts the field from
the given temporal `entity`.

You can see predefined units via `java-time.repl/show-units`.

If you want to make your own custom TemporalUnits resolvable, you need to rebind the
`java-time.properties/*units*` to a custom `java-time.properties.UnitGroup`.

True if this is a `TemporalUnit`.

Units present in this temporal entity.

Value of the property

Creates a `ValueRange` given the `min` and `max` amounts or a map of
`:min-smallest`, `:max-smallest`, `:min-largest` and `:max-largest`.

Returns true if the given time entity with the
`day-of-week` property falls on a wednesday.

Executes the given `forms` in the scope of the provided `clock`.

All the temporal entities that get created without parameters will inherit
their values from the clock:

  (with-clock (system-clock "Europe/London")
    (zone-id))
  => #<java.time.ZoneRegion Europe/London>

Executes the given function in the scope of the provided clock. All the
temporal entities that get created without parameters will inherit their
values from the clock.

Underlying temporal entity with the value set to the largest minimum
available for this property

Underlying temporal entity with the value set to the maximum
available for this property

Underlying temporal entity with the value set to the minimum available for
this property

Sets the offset to the specified value ensuring that the local time stays
the same.

  (offset-time 10 30 0 0 +2)
  => #<java.time.OffsetTime 10:30+02:00>
  (with-offset *1 +3)
  => #<java.time.OffsetTime 10:30+03:00>

Sets the offset to the specified value ensuring that the result has the same instant, e.g.:

(offset-time 10 30 0 0 +2)
=> #<java.time.OffsetTime 10:30+02:00>
(with-offset-same-instant *1 +3)
=> #<java.time.OffsetTime 11:30+03:00>

Underlying temporal entity with the value set to the smallest maximum
available for this property

Underlying temporal entity with the value of this property set to `v`

Returns this temporal entity with the specified `ZoneId`

Sets the zone to the specified value ensuring that the result has the same instant, e.g.:

(zoned-date-time 2015)
=> #<java.time.ZonedDateTime 2015-01-01T00:00+00:00[Europe/London]>
(with-zone-same-instant *1 "America/New_York")
=> #<java.time.ZonedDateTime 2014-12-31T18:00-05:00[America/New_York]>

Returns the `Year` for the given entity, string, clock, zone or number.
Current year if no arguments given.

Returns the `YearMonth` for the given entity, string, clock, zone or
month/day combination. Current year-month if no arguments given.

Returns the `YearQuarter` for the given entity, clock, zone or year with quarter.
Current year quarter if no arguments given.

True if the amount is zero

Creates a `ZoneId` from a string identifier, `java.util.TimeZone` or extracts
from another temporal entity.

Returns default system zone id if no arguments provided.

Given two arguments will use the second as the offset.

Creates a `ZoneOffset` from a string identifier (e.g. "+01"), a number of
hours/hours and minutes/hours, minutes and seconds or extracts from another
temporal entity.

Returns default system zone offset if no arguments provided.

Creates a `ZonedDateTime`. The following arguments are supported:

  * no arguments - current date-time in the default zone
  * one argument
    + clock
    + zone id
    + another temporal entity
    + string representation
    + year
  * two arguments
    + formatter and a string
    + local date-time and a zone id
    + year and month
  * three arguments
    + local date, local time and a zone id
    + year, month and day
  * four to seven arguments - date-time fields
  * eight arguments - last is the zone id

If zone id is not specified, default zone id will be used. You can check the
default zone by invoking `(zone-id)`.

True if an instance of ZonedDateTime.