delete(cache.iamUsersMap, k)
				}
			}
			for k, u := range cache.iamSTSAccountsMap {
				if u.Credentials.ParentUser == accessKey {
					delete(cache.iamSTSAccountsMap, k)
				}
			}
		}

		// 3. Delete any mapped policy
		cache.iamUserPolicyMap.Delete(accessKey)

		return nil
	}

	if err != nil {

    }

    /**
     * Deletes a role setting by ID.
     *
     * @param id the ID of the role setting to delete
     * @return JSON response indicating success or failure
     */
    // DELETE /api/admin/role/setting/{id}
    @Execute
    public JsonResponse<ApiResult> delete$setting(final String id) {
        final Role entity = roleService.getRole(id).orElseGet(() -> {

    return {"item_id": item_id}


def get_not_decorated(item_id: str):
    return {"item_id": item_id}


app.add_api_route("/items-not-decorated/{item_id}", get_not_decorated)


@app.delete("/items/{item_id}")
def delete_item(item_id: str, item: Item):
    return {"item_id": item_id, "item": item}


@app.head("/items/{item_id}")
def head_item(item_id: str):

		t.Errorf("Failed to commit transaction, got error %v\n", err)
	}

	if result := db.Where("name=?", "zzjin").Delete(&User{}); result.Error != nil || result.RowsAffected != 1 {
		t.Fatalf("Failed, got error: %v, rows affected: %v", result.Error, result.RowsAffected)
	}

	tx2 := db.Begin()
	if result := tx2.Where("name=?", "zzjin").Delete(&User{}); result.Error != nil || result.RowsAffected != 0 {

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


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

                }
                try {
                    Files.delete(f);
                } catch (final IOException e) {
                    logger.warn("Failed to delete: path={}", f, e);
                }
            });
            Files.deleteIfExists(dir);
        } catch (final IOException e) {
            logger.warn("Failed to delete: path={}", dir, e);
        }
    }

    /**

            op.setRefreshPolicy(Constants.TRUE);
        });

    }

    /**
     * Deletes a role type.
     * @param roleType The role type to delete.
     */
    public void delete(final RoleType roleType) {

        roleTypeBhv.delete(roleType, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

    }

    /**
     * Sets up the list condition for the role type query.

    }

    /**
     * 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}
    @Execute
    public JsonResponse<ApiResult> delete$setting(final String id) {
        final ScheduledJob entity = scheduledJobService.getScheduledJob(id).orElseGet(() -> {

     *
     * @param dataConfig the data configuration to delete
     * @throws IllegalArgumentException if dataConfig is null
     * @throws org.dbflute.exception.EntityAlreadyDeletedException if the entity has already been deleted
     */
    public void delete(final DataConfig dataConfig) {
        dataConfigBhv.delete(dataConfig, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });
    }

    //                                         Actually Crud
    //                                         -------------
    /**
     * Delete a crawling info.
     * @param form The edit form.
     * @return The HTML response.
     */
    @Execute
    @Secured({ ROLE })
    public HtmlResponse delete(final EditForm form) {
        verifyCrudMode(form.crudMode, CrudMode.DETAILS, this::asListHtml);