return
	}

	users := []*User{
		GetUser("delete-returning-1", Config{}),
		GetUser("delete-returning-2", Config{}),
		GetUser("delete-returning-3", Config{}),
	}
	DB.Create(&users)

	var results []User
	DB.Where("name IN ?", []string{users[0].Name, users[1].Name}).Clauses(clause.Returning{}).Delete(&results)
	if len(results) != 2 {
		t.Errorf("failed to return delete data, got %v", results)
	}

	var count int64

    }

    /**
     * Deletes all documents associated with the specified session ID from the given index.
     *
     * @param searchEngineClient the search engine client to use for deletion
     * @param index the index name to delete documents from
     * @param sessionId the session ID to delete documents for
     * @return the number of documents that were deleted
     */

case of versioned deletes a.k.a permanent delete of a version by doing a `mc rm --version-id` on a object, replication implementation marks a object version permanently deleted as `PENDING` purge and deletes the version from source after syncing to the target and ensuring target version is deleted. The delete marker being deleted or object version being deleted will still be visible on listing with `mc ls --versions` until the sync is completed. Objects marked as deleted will not be accessible via `GET`...

```
mc replicate edit alias/bucket --id xyz.id --replicate "delete,delete-marker"
```

To re-enable replica metadata modification syncing,

```
mc replicate edit alias/bucket --id xyz.id --replicate "delete,delete-marker,replica-metadata-sync"
```

## MinIO Extension

### Replicating Deletes

			if versioned || suspended {
				// Bucket is versioned and no version was explicitly
				// mentioned for deletes, create a delete marker instead.
				vr.ModTime = UTCNow()
				vr.Deleted = true
				// Versioning suspended means that we add a `null` version
				// delete marker, if not add a new version for this delete
				// marker.
				if versioned {
					vr.VersionID = mustGetUUID()
				}
			}
		}

            reload(updater);
        }
    }

    /**
     * Deletes a character mapping item from the dictionary file.
     *
     * @param item the character mapping item to delete
     */
    @Override
    public synchronized void delete(final CharMappingItem item) {
        final CharMappingItem mappingItem = item;

    }

    /**
     * Deletes a crawling information record and all its associated parameters.
     * First deletes all related CrawlingInfoParam records, then deletes the main record
     * with immediate refresh to ensure consistency.
     *
     * @param crawlingInfo the crawling information entity to delete
     */
    public void delete(final CrawlingInfo crawlingInfo) {

To permanently delete an object you need to specify the version you want to delete, only the user with appropriate permissions can permanently delete a version.  As shown below DELETE request called with a specific version id permanently deletes an object from a bucket. Delete marker is not added for DELETE requests with version id.

     */
    public void delete(final DuplicateHost duplicateHost) {

        duplicateHostBhv.delete(duplicateHost, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

    }

    /**
     * Retrieves all duplicate host configurations without pagination.
     *

                        Files.deleteIfExists(handleFile);
                    } catch (IOException deleteEx) {
                        log.error("Failed to delete corrupted handle file: " + handleFile, deleteEx);
                    }
                }
            }
        } catch (IOException e) {
            log.error("Failed to load persisted handles from directory: " + stateDirectory, e);
        }
    }

    /**