}
	set := s.getHashedSet(object)
	return set.DeleteObject(ctx, bucket, object, opts)
}

// DeleteObjects - bulk delete of objects
// Bulk delete is only possible within one set. For that purpose
// objects are group by set first, and then bulk delete is invoked
// for each set, the error response of each delete will be returned

                    logger.warn("Failed to execute command for thumbnail ID: {}", thumbnailId);
                    if (outputFile.isFile() && !outputFile.delete()) {
                        logger.warn("Failed to delete output file: {}", outputFile.getAbsolutePath());
                    }
                    return false;
                }

		default:
			return err
		}
	}

	// Delete parent directory obviously not recursively. Errors for
	// parent directories shouldn't trickle down.
	s.deleteFile(basePath, pathutil.Dir(pathutil.Clean(deletePath)), false, false)

	return nil
}

// DeleteBulk - delete many files in bulk to trash.
// this delete does not recursively delete empty
// parents, if you need empty parent delete support

	DeleteAll Boolean `xml:"ExpiredObjectAllVersions"`

	set bool
}

// MarshalXML encodes delete marker boolean into an XML form.
func (b Boolean) MarshalXML(e *xml.Encoder, startElement xml.StartElement) error {
	if !b.set {
		return nil
	}
	return e.EncodeElement(b.val, startElement)
}

// UnmarshalXML decodes delete marker boolean from the XML form.

        assertEquals(value3, settings.array().get(key)[2]);

        settings.array().delete(key, value2);
        assertEquals(2, settings.array().get(key).length);
        assertEquals(value1, settings.array().get(key)[0]);
        assertEquals(value3, settings.array().get(key)[1]);

        settings.array().delete(key);
        assertEquals(0, settings.array().get(key).length);
    }

     *
     * @param request the delete request
     * @return a future for the delete response
     */
    @Override
    public ActionFuture<DeleteResponse> delete(final DeleteRequest request) {
        return client.delete(request);
    }

    /**
     * Deletes a document asynchronously with a callback.
     *
     * @param request  the delete request
     * @param listener the response listener

            }

            @Override
            public void insert(UrlQueue<?> urlQueue) {
            }

            @Override
            public void delete(String sessionId) {
            }

            @Override
            public void deleteAll() {
            }

            @Override

        });
        return redirect(getClass());
    }

    /**
     * Delete a data config.
     * @param form The edit form.
     * @return The HTML response.
     */
    @Execute
    @Secured({ ROLE })
    public HtmlResponse delete(final EditForm form) {
        verifyCrudMode(form.crudMode, CrudMode.DETAILS, this::asListHtml);

                try {
                    dictionaryManager.store(StemmerOverrideFile.this, newFile);
                } finally {
                    newFile.delete();
                }
            } else {
                newFile.delete();
            }
        }
    }

> Without a 'Complete' status any 'Active' or 'Draining' pool(s) are not allowed to be removed once configured.

## NOTE

- Empty delete markers (such as for objects with no other successor versions) do not transition to the new pool to avoid creating empty metadata on the other pool(s). If you believe transitioning empty delete markers is required, open a GitHub issue.

## TODO