}

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

}

void TF_DeleteShapeAndTypeList(TF_ShapeAndTypeList* shape_list) {
  if (shape_list == nullptr) return;
  for (size_t i = 0; i < shape_list->num_items; ++i) {
    delete[] shape_list->items[i].dims;
  }
  delete[] shape_list->items;
  delete shape_list;
}

void TF_DeleteShapeAndTypeListArray(TF_ShapeAndTypeList** shape_list_array,
                                    int num_items) {

  @CanIgnoreReturnValue
  private boolean delete(File file) {
    if (file.isDirectory()) {
      File[] files = file.listFiles();
      if (files != null) {
        for (File f : files) {
          if (!delete(f)) {
            return false;
          }
        }
      }
    }

    if (!file.delete()) {
      logger.log(Level.WARNING, "couldn't delete file: {0}", new Object[] {file});
      return false;

                                                </p>
                                                <p>
                                                    <strong id="delete-doc-title"></strong><br/> <span
                                                        id="delete-doc-url"></span>
                                                </p>
                                            </div>

					DeleteReplication:       DeleteReplication{Status: Enabled},
					Filter:                  Filter{},
				},
			},
		},
		{ // Config1 - Replication config has no filters, delete,delete-marker replication disabled
			Rules: []Rule{
				{
					Status:                  Enabled,
					Priority:                3,
					DeleteMarkerReplication: DeleteMarkerReplication{Status: Disabled},

    }

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

                throwValidationErrorApi(messages -> messages.addErrorsStorageFileDownloadFailure(GLOBAL, pi.getName()));
            }
        });
    }

    // DELETE /api/admin/storage/delete/{id}/
    @Execute
    public JsonResponse<ApiResult> delete$delete(final String id) {
        final PathInfo pi = convertToItem(id);
        if (StringUtil.isEmpty(pi.getName())) {

 * an expressive source hint for the model problem. Instead, the source hint is configured by the model builder before
 * it delegates to other components that potentially encounter problems. Then, the problem reporter can focus on
 * providing a simple error message, leaving the donkey work of creating a nice model problem to this component.
 *

				if !exit {
					v.cleanup()
				}
			}
			m.mu.RUnlock()
			m.mu.Lock()
			for k, v := range m.trash {
				if time.Since(v.lastUpdate) > metacacheMaxRunningAge {
					v.delete(context.Background())
					delete(m.trash, k)
				}
			}
			m.mu.Unlock()
		}
	}()
}

// updateCacheEntry will update non-transient state.
func (m *metacacheManager) updateCacheEntry(update metacache) (metacache, error) {

    dir: Path,
    mustCreate: Boolean,
  ) {
    log("createDirectory($dir)")

    super.createDirectory(dir, mustCreate)
  }

  override fun delete(
    path: Path,
    mustExist: Boolean,
  ) {
    log("delete($path)")

    super.delete(path, mustExist)
  }

  override fun sink(
    path: Path,
    mustCreate: Boolean,
  ): Sink {
    log("sink($path)")