Instant.bal

import ballerina/jballerina.java;

# Ballerina class mapping for the Java `java.time.Instant` class.
@java:Binding {'class: "java.time.Instant"}
public distinct class Instant {

    *java:JObject;
    *Object;

    # The `handle` field that stores the reference to the `java.time.Instant` object.
    public handle jObj;

    # The init function of the Ballerina class mapping the `java.time.Instant` Java class.
    #
    # + obj - The `handle` value containing the Java reference of the object.
    public function init(handle obj) {
        self.jObj = obj;
    }

    # Returns the string representation of this instant, in ISO-8601 format such as "2026-07-27T11:30:00Z".
    #
    # + return - The `string` form of the Java object instance.
    public function toString() returns string {
        return java:toString(self.jObj) ?: "";
    }

    # Adjusts the specified temporal object to have the same instant as this object.
    #
    # + temporal - The target temporal object to adjust, not null
    # + return - The adjusted temporal object, not null
    public function adjustInto(Temporal temporal) returns Temporal {
        handle externalObj = java_time_Instant_adjustInto(self.jObj, temporal.jObj);
        Temporal newObj = new (externalObj);
        return newObj;
    }

    # Combines this instant with an offset to create an OffsetDateTime.
    #
    # + offset - The offset to combine with, not null
    # + return - The offset date-time formed from this instant and the specified offset, not null
    public function atOffset(ZoneOffset offset) returns OffsetDateTime {
        handle externalObj = java_time_Instant_atOffset(self.jObj, offset.jObj);
        OffsetDateTime newObj = new (externalObj);
        return newObj;
    }

    # Combines this instant with a time-zone to create a ZonedDateTime.
    #
    # + zone - The zone to combine with, not null
    # + return - The zoned date-time formed from this instant and the specified zone, not null
    public function atZone(ZoneId zone) returns ZonedDateTime {
        handle externalObj = java_time_Instant_atZone(self.jObj, zone.jObj);
        ZonedDateTime newObj = new (externalObj);
        return newObj;
    }

    # Compares this instant to another instant on the time-line.
    #
    # + other - The other instant to compare to, not null
    # + return - A negative number if this instant is earlier, positive if later, zero if equal
    public function compareTo(Instant other) returns int {
        return java_time_Instant_compareTo(self.jObj, other.jObj);
    }

    # Checks whether this instant is equal to another object.
    #
    # + other - The object to compare with, may be `()`
    # + return - `true` if this instant is equal to the specified object
    public function isEquals(Object other) returns boolean {
        return java_time_Instant_equals(self.jObj, other.jObj);
    }

    # Gets the value of the specified field from this instant as an int.
    #
    # + fieldToGet - The field to query, not null
    # + return - The value of the field
    public function get(TemporalField fieldToGet) returns int {
        return java_time_Instant_get(self.jObj, fieldToGet.jObj);
    }

    # Gets the runtime class of this `Instant` object.
    #
    # + return - The `Class` object representing the runtime class, not null
    public function getClass() returns Class {
        handle externalObj = java_time_Instant_getClass(self.jObj);
        Class newObj = new (externalObj);
        return newObj;
    }

    # Gets the number of seconds from the epoch of 1970-01-01T00:00:00Z.
    #
    # + return - The seconds from the epoch, may be negative for instants before the epoch
    public function getEpochSecond() returns int {
        return java_time_Instant_getEpochSecond(self.jObj);
    }

    # Gets the value of the specified field from this instant as a long.
    #
    # + fieldToGet - The field to query, not null
    # + return - The value of the field
    function getLong(TemporalField fieldToGet) returns int {
        return java_time_Instant_getLong(self.jObj, fieldToGet.jObj);
    }

    # Gets the number of nanoseconds, later along the time-line, from the start of the second.
    #
    # + return - The nano-of-second, from 0 to 999,999,999
    public function getNano() returns int {
        return java_time_Instant_getNano(self.jObj);
    }

    # Returns a hash code value for this instant.
    #
    # + return - A suitable hash code
    public function hashCode() returns int {
        return java_time_Instant_hashCode(self.jObj);
    }

    # Checks whether this instant is after the specified instant.
    #
    # + other - The other instant to compare to, not null
    # + return - `true` if this instant is after the specified instant
    public function isAfter(Instant other) returns boolean {
        return java_time_Instant_isAfter(self.jObj, other.jObj);
    }

    # Checks whether this instant is before the specified instant.
    #
    # + other - The other instant to compare to, not null
    # + return - `true` if this instant is before the specified instant
    public function isBefore(Instant other) returns boolean {
        return java_time_Instant_isBefore(self.jObj, other.jObj);
    }

    # Checks whether the specified field is supported by this instant.
    #
    # + fieldToCheck - The field to check, may be `()`
    # + return - `true` if the field is supported on this instant
    function isSupported(TemporalField fieldToCheck) returns boolean {
        return java_time_Instant_isSupported(self.jObj, fieldToCheck.jObj);
    }

    # Checks whether the specified unit is supported for addition/subtraction on this instant.
    #
    # + unitToCheck - The unit to check, may be `()`
    # + return - `true` if the unit can be added to or subtracted from this instant
    function isSupportedUnit(TemporalUnit unitToCheck) returns boolean {
        return java_time_Instant_isSupported2(self.jObj, unitToCheck.jObj);
    }

    # Returns a copy of this instant with the specified amount subtracted, measured in the given unit.
    #
    # + amountToSubtract - The amount of the unit to subtract, may be negative
    # + unit - The unit of the amount to subtract, not null
    # + return - A copy of this instant with the specified amount subtracted, not null
    function minus(int amountToSubtract, TemporalUnit unit) returns Instant {
        handle externalObj = java_time_Instant_minus(self.jObj, amountToSubtract, unit.jObj);
        Instant newObj = new (externalObj);
        return newObj;
    }

    # Returns a copy of this `Instant` with the specified amount subtracted.
    #
    # + amount - The amount to subtract, either a `Duration` or a `Period`. 
    # Note: a `Period` with years or months is not supported by 
    # `Instant` and will return an error, not null
    # + return - A copy of this `Instant` with the amount subtracted, or an error
    public function minusAmount(Duration|Period amount) returns Instant|error {
        handle externalObj = check java_time_Instant_minus2(self.jObj, amount.jObj);
        Instant newObj = new (externalObj);
        return newObj;
    }

    # Returns a copy of this instant with the specified number of milliseconds subtracted.
    #
    # + millisToSubtract - The milliseconds to subtract, may be negative
    # + return - A copy of this instant with the specified milliseconds subtracted, not null
    public function minusMillis(int millisToSubtract) returns Instant {
        handle externalObj = java_time_Instant_minusMillis(self.jObj, millisToSubtract);
        Instant newObj = new (externalObj);
        return newObj;
    }

    # Returns a copy of this instant with the specified number of nanoseconds subtracted.
    #
    # + nanosToSubtract - The nanoseconds to subtract, may be negative
    # + return - A copy of this instant with the specified nanoseconds subtracted, not null
    public function minusNanos(int nanosToSubtract) returns Instant {
        handle externalObj = java_time_Instant_minusNanos(self.jObj, nanosToSubtract);
        Instant newObj = new (externalObj);
        return newObj;
    }

    # Returns a copy of this instant with the specified number of seconds subtracted.
    #
    # + secondsToSubtract - The seconds to subtract, may be negative
    # + return - A copy of this instant with the specified seconds subtracted, not null
    public function minusSeconds(int secondsToSubtract) returns Instant {
        handle externalObj = java_time_Instant_minusSeconds(self.jObj, secondsToSubtract);
        Instant newObj = new (externalObj);
        return newObj;
    }

    # Wakes up a single thread that is waiting on this object's monitor.
    public function notify() {
        java_time_Instant_notify(self.jObj);
    }

    # Wakes up all threads that are waiting on this object's monitor.
    public function notifyAll() {
        java_time_Instant_notifyAll(self.jObj);
    }

    # Returns a copy of this instant with the specified amount added, measured in the given unit.
    #
    # + amountToAdd - The amount of the unit to add, may be negative
    # + unit - The unit of the amount to add, not null
    # + return - A copy of this instant with the specified amount added, not null
    function plus(int amountToAdd, TemporalUnit unit) returns Instant {
        handle externalObj = java_time_Instant_plus(self.jObj, amountToAdd, unit.jObj);
        Instant newObj = new (externalObj);
        return newObj;
    }

    # Returns a copy of this `Instant` with the specified amount added.
    #
    # + amount - The amount to add, either a `Duration` or a `Period`. 
    # Note: a `Period` with years or months is not supported by 
    # `Instant` and will return an error, not null
    # + return - A copy of this `Instant` with the amount added, or an error
    public function plusAmount(Duration|Period amount) returns Instant|error {
        handle externalObj = check java_time_Instant_plus2(self.jObj, amount.jObj);
        Instant newObj = new (externalObj);
        return newObj;
    }

    # Returns a copy of this instant with the specified number of milliseconds added.
    #
    # + millisToAdd - The milliseconds to add, may be negative
    # + return - A copy of this instant with the specified milliseconds added, not null
    public function plusMillis(int millisToAdd) returns Instant {
        handle externalObj = java_time_Instant_plusMillis(self.jObj, millisToAdd);
        Instant newObj = new (externalObj);
        return newObj;
    }

    # Returns a copy of this instant with the specified number of nanoseconds added.
    #
    # + nanosToAdd - The nanoseconds to add, may be negative
    # + return - A copy of this instant with the specified nanoseconds added, not null
    public function plusNanos(int nanosToAdd) returns Instant {
        handle externalObj = java_time_Instant_plusNanos(self.jObj, nanosToAdd);
        Instant newObj = new (externalObj);
        return newObj;
    }

    # Returns a copy of this instant with the specified number of seconds added.
    #
    # + secondsToAdd - The seconds to add, may be negative
    # + return - A copy of this instant with the specified seconds added, not null
    public function plusSeconds(int secondsToAdd) returns Instant {
        handle externalObj = java_time_Instant_plusSeconds(self.jObj, secondsToAdd);
        Instant newObj = new (externalObj);
        return newObj;
    }

    # Queries this instant using the specified query.
    #
    # + temporalQuery - The query to invoke, not null
    # + return - The query result, may be `()`
    function query(TemporalQuery temporalQuery) returns Object {
        handle externalObj = java_time_Instant_query(self.jObj, temporalQuery.jObj);
        Object newObj = new (externalObj);
        return newObj;
    }

    # Gets the valid range of values for the specified field.
    #
    # + fieldToQuery - The field to query the range for, not null
    # + return - The valid range of values for the field, not null
    function range(TemporalField fieldToQuery) returns ValueRange {
        handle externalObj = java_time_Instant_range(self.jObj, fieldToQuery.jObj);
        ValueRange newObj = new (externalObj);
        return newObj;
    }

    # Converts this instant to the number of milliseconds from the epoch of 1970-01-01T00:00:00Z.
    #
    # + return - The number of milliseconds since the epoch
    public function toEpochMilli() returns int {
        return java_time_Instant_toEpochMilli(self.jObj);
    }

    # Returns a copy of this instant truncated to the specified unit, such as truncating to the
    # nearest second or minute (discarding finer-grained precision).
    #
    # + unit - The unit to truncate to, not null
    # + return - A copy of this instant truncated to the specified unit, not null
    function truncatedTo(TemporalUnit unit) returns Instant {
        handle externalObj = java_time_Instant_truncatedTo(self.jObj, unit.jObj);
        Instant newObj = new (externalObj);
        return newObj;
    }

    # Calculates the amount of time until another instant in terms of the specified unit.
    #
    # + endExclusive - The end temporal, which is converted to an Instant, not null
    # + unit - The unit to measure the amount in, not null
    # + return - The amount of time between this instant and the end instant
    function until(Temporal endExclusive, TemporalUnit unit) returns int {
        return java_time_Instant_until(self.jObj, endExclusive.jObj, unit.jObj);
    }

    # Causes the current thread to wait until it is woken up on this object's monitor, typically via
    # a call to notify() or notifyAll().
    #
    # + return - An `InterruptedException` if the waiting thread is interrupted, otherwise `()`
    public function doWait() returns InterruptedException? {
        error|() externalObj = java_time_Instant_wait(self.jObj);
        if (externalObj is error) {
            InterruptedException e = error InterruptedException(INTERRUPTEDEXCEPTION, externalObj, message = externalObj.message());
            return e;
        }
    }

    # Causes the current thread to wait until either it is woken up or the specified timeout elapses.
    #
    # + timeoutMillis - The maximum time to wait, in milliseconds
    # + return - An `InterruptedException` if the waiting thread is interrupted, otherwise `()`
    public function waitWithTimeout(int timeoutMillis) returns InterruptedException? {
        error|() externalObj = java_time_Instant_wait2(self.jObj, timeoutMillis);
        if (externalObj is error) {
            InterruptedException e = error InterruptedException(INTERRUPTEDEXCEPTION, externalObj, message = externalObj.message());
            return e;
        }
    }

    # Causes the current thread to wait until either it is woken up or the specified timeout elapses,
    # with additional nanosecond precision.
    #
    # + timeoutMillis - The maximum time to wait, in milliseconds
    # + additionalNanos - The additional time to wait, in nanoseconds, from 0 to 999999
    # + return - An `InterruptedException` if the waiting thread is interrupted, otherwise `()`
    public function waitWithTimeoutAndNanos(int timeoutMillis, int additionalNanos) returns InterruptedException? {
        error|() externalObj = java_time_Instant_wait3(self.jObj, timeoutMillis, additionalNanos);
        if (externalObj is error) {
            InterruptedException e = error InterruptedException(INTERRUPTEDEXCEPTION, externalObj, message = externalObj.message());
            return e;
        }
    }

    # Returns a copy of this instant with the specified adjuster performed.
    #
    # + adjuster - The adjuster to use, not null
    # + return - A copy of this instant with the adjustment made, not null
    function 'with(TemporalAdjuster adjuster) returns Instant {
        handle externalObj = java_time_Instant_with(self.jObj, adjuster.jObj);
        Instant newObj = new (externalObj);
        return newObj;
    }

    # Returns a copy of this instant with the specified field set to a new value.
    #
    # + fieldToSet - The field to set in the result, not null
    # + newValue - The new value of the field in the result
    # + return - A copy of this instant with the specified field set, not null
    function withField(TemporalField fieldToSet, int newValue) returns Instant {
        handle externalObj = java_time_Instant_with2(self.jObj, fieldToSet.jObj, newValue);
        Instant newObj = new (externalObj);
        return newObj;
    }

}

