diff --git a/CHANGELOG.md b/CHANGELOG.md
index 44e887a..2793527 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,12 @@
 # Changelog
 
+## 3.0.9
+
+Added the following PostgreSQL builtin types:
+- Geometric types `line`, `lseg`,`path`,`polygon`,`box`,`circle`
+- Range types `int4range`, `int8range`, `daterange`, `tsrange`,`tstzrange`
+- Time type `time`
+
 ## 3.0.8
 
 - Properly react to connection losses by reporting the database connection as
diff --git a/lib/postgres.dart b/lib/postgres.dart
index 85f2b5c..98e8b58 100644
--- a/lib/postgres.dart
+++ b/lib/postgres.dart
@@ -17,6 +17,8 @@ export 'src/exceptions.dart';
 export 'src/pool/pool_api.dart';
 export 'src/replication.dart';
 export 'src/types.dart';
+export 'src/types/geo_types.dart';
+export 'src/types/range_types.dart';
 export 'src/types/type_registry.dart' show TypeRegistry;
 
 /// A description of a SQL query as interpreted by this package.
@@ -227,6 +229,7 @@ abstract class ResultStream implements Stream<ResultRow> {
 abstract class ResultStreamSubscription
     implements StreamSubscription<ResultRow> {
   Future<int> get affectedRows;
+
   Future<ResultSchema> get schema;
 }
 
@@ -335,7 +338,9 @@ abstract class Channels {
   Stream<Notification> get all;
 
   Stream<String> operator [](String channel);
+
   Future<void> notify(String channel, [String? payload]);
+
   Future<void> cancelAll();
 }
 
@@ -415,6 +420,7 @@ enum SslMode {
   ;
 
   bool get ignoreCertificateIssues => this == SslMode.require;
+
   bool get allowCleartextPassword => this == SslMode.disable;
 }
 
diff --git a/lib/src/messages/server_messages.dart b/lib/src/messages/server_messages.dart
index 5ee0f51..77edda7 100644
--- a/lib/src/messages/server_messages.dart
+++ b/lib/src/messages/server_messages.dart
@@ -409,7 +409,7 @@ class UnknownMessage extends ServerMessage {
   }
 
   @override
-  bool operator ==(dynamic other) {
+  bool operator ==(Object other) {
     if (other is! UnknownMessage) {
       return false;
     }
diff --git a/lib/src/types.dart b/lib/src/types.dart
index 2d7d186..e7ccded 100644
--- a/lib/src/types.dart
+++ b/lib/src/types.dart
@@ -1,11 +1,13 @@
 import 'dart:convert';
-import 'dart:core';
 import 'dart:core' as core;
+import 'dart:core';
 import 'dart:typed_data';
 
 import 'package:meta/meta.dart';
 
 import 'types/generic_type.dart';
+import 'types/geo_types.dart';
+import 'types/range_types.dart';
 import 'types/type_registry.dart';
 
 /// In Postgresql `interval` values are stored as [months], [days], and [microseconds].
@@ -119,27 +121,84 @@ class LSN {
   int get hashCode => value.hashCode;
 }
 
-/// Describes PostgreSQL's geometric type: `point`.
-@immutable
-class Point {
-  /// also referred as `x`
-  final double latitude;
+/// Describes PostgreSQL's `time without time zone` type.
+///
+/// See https://www.postgresql.org/docs/current/datatype-datetime.html
+///
+/// `time with time zone` is not implemented as Postgres wiki recommends against its use:
+///
+/// https://wiki.postgresql.org/wiki/Don't_Do_This#Don.27t_use_timetz
+class Time {
+  /// The time in microseconds
+  late final int microseconds;
+
+  /// Construct a [Time] instance from [microseconds].
+  ///
+  /// [microseconds] must be positive and not resolve to a time larger than 24:00:00.000000.
+  Time.fromMicroseconds(this.microseconds) {
+    _check();
+  }
+
+  /// Construct a [Time] instance.
+  ///
+  /// [Time] value must be positive and not larger than 24:00:00.000000.
+  Time(
+      [int hour = 0,
+      int minute = 0,
+      int second = 0,
+      int millisecond = 0,
+      int microsecond = 0]) {
+    microseconds = hour * Duration.microsecondsPerHour +
+        minute * Duration.microsecondsPerMinute +
+        second * Duration.microsecondsPerSecond +
+        millisecond * Duration.microsecondsPerMillisecond +
+        microsecond;
+    _check();
+  }
+
+  _check() {
+    if (microseconds > Duration.microsecondsPerDay) {
+      throw ArgumentError(
+          'Time: values greater than 24:00:00.000000 are not allowed');
+    }
+    if (microseconds < 0) {
+      throw ArgumentError('Time: negative value not allowed');
+    }
+  }
+
+  DateTime get utcDateTime =>
+      DateTime.fromMicrosecondsSinceEpoch(microseconds, isUtc: true);
+
+  /// The hour of the day, expressed as in a 25-hour clock `0...24`.
+  int get hour =>
+      microseconds == Duration.microsecondsPerDay ? 24 : utcDateTime.hour;
 
-  /// also referred as `y`
-  final double longitude;
+  /// The minute `[0...59]`.
+  int get minute => utcDateTime.minute;
 
-  const Point(this.latitude, this.longitude);
+  /// The second `[0...59]`.
+  int get second => utcDateTime.second;
+
+  /// The millisecond `[0...999]`.
+  int get millisecond => utcDateTime.millisecond;
+
+  /// The microsecond `[0...999]`.
+  int get microsecond => utcDateTime.microsecond;
+
+  @override
+  String toString() => microseconds == Duration.microsecondsPerDay
+      ? 'Time(24:00:00.000)'
+      : 'Time(${utcDateTime.toIso8601String().split('T')[1].replaceAll('Z', '')})';
 
   @override
   bool operator ==(Object other) =>
       identical(this, other) ||
-      other is Point &&
+      other is Time &&
           runtimeType == other.runtimeType &&
-          latitude == other.latitude &&
-          longitude == other.longitude;
+          microseconds == other.microseconds;
 
   @override
-  int get hashCode => Object.hash(latitude, longitude);
+  int get hashCode => microseconds;
 }
 
 /// Supported data types.
@@ -177,6 +236,9 @@ abstract class Type<T extends Object> {
   /// Must be a [bool]
   static const boolean = GenericType<bool>(TypeOid.boolean);
 
+  /// Must be a [Time]
+  static const time = GenericType<Time>(TypeOid.time);
+
   /// Must be a [DateTime] (microsecond date and time precision)
   static const timestampWithoutTimezone =
       GenericType<DateTime>(TypeOid.timestampWithoutTimezone);
@@ -227,6 +289,24 @@ abstract class Type<T extends Object> {
   /// Must be a [Point]
   static const point = GenericType<Point>(TypeOid.point);
 
+  /// Must be a [Line]
+  static const line = GenericType<Line>(TypeOid.line);
+
+  /// Must be a [LineSegment]
+  static const lineSegment = GenericType<LineSegment>(TypeOid.lineSegment);
+
+  /// Must be a [Box]
+  static const box = GenericType<Box>(TypeOid.box);
+
+  /// Must be a [Polygon]
+  static const polygon = GenericType<Polygon>(TypeOid.polygon);
+
+  /// Must be a [Path]
+  static const path = GenericType<Path>(TypeOid.path);
+
+  /// Must be a [Circle]
+  static const circle = GenericType<Circle>(TypeOid.circle);
+
   /// Must be a [List<bool>]
   static const booleanArray = GenericType<List<bool>>(TypeOid.booleanArray);
 
@@ -259,6 +339,29 @@ abstract class Type<T extends Object> {
   /// Impossible to bind to, always null when read.
   static const voidType = GenericType<Object>(TypeOid.voidType);
 
+  /// Must be a [IntRange]
+  static const int4range = GenericType<IntRange>(TypeOid.int4range);
+
+  /// Must be a [IntRange]
+  static const int8range = GenericType<IntRange>(TypeOid.int8range);
+
+  /// Must be a [DateRange]
+  static const dateRange = GenericType<DateRange>(TypeOid.dateRange);
+
+  /// Must be a [Range<Object>]
+  ///
+  /// Supported element types are the same as for [Type.numeric].
+  // static const numrange =
+  //     GenericType<ContinuousRange<String>>(TypeOid.numrange);
+
+  /// Must be a [Range<DateTime>]
+  static const timestampRange =
+      GenericType<DateTimeRange>(TypeOid.timestampRange);
+
+  /// Must be a [Range<DateTime>]
+  static const timestampTzRange =
+      GenericType<DateTimeRange>(TypeOid.timestampTzRange);
+
   /// The object ID of this data type.
   final int? oid;
 
diff --git a/lib/src/types/binary_codec.dart b/lib/src/types/binary_codec.dart
index 63a8e71..b5c28d2 100644
--- a/lib/src/types/binary_codec.dart
+++ b/lib/src/types/binary_codec.dart
@@ -6,6 +6,8 @@ import 'package:postgres/src/types/generic_type.dart';
 
 import '../buffer.dart';
 import '../types.dart';
+import 'geo_types.dart';
+import 'range_types.dart';
 import 'type_registry.dart';
 
 final _bool0 = Uint8List(1)..[0] = 0;
@@ -134,12 +136,23 @@ class PostgresBinaryEncoder {
               'Invalid type for parameter value. Expected: DateTime Got: ${input.runtimeType}');
         }
 
+      case TypeOid.time:
+        {
+          if (input is Time) {
+            final bd = ByteData(8);
+            bd.setInt64(0, input.microseconds);
+            return bd.buffer.asUint8List();
+          }
+          throw FormatException(
+              'Invalid type for parameter value. Expected: Time Got: ${input.runtimeType}');
+        }
+
       case TypeOid.timestampWithoutTimezone:
         {
           if (input is DateTime) {
             final bd = ByteData(8);
-            final diff = input.toUtc().difference(DateTime.utc(2000));
-            bd.setInt64(0, diff.inMicroseconds);
+            bd.setInt64(
+                0, input.toUtc().difference(DateTime.utc(2000)).inMicroseconds);
             return bd.buffer.asUint8List();
           }
           throw FormatException(
@@ -262,6 +275,80 @@ class PostgresBinaryEncoder {
           throw FormatException(
               'Invalid type for parameter value. Expected: Point Got: ${input.runtimeType}');
         }
+
+      case TypeOid.line:
+        if (input is Line) {
+          final bd = ByteData(24);
+          bd.setFloat64(0, input.a);
+          bd.setFloat64(8, input.b);
+          bd.setFloat64(16, input.c);
+          return bd.buffer.asUint8List();
+        }
+        throw FormatException(
+            'Invalid type for parameter value. Expected: Line Got: ${input.runtimeType}');
+
+      case TypeOid.lineSegment:
+        if (input is LineSegment) {
+          final bd = ByteData(32);
+          bd.setFloat64(0, input.p1.latitude);
+          bd.setFloat64(8, input.p1.longitude);
+          bd.setFloat64(16, input.p2.latitude);
+          bd.setFloat64(24, input.p2.longitude);
+          return bd.buffer.asUint8List();
+        }
+        throw FormatException(
+            'Invalid type for parameter value. Expected: LineSegment Got: ${input.runtimeType}');
+
+      case TypeOid.box:
+        if (input is Box) {
+          final bd = ByteData(32);
+          bd.setFloat64(0, input.p1.latitude);
+          bd.setFloat64(8, input.p1.longitude);
+          bd.setFloat64(16, input.p2.latitude);
+          bd.setFloat64(24, input.p2.longitude);
+          return bd.buffer.asUint8List();
+        }
+        throw FormatException(
+            'Invalid type for parameter value. Expected: Box Got: ${input.runtimeType}');
+
+      case TypeOid.path:
+        if (input is Path) {
+          final bd = ByteData(5 + 16 * input.points.length);
+          bd.setInt8(0, input.open ? 0 : 1);
+          bd.setInt32(1, input.points.length);
+          for (int i = 0; i < input.points.length; i++) {
+            bd.setFloat64(i * 16 + 5, input.points[i].latitude);
+            bd.setFloat64(i * 16 + 13, input.points[i].longitude);
+          }
+          return bd.buffer.asUint8List();
+        }
+        throw FormatException(
+            'Invalid type for parameter value. Expected: Path Got: ${input.runtimeType}');
+
+      case TypeOid.polygon:
+        if (input is Polygon) {
+          final bd = ByteData(4 + 16 * input.points.length);
+          bd.setInt32(0, input.points.length);
+          for (int i = 0; i < input.points.length; i++) {
+            bd.setFloat64(i * 16 + 4, input.points[i].latitude);
+            bd.setFloat64(i * 16 + 12, input.points[i].longitude);
+          }
+          return bd.buffer.asUint8List();
+        }
+        throw FormatException(
+            'Invalid type for parameter value. Expected: Polygon Got: ${input.runtimeType}');
+
+      case TypeOid.circle:
+        if (input is Circle) {
+          final bd = ByteData(24);
+          bd.setFloat64(0, input.center.latitude);
+          bd.setFloat64(8, input.center.longitude);
+          bd.setFloat64(16, input.radius);
+          return bd.buffer.asUint8List();
+        }
+        throw FormatException(
+            'Invalid type for parameter value. Expected: Circle Got: ${input.runtimeType}');
+
       case TypeOid.regtype:
         final oid = input is Type ? input.oid : (input is int ? input : null);
         if (oid == null) {
@@ -384,6 +471,42 @@ class PostgresBinaryEncoder {
           throw FormatException(
               'Invalid type for parameter value. Expected: List Got: ${input.runtimeType}');
         }
+
+      case TypeOid.int4range:
+        if (input is IntRange) {
+          return _encodeRange(input, encoding, Type.integer.oid!);
+        }
+        throw FormatException(
+            'Invalid type for parameter value. Expected: IntRange Got: ${input.runtimeType}');
+
+      case TypeOid.int8range:
+        if (input is IntRange) {
+          return _encodeRange(input, encoding, Type.bigInteger.oid!);
+        }
+        throw FormatException(
+            'Invalid type for parameter value. Expected: IntRange Got: ${input.runtimeType}');
+
+      case TypeOid.dateRange:
+        if (input is DateRange) {
+          return _encodeRange(input, encoding, Type.date.oid!);
+        }
+        throw FormatException(
+            'Invalid type for parameter value. Expected: DateRange Got: ${input.runtimeType}');
+
+      case TypeOid.timestampRange:
+        if (input is DateTimeRange) {
+          return _encodeRange(
+              input, encoding, Type.timestampWithoutTimezone.oid!);
+        }
+        throw FormatException(
+            'Invalid type for parameter value. Expected: DateTimeRange Got: ${input.runtimeType}');
+
+      case TypeOid.timestampTzRange:
+        if (input is DateTimeRange) {
+          return _encodeRange(input, encoding, Type.timestampWithTimezone.oid!);
+        }
+        throw FormatException(
+            'Invalid type for parameter value. Expected: DateTimeRange Got: ${input.runtimeType}');
     }
     // Pass-through of Uint8List instances allows client with custom types to
     // encode their types for efficient binary transport.
@@ -505,6 +628,36 @@ class PostgresBinaryEncoder {
     }
     return writer.toBytes();
   }
+
+  Uint8List _encodeRange<T>(
+      Range<T> range, Encoding encoding, int elementTypeOid) {
+    final buffer = BytesBuffer();
+    buffer.add([range.flag]);
+    switch ((range.lower == null, range.upper == null)) {
+      case (false, false):
+        if (range.flag == 1) break;
+        _encodeRangeValue(range.lower, encoding, elementTypeOid, buffer);
+        _encodeRangeValue(range.upper, encoding, elementTypeOid, buffer);
+        break;
+      case (false, true) || (true, false):
+        final value = range.lower ?? range.upper!;
+        _encodeRangeValue(value, encoding, elementTypeOid, buffer);
+        break;
+      case (true, true):
+        break;
+    }
+    return buffer.toBytes();
+  }
+
+  // Returns 4 length bytes + value bytes
+  _encodeRangeValue<T>(
+      T value, Encoding encoding, int elementTypeOid, BytesBuffer buffer) {
+    final encoder = PostgresBinaryEncoder(elementTypeOid);
+    final valueBytes = encoder.convert(value as Object, encoding);
+    final lengthBytes = ByteData(4)..setInt32(0, valueBytes.length);
+    buffer.add(lengthBytes.buffer.asUint8List());
+    buffer.add(valueBytes);
+  }
 }
 
 class PostgresBinaryDecoder {
@@ -536,6 +689,8 @@ class PostgresBinaryDecoder {
         return buffer.getFloat32(0);
       case TypeOid.double:
         return buffer.getFloat64(0);
+      case TypeOid.time:
+        return Time.fromMicroseconds(buffer.getInt64(0));
       case TypeOid.timestampWithoutTimezone:
       case TypeOid.timestampWithTimezone:
         return DateTime.utc(2000)
@@ -597,6 +752,43 @@ class PostgresBinaryDecoder {
       case TypeOid.point:
         return Point(buffer.getFloat64(0), buffer.getFloat64(8));
 
+      case TypeOid.line:
+        return Line(
+            buffer.getFloat64(0), buffer.getFloat64(8), buffer.getFloat64(16));
+
+      case TypeOid.lineSegment:
+        return LineSegment(Point(buffer.getFloat64(0), buffer.getFloat64(8)),
+            Point(buffer.getFloat64(16), buffer.getFloat64(24)));
+
+      case TypeOid.box:
+        return Box(Point(buffer.getFloat64(0), buffer.getFloat64(8)),
+            Point(buffer.getFloat64(16), buffer.getFloat64(24)));
+
+      case TypeOid.path:
+        final open = buffer.getInt8(0) == 0;
+        final length = buffer.getInt32(1);
+        final points = <Point>[];
+        for (int i = 0; i < length; i++) {
+          final x = buffer.getFloat64(i * 16 + 5);
+          final y = buffer.getFloat64(i * 16 + 13);
+          points.add(Point(x, y));
+        }
+        return Path(points, open);
+
+      case TypeOid.polygon:
+        final length = buffer.getInt32(0);
+        final points = <Point>[];
+        for (int i = 0; i < length; i++) {
+          final x = buffer.getFloat64(i * 16 + 4);
+          final y = buffer.getFloat64(i * 16 + 12);
+          points.add(Point(x, y));
+        }
+        return Polygon(points);
+
+      case TypeOid.circle:
+        return Circle(Point(buffer.getFloat64(0), buffer.getFloat64(8)),
+            buffer.getFloat64(16));
+
       case TypeOid.booleanArray:
         return readListBytes<bool>(
             input, (reader, _) => reader.readUint8() != 0);
@@ -622,6 +814,34 @@ class PostgresBinaryDecoder {
           final bytes = reader.read(length - 1);
           return _jsonFusedEncoding(encoding).decode(bytes);
         });
+
+      case TypeOid.int4range:
+        final range = _decodeRange(buffer, dinput, Type.integer.oid!);
+        return range == null
+            ? IntRange.empty()
+            : IntRange(range.$1, range.$2, range.$3);
+      case TypeOid.int8range:
+        final range = _decodeRange(buffer, dinput, Type.bigInteger.oid!);
+        return range == null
+            ? IntRange.empty()
+            : IntRange(range.$1, range.$2, range.$3);
+      case TypeOid.dateRange:
+        final range = _decodeRange(buffer, dinput, Type.date.oid!);
+        return range == null
+            ? DateRange.empty()
+            : DateRange(range.$1, range.$2, range.$3);
+      case TypeOid.timestampRange:
+        final range =
+            _decodeRange(buffer, dinput, Type.timestampWithoutTimezone.oid!);
+        return range == null
+            ? DateTimeRange.empty()
+            : DateTimeRange(range.$1, range.$2, range.$3);
+      case TypeOid.timestampTzRange:
+        final range =
+            _decodeRange(buffer, dinput, Type.timestampWithTimezone.oid!);
+        return range == null
+            ? DateTimeRange.empty()
+            : DateTimeRange(range.$1, range.$2, range.$3);
     }
     return UndecodedBytes(
       typeOid: typeOid,
@@ -699,4 +919,41 @@ class PostgresBinaryDecoder {
     }
     return result;
   }
+
+  (T?, T?, Bounds)? _decodeRange<T>(
+      ByteData buffer, DecodeInput dinput, int elementTypeOid) {
+    final flag = buffer.getInt8(0);
+    final bounds = Bounds.fromFlag(flag);
+    switch (flag) {
+      case 0 || 2 || 4 || 6:
+        final lowerLength = buffer.getInt32(1);
+        final lowerBytes = dinput.bytes.sublist(5, 5 + lowerLength);
+        final lower = _decodeRangeElement(dinput, elementTypeOid, lowerBytes);
+        final upperBytes = dinput.bytes.sublist(9 + lowerLength);
+        final upper = _decodeRangeElement(dinput, elementTypeOid, upperBytes);
+        return (lower, upper, bounds);
+      case 8 || 12:
+        final bytes = dinput.bytes.sublist(5);
+        final upper = _decodeRangeElement(dinput, elementTypeOid, bytes);
+        return (null, upper, bounds);
+      case 16 || 18:
+        final bytes = dinput.bytes.sublist(5);
+        final lower = _decodeRangeElement(dinput, elementTypeOid, bytes);
+        return (lower, null, bounds);
+      case 24:
+        return (null, null, bounds);
+      default:
+        return null;
+    }
+  }
+
+  T _decodeRangeElement<T>(
+      DecodeInput dinput, int elementTypeOid, Uint8List bytes) {
+    final decoder = PostgresBinaryDecoder(elementTypeOid);
+    return decoder.convert(DecodeInput(
+        bytes: bytes,
+        isBinary: dinput.isBinary,
+        encoding: dinput.encoding,
+        typeRegistry: dinput.typeRegistry)) as T;
+  }
 }
diff --git a/lib/src/types/geo_types.dart b/lib/src/types/geo_types.dart
new file mode 100644
index 0000000..0ab9121
--- /dev/null
+++ b/lib/src/types/geo_types.dart
@@ -0,0 +1,186 @@
+import 'dart:core';
+
+import 'package:meta/meta.dart';
+
+/// Describes PostgreSQL's geometric type: `point`.
+@immutable
+class Point {
+  /// also referred as `x`
+  final double latitude;
+
+  /// also referred as `y`
+  final double longitude;
+
+  const Point(this.latitude, this.longitude);
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is Point &&
+          runtimeType == other.runtimeType &&
+          latitude == other.latitude &&
+          longitude == other.longitude;
+
+  @override
+  int get hashCode => Object.hash(latitude, longitude);
+
+  @override
+  String toString() => 'Point($latitude,$longitude)';
+}
+
+/// Describes PostgreSQL's geometric type: `line`.
+///
+/// A line as defined by the linear equation _ax + by + c = 0_.
+///
+/// See https://www.postgresql.org/docs/current/datatype-geometric.html#DATATYPE-LINE
+///
+@immutable
+class Line {
+  final double a, b, c;
+
+  Line(this.a, this.b, this.c) {
+    if (a == 0 && b == 0) {
+      throw ArgumentError('Line: a and b cannot both be zero');
+    }
+  }
+
+  @override
+  String toString() => 'Line($a,$b,$c)';
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is Line &&
+          runtimeType == other.runtimeType &&
+          a == other.a &&
+          b == other.b &&
+          c == other.c;
+
+  @override
+  int get hashCode => Object.hash(a, b, c);
+}
+
+/// Describes PostgreSQL's geometric type: `lseg`.
+@immutable
+class LineSegment {
+  late final Point p1, p2;
+
+  LineSegment(this.p1, this.p2);
+
+  @override
+  String toString() => 'LineSegment($p1,$p2)';
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is LineSegment &&
+          runtimeType == other.runtimeType &&
+          p1 == other.p1 &&
+          p2 == other.p2;
+
+  @override
+  int get hashCode => Object.hash(p1, p2);
+}
+
+/// Describes PostgreSQL's geometric type: `box`.
+@immutable
+class Box {
+  late final Point p1, p2;
+
+  Box(this.p1, this.p2);
+
+  @override
+  String toString() => 'Box($p1,$p2)';
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is Box &&
+          runtimeType == other.runtimeType &&
+          (p1 == other.p1 && p2 == other.p2 ||
+              p1 == other.p2 && p2 == other.p1);
+
+  @override
+  int get hashCode => Object.hash(p1, p2);
+}
+
+/// Describes PostgreSQL's geometric type: `polygon`.
+@immutable
+class Polygon {
+  late final List<Point> _points;
+
+  List<Point> get points => _points;
+
+  Polygon(Iterable<Point> points) {
+    if (points.isEmpty) {
+      throw ArgumentError('$runtimeType: at least one point required');
+    }
+    _points = List.unmodifiable(points);
+  }
+
+  @override
+  String toString() => 'Polygon(${points.map((e) => e.toString()).join(',')})';
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is Polygon &&
+          runtimeType == other.runtimeType &&
+          _allPointsAreEqual(other.points);
+
+  bool _allPointsAreEqual(List<Point> otherPoints) {
+    if (points.length != otherPoints.length) return false;
+    for (int i = 0; i < points.length; i++) {
+      if (points[i] != otherPoints[i]) return false;
+    }
+    return true;
+  }
+
+  @override
+  int get hashCode => Object.hashAll(points);
+}
+
+/// Describes PostgreSQL's geometric type: `path`.
+class Path extends Polygon {
+  final bool open;
+
+  Path(super.points, this.open);
+
+  @override
+  String toString() =>
+      'Path(${open ? 'open' : 'closed'},${points.map((e) => e.toString()).join(',')})';
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is Path &&
+          runtimeType == other.runtimeType &&
+          open == other.open &&
+          _allPointsAreEqual(other.points);
+
+  @override
+  int get hashCode => Object.hashAll([...points, open]);
+}
+
+class Circle {
+  final Point center;
+  final double radius;
+
+  Circle(this.center, this.radius) {
+    if (radius < 0) throw ArgumentError('Circle: radius must not negative');
+  }
+
+  @override
+  String toString() => 'Circle($center,$radius)';
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is Circle &&
+          runtimeType == other.runtimeType &&
+          radius == other.radius &&
+          center == other.center;
+
+  @override
+  int get hashCode => Object.hash(center, radius);
+}
diff --git a/lib/src/types/range_types.dart b/lib/src/types/range_types.dart
new file mode 100644
index 0000000..4164024
--- /dev/null
+++ b/lib/src/types/range_types.dart
@@ -0,0 +1,263 @@
+import 'package:meta/meta.dart';
+
+/// Describes PostgreSQL range bound state
+///
+/// https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-INCLUSIVITY
+enum Bound {
+  /// Equivalent to '(' or ')'
+  exclusive,
+
+  /// Equivalent to '[' or ']'
+  inclusive,
+}
+
+/// Describes the bounds of PostgreSQL range types.
+///
+/// https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-INCLUSIVITY
+@immutable
+class Bounds {
+  late final Bound lower;
+  late final Bound upper;
+
+  Bounds(this.lower, this.upper);
+
+  ///  Construct a [Bounds] instance from a PostgreSQL [flag] value.
+  ///
+  ///
+  ///  PostgreSQL stores a flag byte that determines range bounds and
+  ///  whether a range is empty. The default lower and upper bounds are `exclusive`.
+  ///
+  ///  A range's flags byte contains these bits:
+  ///  - #define RANGE_EMPTY         0x01    (range is empty)
+  ///  - #define RANGE_LB_INC        0x02    (lower bound is inclusive)
+  ///  - #define RANGE_UB_INC        0x04    (upper bound is inclusive)
+  ///  - #define RANGE_LB_INF        0x08    (lower bound is -infinity)
+  ///  - #define RANGE_UB_INF        0x10    (upper bound is +infinity)
+  ///
+  ///  - #define RANGE_LB_NULL       0x20    (lower bound is null (NOT USED))
+  ///  - #define RANGE_UB_NULL       0x40    (upper bound is null (NOT USED))
+  ///  - #define RANGE_CONTAIN_EMPTY 0x80    (marks a GiST internal-page entry whose subtree contains some empty ranges)
+  ///
+  /// See https://www.npgsql.org/doc/dev/type-representations.html
+  Bounds.fromFlag(int flag) {
+    switch (flag) {
+      case 0 || 1 || 8 || 16 || 24:
+        lower = Bound.exclusive;
+        upper = Bound.exclusive;
+      case 2 || 18:
+        lower = Bound.inclusive;
+        upper = Bound.exclusive;
+      case 4 || 12:
+        lower = Bound.exclusive;
+        upper = Bound.inclusive;
+      case 6:
+        lower = Bound.inclusive;
+        upper = Bound.inclusive;
+      default:
+        throw UnimplementedError('Range flag $flag not implemented');
+    }
+  }
+
+  int get _lowerFlag {
+    switch (lower) {
+      case Bound.exclusive:
+        return 0;
+      case Bound.inclusive:
+        return 2;
+    }
+  }
+
+  int get _upperFlag {
+    switch (upper) {
+      case Bound.exclusive:
+        return 0;
+      case Bound.inclusive:
+        return 4;
+    }
+  }
+
+  @override
+  String toString() => 'Bounds(${lower.name},${upper.name})';
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is Bounds &&
+          runtimeType == other.runtimeType &&
+          lower == other.lower &&
+          upper == other.upper;
+
+  @override
+  int get hashCode => _lowerFlag + _upperFlag;
+}
+
+abstract interface class Range<T> {
+  late final T? _lower;
+  late final T? _upper;
+  late final Bounds _bounds;
+
+  Bounds get bounds => _bounds;
+
+  T? get lower => _lower;
+
+  T? get upper => _upper;
+
+  int get flag {
+    switch ((lower == null, upper == null)) {
+      case (true, true):
+        return 24;
+      case (true, false):
+        return 8 + bounds._upperFlag;
+      case (false, true):
+        return 16 + bounds._lowerFlag;
+      case (false, false):
+        return lower == upper ? 1 : bounds._lowerFlag + bounds._upperFlag;
+    }
+  }
+
+  _throwIfLowerGreaterThanUpper(T? lower, T? upper) {
+    if (_lowerGreaterThanUpper(lower, upper)) {
+      throw ArgumentError(
+          'Range: lower bound must be less than or equal to upper bound');
+    }
+  }
+
+  bool _lowerGreaterThanUpper(T? lower, T? upper) =>
+      lower != null &&
+      upper != null &&
+      lower is Comparable &&
+      lower.compareTo(upper as Comparable) > 0;
+
+  @override
+  String toString() => '$runtimeType($lower,$upper,$bounds)';
+
+  @override
+  bool operator ==(Object other) {
+    if (identical(this, other)) return true;
+    if (other is Range<T> && runtimeType == other.runtimeType) {
+      return flag == 1
+          ? flag == other.flag
+          : flag == other.flag && lower == other.lower && upper == other.upper;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode => flag == 1 ? flag : Object.hash(lower, upper, flag);
+}
+
+abstract interface class DiscreteRange<T> extends Range<T> {
+  DiscreteRange(T? lower, T? upper, Bounds bounds) {
+    _throwIfLowerGreaterThanUpper(lower, upper);
+    final (l, lBound) = _canonicalizeLower(lower, bounds.lower);
+    final (u, uBound) = _canonicalizeUpper(upper, bounds.upper);
+    _lower = _lowerGreaterThanUpper(l, u) ? lower : l;
+    _upper = u;
+    _bounds = Bounds(lBound, uBound);
+  }
+
+  (T?, Bound) _canonicalizeLower(T? lower, Bound bound);
+
+  (T?, Bound) _canonicalizeUpper(T? upper, Bound bound);
+}
+
+/// Describes PostgreSQL's builtin `int4range` and `int8range`
+///
+/// https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-BUILTIN
+class IntRange extends DiscreteRange<int> {
+  IntRange(super.lower, super.upper, super.bounds);
+
+  /// Construct an empty [IntRange]
+  IntRange.empty() : super(0, 0, Bounds(Bound.inclusive, Bound.exclusive));
+
+  @override
+  (int?, Bound) _canonicalizeLower(int? lower, Bound bound) {
+    if (lower == null) return (null, Bound.exclusive);
+    if (bound == Bound.exclusive) return (lower + 1, Bound.inclusive);
+    return (lower, bound);
+  }
+
+  @override
+  (int?, Bound) _canonicalizeUpper(int? upper, Bound bound) {
+    if (upper == null) return (null, Bound.exclusive);
+    if (bound == Bound.inclusive) return (upper + 1, Bound.exclusive);
+    return (upper, bound);
+  }
+}
+
+final _z0 = DateTime.utc(1970);
+
+/// Describes PostgreSQL's builtin `daterange`
+///
+/// https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-BUILTIN
+class DateRange extends DiscreteRange<DateTime> {
+  DateRange(super.lower, super.upper, super.bounds);
+
+  /// Construct an empty [DateRange]
+  DateRange.empty() : super(_z0, _z0, Bounds(Bound.inclusive, Bound.exclusive));
+
+  /// Remove hours, minutes, seconds, milliseconds and microseconds from [DateTime]
+  DateTime? _removeTime(DateTime? dt) {
+    if (dt == null) return null;
+    final days = dt.microsecondsSinceEpoch ~/ Duration.microsecondsPerDay;
+    final microseconds = days * Duration.microsecondsPerDay;
+    return DateTime.fromMicrosecondsSinceEpoch(microseconds, isUtc: true);
+  }
+
+  @override
+  (DateTime?, Bound) _canonicalizeLower(DateTime? lower, Bound bound) {
+    if (lower == null) return (null, Bound.exclusive);
+    if (bound == Bound.exclusive) {
+      return (_removeTime(lower.add(Duration(days: 1))), Bound.inclusive);
+    }
+    return (_removeTime(lower), bound);
+  }
+
+  @override
+  (DateTime?, Bound) _canonicalizeUpper(DateTime? upper, Bound bound) {
+    if (upper == null) return (null, Bound.exclusive);
+    if (bound == Bound.inclusive) {
+      return (_removeTime(upper.add(Duration(days: 1))), Bound.exclusive);
+    }
+    return (_removeTime(upper), bound);
+  }
+}
+
+/// Describes PostgreSQL's continuous builtin range types:
+/// - `numrange`
+/// - `tsrange`
+/// - `tstzrange`
+///
+/// https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-BUILTIN
+interface class ContinuousRange<T> extends Range<T> {
+  ContinuousRange(T? lower, T? upper, Bounds bounds) {
+    _throwIfLowerGreaterThanUpper(lower, upper);
+    _lower = lower;
+    _upper = upper;
+    _bounds = _canonicalizeNullBounds(bounds);
+  }
+
+  /// Infinity (or `null`-valued) bounds are always stored as [Bound.exclusive]
+  ///
+  /// https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-INFINITE
+  Bounds _canonicalizeNullBounds(Bounds bounds) {
+    switch ((lower == null, upper == null)) {
+      case (true, true):
+        return Bounds(Bound.exclusive, Bound.exclusive);
+      case (false, true):
+        return Bounds(bounds.lower, Bound.exclusive);
+      case (true, false):
+        return Bounds(Bound.exclusive, bounds.upper);
+      case (false, false):
+        return bounds;
+    }
+  }
+}
+
+class DateTimeRange extends ContinuousRange<DateTime> {
+  DateTimeRange(super.lower, super.upper, super.bounds);
+
+  /// Construct an empty [TsRange]
+  DateTimeRange.empty()
+      : super(_z0, _z0, Bounds(Bound.inclusive, Bound.exclusive));
+}
diff --git a/lib/src/types/text_codec.dart b/lib/src/types/text_codec.dart
index ed8acb8..be0864a 100644
--- a/lib/src/types/text_codec.dart
+++ b/lib/src/types/text_codec.dart
@@ -4,6 +4,7 @@ import 'package:postgres/src/types/generic_type.dart';
 
 import '../exceptions.dart';
 import '../types.dart';
+import 'geo_types.dart';
 import 'type_registry.dart';
 
 class PostgresTextEncoder {
diff --git a/lib/src/types/type_registry.dart b/lib/src/types/type_registry.dart
index 0ec3a93..b0a1d9c 100644
--- a/lib/src/types/type_registry.dart
+++ b/lib/src/types/type_registry.dart
@@ -7,7 +7,6 @@ import 'package:postgres/src/exceptions.dart';
 import 'package:postgres/src/types/text_codec.dart';
 
 import '../types.dart';
-
 import 'generic_type.dart';
 
 typedef TypeEncoderFn = EncodeOutput Function(EncodeInput input);
@@ -19,27 +18,40 @@ class TypeOid {
   static const bigIntegerArray = 1016;
   static const boolean = 16;
   static const booleanArray = 1000;
+  static const box = 603;
   static const byteArray = 17;
   static const character = 1042;
+  static const circle = 718;
   static const date = 1082;
+  static const dateRange = 3912;
   static const double = 701;
   static const doubleArray = 1022;
+  static const int4range = 3904;
+  static const int8range = 3926;
   static const integer = 23;
   static const integerArray = 1007;
   static const interval = 1186;
   static const json = 114;
   static const jsonb = 3802;
   static const jsonbArray = 3807;
+  static const line = 628;
+  static const lineSegment = 601;
   static const name = 19;
   static const numeric = 1700;
+  static const numrange = 3906;
+  static const path = 602;
   static const point = 600;
+  static const polygon = 604;
   static const real = 700;
   static const regtype = 2206;
   static const smallInteger = 21;
   static const text = 25;
   static const textArray = 1009;
+  static const time = 1083;
   static const timestampWithoutTimezone = 1114;
   static const timestampWithTimezone = 1184;
+  static const timestampRange = 3908;
+  static const timestampTzRange = 3910;
   static const uuid = 2950;
   static const varChar = 1043;
   static const varCharArray = 1015;
@@ -59,6 +71,7 @@ final _builtInTypes = <Type>{
   Type.double,
   Type.boolean,
   Type.voidType,
+  Type.time,
   Type.timestampWithTimezone,
   Type.timestampWithoutTimezone,
   Type.interval,
@@ -69,6 +82,12 @@ final _builtInTypes = <Type>{
   Type.jsonb,
   Type.uuid,
   Type.point,
+  Type.line,
+  Type.lineSegment,
+  Type.box,
+  Type.polygon,
+  Type.path,
+  Type.circle,
   Type.booleanArray,
   Type.integerArray,
   Type.bigIntegerArray,
@@ -77,6 +96,12 @@ final _builtInTypes = <Type>{
   Type.varCharArray,
   Type.jsonbArray,
   Type.regtype,
+  Type.int4range,
+  Type.int8range,
+  Type.dateRange,
+  // Type.numrange,
+  Type.timestampRange,
+  Type.timestampTzRange,
 };
 
 final _builtInTypeNames = <String, Type>{
@@ -87,28 +112,41 @@ final _builtInTypeNames = <String, Type>{
   'char': Type.character,
   'character': Type.character,
   'date': Type.date,
+  'daterange': Type.dateRange,
   'double precision': Type.double,
   'float4': Type.real,
   'float8': Type.double,
   'int': Type.integer,
   'int2': Type.smallInteger,
   'int4': Type.integer,
+  'int4range': Type.int4range,
   'int8': Type.bigInteger,
+  'int8range': Type.int8range,
   'integer': Type.integer,
   'interval': Type.interval,
   'json': Type.json,
   'jsonb': Type.jsonb,
   'name': Type.name,
   'numeric': Type.numeric,
+  // 'numrange': Type.numrange,
   'point': Type.point,
+  'line': Type.line,
+  'lseg': Type.lineSegment,
+  'box': Type.box,
+  'polygon': Type.polygon,
+  'path': Type.path,
+  'circle': Type.circle,
   'read': Type.real,
   'regtype': Type.regtype,
   'serial4': Type.serial,
   'serial8': Type.bigSerial,
   'smallint': Type.smallInteger,
   'text': Type.text,
+  'time': Type.time,
   'timestamp': Type.timestampWithoutTimezone,
   'timestamptz': Type.timestampWithTimezone,
+  'tsrange': Type.timestampRange,
+  'tstzrange': Type.timestampTzRange,
   'varchar': Type.varChar,
   'uuid': Type.uuid,
   '_bool': Type.booleanArray,
diff --git a/pubspec.yaml b/pubspec.yaml
index 046e1dd..bd6b9aa 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,6 +1,6 @@
 name: postgres
 description: PostgreSQL database driver. Supports statement reuse and binary protocol and connection pooling.
-version: 3.0.8
+version: 3.0.9
 homepage: https://github.com/isoos/postgresql-dart
 topics:
   - sql
diff --git a/test/encoding_test.dart b/test/encoding_test.dart
index 533020c..73eec6b 100644
--- a/test/encoding_test.dart
+++ b/test/encoding_test.dart
@@ -503,6 +503,273 @@ void main() {
       await conn.execute(Sql.named('SELECT TO_TIMESTAMP(@ts:int8 / 1000)'),
           parameters: {'ts': 1640556171599});
     });
+
+    test('time', () async {
+      await expectReversible(
+        'time',
+        [
+          null,
+          Time(16, 0, 44, 0, 888),
+          Time.fromMicroseconds(57644000888),
+          Time(0, 0, 0, 0, 86400000000),
+          Time(0),
+        ],
+        expectedDartType: 'Time',
+      );
+    });
+
+    test('line', () async {
+      await expectReversible(
+        'line',
+        [
+          null,
+          Line(1, 2, 3),
+          Line(.0002, .000001, 100000),
+        ],
+        expectedDartType: 'Line',
+      );
+    });
+
+    test('lseg', () async {
+      await expectReversible(
+        'lseg',
+        [
+          null,
+          LineSegment(Point(1, 2), Point(3, 4)),
+          LineSegment(Point(1, 2), Point(1, 2)),
+        ],
+        expectedDartType: 'LineSegment',
+      );
+    });
+
+    test('box', () async {
+      await expectReversible(
+        'box',
+        [
+          null,
+          Box(Point(1, 2), Point(3, 4)),
+          Box(Point(1.0, 2), Point(1, 2)),
+          Box(Point(3, 4), Point(-12, -12312.123412)),
+        ],
+        expectedDartType: 'Box',
+      );
+    });
+
+    test('polygon', () async {
+      await expectReversible(
+        'polygon',
+        [
+          null,
+          Polygon([Point(0, 0)]),
+          Polygon([Point(1, 2), Point(3, 4), Point(5, 6), Point(7, 8.2)]),
+          Polygon([Point(1, 2), Point(3, 4), Point(5, 6), Point(-7, -8.2)]),
+        ],
+        expectedDartType: 'Polygon',
+      );
+    });
+
+    test('path', () async {
+      await expectReversible(
+        'path',
+        [
+          null,
+          Path([Point(0, 0)], false),
+          Path([Point(1, 2), Point(3, 4), Point(5, 6), Point(7, 8.2)], true),
+          Path([Point(1, 2), Point(3, 4), Point(5, 6), Point(-7, -8.2)], true),
+        ],
+        expectedDartType: 'Path',
+      );
+    });
+
+    test('circle', () async {
+      await expectReversible(
+        'circle',
+        [
+          null,
+          Circle(Point(0, 0), 0),
+          Circle(Point(-1, 1), 1.234),
+        ],
+        expectedDartType: 'Circle',
+      );
+    });
+
+    test('int4range', () async {
+      await expectReversible(
+        'int4range',
+        [
+          null,
+          // normal ranges
+          IntRange(4, 4, Bounds(Bound.inclusive, Bound.inclusive)),
+          IntRange(4, 5, Bounds(Bound.inclusive, Bound.inclusive)),
+          IntRange(4, 6, Bounds(Bound.exclusive, Bound.exclusive)),
+          // partially unbounded ranges
+          IntRange(null, 4, Bounds(Bound.inclusive, Bound.exclusive)),
+          IntRange(4, null, Bounds(Bound.inclusive, Bound.exclusive)),
+          IntRange(null, 4, Bounds(Bound.exclusive, Bound.inclusive)),
+          IntRange(4, null, Bounds(Bound.exclusive, Bound.inclusive)),
+          // unbounded ranges
+          IntRange(null, null, Bounds(Bound.exclusive, Bound.inclusive)),
+          IntRange(null, null, Bounds(Bound.exclusive, Bound.exclusive)),
+          IntRange(null, null, Bounds(Bound.inclusive, Bound.exclusive)),
+          IntRange(null, null, Bounds(Bound.inclusive, Bound.inclusive)),
+          // empty ranges
+          IntRange(4, 4, Bounds(Bound.exclusive, Bound.exclusive)),
+          IntRange(4, 4, Bounds(Bound.inclusive, Bound.exclusive)),
+          IntRange(4, 4, Bounds(Bound.exclusive, Bound.inclusive)),
+          IntRange(4, 5, Bounds(Bound.exclusive, Bound.exclusive)),
+        ],
+        expectedDartType: 'IntRange',
+      );
+    });
+
+    test('int8range', () async {
+      await expectReversible(
+        'int8range',
+        [
+          null,
+          // normal ranges
+          IntRange(4, 4, Bounds(Bound.inclusive, Bound.inclusive)),
+          IntRange(4, 5, Bounds(Bound.inclusive, Bound.inclusive)),
+          IntRange(4, 6, Bounds(Bound.exclusive, Bound.exclusive)),
+          // partially unbounded ranges
+          IntRange(null, 4, Bounds(Bound.inclusive, Bound.exclusive)),
+          IntRange(4, null, Bounds(Bound.inclusive, Bound.exclusive)),
+          IntRange(null, 4, Bounds(Bound.exclusive, Bound.inclusive)),
+          IntRange(4, null, Bounds(Bound.exclusive, Bound.inclusive)),
+          // unbounded ranges
+          IntRange(null, null, Bounds(Bound.exclusive, Bound.inclusive)),
+          IntRange(null, null, Bounds(Bound.exclusive, Bound.exclusive)),
+          IntRange(null, null, Bounds(Bound.inclusive, Bound.exclusive)),
+          IntRange(null, null, Bounds(Bound.inclusive, Bound.inclusive)),
+          // empty ranges
+          IntRange(4, 4, Bounds(Bound.exclusive, Bound.exclusive)),
+          IntRange(4, 4, Bounds(Bound.inclusive, Bound.exclusive)),
+          IntRange(4, 4, Bounds(Bound.exclusive, Bound.inclusive)),
+          IntRange(4, 5, Bounds(Bound.exclusive, Bound.exclusive)),
+        ],
+        expectedDartType: 'IntRange',
+      );
+    });
+
+    test('daterange', () async {
+      await expectReversible(
+        'daterange',
+        [
+          null,
+          // normal ranges
+          DateRange(DateTime.utc(2000, 4, 4), DateTime.utc(2000, 4, 4, 12),
+              Bounds(Bound.inclusive, Bound.inclusive)),
+          DateRange(DateTime.utc(2000, 4, 4), DateTime.utc(2000, 4, 5),
+              Bounds(Bound.inclusive, Bound.inclusive)),
+          DateRange(DateTime.utc(2000, 4, 4), DateTime.utc(2000, 4, 6),
+              Bounds(Bound.exclusive, Bound.exclusive)),
+          // partially unbounded ranges
+          DateRange(null, DateTime.utc(2000, 4, 4),
+              Bounds(Bound.inclusive, Bound.exclusive)),
+          DateRange(DateTime.utc(2000, 4, 4), null,
+              Bounds(Bound.inclusive, Bound.exclusive)),
+          DateRange(null, DateTime.utc(2000, 4, 4),
+              Bounds(Bound.exclusive, Bound.inclusive)),
+          DateRange(DateTime.utc(2000, 4, 4), null,
+              Bounds(Bound.exclusive, Bound.inclusive)),
+          // unbounded ranges
+          DateRange(null, null, Bounds(Bound.exclusive, Bound.inclusive)),
+          DateRange(null, null, Bounds(Bound.exclusive, Bound.exclusive)),
+          DateRange(null, null, Bounds(Bound.inclusive, Bound.exclusive)),
+          DateRange(null, null, Bounds(Bound.inclusive, Bound.inclusive)),
+          // empty ranges
+          DateRange(DateTime.utc(2000, 4, 4), DateTime.utc(2000, 4, 4, 12),
+              Bounds(Bound.exclusive, Bound.exclusive)),
+          DateRange(DateTime.utc(2000, 4, 4), DateTime.utc(2000, 4, 4),
+              Bounds(Bound.inclusive, Bound.exclusive)),
+          DateRange(DateTime.utc(2000, 4, 4), DateTime.utc(2000, 4, 4),
+              Bounds(Bound.exclusive, Bound.inclusive)),
+          DateRange(DateTime.utc(2000, 4, 4), DateTime.utc(2000, 4, 5),
+              Bounds(Bound.exclusive, Bound.exclusive)),
+        ],
+        expectedDartType: 'DateRange',
+      );
+    });
+
+    test('tsrange', () async {
+      await expectReversible(
+        'tsrange',
+        [
+          null,
+          // normal ranges
+          DateTimeRange(DateTime.utc(2000, 4, 4), DateTime.utc(2000, 4, 4, 12),
+              Bounds(Bound.inclusive, Bound.inclusive)),
+          DateTimeRange(DateTime.utc(2000, 4, 4), DateTime.utc(2000, 4, 5),
+              Bounds(Bound.inclusive, Bound.inclusive)),
+          DateTimeRange(DateTime.utc(2000, 4, 4), DateTime.utc(2000, 4, 6),
+              Bounds(Bound.exclusive, Bound.exclusive)),
+          // partially unbounded ranges
+          DateTimeRange(null, DateTime.utc(2000, 4, 4),
+              Bounds(Bound.inclusive, Bound.exclusive)),
+          DateTimeRange(DateTime.utc(2000, 4, 4), null,
+              Bounds(Bound.inclusive, Bound.exclusive)),
+          DateTimeRange(null, DateTime.utc(2000, 4, 4),
+              Bounds(Bound.exclusive, Bound.inclusive)),
+          DateTimeRange(DateTime.utc(2000, 4, 4), null,
+              Bounds(Bound.exclusive, Bound.inclusive)),
+          // unbounded ranges
+          DateTimeRange(null, null, Bounds(Bound.exclusive, Bound.inclusive)),
+          DateTimeRange(null, null, Bounds(Bound.exclusive, Bound.exclusive)),
+          DateTimeRange(null, null, Bounds(Bound.inclusive, Bound.exclusive)),
+          DateTimeRange(null, null, Bounds(Bound.inclusive, Bound.inclusive)),
+          // empty ranges
+          DateTimeRange(DateTime.utc(2000, 4, 4), DateTime.utc(2000, 4, 4),
+              Bounds(Bound.exclusive, Bound.exclusive)),
+          DateTimeRange(DateTime.utc(2000, 4, 4), DateTime.utc(2000, 4, 4),
+              Bounds(Bound.inclusive, Bound.exclusive)),
+          DateTimeRange(DateTime.utc(2000, 4, 4), DateTime.utc(2000, 4, 4),
+              Bounds(Bound.exclusive, Bound.inclusive)),
+          DateTimeRange(DateTime.utc(2000, 4, 4), DateTime.utc(2000, 4, 5),
+              Bounds(Bound.exclusive, Bound.exclusive)),
+        ],
+        expectedDartType: 'DateTimeRange',
+      );
+    });
+
+    test('tstzrange', () async {
+      await expectReversible(
+        'tstzrange',
+        [
+          null,
+          // normal ranges
+          DateTimeRange(DateTime.utc(2000, 4, 4), DateTime.utc(2000, 4, 4, 12),
+              Bounds(Bound.inclusive, Bound.inclusive)),
+          DateTimeRange(DateTime.utc(2000, 4, 4), DateTime.utc(2000, 4, 5),
+              Bounds(Bound.inclusive, Bound.inclusive)),
+          DateTimeRange(DateTime.utc(2000, 4, 4), DateTime.utc(2000, 4, 6),
+              Bounds(Bound.exclusive, Bound.exclusive)),
+          // partially unbounded ranges
+          DateTimeRange(null, DateTime.utc(2000, 4, 4),
+              Bounds(Bound.inclusive, Bound.exclusive)),
+          DateTimeRange(DateTime.utc(2000, 4, 4), null,
+              Bounds(Bound.inclusive, Bound.exclusive)),
+          DateTimeRange(null, DateTime.utc(2000, 4, 4),
+              Bounds(Bound.exclusive, Bound.inclusive)),
+          DateTimeRange(DateTime.utc(2000, 4, 4), null,
+              Bounds(Bound.exclusive, Bound.inclusive)),
+          // unbounded ranges
+          DateTimeRange(null, null, Bounds(Bound.exclusive, Bound.inclusive)),
+          DateTimeRange(null, null, Bounds(Bound.exclusive, Bound.exclusive)),
+          DateTimeRange(null, null, Bounds(Bound.inclusive, Bound.exclusive)),
+          DateTimeRange(null, null, Bounds(Bound.inclusive, Bound.inclusive)),
+          // empty ranges
+          DateTimeRange(DateTime.utc(2000, 4, 4), DateTime.utc(2000, 4, 4),
+              Bounds(Bound.exclusive, Bound.exclusive)),
+          DateTimeRange(DateTime.utc(2000, 4, 4), DateTime.utc(2000, 4, 4),
+              Bounds(Bound.inclusive, Bound.exclusive)),
+          DateTimeRange(DateTime.utc(2000, 4, 4), DateTime.utc(2000, 4, 4),
+              Bounds(Bound.exclusive, Bound.inclusive)),
+          DateTimeRange(DateTime.utc(2000, 4, 4), DateTime.utc(2000, 4, 5),
+              Bounds(Bound.exclusive, Bound.exclusive)),
+        ],
+        expectedDartType: 'DateTimeRange',
+      );
+    });
   });
 
   group('Text encoders', () {