*   <li>{@code add(ElevateWord elevateWord)} - Adds a new elevate word to the settings.</li>
 *   <li>{@code delete(String elevateWord)} - Deletes an elevate word from the settings.</li>
 *   <li>{@code deleteAll()} - Deletes all elevate words from the settings.</li>
 * </ul>
 *
 * <p>Protected Constructor:</p>
 * <ul>

            op.setRefreshPolicy(Constants.TRUE);
        });

    }

    /**
     * Deletes a role.
     * @param role The role to delete.
     */
    public void delete(final Role role) {
        ComponentUtil.getLdapManager().delete(role);

        roleBhv.delete(role, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

        saveToken();
        return asListHtml();
    }

    /**
     * Deletes the specified plugin.
     *
     * @param form the delete form containing plugin information
     * @return HTML response redirecting to the plugin list
     */
    @Execute
    @Secured({ ROLE })
    public HtmlResponse delete(final DeleteForm form) {

        });

    }

    /**
     * Deletes a group from both LDAP and the database, and removes the group
     * association from all users that belong to this group.
     *
     * @param group the group entity to delete
     */
    public void delete(final Group group) {
        ComponentUtil.getLdapManager().delete(group);

        groupBhv.delete(group, op -> {
            op.setRefreshPolicy(Constants.TRUE);

    }

    /**
     * Deletes a user setting by ID.
     *
     * @param id the ID of the user setting to delete
     * @return JSON response indicating success or failure
     */
    // DELETE /api/admin/user/setting/{id}
    @Execute
    public JsonResponse<ApiResult> delete$setting(final String id) {
        final User entity = userService.getUser(id).orElseGet(() -> {

    }

    /**
     * Deletes a related content entity from the database.
     * After deletion, updates the related content helper to refresh the cache.
     *
     * @param relatedContent the RelatedContent entity to delete
     */
    public void delete(final RelatedContent relatedContent) {

        relatedContentBhv.delete(relatedContent, op -> op.setRefreshPolicy(Constants.TRUE));

	}
}

// DeleteBucket deletes monitoring the 'bucket'
func (m *Monitor) DeleteBucket(bucket string) {
	m.tlock.Lock()
	for opts := range m.bucketsThrottle {
		if opts.Name == bucket {
			delete(m.bucketsThrottle, opts)
		}
	}
	m.tlock.Unlock()

	m.mlock.Lock()
	for opts := range m.bucketsMeasurement {
		if opts.Name == bucket {
			delete(m.bucketsMeasurement, opts)
		}
	}

    /**
     * Updates an existing user in the authentication chain.
     * @param user The user to update.
     */
    void update(User user);

    /**
     * Deletes a user from the authentication chain.
     * @param user The user to delete.
     */
    void delete(User user);

    /**
     * Changes the password for the specified user.
     * @param username The username for which to change the password.

	errInvalidDeleteMarkerReplicationStatus   = Errorf("Delete marker replication status is invalid")
	errDestinationSourceIdentical             = Errorf("Destination bucket cannot be the same as the source bucket.")
	errDeleteReplicationMissing               = Errorf("Delete replication must be specified")
	errInvalidDeleteReplicationStatus         = Errorf("Delete replication is either enable|disable")

        return chains().get(stream -> stream.allMatch(c -> c.changePassword(username, password)));
    }

    /**
     * Deletes a user from all authentication chains.
     * @param user The user to delete.
     */
    public void delete(final User user) {
        chains().of(stream -> stream.forEach(c -> c.delete(user)));
    }

    /**
     * Loads user information by processing through all authentication chains.