}
		}
		delete(checkHeader, formCanonicalName)
	}
	// For SignV2 - Signature/AWSAccessKeyId field will be ignored.
	if _, ok := formValues[xhttp.AmzSignatureV2]; ok {
		delete(checkHeader, xhttp.AmzSignatureV2)
		for k := range checkHeader {
			// case-insensitivity for AWSAccessKeyId
			if strings.EqualFold(k, xhttp.AmzAccessKeyID) {
				delete(checkHeader, k)
				break
			}
		}
	}

              SmbResource exclFile = new SmbFile(sr, fname) ) {

            try ( OutputStream s = exclFile.openOutputStream(false, SmbConstants.FILE_NO_SHARE) ) {
                try {
                    exclFile.delete();
                    fail("Could remove locked file");
                }
                catch ( SmbException e ) {
                    if ( e.getNtStatus() == NtStatus.NT_STATUS_SHARING_VIOLATION ) {

}

func (cs *callbacks) Query() *processor {
	return cs.processors["query"]
}

func (cs *callbacks) Update() *processor {
	return cs.processors["update"]
}

func (cs *callbacks) Delete() *processor {
	return cs.processors["delete"]
}

func (cs *callbacks) Row() *processor {
	return cs.processors["row"]
}

func (cs *callbacks) Raw() *processor {
	return cs.processors["raw"]
}

     */
    private
    fun cleanUp(filesToCleanUp: Collection<File>) {
        try {
            fileSystemOperations.delete {
                delete(*filesToCleanUp.toTypedArray())
            }
        } catch (e: Exception) {
            // https://github.com/gradle/gradle-private/issues/2983#issuecomment-596083202
            e.printStackTrace()

}

// delete all cache data on disks.
func (m *metacache) delete(ctx context.Context) {
	if m.bucket == "" || m.id == "" {
		bugLogIf(ctx, fmt.Errorf("metacache.delete: bucket (%s) or id (%s) empty", m.bucket, m.id))
		return
	}
	objAPI := newObjectLayerFn()
	if objAPI == nil {
		internalLogIf(ctx, errors.New("metacache.delete: no object layer"))
		return
	}

    session.add(hero_db)
    session.commit()
    session.refresh(hero_db)
    return hero_db


@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()

            }).orElse(() -> {
                throw new FessUserNotFoundException(username);
            });
        }

    }

    public void delete(final User user) {
        ComponentUtil.getAuthenticationManager().delete(user);

        userBhv.delete(user, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

    }

					"runtime.wasmExit": (sp) => {
						sp >>>= 0;
						const code = this.mem.getInt32(sp + 8, true);
						this.exited = true;
						delete this._inst;
						delete this._values;
						delete this._goRefCounts;
						delete this._ids;
						delete this._idPool;
						this.exit(code);
					},

					// func wasmWrite(fd uintptr, p unsafe.Pointer, n int32)
					"runtime.wasmWrite": (sp) => {

  }
  delete(file)
  return false
}

/** Delete file we expect but don't require to exist. */
internal fun FileSystem.deleteIfExists(path: Path) {
  try {
    delete(path)
  } catch (fnfe: FileNotFoundException) {
    return
  }
}

/** Tolerant delete, try to clear as many files as possible even after a failure. */
internal fun FileSystem.deleteContents(directory: Path) {
  var exception: IOException? = null

        failureUrlBhv.insertOrUpdate(failureUrl, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

    }

    public void delete(final FailureUrl failureUrl) {

        failureUrlBhv.delete(failureUrl, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

    }