}
	}

	return nil
}

// Delete - Remove the store directory from disk
func (store *QueueStore[_]) Delete() error {
	return os.Remove(store.directory)
}

// PutMultiple - puts an item to the store.
func (store *QueueStore[I]) PutMultiple(items []I) (Key, error) {
	// Generate a new UUID for the key.
	uid, err := uuid.NewRandom()
	if err != nil {
		return Key{}, err
	}

	store.Lock()

	var items []TestItem
	for i := 0; i < 10; i++ {
		items = append(items, TestItem{
			Name:     fmt.Sprintf("test-item-%d", i),
			Property: "property",
		})
	}

	if _, err := store.PutMultiple(items); err != nil {
		t.Fatalf("failed to put multiple; %v", err)
	}

	keys := store.List()
	if len(keys) != 1 {
		t.Fatalf("expected len(keys)=1, but found %d", len(keys))
	}

	key := keys[0]

}

func (b *Batch[I]) commit() error {
	switch len(b.items) {
	case 0:
		return nil
	case 1:
		_, err := b.store.Put(b.items[0])
		return err
	default:
	}
	if _, err := b.store.PutMultiple(b.items); err != nil {
		return err
	}
	b.items = make([]I, 0, b.limit)
	return nil
}

// Close commits the pending items and quits the goroutines
func (b *Batch[I]) Close() error {
	defer func() {

// Target - store target interface
type Target interface {
	Name() string
	SendFromStore(key Key) error
}

// Store - Used to persist items.
type Store[I any] interface {
	Put(item I) (Key, error)
	PutMultiple(item []I) (Key, error)
	Get(key Key) (I, error)
	GetMultiple(key Key) ([]I, error)
	GetRaw(key Key) ([]byte, error)
	PutRaw(b []byte) (Key, error)
	Len() int
	List() []Key
	Del(key Key) error
	Open() error