@@ -89,20 +89,20 @@
 {
 	distantPast = [[OFDateSingleton alloc]
 	    initWithTimeIntervalSince1970: -62167219200.0];
 }
 
-static of_time_interval_t
+static OFTimeInterval
 now(void)
 {
 	struct timeval tv;
-	of_time_interval_t seconds;
+	OFTimeInterval seconds;
 
 	OF_ENSURE(gettimeofday(&tv, NULL) == 0);
 
 	seconds = tv.tv_sec;
-	seconds += (of_time_interval_t)tv.tv_usec / 1000000;
+	seconds += (OFTimeInterval)tv.tv_usec / 1000000;
 
 	return seconds;
 }
 
 #if (!defined(HAVE_GMTIME_R) || !defined(HAVE_LOCALTIME_R)) && \
@@ -120,11 +120,11 @@
 static __time64_t (*func__mktime64)(struct tm *);
 #endif
 
 #ifdef HAVE_GMTIME_R
 # define GMTIME_RET(field)						\
-	of_time_interval_t timeInterval = self.timeIntervalSince1970;	\
+	OFTimeInterval timeInterval = self.timeIntervalSince1970;	\
 	time_t seconds = (time_t)timeInterval;				\
 	struct tm tm;							\
 									\
 	if (seconds != trunc(timeInterval))				\
 		@throw [OFOutOfRangeException exception];		\
@@ -132,11 +132,11 @@
 	if (gmtime_r(&seconds, &tm) == NULL)				\
 		@throw [OFOutOfRangeException exception];		\
 									\
 	return tm.field;
 # define LOCALTIME_RET(field)						\
-	of_time_interval_t timeInterval = self.timeIntervalSince1970;	\
+	OFTimeInterval timeInterval = self.timeIntervalSince1970;	\
 	time_t seconds = (time_t)timeInterval;				\
 	struct tm tm;							\
 									\
 	if (seconds != trunc(timeInterval))				\
 		@throw [OFOutOfRangeException exception];		\
@@ -146,11 +146,11 @@
 									\
 	return tm.field;
 #else
 # ifdef OF_HAVE_THREADS
 #  define GMTIME_RET(field)						\
-	of_time_interval_t timeInterval = self.timeIntervalSince1970;	\
+	OFTimeInterval timeInterval = self.timeIntervalSince1970;	\
 	time_t seconds = (time_t)timeInterval;				\
 	struct tm *tm;							\
 									\
 	if (seconds != trunc(timeInterval))				\
 		@throw [OFOutOfRangeException exception];		\
@@ -164,11 +164,11 @@
 		return tm->field;					\
 	} @finally {							\
 		[mutex unlock];						\
 	}
 #  define LOCALTIME_RET(field)						\
-	of_time_interval_t timeInterval = self.timeIntervalSince1970;	\
+	OFTimeInterval timeInterval = self.timeIntervalSince1970;	\
 	time_t seconds = (time_t)timeInterval;				\
 	struct tm *tm;							\
 									\
 	if (seconds != trunc(timeInterval))				\
 		@throw [OFOutOfRangeException exception];		\
@@ -183,11 +183,11 @@
 	} @finally {							\
 		[mutex unlock];						\
 	}
 # else
 #  define GMTIME_RET(field)						\
-	of_time_interval_t timeInterval = self.timeIntervalSince1970;	\
+	OFTimeInterval timeInterval = self.timeIntervalSince1970;	\
 	time_t seconds = (time_t)timeInterval;				\
 	struct tm *tm;							\
 									\
 	if (seconds != trunc(timeInterval))				\
 		@throw [OFOutOfRangeException exception];		\
@@ -195,11 +195,11 @@
 	if ((tm = gmtime(&seconds)) == NULL)				\
 		@throw [OFOutOfRangeException exception];		\
 									\
 	return tm->field;
 #  define LOCALTIME_RET(field)						\
-	of_time_interval_t timeInterval = self.timeIntervalSince1970;	\
+	OFTimeInterval timeInterval = self.timeIntervalSince1970;	\
 	time_t seconds = (time_t)timeInterval;				\
 	struct tm *tm;							\
 									\
 	if (seconds != trunc(timeInterval))				\
 		@throw [OFOutOfRangeException exception];		\
@@ -286,11 +286,11 @@
 /* We intentionally don't call into super, so silence the warning. */
 # pragma clang diagnostic push
 # pragma clang diagnostic ignored "-Wunknown-pragmas"
 # pragma clang diagnostic ignored "-Wobjc-designated-initializers"
 #endif