# Obtains an instance of Instant from a temporal object.
#
# + temporalAccessor - The temporal object to convert, not null
# + return - The instant, not null
function instantFrom(TemporalAccessor temporalAccessor) returns Instant {
    handle externalObj = java_time_Instant_from(temporalAccessor.jObj);
    Instant newObj = new (externalObj);
    return newObj;
}

# Obtains the current instant from the system clock.
#
# + return - The current instant using the system clock, not null
public function instantNow() returns Instant {
    handle externalObj = java_time_Instant_now();
    Instant newObj = new (externalObj);
    return newObj;
}

# Obtains an instance of Instant using milliseconds from the epoch of 1970-01-01T00:00:00Z.
#
# + epochMilli - The number of milliseconds from 1970-01-01T00:00:00Z
# + return - The instant, not null
public function instantOfEpochMilli(int epochMilli) returns Instant {
    handle externalObj = java_time_Instant_ofEpochMilli(epochMilli);
    Instant newObj = new (externalObj);
    return newObj;
}

# Obtains an instance of Instant using seconds from the epoch of 1970-01-01T00:00:00Z.
#
# + epochSecond - The number of seconds from 1970-01-01T00:00:00Z
# + return - The instant, not null
public function instantOfEpochSecond(int epochSecond) returns Instant {
    handle externalObj = java_time_Instant_ofEpochSecond(epochSecond);
    Instant newObj = new (externalObj);
    return newObj;
}

