}

    // DELETE /api/admin/dict/stopwords/setting/{dictId}/{id}
    @Execute
    public JsonResponse<ApiResult> delete$setting(final String dictId, final long id) {
        stopwordsService.getStopwordsItem(dictId, id).ifPresent(entity -> {
            stopwordsService.delete(dictId, entity);
            saveInfo(messages -> messages.addSuccessCrudDeleteCrudTable(GLOBAL));

    }

    // DELETE /api/admin/fileconfig/setting/{id}
    @Execute
    public JsonResponse<ApiResult> delete$setting(final String id) {
        fileConfigService.getFileConfig(id).ifPresent(entity -> {
            try {
                fileConfigService.delete(entity);
                saveInfo(messages -> messages.addSuccessCrudDeleteCrudTable(GLOBAL));

            if (isCommit) {
                try {
                    dictionaryManager.store(SynonymFile.this, newFile);
                } finally {
                    newFile.delete();
                }
            } else {
                newFile.delete();
            }
        }
    }

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

    }

    public void delete(final DuplicateHost duplicateHost) {

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

    }

    public List<DuplicateHost> getDuplicateHostList() {

            } else {
                file.update(kuromojiItem);
            }
        });
    }

    public void delete(final String dictId, final KuromojiItem kuromojiItem) {
        getKuromojiFile(dictId).ifPresent(file -> {
            file.delete(kuromojiItem);
        });
    }

        relatedQueryBhv.insertOrUpdate(relatedQuery, op -> op.setRefreshPolicy(Constants.TRUE));
        ComponentUtil.getRelatedQueryHelper().update();
    }

    public void delete(final RelatedQuery relatedQuery) {

        relatedQueryBhv.delete(relatedQuery, op -> op.setRefreshPolicy(Constants.TRUE));
        ComponentUtil.getRelatedQueryHelper().update();
    }

        raise HTTPException(status_code=404, detail="Hero not found")
    return hero


@app.delete("/heroes/{hero_id}")
def delete_hero(hero_id: int, session: SessionDep):
    hero = session.get(Hero, hero_id)
    if not hero:
        raise HTTPException(status_code=404, detail="Hero not found")
    session.delete(hero)
    session.commit()

 and is deleted after 24 hours by default to limit the exposure of the
 valuable credential. You can create a new Bootstrap Token with
 `kubeadm token create` or make the default token permanently valid by specifying
 `--token-ttl 0` to `kubeadm init`. The default token can later be deleted with
 `kubeadm token delete`.

            op.rangeSize(fessConfig.getPagingPageRangeSizeAsInteger());
        }).createPageNumberList());

        return dataConfigList;
    }

    public void delete(final DataConfig dataConfig) {
        dataConfigBhv.delete(dataConfig, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });
    }

    public OptionalEntity<DataConfig> getDataConfig(final String id) {

            try {
                unregister(scheduledJob);
            } catch (final Exception e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Failed to delete Job {}", scheduledJob, e);
                }
            }
            return;
        }

        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        final CronParamsSupplier paramsOp = () -> {