-- (instancetype)initWithTimeIntervalSince1970: (of_time_interval_t)seconds
+- (instancetype)initWithTimeIntervalSince1970: (OFTimeInterval)seconds
 {
 #if defined(OF_OBJFW_RUNTIME) && UINTPTR_MAX == UINT64_MAX
 	uint64_t value;
 #endif
 
@@ -321,11 +321,11 @@
 #endif
 @end
 
 #if defined(OF_OBJFW_RUNTIME) && UINTPTR_MAX == UINT64_MAX
 @implementation OFTaggedPointerDate
-- (of_time_interval_t)timeIntervalSince1970
+- (OFTimeInterval)timeIntervalSince1970
 {
 	uint64_t value = (uint64_t)object_getTaggedPointerValue(self);
 
 	value |= UINT64_C(4) << 60;
 
@@ -380,17 +380,17 @@
 + (instancetype)date
 {
 	return [[[self alloc] init] autorelease];
 }
 
-+ (instancetype)dateWithTimeIntervalSince1970: (of_time_interval_t)seconds
++ (instancetype)dateWithTimeIntervalSince1970: (OFTimeInterval)seconds
 {
 	return [[[self alloc]
 	    initWithTimeIntervalSince1970: seconds] autorelease];
 }
 
-+ (instancetype)dateWithTimeIntervalSinceNow: (of_time_interval_t)seconds
++ (instancetype)dateWithTimeIntervalSinceNow: (OFTimeInterval)seconds
 {
 	return [[[self alloc]
 	    initWithTimeIntervalSinceNow: seconds] autorelease];
 }
 
@@ -425,20 +425,20 @@
 - (instancetype)init
 {
 	return [self initWithTimeIntervalSince1970: now()];
 }
 
-- (instancetype)initWithTimeIntervalSince1970: (of_time_interval_t)seconds
+- (instancetype)initWithTimeIntervalSince1970: (OFTimeInterval)seconds
 {
 	self = [super init];
 
 	_seconds = seconds;
 
 	return self;
 }
 
-- (instancetype)initWithTimeIntervalSinceNow: (of_time_interval_t)seconds
+- (instancetype)initWithTimeIntervalSinceNow: (OFTimeInterval)seconds
 {
 	return [self initWithTimeIntervalSince1970: now() + seconds];
 }
 
 - (instancetype)initWithDateString: (OFString *)string
@@ -468,11 +468,11 @@
 	 * of_strptime() can never set this to SHRT_MAX, no matter what is
 	 * passed to it, so this is a safe way to figure out if the date
 	 * contains a time zone.
 	 */
 	short tz = SHRT_MAX;
-	of_time_interval_t seconds;
+	OFTimeInterval seconds;
 
 	if (of_strptime(UTF8String, format.UTF8String, &tm, &tz) !=
 	    UTF8String + string.UTF8StringLength)
 		@throw [OFInvalidFormatException exception];
 
@@ -496,11 +496,11 @@
 	return [self initWithTimeIntervalSince1970: seconds];
 }
 
 - (instancetype)initWithSerialization: (OFXMLElement *)element
 {
-	of_time_interval_t seconds;
+	OFTimeInterval seconds;
 
 	@try {
 		void *pool = objc_autoreleasePoolPush();
 		unsigned long long value;
 
@@ -603,11 +603,11 @@
 }
 
 - (OFData *)messagePackRepresentation
 {
 	void *pool = objc_autoreleasePoolPush();
-	of_time_interval_t timeInterval = self.timeIntervalSince1970;
+	OFTimeInterval timeInterval = self.timeIntervalSince1970;
 	int64_t seconds = (int64_t)timeInterval;
 	uint32_t nanoseconds =
 	    (uint32_t)((timeInterval - trunc(timeInterval)) * 1000000000);
 	OFData *ret;
 
@@ -656,11 +656,11 @@
 	return [ret autorelease];
 }
 
 - (unsigned long)microsecond
 {
-	of_time_interval_t timeInterval = self.timeIntervalSince1970;
+	OFTimeInterval timeInterval = self.timeIntervalSince1970;
 
 	return (unsigned long)((timeInterval - trunc(timeInterval)) * 1000000);
 }
 
 - (unsigned char)second
@@ -739,11 +739,11 @@
 }
 
 - (OFString *)dateStringWithFormat: (OFConstantString *)format
 {
 	OFString *ret;
-	of_time_interval_t timeInterval = self.timeIntervalSince1970;
+	OFTimeInterval timeInterval = self.timeIntervalSince1970;
 	time_t seconds = (time_t)timeInterval;
 	struct tm tm;
 	size_t pageSize;
 #ifndef OF_WINDOWS
 	char *buffer;
@@ -799,11 +799,11 @@
 }
 
 - (OFString *)localDateStringWithFormat: (OFConstantString *)format
 {
 	OFString *ret;
-	of_time_interval_t timeInterval = self.timeIntervalSince1970;
+	OFTimeInterval timeInterval = self.timeIntervalSince1970;
 	time_t seconds = (time_t)timeInterval;
 	struct tm tm;
 	size_t pageSize;
 #ifndef OF_WINDOWS
 	char *buffer;
@@ -878,34 +878,34 @@
 		return otherDate;
 
 	return self;
 }
 
-- (of_time_interval_t)timeIntervalSince1970
+- (OFTimeInterval)timeIntervalSince1970
 {
 	return _seconds;
 }
 
-- (of_time_interval_t)timeIntervalSinceDate: (OFDate *)otherDate
+- (OFTimeInterval)timeIntervalSinceDate: (OFDate *)otherDate
 {
 	return self.timeIntervalSince1970 - otherDate.timeIntervalSince1970;
 }
 
-- (of_time_interval_t)timeIntervalSinceNow
+- (OFTimeInterval)timeIntervalSinceNow
 {
 	struct timeval t;
-	of_time_interval_t seconds;
+	OFTimeInterval seconds;
 
 	OF_ENSURE(gettimeofday(&t, NULL) == 0);
 
 	seconds = t.tv_sec;
-	seconds += (of_time_interval_t)t.tv_usec / 1000000;
+	seconds += (OFTimeInterval)t.tv_usec / 1000000;
 
 	return self.timeIntervalSince1970 - seconds;
 }
 
-- (OFDate *)dateByAddingTimeInterval: (of_time_interval_t)seconds
+- (OFDate *)dateByAddingTimeInterval: (OFTimeInterval)seconds
 {
 	return [OFDate dateWithTimeIntervalSince1970:
 	    self.timeIntervalSince1970 + seconds];
 }
 @end