# Obtains an instance of Instant using seconds from the epoch, with an additional nanosecond
# adjustment that may exceed the range 0-999,999,999 and will be normalized accordingly.
#
# + epochSecond - The number of seconds from 1970-01-01T00:00:00Z
# + nanoAdjustment - The nanosecond adjustment to the number of seconds, positive or negative
# + return - The instant, not null
public function instantOfEpochSecondWithNanoAdjustment(int epochSecond, int nanoAdjustment) returns Instant|error {
    handle externalObj = check trap java_time_Instant_ofEpochSecond2(epochSecond, nanoAdjustment);
    Instant newObj = new (externalObj);
    return newObj;
}

# Obtains an instance of Instant from a text string such as "2007-12-03T10:15:30.00Z".
#
# + text - The text to parse, not null
# + return - The parsed instant, not null
public function parseInstant(string text) returns Instant|error {
    handle externalObj = check trap java_time_Instant_parse(java:fromString(text));
    Instant newObj = new (externalObj);
    return newObj;
}

# Gets the constant for the epoch of 1970-01-01T00:00:00Z.
#
# + return - The instant constant for the epoch, not null
public function getEpoch() returns Instant {
    handle externalObj = java_time_Instant_getEPOCH();
    Instant newObj = new (externalObj);
    return newObj;
}

