diff --git a/bfcodegen/id-generate.template b/bfcodegen/id-generate.template
index 6d9af2e..eddf863 100644
--- a/bfcodegen/id-generate.template
+++ b/bfcodegen/id-generate.template
@@ -2,9 +2,7 @@
 
 package {{.PkgName}}
 
-import "go.mongodb.org/mongo-driver/bson"
-import "go.mongodb.org/mongo-driver/bson/bsontype"
-import "go.mongodb.org/mongo-driver/bson/primitive"
+import "go.mongodb.org/mongo-driver/v2/bson"
 import "git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 
 const ChecksumIDGenerator = "{{.Checksum}}" // GoExtVersion: {{.GoextVersion}}
@@ -13,9 +11,10 @@ const ChecksumIDGenerator = "{{.Checksum}}" // GoExtVersion: {{.GoextVersion}}
 
 // ================================ {{.Name}} ({{.FileRelative}}) ================================
 
-func (i {{.Name}}) MarshalBSONValue() (bsontype.Type, []byte, error) {
-	if objId, err := primitive.ObjectIDFromHex(string(i)); err == nil {
-		return bson.MarshalValue(objId)
+func (i {{.Name}}) MarshalBSONValue() (byte, []byte, error) {
+	if objId, err := bson.ObjectIDFromHex(string(i)); err == nil {
+		tp, data, err := bson.MarshalValue(objId)
+		return byte(tp), data, err
 	} else {
 		return 0, nil, exerr.New(exerr.TypeMarshalEntityID, "Failed to marshal {{.Name}}("+i.String()+") to ObjectId").Str("value", string(i)).Type("type", i).Build()
 	}
@@ -25,12 +24,12 @@ func (i {{.Name}}) String() string {
 	return string(i)
 }
 
-func (i {{.Name}}) ObjID() (primitive.ObjectID, error) {
-	return primitive.ObjectIDFromHex(string(i))
+func (i {{.Name}}) ObjID() (bson.ObjectID, error) {
+	return bson.ObjectIDFromHex(string(i))
 }
 
 func (i {{.Name}}) Valid() bool {
-	_, err := primitive.ObjectIDFromHex(string(i))
+	_, err := bson.ObjectIDFromHex(string(i))
 	return err == nil
 }
 
@@ -50,7 +49,7 @@ func (i {{.Name}}) IsZero() bool {
 }
 
 func New{{.Name}}() {{.Name}} {
-	return {{.Name}}(primitive.NewObjectID().Hex())
+	return {{.Name}}(bson.NewObjectID().Hex())
 }
 
 {{end}}
\ No newline at end of file
diff --git a/cursortoken/filter.go b/cursortoken/filter.go
index 4aa3b29..f63c124 100644
--- a/cursortoken/filter.go
+++ b/cursortoken/filter.go
@@ -2,7 +2,8 @@ package cursortoken
 
 import (
 	"context"
-	"go.mongodb.org/mongo-driver/mongo"
+
+	"go.mongodb.org/mongo-driver/v2/mongo"
 )
 
 type RawFilter interface {
diff --git a/cursortoken/tokenKeySort.go b/cursortoken/tokenKeySort.go
index 4b03bb6..fd48165 100644
--- a/cursortoken/tokenKeySort.go
+++ b/cursortoken/tokenKeySort.go
@@ -3,8 +3,9 @@ package cursortoken
 import (
 	"encoding/base32"
 	"encoding/json"
-	"go.mongodb.org/mongo-driver/bson/primitive"
 	"time"
+
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
 type CTKeySort struct {
@@ -119,18 +120,18 @@ func (c CTKeySort) IsStart() bool {
 	return c.Mode == CTMStart
 }
 
-func (c CTKeySort) valuePrimaryObjectId() (primitive.ObjectID, bool) {
-	if oid, err := primitive.ObjectIDFromHex(c.ValuePrimary); err == nil {
+func (c CTKeySort) valuePrimaryObjectId() (bson.ObjectID, bool) {
+	if oid, err := bson.ObjectIDFromHex(c.ValuePrimary); err == nil {
 		return oid, true
 	} else {
-		return primitive.ObjectID{}, false
+		return bson.ObjectID{}, false
 	}
 }
 
-func (c CTKeySort) valueSecondaryObjectId() (primitive.ObjectID, bool) {
-	if oid, err := primitive.ObjectIDFromHex(c.ValueSecondary); err == nil {
+func (c CTKeySort) valueSecondaryObjectId() (bson.ObjectID, bool) {
+	if oid, err := bson.ObjectIDFromHex(c.ValueSecondary); err == nil {
 		return oid, true
 	} else {
-		return primitive.ObjectID{}, false
+		return bson.ObjectID{}, false
 	}
 }
diff --git a/exerr/builder.go b/exerr/builder.go
index ecf8738..7cbcfda 100644
--- a/exerr/builder.go
+++ b/exerr/builder.go
@@ -16,7 +16,7 @@ import (
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"github.com/gin-gonic/gin"
 	"github.com/rs/zerolog"
-	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
 //
@@ -253,7 +253,7 @@ func (b *Builder) Bytes(key string, val []byte) *Builder {
 	return b.addMeta(key, MDTBytes, val)
 }
 
-func (b *Builder) ObjectID(key string, val primitive.ObjectID) *Builder {
+func (b *Builder) ObjectID(key string, val bson.ObjectID) *Builder {
 	return b.addMeta(key, MDTObjectID, val)
 }
 
diff --git a/exerr/constructor.go b/exerr/constructor.go
index 9e17a90..78cd3a1 100644
--- a/exerr/constructor.go
+++ b/exerr/constructor.go
@@ -3,11 +3,12 @@ package exerr
 import (
 	"encoding/json"
 	"fmt"
-	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"go.mongodb.org/mongo-driver/bson/primitive"
 	"maps"
 	"reflect"
 	"time"
+
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
 var reflectTypeStr = reflect.TypeFor[string]()
@@ -222,7 +223,7 @@ func getReflectedMetaValues(value any, remainingDepth int) map[string]MetaValue
 		return map[string]MetaValue{"": {DataType: MDTIntArray, Value: ifraw}}
 	case []int32:
 		return map[string]MetaValue{"": {DataType: MDTInt32Array, Value: ifraw}}
-	case primitive.ObjectID:
+	case bson.ObjectID:
 		return map[string]MetaValue{"": {DataType: MDTObjectID, Value: ifraw}}
 	case []string:
 		return map[string]MetaValue{"": {DataType: MDTStringArray, Value: ifraw}}
diff --git a/exerr/dataCategory.go b/exerr/dataCategory.go
index f1fd396..ced8453 100644
--- a/exerr/dataCategory.go
+++ b/exerr/dataCategory.go
@@ -4,11 +4,8 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"reflect"
+
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
 type ErrorCategory struct{ Category string }
@@ -28,8 +25,8 @@ func (e ErrorCategory) MarshalJSON() ([]byte, error) {
 	return json.Marshal(e.Category)
 }
 
-func (e *ErrorCategory) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
-	if bt == bson.TypeNull {
+func (e *ErrorCategory) UnmarshalBSONValue(bt byte, data []byte) error {
+	if bson.Type(bt) == bson.TypeNull {
 		// we can't set nil in UnmarshalBSONValue (so we use default(struct))
 		// Use mongoext.CreateGoExtBsonRegistry if you need to unmarsh pointer values
 		// https://stackoverflow.com/questions/75167597
@@ -37,11 +34,11 @@ func (e *ErrorCategory) UnmarshalBSONValue(bt bsontype.Type, data []byte) error
 		*e = ErrorCategory{}
 		return nil
 	}
-	if bt != bson.TypeString {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into String", bt))
+	if bson.Type(bt) != bson.TypeString {
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into String", bson.Type(bt)))
 	}
 	var tt string
-	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)
+	err := bson.RawValue{Type: bson.Type(bt), Value: data}.Unmarshal(&tt)
 	if err != nil {
 		return err
 	}
@@ -49,40 +46,9 @@ func (e *ErrorCategory) UnmarshalBSONValue(bt bsontype.Type, data []byte) error
 	return nil
 }
 
-func (e ErrorCategory) MarshalBSONValue() (bsontype.Type, []byte, error) {
-	return bson.MarshalValue(e.Category)
-}
-
-func (e ErrorCategory) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
-	if val.Kind() == reflect.Pointer && val.IsNil() {
-		if !val.CanSet() {
-			return errors.New("ValueUnmarshalerDecodeValue")
-		}
-		val.Set(reflect.New(val.Type().Elem()))
-	}
-
-	tp, src, err := bsonrw.Copier{}.CopyValueToBytes(vr)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer && len(src) == 0 {
-		val.Set(reflect.Zero(val.Type()))
-		return nil
-	}
-
-	err = e.UnmarshalBSONValue(tp, src)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer {
-		val.Set(reflect.ValueOf(&e))
-	} else {
-		val.Set(reflect.ValueOf(e))
-	}
-
-	return nil
+func (e ErrorCategory) MarshalBSONValue() (byte, []byte, error) {
+	tp, data, err := bson.MarshalValue(e.Category)
+	return byte(tp), data, err
 }
 
 //goland:noinspection GoUnusedGlobalVariable
diff --git a/exerr/dataSeverity.go b/exerr/dataSeverity.go
index 21b75c8..293e418 100644
--- a/exerr/dataSeverity.go
+++ b/exerr/dataSeverity.go
@@ -4,11 +4,8 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"reflect"
+
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
 type ErrorSeverity struct{ Severity string }
@@ -30,8 +27,8 @@ func (e ErrorSeverity) MarshalJSON() ([]byte, error) {
 	return json.Marshal(e.Severity)
 }
 
-func (e *ErrorSeverity) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
-	if bt == bson.TypeNull {
+func (e *ErrorSeverity) UnmarshalBSONValue(bt byte, data []byte) error {
+	if bson.Type(bt) == bson.TypeNull {
 		// we can't set nil in UnmarshalBSONValue (so we use default(struct))
 		// Use mongoext.CreateGoExtBsonRegistry if you need to unmarsh pointer values
 		// https://stackoverflow.com/questions/75167597
@@ -39,11 +36,11 @@ func (e *ErrorSeverity) UnmarshalBSONValue(bt bsontype.Type, data []byte) error
 		*e = ErrorSeverity{}
 		return nil
 	}
-	if bt != bson.TypeString {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into String", bt))
+	if bson.Type(bt) != bson.TypeString {
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into String", bson.Type(bt)))
 	}
 	var tt string
-	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)
+	err := bson.RawValue{Type: bson.Type(bt), Value: data}.Unmarshal(&tt)
 	if err != nil {
 		return err
 	}
@@ -51,40 +48,9 @@ func (e *ErrorSeverity) UnmarshalBSONValue(bt bsontype.Type, data []byte) error
 	return nil
 }
 
-func (e ErrorSeverity) MarshalBSONValue() (bsontype.Type, []byte, error) {
-	return bson.MarshalValue(e.Severity)
-}
-
-func (e ErrorSeverity) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
-	if val.Kind() == reflect.Pointer && val.IsNil() {
-		if !val.CanSet() {
-			return errors.New("ValueUnmarshalerDecodeValue")
-		}
-		val.Set(reflect.New(val.Type().Elem()))
-	}
-
-	tp, src, err := bsonrw.Copier{}.CopyValueToBytes(vr)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer && len(src) == 0 {
-		val.Set(reflect.Zero(val.Type()))
-		return nil
-	}
-
-	err = e.UnmarshalBSONValue(tp, src)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer {
-		val.Set(reflect.ValueOf(&e))
-	} else {
-		val.Set(reflect.ValueOf(e))
-	}
-
-	return nil
+func (e ErrorSeverity) MarshalBSONValue() (byte, []byte, error) {
+	tp, data, err := bson.MarshalValue(e.Severity)
+	return byte(tp), data, err
 }
 
 //goland:noinspection GoUnusedGlobalVariable
diff --git a/exerr/dataType.go b/exerr/dataType.go
index 2d591d2..c38f76a 100644
--- a/exerr/dataType.go
+++ b/exerr/dataType.go
@@ -4,13 +4,9 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"reflect"
 
 	"git.blackforestbytes.com/BlackForestBytes/goext/dataext"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
 type ErrorType struct {
@@ -80,8 +76,8 @@ func (e ErrorType) MarshalJSON() ([]byte, error) {
 	return json.Marshal(e.Key)
 }
 
-func (e *ErrorType) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
-	if bt == bson.TypeNull {
+func (e *ErrorType) UnmarshalBSONValue(bt byte, data []byte) error {
+	if bson.Type(bt) == bson.TypeNull {
 		// we can't set nil in UnmarshalBSONValue (so we use default(struct))
 		// Use mongoext.CreateGoExtBsonRegistry if you need to unmarsh pointer values
 		// https://stackoverflow.com/questions/75167597
@@ -89,11 +85,11 @@ func (e *ErrorType) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
 		*e = ErrorType{}
 		return nil
 	}
-	if bt != bson.TypeString {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into String", bt))
+	if bson.Type(bt) != bson.TypeString {
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into String", bson.Type(bt)))
 	}
 	var tt string
-	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)
+	err := bson.RawValue{Type: bson.Type(bt), Value: data}.Unmarshal(&tt)
 	if err != nil {
 		return err
 	}
@@ -107,40 +103,9 @@ func (e *ErrorType) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
 	}
 }
 
-func (e ErrorType) MarshalBSONValue() (bsontype.Type, []byte, error) {
-	return bson.MarshalValue(e.Key)
-}
-
-func (e ErrorType) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
-	if val.Kind() == reflect.Pointer && val.IsNil() {
-		if !val.CanSet() {
-			return errors.New("ValueUnmarshalerDecodeValue")
-		}
-		val.Set(reflect.New(val.Type().Elem()))
-	}
-
-	tp, src, err := bsonrw.Copier{}.CopyValueToBytes(vr)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer && len(src) == 0 {
-		val.Set(reflect.Zero(val.Type()))
-		return nil
-	}
-
-	err = e.UnmarshalBSONValue(tp, src)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer {
-		val.Set(reflect.ValueOf(&e))
-	} else {
-		val.Set(reflect.ValueOf(e))
-	}
-
-	return nil
+func (e ErrorType) MarshalBSONValue() (byte, []byte, error) {
+	tp, data, err := bson.MarshalValue(e.Key)
+	return byte(tp), data, err
 }
 
 var registeredTypes = dataext.SyncMap[string, ErrorType]{}
diff --git a/exerr/data_test.go b/exerr/data_test.go
index 8687e22..65b0992 100644
--- a/exerr/data_test.go
+++ b/exerr/data_test.go
@@ -3,12 +3,12 @@ package exerr
 import (
 	"context"
 	"encoding/json"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-	"go.mongodb.org/mongo-driver/mongo"
-	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"testing"
 	"time"
+
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
 )
 
 func TestJSONMarshalErrorCategory(t *testing.T) {
@@ -57,7 +57,7 @@ func TestBSONMarshalErrorCategory(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), 350*time.Millisecond)
 	defer cancel()
 
-	client, err := mongo.Connect(ctx)
+	client, err := mongo.Connect()
 	if err != nil {
 		t.Skip("Skip test - no local mongo found")
 		return
@@ -68,7 +68,7 @@ func TestBSONMarshalErrorCategory(t *testing.T) {
 		return
 	}
 
-	primimd := primitive.NewObjectID()
+	primimd := bson.NewObjectID()
 
 	_, err = client.Database("_test").Collection("goext-cicd").InsertOne(ctx, bson.M{"_id": primimd, "val": CatSystem})
 	tst.AssertNoErr(t, err)
@@ -76,8 +76,8 @@ func TestBSONMarshalErrorCategory(t *testing.T) {
 	cursor := client.Database("_test").Collection("goext-cicd").FindOne(ctx, bson.M{"_id": primimd, "val": bson.M{"$type": "string"}})
 
 	var c1 struct {
-		ID  primitive.ObjectID `bson:"_id"`
-		Val ErrorCategory      `bson:"val"`
+		ID  bson.ObjectID `bson:"_id"`
+		Val ErrorCategory `bson:"val"`
 	}
 
 	err = cursor.Decode(&c1)
@@ -90,7 +90,7 @@ func TestBSONMarshalErrorSeverity(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), 350*time.Millisecond)
 	defer cancel()
 
-	client, err := mongo.Connect(ctx)
+	client, err := mongo.Connect()
 	if err != nil {
 		t.Skip("Skip test - no local mongo found")
 		return
@@ -101,7 +101,7 @@ func TestBSONMarshalErrorSeverity(t *testing.T) {
 		return
 	}
 
-	primimd := primitive.NewObjectID()
+	primimd := bson.NewObjectID()
 
 	_, err = client.Database("_test").Collection("goext-cicd").InsertOne(ctx, bson.M{"_id": primimd, "val": SevErr})
 	tst.AssertNoErr(t, err)
@@ -109,8 +109,8 @@ func TestBSONMarshalErrorSeverity(t *testing.T) {
 	cursor := client.Database("_test").Collection("goext-cicd").FindOne(ctx, bson.M{"_id": primimd, "val": bson.M{"$type": "string"}})
 
 	var c1 struct {
-		ID  primitive.ObjectID `bson:"_id"`
-		Val ErrorSeverity      `bson:"val"`
+		ID  bson.ObjectID `bson:"_id"`
+		Val ErrorSeverity `bson:"val"`
 	}
 
 	err = cursor.Decode(&c1)
@@ -123,7 +123,7 @@ func TestBSONMarshalErrorType(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), 350*time.Millisecond)
 	defer cancel()
 
-	client, err := mongo.Connect(ctx)
+	client, err := mongo.Connect()
 	if err != nil {
 		t.Skip("Skip test - no local mongo found")
 		return
@@ -134,7 +134,7 @@ func TestBSONMarshalErrorType(t *testing.T) {
 		return
 	}
 
-	primimd := primitive.NewObjectID()
+	primimd := bson.NewObjectID()
 
 	_, err = client.Database("_test").Collection("goext-cicd").InsertOne(ctx, bson.M{"_id": primimd, "val": TypeNotImplemented})
 	tst.AssertNoErr(t, err)
@@ -142,8 +142,8 @@ func TestBSONMarshalErrorType(t *testing.T) {
 	cursor := client.Database("_test").Collection("goext-cicd").FindOne(ctx, bson.M{"_id": primimd, "val": bson.M{"$type": "string"}})
 
 	var c1 struct {
-		ID  primitive.ObjectID `bson:"_id"`
-		Val ErrorType          `bson:"val"`
+		ID  bson.ObjectID `bson:"_id"`
+		Val ErrorType     `bson:"val"`
 	}
 
 	err = cursor.Decode(&c1)
diff --git a/exerr/meta.go b/exerr/meta.go
index b2078b7..2f2551c 100644
--- a/exerr/meta.go
+++ b/exerr/meta.go
@@ -5,14 +5,14 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"github.com/rs/zerolog"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/primitive"
 	"math"
 	"strconv"
 	"strings"
 	"time"
+
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"github.com/rs/zerolog"
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
 // This is a buffed up map[string]any
@@ -99,7 +99,7 @@ func (v MetaValue) SerializeValue() (string, error) {
 	case MDTBytes:
 		return hex.EncodeToString(v.Value.([]byte)), nil
 	case MDTObjectID:
-		return v.Value.(primitive.ObjectID).Hex(), nil
+		return v.Value.(bson.ObjectID).Hex(), nil
 	case MDTTime:
 		return strconv.FormatInt(v.Value.(time.Time).Unix(), 10) + "|" + strconv.FormatInt(int64(v.Value.(time.Time).Nanosecond()), 10), nil
 	case MDTDuration:
@@ -178,7 +178,7 @@ func (v MetaValue) ShortString(lim int) string {
 	case MDTBytes:
 		return langext.StrLimit(hex.EncodeToString(v.Value.([]byte)), lim, "...")
 	case MDTObjectID:
-		return v.Value.(primitive.ObjectID).Hex()
+		return v.Value.(bson.ObjectID).Hex()
 	case MDTTime:
 		return v.Value.(time.Time).Format(time.RFC3339)
 	case MDTDuration:
@@ -266,7 +266,7 @@ func (v MetaValue) Apply(key string, evt *zerolog.Event, limitLen *int) *zerolog
 	case MDTBytes:
 		return evt.Bytes(key, v.Value.([]byte))
 	case MDTObjectID:
-		return evt.Str(key, v.Value.(primitive.ObjectID).Hex())
+		return evt.Str(key, v.Value.(bson.ObjectID).Hex())
 	case MDTTime:
 		return evt.Time(key, v.Value.(time.Time))
 	case MDTDuration:
@@ -460,7 +460,7 @@ func (v *MetaValue) Deserialize(value string, datatype metaDataType) error {
 		v.DataType = datatype
 		return nil
 	case MDTObjectID:
-		r, err := primitive.ObjectIDFromHex(value)
+		r, err := bson.ObjectIDFromHex(value)
 		if err != nil {
 			return err
 		}
@@ -577,7 +577,7 @@ func (v MetaValue) ValueString() string {
 	case MDTBytes:
 		return hex.EncodeToString(v.Value.([]byte))
 	case MDTObjectID:
-		return v.Value.(primitive.ObjectID).Hex()
+		return v.Value.(bson.ObjectID).Hex()
 	case MDTTime:
 		return v.Value.(time.Time).Format(time.RFC3339Nano)
 	case MDTDuration:
@@ -628,8 +628,8 @@ func (v MetaValue) rawValueForJson() any {
 		if v.Value.(AnyWrap).IsError {
 			return bson.M{"@error": true}
 		}
-		jsonobj := primitive.M{}
-		jsonarr := primitive.A{}
+		jsonobj := bson.M{}
+		jsonarr := bson.A{}
 		if err := json.Unmarshal([]byte(v.Value.(AnyWrap).Json), &jsonobj); err == nil {
 			return jsonobj
 		} else if err := json.Unmarshal([]byte(v.Value.(AnyWrap).Json), &jsonarr); err == nil {
@@ -654,7 +654,7 @@ func (v MetaValue) rawValueForJson() any {
 		return v.Value.(time.Time).Format(time.RFC3339Nano)
 	}
 	if v.DataType == MDTObjectID {
-		return v.Value.(primitive.ObjectID).Hex()
+		return v.Value.(bson.ObjectID).Hex()
 	}
 	if v.DataType == MDTNil {
 		return nil
diff --git a/go.mod b/go.mod
index d8d0e25..5c86502 100644
--- a/go.mod
+++ b/go.mod
@@ -8,7 +8,7 @@ require (
 	github.com/jmoiron/sqlx v1.4.0
 	github.com/rs/xid v1.6.0
 	github.com/rs/zerolog v1.35.1
-	go.mongodb.org/mongo-driver v1.17.9
+	go.mongodb.org/mongo-driver/v2 v2.5.1
 	golang.org/x/crypto v0.50.0
 	golang.org/x/sys v0.43.0
 	golang.org/x/term v0.42.0
@@ -20,6 +20,7 @@ require (
 	github.com/gorilla/websocket v1.5.3
 	github.com/jung-kurt/gofpdf v1.16.2
 	github.com/xuri/excelize/v2 v2.10.1
+	go.mongodb.org/mongo-driver v1.17.9
 	golang.org/x/sync v0.20.0
 )
 
@@ -36,7 +37,6 @@ require (
 	github.com/go-playground/validator/v10 v10.30.2 // indirect
 	github.com/goccy/go-json v0.10.6 // indirect
 	github.com/goccy/go-yaml v1.19.2 // indirect
-	github.com/golang/snappy v1.0.0 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/klauspost/compress v1.18.5 // indirect
@@ -47,7 +47,6 @@ require (
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 // indirect
-	github.com/montanaflynn/stats v0.9.0 // indirect
 	github.com/ncruces/go-strftime v1.0.0 // indirect
 	github.com/pelletier/go-toml/v2 v2.3.0 // indirect
 	github.com/quic-go/qpack v0.6.0 // indirect
@@ -64,7 +63,6 @@ require (
 	github.com/xuri/efp v0.0.1 // indirect
 	github.com/xuri/nfp v0.0.2-0.20250530014748-2ddeb826f9a9 // indirect
 	github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 // indirect
-	go.mongodb.org/mongo-driver/v2 v2.5.1 // indirect
 	golang.org/x/arch v0.26.0 // indirect
 	golang.org/x/image v0.39.0 // indirect
 	golang.org/x/net v0.53.0 // indirect
diff --git a/go.sum b/go.sum
index 13d2884..869c951 100644
--- a/go.sum
+++ b/go.sum
@@ -40,8 +40,6 @@ github.com/goccy/go-json v0.10.6 h1:p8HrPJzOakx/mn/bQtjgNjdTcN+/S6FcG2CTtQOrHVU=
 github.com/goccy/go-json v0.10.6/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
 github.com/goccy/go-yaml v1.19.2 h1:PmFC1S6h8ljIz6gMRBopkjP1TVT7xuwrButHID66PoM=
 github.com/goccy/go-yaml v1.19.2/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
-github.com/golang/snappy v1.0.0 h1:Oy607GVXHs7RtbggtPBnr2RmDArIsAefDwvrdWvRhGs=
-github.com/golang/snappy v1.0.0/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
@@ -81,8 +79,6 @@ github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9G
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
 github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 h1:RWengNIwukTxcDr9M+97sNutRR1RKhG96O6jWumTTnw=
 github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826/go.mod h1:TaXosZuwdSHYgviHp1DAtfrULt5eUgsSMsZf+YrPgl8=
-github.com/montanaflynn/stats v0.9.0 h1:tsBJ0RXwph9BmAuFoCmqGv6e8xa0MENQ8m0ptKq29mQ=
-github.com/montanaflynn/stats v0.9.0/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow=
 github.com/ncruces/go-strftime v1.0.0 h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w=
 github.com/ncruces/go-strftime v1.0.0/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
 github.com/pelletier/go-toml/v2 v2.3.0 h1:k59bC/lIZREW0/iVaQR8nDHxVq8OVlIzYCOJf421CaM=
@@ -103,10 +99,6 @@ github.com/richardlehane/msoleps v1.0.6 h1:9BvkpjvD+iUBalUY4esMwv6uBkfOip/Lzvd93
 github.com/richardlehane/msoleps v1.0.6/go.mod h1:BWev5JBpU9Ko2WAgmZEuiz4/u3ZYTKbjLycmwiWUfWg=
 github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU=
 github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
-github.com/rs/zerolog v1.34.0 h1:k43nTLIwcTVQAncfCw4KZ2VY6ukYoZaBPNOE8txlOeY=
-github.com/rs/zerolog v1.34.0/go.mod h1:bJsvje4Z08ROH4Nhs5iH600c3IkWhwp44iRc54W6wYQ=
-github.com/rs/zerolog v1.35.0 h1:VD0ykx7HMiMJytqINBsKcbLS+BJ4WYjz+05us+LRTdI=
-github.com/rs/zerolog v1.35.0/go.mod h1:EjML9kdfa/RMA7h/6z6pYmq1ykOuA8/mjWaEvGI+jcw=
 github.com/rs/zerolog v1.35.1 h1:m7xQeoiLIiV0BCEY4Hs+j2NG4Gp2o2KPKmhnnLiazKI=
 github.com/rs/zerolog v1.35.1/go.mod h1:EjML9kdfa/RMA7h/6z6pYmq1ykOuA8/mjWaEvGI+jcw=
 github.com/ruudk/golang-pdf417 v0.0.0-20181029194003-1af4ab5afa58/go.mod h1:6lfFZQK844Gfx8o5WFuvpxWRwnSoipWe/p622j1v06w=
@@ -146,8 +138,6 @@ github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78/go.mod h1:aL8wCCfTfS
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 go.mongodb.org/mongo-driver v1.17.9 h1:IexDdCuuNJ3BHrELgBlyaH9p60JXAvdzWR128q+U5tU=
 go.mongodb.org/mongo-driver v1.17.9/go.mod h1:LlOhpH5NUEfhxcAwG0UEkMqwYcc4JU18gtCdGudk/tQ=
-go.mongodb.org/mongo-driver/v2 v2.5.0 h1:yXUhImUjjAInNcpTcAlPHiT7bIXhshCTL3jVBkF3xaE=
-go.mongodb.org/mongo-driver/v2 v2.5.0/go.mod h1:yOI9kBsufol30iFsl1slpdq1I0eHPzybRWdyYUs8K/0=
 go.mongodb.org/mongo-driver/v2 v2.5.1 h1:j2U/Qp+wvueSpqitLCSZPT/+ZpVc1xzuwdHWwl7d8ro=
 go.mongodb.org/mongo-driver/v2 v2.5.1/go.mod h1:yOI9kBsufol30iFsl1slpdq1I0eHPzybRWdyYUs8K/0=
 go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y=
diff --git a/mongoext/pipeline.go b/mongoext/pipeline.go
index 3e430d2..5e8f264 100644
--- a/mongoext/pipeline.go
+++ b/mongoext/pipeline.go
@@ -1,8 +1,8 @@
 package mongoext
 
 import (
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
 )
 
 // FixTextSearchPipeline moves {$match:{$text:{$search}}} entries to the front of the pipeline (otherwise its an mongo error)
diff --git a/mongoext/projections.go b/mongoext/projections.go
index 2be6fce..289a112 100644
--- a/mongoext/projections.go
+++ b/mongoext/projections.go
@@ -1,9 +1,10 @@
 package mongoext
 
 import (
-	"go.mongodb.org/mongo-driver/bson"
 	"reflect"
 	"strings"
+
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
 // ProjectionFromStruct automatically generated a mongodb projection for a struct
diff --git a/mongoext/registry.go b/mongoext/registry.go
index dad9c65..c520287 100644
--- a/mongoext/registry.go
+++ b/mongoext/registry.go
@@ -1,51 +1,17 @@
 package mongoext
 
 import (
-	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
-	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"git.blackforestbytes.com/BlackForestBytes/goext/rfctime"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/primitive"
 	"reflect"
+
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
-func CreateGoExtBsonRegistry() *bsoncodec.Registry {
+func CreateGoExtBsonRegistry() *bson.Registry {
 	reg := bson.NewRegistry()
 
-	reg.RegisterTypeDecoder(reflect.TypeFor[rfctime.RFC3339Time](), rfctime.RFC3339Time{})
-	reg.RegisterTypeDecoder(reflect.TypeFor[*rfctime.RFC3339Time](), rfctime.RFC3339Time{})
-
-	reg.RegisterTypeDecoder(reflect.TypeFor[rfctime.RFC3339NanoTime](), rfctime.RFC3339NanoTime{})
-	reg.RegisterTypeDecoder(reflect.TypeFor[*rfctime.RFC3339NanoTime](), rfctime.RFC3339NanoTime{})
-
-	reg.RegisterTypeDecoder(reflect.TypeFor[rfctime.UnixTime](), rfctime.UnixTime{})
-	reg.RegisterTypeDecoder(reflect.TypeFor[*rfctime.UnixTime](), rfctime.UnixTime{})
-
-	reg.RegisterTypeDecoder(reflect.TypeFor[rfctime.UnixMilliTime](), rfctime.UnixMilliTime{})
-	reg.RegisterTypeDecoder(reflect.TypeFor[*rfctime.UnixMilliTime](), rfctime.UnixMilliTime{})
-
-	reg.RegisterTypeDecoder(reflect.TypeFor[rfctime.UnixNanoTime](), rfctime.UnixNanoTime{})
-	reg.RegisterTypeDecoder(reflect.TypeFor[*rfctime.UnixNanoTime](), rfctime.UnixNanoTime{})
-
-	reg.RegisterTypeDecoder(reflect.TypeFor[rfctime.Date](), rfctime.Date{})
-	reg.RegisterTypeDecoder(reflect.TypeFor[*rfctime.Date](), rfctime.Date{})
-
-	reg.RegisterTypeDecoder(reflect.TypeFor[rfctime.SecondsF64](), rfctime.SecondsF64(0))
-	reg.RegisterTypeDecoder(reflect.TypeOf(langext.Ptr(rfctime.SecondsF64(0))), rfctime.SecondsF64(0))
-
-	reg.RegisterTypeDecoder(reflect.TypeFor[exerr.ErrorCategory](), exerr.ErrorCategory{})
-	reg.RegisterTypeDecoder(reflect.TypeOf(new(exerr.ErrorCategory{})), exerr.ErrorCategory{})
-
-	reg.RegisterTypeDecoder(reflect.TypeFor[exerr.ErrorSeverity](), exerr.ErrorSeverity{})
-	reg.RegisterTypeDecoder(reflect.TypeOf(new(exerr.ErrorSeverity{})), exerr.ErrorSeverity{})
-
-	reg.RegisterTypeDecoder(reflect.TypeFor[exerr.ErrorType](), exerr.ErrorType{})
-	reg.RegisterTypeDecoder(reflect.TypeOf(new(exerr.ErrorType{})), exerr.ErrorType{})
-
-	// otherwise we get []primitve.E when unmarshalling into any
+	// otherwise we get []bson.E when unmarshalling into any
 	// which will result in {'key': .., 'value': ...}[] json when json-marshalling
-	reg.RegisterTypeMapEntry(bson.TypeEmbeddedDocument, reflect.TypeFor[primitive.M]())
+	reg.RegisterTypeMapEntry(bson.TypeEmbeddedDocument, reflect.TypeFor[bson.M]())
 
 	return reg
 }
diff --git a/pagination/filter.go b/pagination/filter.go
index 93df968..8563c4e 100644
--- a/pagination/filter.go
+++ b/pagination/filter.go
@@ -2,8 +2,9 @@ package pagination
 
 import (
 	"context"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/mongo"
+
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
 )
 
 type MongoFilter interface {
diff --git a/reflectext/primStrSer.go b/reflectext/primStrSer.go
index 22daa52..5d87510 100644
--- a/reflectext/primStrSer.go
+++ b/reflectext/primStrSer.go
@@ -3,12 +3,13 @@ package reflectext
 import (
 	"errors"
 	"fmt"
-	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"go.mongodb.org/mongo-driver/bson/primitive"
 	"reflect"
 	"strconv"
 	"strings"
 	"time"
+
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
 var primitiveSerializer = map[reflect.Type]genSerializer{
@@ -28,7 +29,7 @@ var primitiveSerializer = map[reflect.Type]genSerializer{
 
 	reflect.TypeFor[bool](): newGenSerializer(serBoolToString, serStringToBool),
 
-	reflect.TypeFor[primitive.ObjectID](): newGenSerializer(serObjectIDToString, serStringToObjectID),
+	reflect.TypeFor[bson.ObjectID](): newGenSerializer(serObjectIDToString, serStringToObjectID),
 
 	reflect.TypeFor[time.Time](): newGenSerializer(serTimeToString, serStringToTime),
 }
@@ -111,15 +112,15 @@ func serStringToBool(v string) (bool, error) {
 	return false, errors.New(fmt.Sprintf("invalid boolean value '%s'", v))
 }
 
-func serObjectIDToString(v primitive.ObjectID) (string, error) {
+func serObjectIDToString(v bson.ObjectID) (string, error) {
 	return v.Hex(), nil
 }
 
-func serStringToObjectID(v string) (primitive.ObjectID, error) {
-	if rv, err := primitive.ObjectIDFromHex(v); err == nil {
+func serStringToObjectID(v string) (bson.ObjectID, error) {
+	if rv, err := bson.ObjectIDFromHex(v); err == nil {
 		return rv, nil
 	} else {
-		return primitive.ObjectID{}, err
+		return bson.ObjectID{}, err
 	}
 }
 
diff --git a/rfctime/date.go b/rfctime/date.go
index 5e35ea3..b8b364e 100644
--- a/rfctime/date.go
+++ b/rfctime/date.go
@@ -4,14 +4,11 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"reflect"
 	"strconv"
 	"strings"
 	"time"
+
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
 type Date struct {
@@ -83,8 +80,8 @@ func (t *Date) UnmarshalText(data []byte) error {
 	return t.ParseString(string(data))
 }
 
-func (t *Date) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
-	if bt == bsontype.Null {
+func (t *Date) UnmarshalBSONValue(bt byte, data []byte) error {
+	if bson.Type(bt) == bson.TypeNull {
 		// we can't set nil in UnmarshalBSONValue (so we use default(struct))
 		// Use mongoext.CreateGoExtBsonRegistry if you need to unmarsh pointer values
 		// https://stackoverflow.com/questions/75167597
@@ -92,12 +89,12 @@ func (t *Date) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
 		*t = Date{}
 		return nil
 	}
-	if bt != bsontype.String {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into Date", bt))
+	if bson.Type(bt) != bson.TypeString {
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into Date", bson.Type(bt)))
 	}
 
 	var tt string
-	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)
+	err := bson.RawValue{Type: bson.Type(bt), Value: data}.Unmarshal(&tt)
 	if err != nil {
 		return err
 	}
@@ -120,43 +117,16 @@ func (t *Date) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
 	return nil
 }
 
-func (t Date) MarshalBSONValue() (bsontype.Type, []byte, error) {
+func (t Date) MarshalBSONValue() (byte, []byte, error) {
+	var tp bson.Type
+	var data []byte
+	var err error
 	if t.IsZero() {
-		return bson.MarshalValue("")
-	}
-	return bson.MarshalValue(t.String())
-}
-
-func (t Date) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
-	if val.Kind() == reflect.Pointer && val.IsNil() {
-		if !val.CanSet() {
-			return errors.New("ValueUnmarshalerDecodeValue")
-		}
-		val.Set(reflect.New(val.Type().Elem()))
-	}
-
-	tp, src, err := bsonrw.Copier{}.CopyValueToBytes(vr)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer && len(src) == 0 {
-		val.Set(reflect.Zero(val.Type()))
-		return nil
-	}
-
-	err = t.UnmarshalBSONValue(tp, src)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer {
-		val.Set(reflect.ValueOf(&t))
+		tp, data, err = bson.MarshalValue("")
 	} else {
-		val.Set(reflect.ValueOf(t))
+		tp, data, err = bson.MarshalValue(t.String())
 	}
-
-	return nil
+	return byte(tp), data, err
 }
 
 func (t Date) Serialize() string {
diff --git a/rfctime/rfc3339.go b/rfctime/rfc3339.go
index 8137625..ac5681e 100644
--- a/rfctime/rfc3339.go
+++ b/rfctime/rfc3339.go
@@ -4,13 +4,9 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"reflect"
 	"time"
 
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
 type RFC3339Time time.Time
@@ -69,8 +65,8 @@ func (t *RFC3339Time) UnmarshalText(data []byte) error {
 	return nil
 }
 
-func (t *RFC3339Time) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
-	if bt == bson.TypeNull {
+func (t *RFC3339Time) UnmarshalBSONValue(bt byte, data []byte) error {
+	if bson.Type(bt) == bson.TypeNull {
 		// we can't set nil in UnmarshalBSONValue (so we use default(struct))
 		// Use mongoext.CreateGoExtBsonRegistry if you need to unmarsh pointer values
 		// https://stackoverflow.com/questions/75167597
@@ -78,11 +74,11 @@ func (t *RFC3339Time) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
 		*t = RFC3339Time{}
 		return nil
 	}
-	if bt != bson.TypeDateTime {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into RFC3339Time", bt))
+	if bson.Type(bt) != bson.TypeDateTime {
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into RFC3339Time", bson.Type(bt)))
 	}
 	var tt time.Time
-	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)
+	err := bson.RawValue{Type: bson.Type(bt), Value: data}.Unmarshal(&tt)
 	if err != nil {
 		return err
 	}
@@ -90,40 +86,9 @@ func (t *RFC3339Time) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
 	return nil
 }
 
-func (t RFC3339Time) MarshalBSONValue() (bsontype.Type, []byte, error) {
-	return bson.MarshalValue(time.Time(t))
-}
-
-func (t RFC3339Time) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
-	if val.Kind() == reflect.Pointer && val.IsNil() {
-		if !val.CanSet() {
-			return errors.New("ValueUnmarshalerDecodeValue")
-		}
-		val.Set(reflect.New(val.Type().Elem()))
-	}
-
-	tp, src, err := bsonrw.Copier{}.CopyValueToBytes(vr)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer && len(src) == 0 {
-		val.Set(reflect.Zero(val.Type()))
-		return nil
-	}
-
-	err = t.UnmarshalBSONValue(tp, src)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer {
-		val.Set(reflect.ValueOf(&t))
-	} else {
-		val.Set(reflect.ValueOf(t))
-	}
-
-	return nil
+func (t RFC3339Time) MarshalBSONValue() (byte, []byte, error) {
+	tp, data, err := bson.MarshalValue(time.Time(t))
+	return byte(tp), data, err
 }
 
 func (t RFC3339Time) Serialize() string {
diff --git a/rfctime/rfc3339Nano.go b/rfctime/rfc3339Nano.go
index 75e2e89..44e387a 100644
--- a/rfctime/rfc3339Nano.go
+++ b/rfctime/rfc3339Nano.go
@@ -4,12 +4,9 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"reflect"
 	"time"
+
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
 type RFC3339NanoTime time.Time
@@ -68,8 +65,8 @@ func (t *RFC3339NanoTime) UnmarshalText(data []byte) error {
 	return nil
 }
 
-func (t *RFC3339NanoTime) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
-	if bt == bson.TypeNull {
+func (t *RFC3339NanoTime) UnmarshalBSONValue(bt byte, data []byte) error {
+	if bson.Type(bt) == bson.TypeNull {
 		// we can't set nil in UnmarshalBSONValue (so we use default(struct))
 		// Use mongoext.CreateGoExtBsonRegistry if you need to unmarsh pointer values
 		// https://stackoverflow.com/questions/75167597
@@ -77,11 +74,11 @@ func (t *RFC3339NanoTime) UnmarshalBSONValue(bt bsontype.Type, data []byte) erro
 		*t = RFC3339NanoTime{}
 		return nil
 	}
-	if bt != bson.TypeDateTime {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into RFC3339NanoTime", bt))
+	if bson.Type(bt) != bson.TypeDateTime {
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into RFC3339NanoTime", bson.Type(bt)))
 	}
 	var tt time.Time
-	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)
+	err := bson.RawValue{Type: bson.Type(bt), Value: data}.Unmarshal(&tt)
 	if err != nil {
 		return err
 	}
@@ -89,40 +86,9 @@ func (t *RFC3339NanoTime) UnmarshalBSONValue(bt bsontype.Type, data []byte) erro
 	return nil
 }
 
-func (t RFC3339NanoTime) MarshalBSONValue() (bsontype.Type, []byte, error) {
-	return bson.MarshalValue(time.Time(t))
-}
-
-func (t RFC3339NanoTime) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
-	if val.Kind() == reflect.Pointer && val.IsNil() {
-		if !val.CanSet() {
-			return errors.New("ValueUnmarshalerDecodeValue")
-		}
-		val.Set(reflect.New(val.Type().Elem()))
-	}
-
-	tp, src, err := bsonrw.Copier{}.CopyValueToBytes(vr)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer && len(src) == 0 {
-		val.Set(reflect.Zero(val.Type()))
-		return nil
-	}
-
-	err = t.UnmarshalBSONValue(tp, src)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer {
-		val.Set(reflect.ValueOf(&t))
-	} else {
-		val.Set(reflect.ValueOf(t))
-	}
-
-	return nil
+func (t RFC3339NanoTime) MarshalBSONValue() (byte, []byte, error) {
+	tp, data, err := bson.MarshalValue(time.Time(t))
+	return byte(tp), data, err
 }
 
 func (t RFC3339NanoTime) Serialize() string {
diff --git a/rfctime/seconds.go b/rfctime/seconds.go
index 7048a8a..a1ce06b 100644
--- a/rfctime/seconds.go
+++ b/rfctime/seconds.go
@@ -4,13 +4,10 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"git.blackforestbytes.com/BlackForestBytes/goext/timeext"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"reflect"
 	"time"
+
+	"git.blackforestbytes.com/BlackForestBytes/goext/timeext"
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
 type SecondsF64 time.Duration
@@ -61,8 +58,8 @@ func (d SecondsF64) MarshalJSON() ([]byte, error) {
 	return json.Marshal(secs)
 }
 
-func (d *SecondsF64) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
-	if bt == bson.TypeNull {
+func (d *SecondsF64) UnmarshalBSONValue(bt byte, data []byte) error {
+	if bson.Type(bt) == bson.TypeNull {
 		// we can't set nil in UnmarshalBSONValue (so we use default(struct))
 		// Use mongoext.CreateGoExtBsonRegistry if you need to unmarsh pointer values
 		// https://stackoverflow.com/questions/75167597
@@ -70,11 +67,11 @@ func (d *SecondsF64) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
 		*d = SecondsF64(0)
 		return nil
 	}
-	if bt != bson.TypeDouble {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into SecondsF64", bt))
+	if bson.Type(bt) != bson.TypeDouble {
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into SecondsF64", bson.Type(bt)))
 	}
 	var secValue float64
-	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&secValue)
+	err := bson.RawValue{Type: bson.Type(bt), Value: data}.Unmarshal(&secValue)
 	if err != nil {
 		return err
 	}
@@ -82,40 +79,9 @@ func (d *SecondsF64) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
 	return nil
 }
 
-func (d SecondsF64) MarshalBSONValue() (bsontype.Type, []byte, error) {
-	return bson.MarshalValue(d.Seconds())
-}
-
-func (d SecondsF64) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
-	if val.Kind() == reflect.Pointer && val.IsNil() {
-		if !val.CanSet() {
-			return errors.New("ValueUnmarshalerDecodeValue")
-		}
-		val.Set(reflect.New(val.Type().Elem()))
-	}
-
-	tp, src, err := bsonrw.Copier{}.CopyValueToBytes(vr)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer && len(src) == 0 {
-		val.Set(reflect.Zero(val.Type()))
-		return nil
-	}
-
-	err = d.UnmarshalBSONValue(tp, src)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer {
-		val.Set(reflect.ValueOf(&d))
-	} else {
-		val.Set(reflect.ValueOf(d))
-	}
-
-	return nil
+func (d SecondsF64) MarshalBSONValue() (byte, []byte, error) {
+	tp, data, err := bson.MarshalValue(d.Seconds())
+	return byte(tp), data, err
 }
 
 func NewSecondsF64(t time.Duration) SecondsF64 {
diff --git a/timeext/weekcount.go b/timeext/weekcount.go
index 4a41315..458f1f7 100644
--- a/timeext/weekcount.go
+++ b/timeext/weekcount.go
@@ -51,10 +51,7 @@ func GetIsoWeekCount(year int) int {
 	w2 -= 1
 	w3 -= 1
 
-	w := max(w2, w1)
-	if w3 > w {
-		w = w3
-	}
+	w := max(w3, max(w2, w1))
 
 	return w
 }
diff --git a/wmo/collection.go b/wmo/collection.go
index 6fb6fd2..bd18119 100644
--- a/wmo/collection.go
+++ b/wmo/collection.go
@@ -2,16 +2,16 @@ package wmo
 
 import (
 	"context"
+	"reflect"
+
 	ct "git.blackforestbytes.com/BlackForestBytes/goext/cursortoken"
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"go.mongodb.org/mongo-driver/mongo"
-	"reflect"
+	"go.mongodb.org/mongo-driver/v2/mongo"
 )
 
 type EntityID interface {
-	MarshalBSONValue() (bsontype.Type, []byte, error)
+	MarshalBSONValue() (byte, []byte, error)
 	String() string
 }
 
diff --git a/wmo/decoding.go b/wmo/decoding.go
index d2357ff..83b024f 100644
--- a/wmo/decoding.go
+++ b/wmo/decoding.go
@@ -2,8 +2,9 @@ package wmo
 
 import (
 	"context"
-	"go.mongodb.org/mongo-driver/bson"
+
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
 func (c *Coll[TData]) decodeSingle(ctx context.Context, dec Decodable) (TData, error) {
diff --git a/wmo/mongo.go b/wmo/mongo.go
index 67c3cd8..1494a9b 100644
--- a/wmo/mongo.go
+++ b/wmo/mongo.go
@@ -1,6 +1,6 @@
 package wmo
 
-import "go.mongodb.org/mongo-driver/mongo"
+import "go.mongodb.org/mongo-driver/v2/mongo"
 
 func W[TData any](collection *mongo.Collection) *Coll[TData] {
 	c := Coll[TData]{coll: collection}
diff --git a/wmo/queryAggregate.go b/wmo/queryAggregate.go
index d82e97c..d2a64d8 100644
--- a/wmo/queryAggregate.go
+++ b/wmo/queryAggregate.go
@@ -2,13 +2,14 @@ package wmo
 
 import (
 	"context"
-	"go.mongodb.org/mongo-driver/mongo"
-	"go.mongodb.org/mongo-driver/mongo/options"
+
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"go.mongodb.org/mongo-driver/v2/mongo"
+	"go.mongodb.org/mongo-driver/v2/mongo/options"
 )
 
-func (c *Coll[TData]) Aggregate(ctx context.Context, pipeline mongo.Pipeline, opts ...*options.AggregateOptions) ([]TData, error) {
+func (c *Coll[TData]) Aggregate(ctx context.Context, pipeline mongo.Pipeline, opts ...options.Lister[options.AggregateOptions]) ([]TData, error) {
 
 	for _, ppl := range c.extraModPipeline {
 		pipeline = langext.ArrConcat(pipeline, ppl(ctx))
@@ -29,7 +30,7 @@ func (c *Coll[TData]) Aggregate(ctx context.Context, pipeline mongo.Pipeline, op
 	return res, nil
 }
 
-func (c *Coll[TData]) AggregateOneOpt(ctx context.Context, pipeline mongo.Pipeline, opts ...*options.AggregateOptions) (*TData, error) {
+func (c *Coll[TData]) AggregateOneOpt(ctx context.Context, pipeline mongo.Pipeline, opts ...options.Lister[options.AggregateOptions]) (*TData, error) {
 
 	for _, ppl := range c.extraModPipeline {
 		pipeline = langext.ArrConcat(pipeline, ppl(ctx))
@@ -53,7 +54,7 @@ func (c *Coll[TData]) AggregateOneOpt(ctx context.Context, pipeline mongo.Pipeli
 	return nil, nil
 }
 
-func (c *Coll[TData]) AggregateOne(ctx context.Context, pipeline mongo.Pipeline, opts ...*options.AggregateOptions) (TData, error) {
+func (c *Coll[TData]) AggregateOne(ctx context.Context, pipeline mongo.Pipeline, opts ...options.Lister[options.AggregateOptions]) (TData, error) {
 
 	for _, ppl := range c.extraModPipeline {
 		pipeline = langext.ArrConcat(pipeline, ppl(ctx))
diff --git a/wmo/queryDelete.go b/wmo/queryDelete.go
index ce7de70..29ece18 100644
--- a/wmo/queryDelete.go
+++ b/wmo/queryDelete.go
@@ -2,9 +2,10 @@ package wmo
 
 import (
 	"context"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/mongo"
+
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
 )
 
 func (c *Coll[TData]) DeleteOneByID(ctx context.Context, id EntityID) error {
diff --git a/wmo/queryFind.go b/wmo/queryFind.go
index f2046c9..c7aa5d3 100644
--- a/wmo/queryFind.go
+++ b/wmo/queryFind.go
@@ -2,12 +2,13 @@ package wmo
 
 import (
 	"context"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/mongo"
-	"go.mongodb.org/mongo-driver/mongo/options"
+	"iter"
+
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"iter"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
+	"go.mongodb.org/mongo-driver/v2/mongo/options"
 )
 
 func (c *Coll[TData]) createFindQuery(ctx context.Context, filter bson.M, opts ...*options.FindOptions) (*mongo.Cursor, error) {
@@ -51,7 +52,7 @@ func (c *Coll[TData]) createFindQuery(ctx context.Context, filter bson.M, opts .
 		}
 	}
 
-	convOpts := make([]*options.AggregateOptions, 0, len(opts))
+	convOpts := make([]*options.AggregateOptionsBuilder, 0, len(opts))
 	for _, v := range opts {
 		vConv, err := convertFindOpt(v)
 		if err != nil {
@@ -60,7 +61,14 @@ func (c *Coll[TData]) createFindQuery(ctx context.Context, filter bson.M, opts .
 		convOpts = append(convOpts, vConv)
 	}
 
-	cursor, err := c.coll.Aggregate(ctx, pipeline, convOpts...)
+	convOptsLister := make([]options.Lister[options.AggregateOptions], 0, len(convOpts))
+	for _, v := range convOpts {
+		if v != nil {
+			convOptsLister = append(convOptsLister, v)
+		}
+	}
+
+	cursor, err := c.coll.Aggregate(ctx, pipeline, convOptsLister...)
 	if err != nil {
 		return nil, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Str("collection", c.Name()).Build()
 	}
@@ -137,7 +145,7 @@ func (c *Coll[TData]) FindIterate(ctx context.Context, filter bson.M, opts ...*o
 }
 
 // converts FindOptions to AggregateOptions
-func convertFindOpt(v *options.FindOptions) (*options.AggregateOptions, error) {
+func convertFindOpt(v *options.FindOptions) (*options.AggregateOptionsBuilder, error) {
 	if v == nil {
 		return nil, nil
 	}
@@ -157,7 +165,7 @@ func convertFindOpt(v *options.FindOptions) (*options.AggregateOptions, error) {
 		r.SetCollation(v.Collation)
 	}
 	if v.Comment != nil {
-		r.SetComment(*v.Comment)
+		r.SetComment(v.Comment)
 	}
 	if v.CursorType != nil {
 		return nil, exerr.New(exerr.TypeMongoInvalidOpt, "Invalid option 'CursorType' (cannot convert to AggregateOptions)").Build()
@@ -171,9 +179,6 @@ func convertFindOpt(v *options.FindOptions) (*options.AggregateOptions, error) {
 	if v.MaxAwaitTime != nil {
 		r.SetMaxAwaitTime(*v.MaxAwaitTime)
 	}
-	if v.MaxTime != nil {
-		r.SetMaxTime(*v.MaxTime)
-	}
 	if v.Min != nil {
 		return nil, exerr.New(exerr.TypeMongoInvalidOpt, "Invalid option 'Min' (cannot convert to AggregateOptions)").Build()
 	}
@@ -189,9 +194,6 @@ func convertFindOpt(v *options.FindOptions) (*options.AggregateOptions, error) {
 	if v.ShowRecordID != nil {
 		return nil, exerr.New(exerr.TypeMongoInvalidOpt, "Invalid option 'ShowRecordID' (cannot convert to AggregateOptions)").Build()
 	}
-	if v.Snapshot != nil {
-		return nil, exerr.New(exerr.TypeMongoInvalidOpt, "Invalid option 'Snapshot' (cannot convert to AggregateOptions)").Build()
-	}
 	if v.Let != nil {
 		r.SetLet(v.Let)
 	}
diff --git a/wmo/queryFindOne.go b/wmo/queryFindOne.go
index 337d216..728f98f 100644
--- a/wmo/queryFindOne.go
+++ b/wmo/queryFindOne.go
@@ -3,10 +3,11 @@ package wmo
 import (
 	"context"
 	"errors"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/mongo"
+
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
 )
 
 func (c *Coll[TData]) FindOne(ctx context.Context, filter bson.M) (TData, error) {
diff --git a/wmo/queryInsert.go b/wmo/queryInsert.go
index 28d007a..16b3c5c 100644
--- a/wmo/queryInsert.go
+++ b/wmo/queryInsert.go
@@ -2,10 +2,11 @@ package wmo
 
 import (
 	"context"
+
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
 )
 
 func (c *Coll[TData]) InsertOne(ctx context.Context, valueIn TData) (TData, error) {
diff --git a/wmo/queryList.go b/wmo/queryList.go
index 6a07b6c..59f84ec 100644
--- a/wmo/queryList.go
+++ b/wmo/queryList.go
@@ -2,12 +2,13 @@ package wmo
 
 import (
 	"context"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/mongo"
+	"iter"
+
 	ct "git.blackforestbytes.com/BlackForestBytes/goext/cursortoken"
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"iter"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
 )
 
 func (c *Coll[TData]) List(ctx context.Context, filter ct.Filter, pageSize *int, inTok ct.CursorToken) ([]TData, ct.CursorToken, error) {
diff --git a/wmo/queryPaginate.go b/wmo/queryPaginate.go
index ac0f552..9965532 100644
--- a/wmo/queryPaginate.go
+++ b/wmo/queryPaginate.go
@@ -2,12 +2,13 @@ package wmo
 
 import (
 	"context"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/mongo"
+	"iter"
+
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	pag "git.blackforestbytes.com/BlackForestBytes/goext/pagination"
-	"iter"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
 )
 
 func (c *Coll[TData]) Paginate(ctx context.Context, filter pag.MongoFilter, page int, limit *int) ([]TData, pag.Pagination, error) {
diff --git a/wmo/queryUpdate.go b/wmo/queryUpdate.go
index c757633..af89df9 100644
--- a/wmo/queryUpdate.go
+++ b/wmo/queryUpdate.go
@@ -2,10 +2,11 @@ package wmo
 
 import (
 	"context"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/mongo"
-	"go.mongodb.org/mongo-driver/mongo/options"
+
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
+	"go.mongodb.org/mongo-driver/v2/mongo/options"
 )
 
 func (c *Coll[TData]) FindOneAndUpdate(ctx context.Context, filterQuery bson.M, updateQuery bson.M) (TData, error) {
diff --git a/wmo/reflection_test.go b/wmo/reflection_test.go
index f516caf..ea62282 100644
--- a/wmo/reflection_test.go
+++ b/wmo/reflection_test.go
@@ -9,8 +9,8 @@ import (
 	"git.blackforestbytes.com/BlackForestBytes/goext/rfctime"
 	"git.blackforestbytes.com/BlackForestBytes/goext/timeext"
 	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
 )
 
 func TestReflectionGetFieldType(t *testing.T) {
@@ -234,8 +234,8 @@ func TestReflectionGetFieldValueAsTokenString(t *testing.T) {
 func TestReflectionWithInterface(t *testing.T) {
 
 	type TestData struct {
-		ID    primitive.ObjectID `bson:"_id"`
-		CDate time.Time          `bson:"cdate"`
+		ID    bson.ObjectID `bson:"_id"`
+		CDate time.Time     `bson:"cdate"`
 	}
 
 	type TestInterface any