doInsertOrUpdate(entity, null, null);
    }

    public void delete(WebConfig entity) {
        doDelete(entity, null);
    }

    public void delete(WebConfig entity, RequestOptionCall<DeleteRequestBuilder> opLambda) {
        entity.asDocMeta().deleteOption(opLambda);
        doDelete(entity, null);
    }

    public int queryDelete(CBCall<WebConfigCB> cbLambda) {

        // Create an item for deletion
        ProtwordsItem item = new ProtwordsItem(1, "toDelete");
        item.setNewInput(""); // empty means delete

        ProtwordsFile.ProtwordsUpdater updater = protwordsFile.new ProtwordsUpdater(item);

        // Write the same item (should delete)
        ProtwordsItem result = updater.write(item);

        assertNull(result);

        updater.close();

labels.popular_word_word_enabled=Popular Word Response
labels.supported_search_web=Web
labels.supported_search_none=Unavailable
labels.purge_search_log_day=Delete old search logs
labels.purge_job_log_day=Delete old job logs
labels.purge_user_info_day=Delete old user logs
labels.purge_by_bots=Bot names to delete logs
labels.log_level=Log Level
labels.csv_file_encoding=CSV File Encoding
labels.notification_to=Notification Mail

        // ## Arrange ##
        final String url = "http://example.com";

        // ## Act ##
        final CurlRequest request = Curl.delete(url);

        // ## Assert ##
        assertNotNull(request);
        assertEquals(Method.DELETE, request.method());
    }

    @Test
    public void test_HeadFactoryMethod() {
        // ## Arrange ##
        final String url = "http://example.com";

            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);
        });

    }

    /**
     * Delete a protected words entry by ID from the specified dictionary.
     *
     * @param dictId identifier of the dictionary
     * @param id identifier of the entry to delete
     * @return JSON response containing deletion result and entry ID
     */
    // DELETE /api/admin/dict/protwords/setting/{dictId}/{id}
    @Execute

     * 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 all suggest words from the system.
     *
     * @return JSON response indicating success or failure
     */
    // DELETE /api/admin/suggest/all
    @Execute
    public JsonResponse<ApiResult> delete$all() {
        if (!suggestHelper.deleteAllWords()) {
            throwValidationErrorApi(messages -> messages.addErrorsFailedToDeleteDocInAdmin(GLOBAL));
        }

    }

    /**
     * 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(() -> {

    }

    // If a bkp file exists, use it instead.
    if (fileSystem.exists(journalFileBackup)) {
      // If journal file also exists just delete backup file.
      if (fileSystem.exists(journalFile)) {
        fileSystem.delete(journalFileBackup)
      } else {
        fileSystem.atomicMove(journalFileBackup, journalFile)
      }
    }