# Gets the constant for the earliest supported instant, "-1000000000-01-01T00:00Z".
#
# + return - The minimum supported instant, not null
public function getMin() returns Instant {
    handle externalObj = java_time_Instant_getMIN();
    Instant newObj = new (externalObj);
    return newObj;
}

# Gets the constant for the latest supported instant, "1000000000-12-31T23:59:59.999999999Z".
#
# + return - The maximum supported instant, not null
public function getMax() returns Instant {
    handle externalObj = java_time_Instant_getMAX();
    Instant newObj = new (externalObj);
    return newObj;
}

function java_time_Instant_adjustInto(handle receiver, handle arg0) returns handle = @java:Method {
    name: "adjustInto",
    'class: "java.time.Instant",
    paramTypes: ["java.time.temporal.Temporal"]
} external;

function java_time_Instant_atOffset(handle receiver, handle arg0) returns handle = @java:Method {
    name: "atOffset",
    'class: "java.time.Instant",
    paramTypes: ["java.time.ZoneOffset"]
} external;

function java_time_Instant_atZone(handle receiver, handle arg0) returns handle = @java:Method {
    name: "atZone",
    'class: "java.time.Instant",
    paramTypes: ["java.time.ZoneId"]
} external;

function java_time_Instant_compareTo(handle receiver, handle arg0) returns int = @java:Method {
    name: "compareTo",
    'class: "java.time.Instant",
    paramTypes: ["java.time.Instant"]
} external;

