diff --git a/changelogs/unreleased/9724-Lyndon-Li b/changelogs/unreleased/9724-Lyndon-Li
new file mode 100644
index 000000000..5eea82187
--- /dev/null
+++ b/changelogs/unreleased/9724-Lyndon-Li
@@ -0,0 +1 @@
+Fix issue #9723, extend Unified Repo Interface to support block uploader
\ No newline at end of file
diff --git a/pkg/repository/udmrepo/kopialib/lib_repo.go b/pkg/repository/udmrepo/kopialib/lib_repo.go
index e6c46ae66..34559baf7 100644
--- a/pkg/repository/udmrepo/kopialib/lib_repo.go
+++ b/pkg/repository/udmrepo/kopialib/lib_repo.go
@@ -388,9 +388,9 @@ func (kr *kopiaRepository) Close(ctx context.Context) error {
 	return nil
 }
 
-func (kr *kopiaRepository) NewObjectWriter(ctx context.Context, opt udmrepo.ObjectWriteOptions) udmrepo.ObjectWriter {
+func (kr *kopiaRepository) NewObjectWriter(ctx context.Context, opt udmrepo.ObjectWriteOptions) (udmrepo.ObjectWriter, error) {
 	if kr.rawWriter == nil {
-		return nil
+		return nil, errors.New("repo writer is closed or not open")
 	}
 
 	writer := kr.rawWriter.NewObjectWriter(kopia.SetupKopiaLog(ctx, kr.logger), object.WriterOptions{
@@ -402,12 +402,22 @@ func (kr *kopiaRepository) NewObjectWriter(ctx context.Context, opt udmrepo.Obje
 	})
 
 	if writer == nil {
-		return nil
+		return nil, errors.Errorf("error creating writer for object %s", opt.Description)
 	}
 
 	return &kopiaObjectWriter{
 		rawWriter: writer,
-	}
+	}, nil
+}
+
+// TODO add implementation in following PRs
+func (kr *kopiaRepository) WriteMetadata(ctx context.Context, meta *udmrepo.Metadata, opt udmrepo.ObjectWriteOptions) (udmrepo.ID, error) {
+	return "", errors.New("not supported")
+}
+
+// TODO add implementation in following PRs
+func (kr *kopiaRepository) ReadMetadata(ctx context.Context, id udmrepo.ID) (*udmrepo.Metadata, error) {
+	return nil, errors.New("not supported")
 }
 
 func (kr *kopiaRepository) PutManifest(ctx context.Context, manifest udmrepo.RepoManifest) (udmrepo.ID, error) {
@@ -436,6 +446,21 @@ func (kr *kopiaRepository) DeleteManifest(ctx context.Context, id udmrepo.ID) er
 	return nil
 }
 
+// TODO add implementation in following PRs
+func (kr *kopiaRepository) SaveSnapshot(ctx context.Context, snap udmrepo.Snapshot) (udmrepo.ID, error) {
+	return "", errors.New("not supported")
+}
+
+// TODO add implementation in following PRs
+func (kr *kopiaRepository) GetSnapshot(ctx context.Context, id udmrepo.ID) (udmrepo.Snapshot, error) {
+	return udmrepo.Snapshot{}, errors.New("not supported")
+}
+
+// TODO add implementation in following PRs
+func (kr *kopiaRepository) DeleteSnapshot(ctx context.Context, id udmrepo.ID) error {
+	return errors.New("not supported")
+}
+
 func (kr *kopiaRepository) Flush(ctx context.Context) error {
 	if kr.rawWriter == nil {
 		return errors.New("repo writer is closed or not open")
@@ -546,8 +571,9 @@ func (kow *kopiaObjectWriter) Write(p []byte) (int, error) {
 	return kow.rawWriter.Write(p)
 }
 
-func (kow *kopiaObjectWriter) Seek(offset int64, whence int) (int64, error) {
-	return -1, errors.New("not supported")
+// TODO add implementation in following PRs
+func (kow *kopiaObjectWriter) WriteAt(p []byte, offset int64) (int, error) {
+	return 0, errors.New("not supported")
 }
 
 func (kow *kopiaObjectWriter) Checkpoint() (udmrepo.ID, error) {
diff --git a/pkg/repository/udmrepo/kopialib/lib_repo_test.go b/pkg/repository/udmrepo/kopialib/lib_repo_test.go
index 2feabaeca..36e331bef 100644
--- a/pkg/repository/udmrepo/kopialib/lib_repo_test.go
+++ b/pkg/repository/udmrepo/kopialib/lib_repo_test.go
@@ -663,13 +663,16 @@ func TestNewObjectWriter(t *testing.T) {
 		rawWriter    *repomocks.MockRepositoryWriter
 		rawWriterRet object.Writer
 		expectedRet  udmrepo.ObjectWriter
+		expectedErr  string
 	}{
 		{
-			name: "raw writer is nil",
+			name:        "raw writer is nil",
+			expectedErr: "repo writer is closed or not open",
 		},
 		{
-			name:      "new object writer fail",
-			rawWriter: repomocks.NewMockRepositoryWriter(t),
+			name:        "new object writer fail",
+			rawWriter:   repomocks.NewMockRepositoryWriter(t),
+			expectedErr: "error creating writer for object ",
 		},
 		{
 			name:         "succeed",
@@ -688,9 +691,14 @@ func TestNewObjectWriter(t *testing.T) {
 				kr.rawWriter = tc.rawWriter
 			}
 
-			ret := kr.NewObjectWriter(t.Context(), udmrepo.ObjectWriteOptions{})
+			ret, err := kr.NewObjectWriter(t.Context(), udmrepo.ObjectWriteOptions{})
 
-			assert.Equal(t, tc.expectedRet, ret)
+			if tc.expectedErr == "" {
+				require.NoError(t, err)
+				require.Equal(t, tc.expectedRet, ret)
+			} else {
+				require.EqualError(t, err, tc.expectedErr)
+			}
 		})
 	}
 }
diff --git a/pkg/repository/udmrepo/mocks/BackupRepo.go b/pkg/repository/udmrepo/mocks/BackupRepo.go
index 7d044356d..e495b6b00 100644
--- a/pkg/repository/udmrepo/mocks/BackupRepo.go
+++ b/pkg/repository/udmrepo/mocks/BackupRepo.go
@@ -1,265 +1,17 @@
-// Code generated by mockery v2.39.1. DO NOT EDIT.
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 
 package mocks
 
 import (
-	context "context"
-	time "time"
+	"context"
+	"time"
 
 	mock "github.com/stretchr/testify/mock"
-
-	udmrepo "github.com/vmware-tanzu/velero/pkg/repository/udmrepo"
+	"github.com/vmware-tanzu/velero/pkg/repository/udmrepo"
 )
 
-// BackupRepo is an autogenerated mock type for the BackupRepo type
-type BackupRepo struct {
-	mock.Mock
-}
-
-// Close provides a mock function with given fields: ctx
-func (_m *BackupRepo) Close(ctx context.Context) error {
-	ret := _m.Called(ctx)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Close")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context) error); ok {
-		r0 = rf(ctx)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ConcatenateObjects provides a mock function with given fields: ctx, objectIDs
-func (_m *BackupRepo) ConcatenateObjects(ctx context.Context, objectIDs []udmrepo.ID) (udmrepo.ID, error) {
-	ret := _m.Called(ctx, objectIDs)
-
-	if len(ret) == 0 {
-		panic("no return value specified for ConcatenateObjects")
-	}
-
-	var r0 udmrepo.ID
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, []udmrepo.ID) (udmrepo.ID, error)); ok {
-		return rf(ctx, objectIDs)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, []udmrepo.ID) udmrepo.ID); ok {
-		r0 = rf(ctx, objectIDs)
-	} else {
-		r0 = ret.Get(0).(udmrepo.ID)
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, []udmrepo.ID) error); ok {
-		r1 = rf(ctx, objectIDs)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeleteManifest provides a mock function with given fields: ctx, id
-func (_m *BackupRepo) DeleteManifest(ctx context.Context, id udmrepo.ID) error {
-	ret := _m.Called(ctx, id)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteManifest")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, udmrepo.ID) error); ok {
-		r0 = rf(ctx, id)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// FindManifests provides a mock function with given fields: ctx, filter
-func (_m *BackupRepo) FindManifests(ctx context.Context, filter udmrepo.ManifestFilter) ([]*udmrepo.ManifestEntryMetadata, error) {
-	ret := _m.Called(ctx, filter)
-
-	if len(ret) == 0 {
-		panic("no return value specified for FindManifests")
-	}
-
-	var r0 []*udmrepo.ManifestEntryMetadata
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, udmrepo.ManifestFilter) ([]*udmrepo.ManifestEntryMetadata, error)); ok {
-		return rf(ctx, filter)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, udmrepo.ManifestFilter) []*udmrepo.ManifestEntryMetadata); ok {
-		r0 = rf(ctx, filter)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]*udmrepo.ManifestEntryMetadata)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, udmrepo.ManifestFilter) error); ok {
-		r1 = rf(ctx, filter)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Flush provides a mock function with given fields: ctx
-func (_m *BackupRepo) Flush(ctx context.Context) error {
-	ret := _m.Called(ctx)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Flush")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context) error); ok {
-		r0 = rf(ctx)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// GetAdvancedFeatures provides a mock function with given fields:
-func (_m *BackupRepo) GetAdvancedFeatures() udmrepo.AdvancedFeatureInfo {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetAdvancedFeatures")
-	}
-
-	var r0 udmrepo.AdvancedFeatureInfo
-	if rf, ok := ret.Get(0).(func() udmrepo.AdvancedFeatureInfo); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(udmrepo.AdvancedFeatureInfo)
-	}
-
-	return r0
-}
-
-// GetManifest provides a mock function with given fields: ctx, id, mani
-func (_m *BackupRepo) GetManifest(ctx context.Context, id udmrepo.ID, mani *udmrepo.RepoManifest) error {
-	ret := _m.Called(ctx, id, mani)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetManifest")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, udmrepo.ID, *udmrepo.RepoManifest) error); ok {
-		r0 = rf(ctx, id, mani)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// NewObjectWriter provides a mock function with given fields: ctx, opt
-func (_m *BackupRepo) NewObjectWriter(ctx context.Context, opt udmrepo.ObjectWriteOptions) udmrepo.ObjectWriter {
-	ret := _m.Called(ctx, opt)
-
-	if len(ret) == 0 {
-		panic("no return value specified for NewObjectWriter")
-	}
-
-	var r0 udmrepo.ObjectWriter
-	if rf, ok := ret.Get(0).(func(context.Context, udmrepo.ObjectWriteOptions) udmrepo.ObjectWriter); ok {
-		r0 = rf(ctx, opt)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(udmrepo.ObjectWriter)
-		}
-	}
-
-	return r0
-}
-
-// OpenObject provides a mock function with given fields: ctx, id
-func (_m *BackupRepo) OpenObject(ctx context.Context, id udmrepo.ID) (udmrepo.ObjectReader, error) {
-	ret := _m.Called(ctx, id)
-
-	if len(ret) == 0 {
-		panic("no return value specified for OpenObject")
-	}
-
-	var r0 udmrepo.ObjectReader
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, udmrepo.ID) (udmrepo.ObjectReader, error)); ok {
-		return rf(ctx, id)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, udmrepo.ID) udmrepo.ObjectReader); ok {
-		r0 = rf(ctx, id)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(udmrepo.ObjectReader)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, udmrepo.ID) error); ok {
-		r1 = rf(ctx, id)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// PutManifest provides a mock function with given fields: ctx, mani
-func (_m *BackupRepo) PutManifest(ctx context.Context, mani udmrepo.RepoManifest) (udmrepo.ID, error) {
-	ret := _m.Called(ctx, mani)
-
-	if len(ret) == 0 {
-		panic("no return value specified for PutManifest")
-	}
-
-	var r0 udmrepo.ID
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, udmrepo.RepoManifest) (udmrepo.ID, error)); ok {
-		return rf(ctx, mani)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, udmrepo.RepoManifest) udmrepo.ID); ok {
-		r0 = rf(ctx, mani)
-	} else {
-		r0 = ret.Get(0).(udmrepo.ID)
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, udmrepo.RepoManifest) error); ok {
-		r1 = rf(ctx, mani)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Time provides a mock function with given fields:
-func (_m *BackupRepo) Time() time.Time {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Time")
-	}
-
-	var r0 time.Time
-	if rf, ok := ret.Get(0).(func() time.Time); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(time.Time)
-	}
-
-	return r0
-}
-
 // NewBackupRepo creates a new instance of BackupRepo. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
 func NewBackupRepo(t interface {
@@ -273,3 +25,991 @@ func NewBackupRepo(t interface {
 
 	return mock
 }
+
+// BackupRepo is an autogenerated mock type for the BackupRepo type
+type BackupRepo struct {
+	mock.Mock
+}
+
+type BackupRepo_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *BackupRepo) EXPECT() *BackupRepo_Expecter {
+	return &BackupRepo_Expecter{mock: &_m.Mock}
+}
+
+// Close provides a mock function for the type BackupRepo
+func (_mock *BackupRepo) Close(ctx context.Context) error {
+	ret := _mock.Called(ctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Close")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
+		r0 = returnFunc(ctx)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// BackupRepo_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
+type BackupRepo_Close_Call struct {
+	*mock.Call
+}
+
+// Close is a helper method to define mock.On call
+//   - ctx context.Context
+func (_e *BackupRepo_Expecter) Close(ctx interface{}) *BackupRepo_Close_Call {
+	return &BackupRepo_Close_Call{Call: _e.mock.On("Close", ctx)}
+}
+
+func (_c *BackupRepo_Close_Call) Run(run func(ctx context.Context)) *BackupRepo_Close_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *BackupRepo_Close_Call) Return(err error) *BackupRepo_Close_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *BackupRepo_Close_Call) RunAndReturn(run func(ctx context.Context) error) *BackupRepo_Close_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ConcatenateObjects provides a mock function for the type BackupRepo
+func (_mock *BackupRepo) ConcatenateObjects(ctx context.Context, objectIDs []udmrepo.ID) (udmrepo.ID, error) {
+	ret := _mock.Called(ctx, objectIDs)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ConcatenateObjects")
+	}
+
+	var r0 udmrepo.ID
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, []udmrepo.ID) (udmrepo.ID, error)); ok {
+		return returnFunc(ctx, objectIDs)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, []udmrepo.ID) udmrepo.ID); ok {
+		r0 = returnFunc(ctx, objectIDs)
+	} else {
+		r0 = ret.Get(0).(udmrepo.ID)
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, []udmrepo.ID) error); ok {
+		r1 = returnFunc(ctx, objectIDs)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// BackupRepo_ConcatenateObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConcatenateObjects'
+type BackupRepo_ConcatenateObjects_Call struct {
+	*mock.Call
+}
+
+// ConcatenateObjects is a helper method to define mock.On call
+//   - ctx context.Context
+//   - objectIDs []udmrepo.ID
+func (_e *BackupRepo_Expecter) ConcatenateObjects(ctx interface{}, objectIDs interface{}) *BackupRepo_ConcatenateObjects_Call {
+	return &BackupRepo_ConcatenateObjects_Call{Call: _e.mock.On("ConcatenateObjects", ctx, objectIDs)}
+}
+
+func (_c *BackupRepo_ConcatenateObjects_Call) Run(run func(ctx context.Context, objectIDs []udmrepo.ID)) *BackupRepo_ConcatenateObjects_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 []udmrepo.ID
+		if args[1] != nil {
+			arg1 = args[1].([]udmrepo.ID)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *BackupRepo_ConcatenateObjects_Call) Return(iD udmrepo.ID, err error) *BackupRepo_ConcatenateObjects_Call {
+	_c.Call.Return(iD, err)
+	return _c
+}
+
+func (_c *BackupRepo_ConcatenateObjects_Call) RunAndReturn(run func(ctx context.Context, objectIDs []udmrepo.ID) (udmrepo.ID, error)) *BackupRepo_ConcatenateObjects_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// DeleteManifest provides a mock function for the type BackupRepo
+func (_mock *BackupRepo) DeleteManifest(ctx context.Context, id udmrepo.ID) error {
+	ret := _mock.Called(ctx, id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteManifest")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ID) error); ok {
+		r0 = returnFunc(ctx, id)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// BackupRepo_DeleteManifest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteManifest'
+type BackupRepo_DeleteManifest_Call struct {
+	*mock.Call
+}
+
+// DeleteManifest is a helper method to define mock.On call
+//   - ctx context.Context
+//   - id udmrepo.ID
+func (_e *BackupRepo_Expecter) DeleteManifest(ctx interface{}, id interface{}) *BackupRepo_DeleteManifest_Call {
+	return &BackupRepo_DeleteManifest_Call{Call: _e.mock.On("DeleteManifest", ctx, id)}
+}
+
+func (_c *BackupRepo_DeleteManifest_Call) Run(run func(ctx context.Context, id udmrepo.ID)) *BackupRepo_DeleteManifest_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 udmrepo.ID
+		if args[1] != nil {
+			arg1 = args[1].(udmrepo.ID)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *BackupRepo_DeleteManifest_Call) Return(err error) *BackupRepo_DeleteManifest_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *BackupRepo_DeleteManifest_Call) RunAndReturn(run func(ctx context.Context, id udmrepo.ID) error) *BackupRepo_DeleteManifest_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// DeleteSnapshot provides a mock function for the type BackupRepo
+func (_mock *BackupRepo) DeleteSnapshot(ctx context.Context, id udmrepo.ID) error {
+	ret := _mock.Called(ctx, id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteSnapshot")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ID) error); ok {
+		r0 = returnFunc(ctx, id)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// BackupRepo_DeleteSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSnapshot'
+type BackupRepo_DeleteSnapshot_Call struct {
+	*mock.Call
+}
+
+// DeleteSnapshot is a helper method to define mock.On call
+//   - ctx context.Context
+//   - id udmrepo.ID
+func (_e *BackupRepo_Expecter) DeleteSnapshot(ctx interface{}, id interface{}) *BackupRepo_DeleteSnapshot_Call {
+	return &BackupRepo_DeleteSnapshot_Call{Call: _e.mock.On("DeleteSnapshot", ctx, id)}
+}
+
+func (_c *BackupRepo_DeleteSnapshot_Call) Run(run func(ctx context.Context, id udmrepo.ID)) *BackupRepo_DeleteSnapshot_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 udmrepo.ID
+		if args[1] != nil {
+			arg1 = args[1].(udmrepo.ID)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *BackupRepo_DeleteSnapshot_Call) Return(err error) *BackupRepo_DeleteSnapshot_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *BackupRepo_DeleteSnapshot_Call) RunAndReturn(run func(ctx context.Context, id udmrepo.ID) error) *BackupRepo_DeleteSnapshot_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FindManifests provides a mock function for the type BackupRepo
+func (_mock *BackupRepo) FindManifests(ctx context.Context, filter udmrepo.ManifestFilter) ([]*udmrepo.ManifestEntryMetadata, error) {
+	ret := _mock.Called(ctx, filter)
+
+	if len(ret) == 0 {
+		panic("no return value specified for FindManifests")
+	}
+
+	var r0 []*udmrepo.ManifestEntryMetadata
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ManifestFilter) ([]*udmrepo.ManifestEntryMetadata, error)); ok {
+		return returnFunc(ctx, filter)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ManifestFilter) []*udmrepo.ManifestEntryMetadata); ok {
+		r0 = returnFunc(ctx, filter)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*udmrepo.ManifestEntryMetadata)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, udmrepo.ManifestFilter) error); ok {
+		r1 = returnFunc(ctx, filter)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// BackupRepo_FindManifests_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindManifests'
+type BackupRepo_FindManifests_Call struct {
+	*mock.Call
+}
+
+// FindManifests is a helper method to define mock.On call
+//   - ctx context.Context
+//   - filter udmrepo.ManifestFilter
+func (_e *BackupRepo_Expecter) FindManifests(ctx interface{}, filter interface{}) *BackupRepo_FindManifests_Call {
+	return &BackupRepo_FindManifests_Call{Call: _e.mock.On("FindManifests", ctx, filter)}
+}
+
+func (_c *BackupRepo_FindManifests_Call) Run(run func(ctx context.Context, filter udmrepo.ManifestFilter)) *BackupRepo_FindManifests_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 udmrepo.ManifestFilter
+		if args[1] != nil {
+			arg1 = args[1].(udmrepo.ManifestFilter)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *BackupRepo_FindManifests_Call) Return(manifestEntryMetadatas []*udmrepo.ManifestEntryMetadata, err error) *BackupRepo_FindManifests_Call {
+	_c.Call.Return(manifestEntryMetadatas, err)
+	return _c
+}
+
+func (_c *BackupRepo_FindManifests_Call) RunAndReturn(run func(ctx context.Context, filter udmrepo.ManifestFilter) ([]*udmrepo.ManifestEntryMetadata, error)) *BackupRepo_FindManifests_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Flush provides a mock function for the type BackupRepo
+func (_mock *BackupRepo) Flush(ctx context.Context) error {
+	ret := _mock.Called(ctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Flush")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
+		r0 = returnFunc(ctx)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// BackupRepo_Flush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Flush'
+type BackupRepo_Flush_Call struct {
+	*mock.Call
+}
+
+// Flush is a helper method to define mock.On call
+//   - ctx context.Context
+func (_e *BackupRepo_Expecter) Flush(ctx interface{}) *BackupRepo_Flush_Call {
+	return &BackupRepo_Flush_Call{Call: _e.mock.On("Flush", ctx)}
+}
+
+func (_c *BackupRepo_Flush_Call) Run(run func(ctx context.Context)) *BackupRepo_Flush_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *BackupRepo_Flush_Call) Return(err error) *BackupRepo_Flush_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *BackupRepo_Flush_Call) RunAndReturn(run func(ctx context.Context) error) *BackupRepo_Flush_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetAdvancedFeatures provides a mock function for the type BackupRepo
+func (_mock *BackupRepo) GetAdvancedFeatures() udmrepo.AdvancedFeatureInfo {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAdvancedFeatures")
+	}
+
+	var r0 udmrepo.AdvancedFeatureInfo
+	if returnFunc, ok := ret.Get(0).(func() udmrepo.AdvancedFeatureInfo); ok {
+		r0 = returnFunc()
+	} else {
+		r0 = ret.Get(0).(udmrepo.AdvancedFeatureInfo)
+	}
+	return r0
+}
+
+// BackupRepo_GetAdvancedFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAdvancedFeatures'
+type BackupRepo_GetAdvancedFeatures_Call struct {
+	*mock.Call
+}
+
+// GetAdvancedFeatures is a helper method to define mock.On call
+func (_e *BackupRepo_Expecter) GetAdvancedFeatures() *BackupRepo_GetAdvancedFeatures_Call {
+	return &BackupRepo_GetAdvancedFeatures_Call{Call: _e.mock.On("GetAdvancedFeatures")}
+}
+
+func (_c *BackupRepo_GetAdvancedFeatures_Call) Run(run func()) *BackupRepo_GetAdvancedFeatures_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *BackupRepo_GetAdvancedFeatures_Call) Return(advancedFeatureInfo udmrepo.AdvancedFeatureInfo) *BackupRepo_GetAdvancedFeatures_Call {
+	_c.Call.Return(advancedFeatureInfo)
+	return _c
+}
+
+func (_c *BackupRepo_GetAdvancedFeatures_Call) RunAndReturn(run func() udmrepo.AdvancedFeatureInfo) *BackupRepo_GetAdvancedFeatures_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetManifest provides a mock function for the type BackupRepo
+func (_mock *BackupRepo) GetManifest(ctx context.Context, id udmrepo.ID, mani *udmrepo.RepoManifest) error {
+	ret := _mock.Called(ctx, id, mani)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetManifest")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ID, *udmrepo.RepoManifest) error); ok {
+		r0 = returnFunc(ctx, id, mani)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// BackupRepo_GetManifest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetManifest'
+type BackupRepo_GetManifest_Call struct {
+	*mock.Call
+}
+
+// GetManifest is a helper method to define mock.On call
+//   - ctx context.Context
+//   - id udmrepo.ID
+//   - mani *udmrepo.RepoManifest
+func (_e *BackupRepo_Expecter) GetManifest(ctx interface{}, id interface{}, mani interface{}) *BackupRepo_GetManifest_Call {
+	return &BackupRepo_GetManifest_Call{Call: _e.mock.On("GetManifest", ctx, id, mani)}
+}
+
+func (_c *BackupRepo_GetManifest_Call) Run(run func(ctx context.Context, id udmrepo.ID, mani *udmrepo.RepoManifest)) *BackupRepo_GetManifest_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 udmrepo.ID
+		if args[1] != nil {
+			arg1 = args[1].(udmrepo.ID)
+		}
+		var arg2 *udmrepo.RepoManifest
+		if args[2] != nil {
+			arg2 = args[2].(*udmrepo.RepoManifest)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *BackupRepo_GetManifest_Call) Return(err error) *BackupRepo_GetManifest_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *BackupRepo_GetManifest_Call) RunAndReturn(run func(ctx context.Context, id udmrepo.ID, mani *udmrepo.RepoManifest) error) *BackupRepo_GetManifest_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetSnapshot provides a mock function for the type BackupRepo
+func (_mock *BackupRepo) GetSnapshot(ctx context.Context, id udmrepo.ID) (udmrepo.Snapshot, error) {
+	ret := _mock.Called(ctx, id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetSnapshot")
+	}
+
+	var r0 udmrepo.Snapshot
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ID) (udmrepo.Snapshot, error)); ok {
+		return returnFunc(ctx, id)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ID) udmrepo.Snapshot); ok {
+		r0 = returnFunc(ctx, id)
+	} else {
+		r0 = ret.Get(0).(udmrepo.Snapshot)
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, udmrepo.ID) error); ok {
+		r1 = returnFunc(ctx, id)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// BackupRepo_GetSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSnapshot'
+type BackupRepo_GetSnapshot_Call struct {
+	*mock.Call
+}
+
+// GetSnapshot is a helper method to define mock.On call
+//   - ctx context.Context
+//   - id udmrepo.ID
+func (_e *BackupRepo_Expecter) GetSnapshot(ctx interface{}, id interface{}) *BackupRepo_GetSnapshot_Call {
+	return &BackupRepo_GetSnapshot_Call{Call: _e.mock.On("GetSnapshot", ctx, id)}
+}
+
+func (_c *BackupRepo_GetSnapshot_Call) Run(run func(ctx context.Context, id udmrepo.ID)) *BackupRepo_GetSnapshot_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 udmrepo.ID
+		if args[1] != nil {
+			arg1 = args[1].(udmrepo.ID)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *BackupRepo_GetSnapshot_Call) Return(snapshot udmrepo.Snapshot, err error) *BackupRepo_GetSnapshot_Call {
+	_c.Call.Return(snapshot, err)
+	return _c
+}
+
+func (_c *BackupRepo_GetSnapshot_Call) RunAndReturn(run func(ctx context.Context, id udmrepo.ID) (udmrepo.Snapshot, error)) *BackupRepo_GetSnapshot_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewObjectWriter provides a mock function for the type BackupRepo
+func (_mock *BackupRepo) NewObjectWriter(ctx context.Context, opt udmrepo.ObjectWriteOptions) (udmrepo.ObjectWriter, error) {
+	ret := _mock.Called(ctx, opt)
+
+	if len(ret) == 0 {
+		panic("no return value specified for NewObjectWriter")
+	}
+
+	var r0 udmrepo.ObjectWriter
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ObjectWriteOptions) (udmrepo.ObjectWriter, error)); ok {
+		return returnFunc(ctx, opt)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ObjectWriteOptions) udmrepo.ObjectWriter); ok {
+		r0 = returnFunc(ctx, opt)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(udmrepo.ObjectWriter)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, udmrepo.ObjectWriteOptions) error); ok {
+		r1 = returnFunc(ctx, opt)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// BackupRepo_NewObjectWriter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewObjectWriter'
+type BackupRepo_NewObjectWriter_Call struct {
+	*mock.Call
+}
+
+// NewObjectWriter is a helper method to define mock.On call
+//   - ctx context.Context
+//   - opt udmrepo.ObjectWriteOptions
+func (_e *BackupRepo_Expecter) NewObjectWriter(ctx interface{}, opt interface{}) *BackupRepo_NewObjectWriter_Call {
+	return &BackupRepo_NewObjectWriter_Call{Call: _e.mock.On("NewObjectWriter", ctx, opt)}
+}
+
+func (_c *BackupRepo_NewObjectWriter_Call) Run(run func(ctx context.Context, opt udmrepo.ObjectWriteOptions)) *BackupRepo_NewObjectWriter_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 udmrepo.ObjectWriteOptions
+		if args[1] != nil {
+			arg1 = args[1].(udmrepo.ObjectWriteOptions)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *BackupRepo_NewObjectWriter_Call) Return(objectWriter udmrepo.ObjectWriter, err error) *BackupRepo_NewObjectWriter_Call {
+	_c.Call.Return(objectWriter, err)
+	return _c
+}
+
+func (_c *BackupRepo_NewObjectWriter_Call) RunAndReturn(run func(ctx context.Context, opt udmrepo.ObjectWriteOptions) (udmrepo.ObjectWriter, error)) *BackupRepo_NewObjectWriter_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// OpenObject provides a mock function for the type BackupRepo
+func (_mock *BackupRepo) OpenObject(ctx context.Context, id udmrepo.ID) (udmrepo.ObjectReader, error) {
+	ret := _mock.Called(ctx, id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OpenObject")
+	}
+
+	var r0 udmrepo.ObjectReader
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ID) (udmrepo.ObjectReader, error)); ok {
+		return returnFunc(ctx, id)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ID) udmrepo.ObjectReader); ok {
+		r0 = returnFunc(ctx, id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(udmrepo.ObjectReader)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, udmrepo.ID) error); ok {
+		r1 = returnFunc(ctx, id)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// BackupRepo_OpenObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenObject'
+type BackupRepo_OpenObject_Call struct {
+	*mock.Call
+}
+
+// OpenObject is a helper method to define mock.On call
+//   - ctx context.Context
+//   - id udmrepo.ID
+func (_e *BackupRepo_Expecter) OpenObject(ctx interface{}, id interface{}) *BackupRepo_OpenObject_Call {
+	return &BackupRepo_OpenObject_Call{Call: _e.mock.On("OpenObject", ctx, id)}
+}
+
+func (_c *BackupRepo_OpenObject_Call) Run(run func(ctx context.Context, id udmrepo.ID)) *BackupRepo_OpenObject_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 udmrepo.ID
+		if args[1] != nil {
+			arg1 = args[1].(udmrepo.ID)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *BackupRepo_OpenObject_Call) Return(objectReader udmrepo.ObjectReader, err error) *BackupRepo_OpenObject_Call {
+	_c.Call.Return(objectReader, err)
+	return _c
+}
+
+func (_c *BackupRepo_OpenObject_Call) RunAndReturn(run func(ctx context.Context, id udmrepo.ID) (udmrepo.ObjectReader, error)) *BackupRepo_OpenObject_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// PutManifest provides a mock function for the type BackupRepo
+func (_mock *BackupRepo) PutManifest(ctx context.Context, mani udmrepo.RepoManifest) (udmrepo.ID, error) {
+	ret := _mock.Called(ctx, mani)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PutManifest")
+	}
+
+	var r0 udmrepo.ID
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.RepoManifest) (udmrepo.ID, error)); ok {
+		return returnFunc(ctx, mani)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.RepoManifest) udmrepo.ID); ok {
+		r0 = returnFunc(ctx, mani)
+	} else {
+		r0 = ret.Get(0).(udmrepo.ID)
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, udmrepo.RepoManifest) error); ok {
+		r1 = returnFunc(ctx, mani)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// BackupRepo_PutManifest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutManifest'
+type BackupRepo_PutManifest_Call struct {
+	*mock.Call
+}
+
+// PutManifest is a helper method to define mock.On call
+//   - ctx context.Context
+//   - mani udmrepo.RepoManifest
+func (_e *BackupRepo_Expecter) PutManifest(ctx interface{}, mani interface{}) *BackupRepo_PutManifest_Call {
+	return &BackupRepo_PutManifest_Call{Call: _e.mock.On("PutManifest", ctx, mani)}
+}
+
+func (_c *BackupRepo_PutManifest_Call) Run(run func(ctx context.Context, mani udmrepo.RepoManifest)) *BackupRepo_PutManifest_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 udmrepo.RepoManifest
+		if args[1] != nil {
+			arg1 = args[1].(udmrepo.RepoManifest)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *BackupRepo_PutManifest_Call) Return(iD udmrepo.ID, err error) *BackupRepo_PutManifest_Call {
+	_c.Call.Return(iD, err)
+	return _c
+}
+
+func (_c *BackupRepo_PutManifest_Call) RunAndReturn(run func(ctx context.Context, mani udmrepo.RepoManifest) (udmrepo.ID, error)) *BackupRepo_PutManifest_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ReadMetadata provides a mock function for the type BackupRepo
+func (_mock *BackupRepo) ReadMetadata(ctx context.Context, id udmrepo.ID) (*udmrepo.Metadata, error) {
+	ret := _mock.Called(ctx, id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ReadMetadata")
+	}
+
+	var r0 *udmrepo.Metadata
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ID) (*udmrepo.Metadata, error)); ok {
+		return returnFunc(ctx, id)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ID) *udmrepo.Metadata); ok {
+		r0 = returnFunc(ctx, id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*udmrepo.Metadata)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, udmrepo.ID) error); ok {
+		r1 = returnFunc(ctx, id)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// BackupRepo_ReadMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadMetadata'
+type BackupRepo_ReadMetadata_Call struct {
+	*mock.Call
+}
+
+// ReadMetadata is a helper method to define mock.On call
+//   - ctx context.Context
+//   - id udmrepo.ID
+func (_e *BackupRepo_Expecter) ReadMetadata(ctx interface{}, id interface{}) *BackupRepo_ReadMetadata_Call {
+	return &BackupRepo_ReadMetadata_Call{Call: _e.mock.On("ReadMetadata", ctx, id)}
+}
+
+func (_c *BackupRepo_ReadMetadata_Call) Run(run func(ctx context.Context, id udmrepo.ID)) *BackupRepo_ReadMetadata_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 udmrepo.ID
+		if args[1] != nil {
+			arg1 = args[1].(udmrepo.ID)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *BackupRepo_ReadMetadata_Call) Return(metadata *udmrepo.Metadata, err error) *BackupRepo_ReadMetadata_Call {
+	_c.Call.Return(metadata, err)
+	return _c
+}
+
+func (_c *BackupRepo_ReadMetadata_Call) RunAndReturn(run func(ctx context.Context, id udmrepo.ID) (*udmrepo.Metadata, error)) *BackupRepo_ReadMetadata_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SaveSnapshot provides a mock function for the type BackupRepo
+func (_mock *BackupRepo) SaveSnapshot(ctx context.Context, snapshot udmrepo.Snapshot) (udmrepo.ID, error) {
+	ret := _mock.Called(ctx, snapshot)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveSnapshot")
+	}
+
+	var r0 udmrepo.ID
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.Snapshot) (udmrepo.ID, error)); ok {
+		return returnFunc(ctx, snapshot)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.Snapshot) udmrepo.ID); ok {
+		r0 = returnFunc(ctx, snapshot)
+	} else {
+		r0 = ret.Get(0).(udmrepo.ID)
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, udmrepo.Snapshot) error); ok {
+		r1 = returnFunc(ctx, snapshot)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// BackupRepo_SaveSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveSnapshot'
+type BackupRepo_SaveSnapshot_Call struct {
+	*mock.Call
+}
+
+// SaveSnapshot is a helper method to define mock.On call
+//   - ctx context.Context
+//   - snapshot udmrepo.Snapshot
+func (_e *BackupRepo_Expecter) SaveSnapshot(ctx interface{}, snapshot interface{}) *BackupRepo_SaveSnapshot_Call {
+	return &BackupRepo_SaveSnapshot_Call{Call: _e.mock.On("SaveSnapshot", ctx, snapshot)}
+}
+
+func (_c *BackupRepo_SaveSnapshot_Call) Run(run func(ctx context.Context, snapshot udmrepo.Snapshot)) *BackupRepo_SaveSnapshot_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 udmrepo.Snapshot
+		if args[1] != nil {
+			arg1 = args[1].(udmrepo.Snapshot)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *BackupRepo_SaveSnapshot_Call) Return(iD udmrepo.ID, err error) *BackupRepo_SaveSnapshot_Call {
+	_c.Call.Return(iD, err)
+	return _c
+}
+
+func (_c *BackupRepo_SaveSnapshot_Call) RunAndReturn(run func(ctx context.Context, snapshot udmrepo.Snapshot) (udmrepo.ID, error)) *BackupRepo_SaveSnapshot_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Time provides a mock function for the type BackupRepo
+func (_mock *BackupRepo) Time() time.Time {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Time")
+	}
+
+	var r0 time.Time
+	if returnFunc, ok := ret.Get(0).(func() time.Time); ok {
+		r0 = returnFunc()
+	} else {
+		r0 = ret.Get(0).(time.Time)
+	}
+	return r0
+}
+
+// BackupRepo_Time_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Time'
+type BackupRepo_Time_Call struct {
+	*mock.Call
+}
+
+// Time is a helper method to define mock.On call
+func (_e *BackupRepo_Expecter) Time() *BackupRepo_Time_Call {
+	return &BackupRepo_Time_Call{Call: _e.mock.On("Time")}
+}
+
+func (_c *BackupRepo_Time_Call) Run(run func()) *BackupRepo_Time_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *BackupRepo_Time_Call) Return(time1 time.Time) *BackupRepo_Time_Call {
+	_c.Call.Return(time1)
+	return _c
+}
+
+func (_c *BackupRepo_Time_Call) RunAndReturn(run func() time.Time) *BackupRepo_Time_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// WriteMetadata provides a mock function for the type BackupRepo
+func (_mock *BackupRepo) WriteMetadata(ctx context.Context, meta *udmrepo.Metadata, opt udmrepo.ObjectWriteOptions) (udmrepo.ID, error) {
+	ret := _mock.Called(ctx, meta, opt)
+
+	if len(ret) == 0 {
+		panic("no return value specified for WriteMetadata")
+	}
+
+	var r0 udmrepo.ID
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *udmrepo.Metadata, udmrepo.ObjectWriteOptions) (udmrepo.ID, error)); ok {
+		return returnFunc(ctx, meta, opt)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *udmrepo.Metadata, udmrepo.ObjectWriteOptions) udmrepo.ID); ok {
+		r0 = returnFunc(ctx, meta, opt)
+	} else {
+		r0 = ret.Get(0).(udmrepo.ID)
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *udmrepo.Metadata, udmrepo.ObjectWriteOptions) error); ok {
+		r1 = returnFunc(ctx, meta, opt)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// BackupRepo_WriteMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteMetadata'
+type BackupRepo_WriteMetadata_Call struct {
+	*mock.Call
+}
+
+// WriteMetadata is a helper method to define mock.On call
+//   - ctx context.Context
+//   - meta *udmrepo.Metadata
+//   - opt udmrepo.ObjectWriteOptions
+func (_e *BackupRepo_Expecter) WriteMetadata(ctx interface{}, meta interface{}, opt interface{}) *BackupRepo_WriteMetadata_Call {
+	return &BackupRepo_WriteMetadata_Call{Call: _e.mock.On("WriteMetadata", ctx, meta, opt)}
+}
+
+func (_c *BackupRepo_WriteMetadata_Call) Run(run func(ctx context.Context, meta *udmrepo.Metadata, opt udmrepo.ObjectWriteOptions)) *BackupRepo_WriteMetadata_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 *udmrepo.Metadata
+		if args[1] != nil {
+			arg1 = args[1].(*udmrepo.Metadata)
+		}
+		var arg2 udmrepo.ObjectWriteOptions
+		if args[2] != nil {
+			arg2 = args[2].(udmrepo.ObjectWriteOptions)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *BackupRepo_WriteMetadata_Call) Return(iD udmrepo.ID, err error) *BackupRepo_WriteMetadata_Call {
+	_c.Call.Return(iD, err)
+	return _c
+}
+
+func (_c *BackupRepo_WriteMetadata_Call) RunAndReturn(run func(ctx context.Context, meta *udmrepo.Metadata, opt udmrepo.ObjectWriteOptions) (udmrepo.ID, error)) *BackupRepo_WriteMetadata_Call {
+	_c.Call.Return(run)
+	return _c
+}
diff --git a/pkg/repository/udmrepo/mocks/ObjectWriter.go b/pkg/repository/udmrepo/mocks/ObjectWriter.go
index 4bc21f8b7..d50a3ce76 100644
--- a/pkg/repository/udmrepo/mocks/ObjectWriter.go
+++ b/pkg/repository/udmrepo/mocks/ObjectWriter.go
@@ -1,147 +1,14 @@
-// Code generated by mockery v2.39.1. DO NOT EDIT.
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 
 package mocks
 
 import (
 	mock "github.com/stretchr/testify/mock"
-	udmrepo "github.com/vmware-tanzu/velero/pkg/repository/udmrepo"
+	"github.com/vmware-tanzu/velero/pkg/repository/udmrepo"
 )
 
-// ObjectWriter is an autogenerated mock type for the ObjectWriter type
-type ObjectWriter struct {
-	mock.Mock
-}
-
-// Checkpoint provides a mock function with given fields:
-func (_m *ObjectWriter) Checkpoint() (udmrepo.ID, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Checkpoint")
-	}
-
-	var r0 udmrepo.ID
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (udmrepo.ID, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() udmrepo.ID); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(udmrepo.ID)
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Close provides a mock function with given fields:
-func (_m *ObjectWriter) Close() error {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Close")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Result provides a mock function with given fields:
-func (_m *ObjectWriter) Result() (udmrepo.ID, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Result")
-	}
-
-	var r0 udmrepo.ID
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (udmrepo.ID, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() udmrepo.ID); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(udmrepo.ID)
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Seek provides a mock function with given fields: offset, whence
-func (_m *ObjectWriter) Seek(offset int64, whence int) (int64, error) {
-	ret := _m.Called(offset, whence)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Seek")
-	}
-
-	var r0 int64
-	var r1 error
-	if rf, ok := ret.Get(0).(func(int64, int) (int64, error)); ok {
-		return rf(offset, whence)
-	}
-	if rf, ok := ret.Get(0).(func(int64, int) int64); ok {
-		r0 = rf(offset, whence)
-	} else {
-		r0 = ret.Get(0).(int64)
-	}
-
-	if rf, ok := ret.Get(1).(func(int64, int) error); ok {
-		r1 = rf(offset, whence)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Write provides a mock function with given fields: p
-func (_m *ObjectWriter) Write(p []byte) (int, error) {
-	ret := _m.Called(p)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Write")
-	}
-
-	var r0 int
-	var r1 error
-	if rf, ok := ret.Get(0).(func([]byte) (int, error)); ok {
-		return rf(p)
-	}
-	if rf, ok := ret.Get(0).(func([]byte) int); ok {
-		r0 = rf(p)
-	} else {
-		r0 = ret.Get(0).(int)
-	}
-
-	if rf, ok := ret.Get(1).(func([]byte) error); ok {
-		r1 = rf(p)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
 // NewObjectWriter creates a new instance of ObjectWriter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
 func NewObjectWriter(t interface {
@@ -155,3 +22,292 @@ func NewObjectWriter(t interface {
 
 	return mock
 }
+
+// ObjectWriter is an autogenerated mock type for the ObjectWriter type
+type ObjectWriter struct {
+	mock.Mock
+}
+
+type ObjectWriter_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *ObjectWriter) EXPECT() *ObjectWriter_Expecter {
+	return &ObjectWriter_Expecter{mock: &_m.Mock}
+}
+
+// Checkpoint provides a mock function for the type ObjectWriter
+func (_mock *ObjectWriter) Checkpoint() (udmrepo.ID, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Checkpoint")
+	}
+
+	var r0 udmrepo.ID
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (udmrepo.ID, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() udmrepo.ID); ok {
+		r0 = returnFunc()
+	} else {
+		r0 = ret.Get(0).(udmrepo.ID)
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// ObjectWriter_Checkpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Checkpoint'
+type ObjectWriter_Checkpoint_Call struct {
+	*mock.Call
+}
+
+// Checkpoint is a helper method to define mock.On call
+func (_e *ObjectWriter_Expecter) Checkpoint() *ObjectWriter_Checkpoint_Call {
+	return &ObjectWriter_Checkpoint_Call{Call: _e.mock.On("Checkpoint")}
+}
+
+func (_c *ObjectWriter_Checkpoint_Call) Run(run func()) *ObjectWriter_Checkpoint_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *ObjectWriter_Checkpoint_Call) Return(iD udmrepo.ID, err error) *ObjectWriter_Checkpoint_Call {
+	_c.Call.Return(iD, err)
+	return _c
+}
+
+func (_c *ObjectWriter_Checkpoint_Call) RunAndReturn(run func() (udmrepo.ID, error)) *ObjectWriter_Checkpoint_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Close provides a mock function for the type ObjectWriter
+func (_mock *ObjectWriter) Close() error {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Close")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// ObjectWriter_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
+type ObjectWriter_Close_Call struct {
+	*mock.Call
+}
+
+// Close is a helper method to define mock.On call
+func (_e *ObjectWriter_Expecter) Close() *ObjectWriter_Close_Call {
+	return &ObjectWriter_Close_Call{Call: _e.mock.On("Close")}
+}
+
+func (_c *ObjectWriter_Close_Call) Run(run func()) *ObjectWriter_Close_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *ObjectWriter_Close_Call) Return(err error) *ObjectWriter_Close_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *ObjectWriter_Close_Call) RunAndReturn(run func() error) *ObjectWriter_Close_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Result provides a mock function for the type ObjectWriter
+func (_mock *ObjectWriter) Result() (udmrepo.ID, error) {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Result")
+	}
+
+	var r0 udmrepo.ID
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func() (udmrepo.ID, error)); ok {
+		return returnFunc()
+	}
+	if returnFunc, ok := ret.Get(0).(func() udmrepo.ID); ok {
+		r0 = returnFunc()
+	} else {
+		r0 = ret.Get(0).(udmrepo.ID)
+	}
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// ObjectWriter_Result_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Result'
+type ObjectWriter_Result_Call struct {
+	*mock.Call
+}
+
+// Result is a helper method to define mock.On call
+func (_e *ObjectWriter_Expecter) Result() *ObjectWriter_Result_Call {
+	return &ObjectWriter_Result_Call{Call: _e.mock.On("Result")}
+}
+
+func (_c *ObjectWriter_Result_Call) Run(run func()) *ObjectWriter_Result_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *ObjectWriter_Result_Call) Return(iD udmrepo.ID, err error) *ObjectWriter_Result_Call {
+	_c.Call.Return(iD, err)
+	return _c
+}
+
+func (_c *ObjectWriter_Result_Call) RunAndReturn(run func() (udmrepo.ID, error)) *ObjectWriter_Result_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Write provides a mock function for the type ObjectWriter
+func (_mock *ObjectWriter) Write(p []byte) (int, error) {
+	ret := _mock.Called(p)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Write")
+	}
+
+	var r0 int
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {
+		return returnFunc(p)
+	}
+	if returnFunc, ok := ret.Get(0).(func([]byte) int); ok {
+		r0 = returnFunc(p)
+	} else {
+		r0 = ret.Get(0).(int)
+	}
+	if returnFunc, ok := ret.Get(1).(func([]byte) error); ok {
+		r1 = returnFunc(p)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// ObjectWriter_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write'
+type ObjectWriter_Write_Call struct {
+	*mock.Call
+}
+
+// Write is a helper method to define mock.On call
+//   - p []byte
+func (_e *ObjectWriter_Expecter) Write(p interface{}) *ObjectWriter_Write_Call {
+	return &ObjectWriter_Write_Call{Call: _e.mock.On("Write", p)}
+}
+
+func (_c *ObjectWriter_Write_Call) Run(run func(p []byte)) *ObjectWriter_Write_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 []byte
+		if args[0] != nil {
+			arg0 = args[0].([]byte)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *ObjectWriter_Write_Call) Return(n int, err error) *ObjectWriter_Write_Call {
+	_c.Call.Return(n, err)
+	return _c
+}
+
+func (_c *ObjectWriter_Write_Call) RunAndReturn(run func(p []byte) (int, error)) *ObjectWriter_Write_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// WriteAt provides a mock function for the type ObjectWriter
+func (_mock *ObjectWriter) WriteAt(p []byte, off int64) (int, error) {
+	ret := _mock.Called(p, off)
+
+	if len(ret) == 0 {
+		panic("no return value specified for WriteAt")
+	}
+
+	var r0 int
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func([]byte, int64) (int, error)); ok {
+		return returnFunc(p, off)
+	}
+	if returnFunc, ok := ret.Get(0).(func([]byte, int64) int); ok {
+		r0 = returnFunc(p, off)
+	} else {
+		r0 = ret.Get(0).(int)
+	}
+	if returnFunc, ok := ret.Get(1).(func([]byte, int64) error); ok {
+		r1 = returnFunc(p, off)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// ObjectWriter_WriteAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteAt'
+type ObjectWriter_WriteAt_Call struct {
+	*mock.Call
+}
+
+// WriteAt is a helper method to define mock.On call
+//   - p []byte
+//   - off int64
+func (_e *ObjectWriter_Expecter) WriteAt(p interface{}, off interface{}) *ObjectWriter_WriteAt_Call {
+	return &ObjectWriter_WriteAt_Call{Call: _e.mock.On("WriteAt", p, off)}
+}
+
+func (_c *ObjectWriter_WriteAt_Call) Run(run func(p []byte, off int64)) *ObjectWriter_WriteAt_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 []byte
+		if args[0] != nil {
+			arg0 = args[0].([]byte)
+		}
+		var arg1 int64
+		if args[1] != nil {
+			arg1 = args[1].(int64)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *ObjectWriter_WriteAt_Call) Return(n int, err error) *ObjectWriter_WriteAt_Call {
+	_c.Call.Return(n, err)
+	return _c
+}
+
+func (_c *ObjectWriter_WriteAt_Call) RunAndReturn(run func(p []byte, off int64) (int, error)) *ObjectWriter_WriteAt_Call {
+	_c.Call.Return(run)
+	return _c
+}
diff --git a/pkg/repository/udmrepo/repo.go b/pkg/repository/udmrepo/repo.go
index 1e7e4d011..095d18973 100644
--- a/pkg/repository/udmrepo/repo.go
+++ b/pkg/repository/udmrepo/repo.go
@@ -62,19 +62,41 @@ const (
 
 // ObjectWriteOptions defines the options when creating an object for write
 type ObjectWriteOptions struct {
-	FullPath    string // Full logical path of the object
-	DataType    int    // OBJECT_DATA_TYPE_*
-	Description string // A description of the object, could be empty
-	Prefix      ID     // A prefix of the name used to save the object
-	AccessMode  int    // OBJECT_DATA_ACCESS_*
-	BackupMode  int    // OBJECT_DATA_BACKUP_*
-	AsyncWrites int    // Num of async writes for the object, 0 means no async write
+	FullPath     string // Full logical path of the object
+	DataType     int    // OBJECT_DATA_TYPE_*
+	Description  string // A description of the object, could be empty
+	Prefix       ID     // A prefix of the name used to save the object
+	AccessMode   int    // OBJECT_DATA_ACCESS_*
+	BackupMode   int    // OBJECT_DATA_BACKUP_*
+	AsyncWrites  int    // Num of async writes for the object, 0 means no async write
+	ParentObject ID     // The object in the previous snapshot, for incremental backup
 }
 
 type AdvancedFeatureInfo struct {
 	MultiPartBackup bool // if set to true, it means the repo supports multiple-part backup
 }
 
+type ObjectMetadata struct {
+	ID   ID
+	Type int // OBJECT_DATA_TYPE_*
+	Size int64
+}
+
+type Metadata struct {
+	SubObjects   []ObjectMetadata // For dir metadata only, the sub objects in this dir.
+	ExtraDataLen int              // Extra data associated to this metadata.
+	ExtraData    []byte
+}
+
+type Snapshot struct {
+	Source      string
+	Description string
+	StartTime   time.Time
+	EndTime     time.Time
+	Tags        map[string]string
+	RootObject  ID
+}
+
 // BackupRepoService is used to initialize, open or maintain a backup repository
 type BackupRepoService interface {
 	// Create creates a new backup repository.
@@ -119,7 +141,14 @@ type BackupRepo interface {
 
 	// NewObjectWriter creates a new object and return the object's writer interface.
 	// return: A unified identifier of the object on success.
-	NewObjectWriter(ctx context.Context, opt ObjectWriteOptions) ObjectWriter
+	NewObjectWriter(ctx context.Context, opt ObjectWriteOptions) (ObjectWriter, error)
+
+	// WriteMetadata writes metadata to the repo, metadata is used to describe data, e.g., file system
+	// dirs are saved as metadata
+	WriteMetadata(ctx context.Context, meta *Metadata, opt ObjectWriteOptions) (ID, error)
+
+	// ReadMetadata reads a metadata from repo by the metadata's object ID
+	ReadMetadata(ctx context.Context, id ID) (*Metadata, error)
 
 	// PutManifest saves a manifest object into the backup repository.
 	PutManifest(ctx context.Context, mani RepoManifest) (ID, error)
@@ -139,6 +168,15 @@ type BackupRepo interface {
 	// Time returns the local time of the backup repository. It may be different from the time of the caller
 	Time() time.Time
 
+	// SaveSnapshot saves a repo snapshot
+	SaveSnapshot(ctx context.Context, snapshot Snapshot) (ID, error)
+
+	// GetSnapshot returns a repo snapshot from snapshot ID
+	GetSnapshot(ctx context.Context, id ID) (Snapshot, error)
+
+	// DeleteSnapshot deletes a repo snapshot
+	DeleteSnapshot(ctx context.Context, id ID) error
+
 	// Close closes the backup repository
 	Close(ctx context.Context) error
 }
@@ -154,8 +192,8 @@ type ObjectReader interface {
 type ObjectWriter interface {
 	io.WriteCloser
 
-	// Seeker is used in the cases that the object is not written sequentially
-	io.Seeker
+	// WriterAt is used in the cases that the object is not written sequentially
+	io.WriterAt
 
 	// Checkpoint is periodically called to preserve the state of data written to the repo so far.
 	// Checkpoint returns a unified identifier that represent the current state.
diff --git a/pkg/uploader/kopia/shim.go b/pkg/uploader/kopia/shim.go
index 1b9812d48..f146348fa 100644
--- a/pkg/uploader/kopia/shim.go
+++ b/pkg/uploader/kopia/shim.go
@@ -183,8 +183,8 @@ func (sr *shimRepository) NewObjectWriter(ctx context.Context, option object.Wri
 		opt.DataType = udmrepo.ObjectDataTypeData
 	}
 
-	writer := sr.udmRepo.NewObjectWriter(ctx, opt)
-	if writer == nil {
+	writer, err := sr.udmRepo.NewObjectWriter(ctx, opt)
+	if err != nil || writer == nil {
 		return nil
 	}
 
diff --git a/pkg/uploader/kopia/shim_test.go b/pkg/uploader/kopia/shim_test.go
index 69d1605a6..7933ec6b8 100644
--- a/pkg/uploader/kopia/shim_test.go
+++ b/pkg/uploader/kopia/shim_test.go
@@ -66,7 +66,7 @@ func TestShimRepo(t *testing.T) {
 	backupRepo.On("Flush", mock.Anything).Return(nil)
 	NewShimRepo(backupRepo).Flush(ctx)
 
-	backupRepo.On("NewObjectWriter", mock.Anything, mock.Anything).Return(nil)
+	backupRepo.On("NewObjectWriter", mock.Anything, mock.Anything).Return(nil, nil)
 	NewShimRepo(backupRepo).NewObjectWriter(ctx, object.WriterOptions{})
 }