}
        return asJson(new ApiResult.ApiUpdateResponse().id(entity.getId()).created(false).status(ApiResult.Status.OK).result());
    }

    /**
     * Deletes a scheduler setting by ID.
     *
     * @param id the ID of the scheduler setting to delete
     * @return JSON response indicating success or failure
     */
    // DELETE /api/admin/scheduler/setting/{id}

            ChannelUtil.write(fos.getChannel(), ByteBuffer.wrap(bytes));
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * Deletes the specified file in a background thread.
     *
     * @param file
     *            The file to delete.
     */
    public static void deleteInBackground(final File file) {
        if (file != null) {

	if r == nil {
		return
	}

	for {
		select {
		case <-ctx.Done():
			return
		case <-r.qTimer.C:
			r.qCache.update()
		}
	}
}

// Delete deletes in-memory replication statistics for a bucket.
func (r *ReplicationStats) Delete(bucket string) {
	if r == nil {
		return
	}

	r.Lock()
	defer r.Unlock()
	delete(r.Cache, bucket)
}

            maxPurgeSize = fessConfig.getPageThumbnailPurgeMaxFetchSizeAsInteger();
            searchEngineClient = ComponentUtil.getSearchEngineClient();
        }

        /**
         * Deletes files marked for deletion after checking if they exist in the search index.
         */
        protected void deleteFiles() {
            final Map<String, Path> deleteFileMap = new HashMap<>();

        });
        return asJson(new ApiUpdateResponse().id(fileConfig.getId()).created(false).status(Status.OK).result());
    }

    // DELETE /api/admin/fileconfig/setting/{id}
    /**
     * Deletes a specific file configuration setting.
     *
     * @param id the file configuration setting ID to delete
     * @return JSON response with deletion status
     */
    @Execute

	for k, v := range b.cachesRoot {
		tmp := make([]string, len(v))
		copy(tmp, v)
		dst2[k] = tmp
	}

	return dst, dst2
}

// deleteAll will delete all on disk data for ALL caches.
// Deletes are performed concurrently.
func (b *bucketMetacache) deleteAll() {
	ctx := context.Background()

	objAPI := newObjectLayerFn()
	if objAPI == nil {
		return
	}

	ez, ok := objAPI.(deleteAllStorager)

    public synchronized void update(final CharMappingItem item) {
        try (MappingUpdater updater = new MappingUpdater(item)) {
            reload(updater);
        }
    }

    /**
     * Deletes a character mapping item from the dictionary file.
     *
     * @param item the character mapping item to delete
     */
    @Override
    public synchronized void delete(final CharMappingItem item) {

     */
    @Override
    public int getCount(final String sessionId) {
        return getCount(builder -> builder.setQuery(QueryBuilders.termQuery(SESSION_ID, sessionId)));
    }

    /**
     * Deletes all access results for a specific session.
     *
     * @param sessionId The session ID.
     */
    @Override
    public void delete(final String sessionId) {
        deleteBySessionId(sessionId);
    }

        return asJson(
                new ApiResult.ApiUpdateResponse().id(String.valueOf(entity.getId())).created(false).status(ApiResult.Status.OK).result());
    }

    /**
     * Deletes a stopwords dictionary item by ID.
     *
     * @param dictId the dictionary ID
     * @param id the ID of the stopwords item to delete
     * @return JSON response indicating the deletion status
     */

    stream: Http2Stream? = null,
  ): Sink {
    var result: Sink = this

    if (policy.throttlePeriodNanos > 0L) {
      result =
        ThrottledSink(
          socket = socket,
          delegate = result,
          bytesPerPeriod = policy.throttleBytesPerPeriod,
          periodDelayNanos = policy.throttlePeriodNanos,
        )
    }

    if (socketEffect != null) {
      val halfwayByteCount =