function java_time_Instant_equals(handle receiver, handle arg0) returns boolean = @java:Method {
    name: "equals",
    'class: "java.time.Instant",
    paramTypes: ["java.lang.Object"]
} external;

function java_time_Instant_from(handle arg0) returns handle = @java:Method {
    name: "from",
    'class: "java.time.Instant",
    paramTypes: ["java.time.temporal.TemporalAccessor"]
} external;

function java_time_Instant_get(handle receiver, handle arg0) returns int = @java:Method {
    name: "get",
    'class: "java.time.Instant",
    paramTypes: ["java.time.temporal.TemporalField"]
} external;

function java_time_Instant_getClass(handle receiver) returns handle = @java:Method {
    name: "getClass",
    'class: "java.time.Instant",
    paramTypes: []
} external;

function java_time_Instant_getEpochSecond(handle receiver) returns int = @java:Method {
    name: "getEpochSecond",
    'class: "java.time.Instant",
    paramTypes: []
} external;

function java_time_Instant_getLong(handle receiver, handle arg0) returns int = @java:Method {
    name: "getLong",
    'class: "java.time.Instant",
    paramTypes: ["java.time.temporal.TemporalField"]
} external;

function java_time_Instant_getNano(handle receiver) returns int = @java:Method {
    name: "getNano",
    'class: "java.time.Instant",
    paramTypes: []
} external;

