const (
	secondsPerMinute       = 60
	secondsPerHour         = 60 * 60
	secondsPerDay          = 24 * secondsPerHour
	unixToInternal   int64 = (1969*365 + 1969/4 - 1969/100 + 1969/400) * secondsPerDay
)

var (
	MinTime = time.Unix(0, 0)
	MaxTime = time.Unix(1<<63-1-unixToInternal, 999999999)
)

func TryWrapTimeEncodePlan(value interface{}) (plan pgtype.WrappedEncodePlanNextSetter, nextValue interface{}, ok bool) {
	switch value := value.(type) {
	case time.Time:
		return &wrapTimeEncodePlan{}, timeWrapper(value), true
	}

	return nil, nil, false
}

type wrapTimeEncodePlan struct {
	next pgtype.EncodePlan
}

func (plan *wrapTimeEncodePlan) SetNext(next pgtype.EncodePlan) { plan.next = next }

func (plan *wrapTimeEncodePlan) Encode(value any, buf []byte) (newBuf []byte, err error) {
	return plan.next.Encode(timeWrapper(value.(time.Time)), buf)
}

func TryWrapTimeScanPlan(target any) (plan pgtype.WrappedScanPlanNextSetter, nextDst any, ok bool) {
	switch target := target.(type) {
	case *time.Time:
		return &wrapTimeScanPlan{}, (*timeWrapper)(target), true
	}

	return nil, nil, false
}

type wrapTimeScanPlan struct {
	next pgtype.ScanPlan
}

func (plan *wrapTimeScanPlan) SetNext(next pgtype.ScanPlan) { plan.next = next }

func (plan *wrapTimeScanPlan) Scan(src []byte, dst any) error {
	return plan.next.Scan(src, (*timeWrapper)(dst.(*time.Time)))
}

type timeWrapper time.Time

func (w *timeWrapper) ScanTimestamptz(v pgtype.Timestamptz) error {
	if !v.Valid {
		return fmt.Errorf("cannot scan NULL into *time.Time")
	}

	switch v.InfinityModifier {
	case pgtype.Finite:
		*w = timeWrapper(v.Time)
		return nil
	case pgtype.Infinity:
		*w = timeWrapper(MaxTime)
		return nil
	case pgtype.NegativeInfinity:
		*w = timeWrapper(MinTime)
		return nil
	default:
		return fmt.Errorf("invalid InfinityModifier: %v", v.InfinityModifier)
	}
}

func (w timeWrapper) TimestamptzValue() (pgtype.Timestamptz, error) {
	infinityModifier := pgtype.Finite
	if time.Time(w).Equal(MaxTime) {
		infinityModifier = pgtype.Infinity
	} else if time.Time(w).Equal(MinTime) {
		infinityModifier = pgtype.NegativeInfinity
	}
	return pgtype.Timestamptz{Time: time.Time(w), InfinityModifier: infinityModifier, Valid: true}, nil
}

// ...
	config.AfterConnect = func(ctx context.Context, conn *pgx.Conn) error {
		tm := conn.TypeMap()
		tm.TryWrapEncodePlanFuncs = append([]pgtype.TryWrapEncodePlanFunc{TryWrapTimeEncodePlan}, tm.TryWrapEncodePlanFuncs...)
		tm.TryWrapScanPlanFuncs = append([]pgtype.TryWrapScanPlanFunc{TryWrapTimeScanPlan}, tm.TryWrapScanPlanFuncs...)
		return nil
	}
// ...
	var tmin, tmax, tval time.Time
	err := pool.
		QueryRow(context.Background(), "select '-infinity'::timestamptz, 'infinity'::timestamptz, '2024-01-01T00:00:00Z'::timestamptz").
		Scan(&tmin, &tmax, &tval)
// ...