function java_time_Instant_hashCode(handle receiver) returns int = @java:Method {
    name: "hashCode",
    'class: "java.time.Instant",
    paramTypes: []
} external;

function java_time_Instant_isAfter(handle receiver, handle arg0) returns boolean = @java:Method {
    name: "isAfter",
    'class: "java.time.Instant",
    paramTypes: ["java.time.Instant"]
} external;

function java_time_Instant_isBefore(handle receiver, handle arg0) returns boolean = @java:Method {
    name: "isBefore",
    'class: "java.time.Instant",
    paramTypes: ["java.time.Instant"]
} external;

function java_time_Instant_isSupported(handle receiver, handle arg0) returns boolean = @java:Method {
    name: "isSupported",
    'class: "java.time.Instant",
    paramTypes: ["java.time.temporal.TemporalField"]
} external;

function java_time_Instant_isSupported2(handle receiver, handle arg0) returns boolean = @java:Method {
    name: "isSupported",
    'class: "java.time.Instant",
    paramTypes: ["java.time.temporal.TemporalUnit"]
} external;

function java_time_Instant_minus(handle receiver, int arg0, handle arg1) returns handle = @java:Method {
    name: "minus",
    'class: "java.time.Instant",
    paramTypes: ["long", "java.time.temporal.TemporalUnit"]
} external;

function java_time_Instant_minus2(handle receiver, handle arg0) returns handle|error = @java:Method {
    name: "minus",
    'class: "java.time.Instant",
    paramTypes: ["java.time.temporal.TemporalAmount"]
} external;

function java_time_Instant_minusMillis(handle receiver, int arg0) returns handle = @java:Method {
    name: "minusMillis",
    'class: "java.time.Instant",
    paramTypes: ["long"]
} external;

function java_time_Instant_minusNanos(handle receiver, int arg0) returns handle = @java:Method {
    name: "minusNanos",
    'class: "java.time.Instant",
    paramTypes: ["long"]
} external;

function java_time_Instant_minusSeconds(handle receiver, int arg0) returns handle = @java:Method {
    name: "minusSeconds",
    'class: "java.time.Instant",
    paramTypes: ["long"]
} external;

function java_time_Instant_notify(handle receiver) = @java:Method {
    name: "notify",
    'class: "java.time.Instant",
    paramTypes: []
} external;

function java_time_Instant_notifyAll(handle receiver) = @java:Method {
    name: "notifyAll",
    'class: "java.time.Instant",
    paramTypes: []
} external;

function java_time_Instant_now() returns handle = @java:Method {
    name: "now",
    'class: "java.time.Instant",
    paramTypes: []
} external;

function java_time_Instant_ofEpochMilli(int arg0) returns handle = @java:Method {
    name: "ofEpochMilli",
    'class: "java.time.Instant",
    paramTypes: ["long"]
} external;

function java_time_Instant_ofEpochSecond(int arg0) returns handle = @java:Method {
    name: "ofEpochSecond",
    'class: "java.time.Instant",
    paramTypes: ["long"]
} external;

function java_time_Instant_ofEpochSecond2(int arg0, int arg1) returns handle|error = @java:Method {
    name: "ofEpochSecond",
    'class: "java.time.Instant",
    paramTypes: ["long", "long"]
} external;

function java_time_Instant_parse(handle arg0) returns handle|error = @java:Method {
    name: "parse",
    'class: "java.time.Instant",
    paramTypes: ["java.lang.CharSequence"]
} external;

function java_time_Instant_plus(handle receiver, int arg0, handle arg1) returns handle = @java:Method {
    name: "plus",
    'class: "java.time.Instant",
    paramTypes: ["long", "java.time.temporal.TemporalUnit"]
} external;

function java_time_Instant_plus2(handle receiver, handle arg0) returns handle|error = @java:Method {
    name: "plus",
    'class: "java.time.Instant",
    paramTypes: ["java.time.temporal.TemporalAmount"]
} external;

function java_time_Instant_plusMillis(handle receiver, int arg0) returns handle = @java:Method {
    name: "plusMillis",
    'class: "java.time.Instant",
    paramTypes: ["long"]
} external;

function java_time_Instant_plusNanos(handle receiver, int arg0) returns handle = @java:Method {
    name: "plusNanos",
    'class: "java.time.Instant",
    paramTypes: ["long"]
} external;

function java_time_Instant_plusSeconds(handle receiver, int arg0) returns handle = @java:Method {
    name: "plusSeconds",
    'class: "java.time.Instant",
    paramTypes: ["long"]
} external;

function java_time_Instant_query(handle receiver, handle arg0) returns handle = @java:Method {
    name: "query",
    'class: "java.time.Instant",
    paramTypes: ["java.time.temporal.TemporalQuery"]
} external;

function java_time_Instant_range(handle receiver, handle arg0) returns handle = @java:Method {
    name: "range",
    'class: "java.time.Instant",
    paramTypes: ["java.time.temporal.TemporalField"]
} external;

function java_time_Instant_toEpochMilli(handle receiver) returns int = @java:Method {
    name: "toEpochMilli",
    'class: "java.time.Instant",
    paramTypes: []
} external;

function java_time_Instant_truncatedTo(handle receiver, handle arg0) returns handle = @java:Method {
    name: "truncatedTo",
    'class: "java.time.Instant",
    paramTypes: ["java.time.temporal.TemporalUnit"]
} external;

function java_time_Instant_until(handle receiver, handle arg0, handle arg1) returns int = @java:Method {
    name: "until",
    'class: "java.time.Instant",
    paramTypes: ["java.time.temporal.Temporal", "java.time.temporal.TemporalUnit"]
} external;

function java_time_Instant_wait(handle receiver) returns error? = @java:Method {
    name: "wait",
    'class: "java.time.Instant",
    paramTypes: []
} external;

function java_time_Instant_wait2(handle receiver, int arg0) returns error? = @java:Method {
    name: "wait",
    'class: "java.time.Instant",
    paramTypes: ["long"]
} external;

function java_time_Instant_wait3(handle receiver, int arg0, int arg1) returns error? = @java:Method {
    name: "wait",
    'class: "java.time.Instant",
    paramTypes: ["long", "int"]
} external;

function java_time_Instant_with(handle receiver, handle arg0) returns handle = @java:Method {
    name: "with",
    'class: "java.time.Instant",
    paramTypes: ["java.time.temporal.TemporalAdjuster"]
} external;

function java_time_Instant_with2(handle receiver, handle arg0, int arg1) returns handle = @java:Method {
    name: "with",
    'class: "java.time.Instant",
    paramTypes: ["java.time.temporal.TemporalField", "long"]
} external;

function java_time_Instant_getEPOCH() returns handle = @java:FieldGet {
    name: "EPOCH",
    'class: "java.time.Instant"
} external;

function java_time_Instant_getMIN() returns handle = @java:FieldGet {
    name: "MIN",
    'class: "java.time.Instant"
} external;

function java_time_Instant_getMAX() returns handle = @java:FieldGet {
    name: "MAX",
    'class: "java.time.Instant"
} external;