} finally {
            try {
                processHelper.destroyProcess(sessionId);
            } finally {
                if (propFile != null && !propFile.delete()) {
                    logger.warn("Failed to delete {}.", propFile.getAbsolutePath());
                }
                deleteTempDir(ownTmpDir);
            }
        }
    }

    @Override

     * </p>
     *
     * @param dictId the dictionary ID to delete the character mapping item from
     * @param charMappingItem the character mapping item to delete
     */
    public void delete(final String dictId, final CharMappingItem charMappingItem) {
        getCharMappingFile(dictId).ifPresent(file -> {
            file.delete(charMappingItem);
        });
    }

            }
        });
    }

    // DELETE /api/admin/storage/delete/{id}/
    /**
     * Deletes a file from storage.
     * @param id The ID of the file to delete.
     * @return A JSON response indicating the success or failure of the operation.
     */
    @Execute
    public JsonResponse<ApiResult> delete$delete(final String id) {
        final PathInfo pi = convertToItem(id);

import org.jspecify.annotations.NullUnmarked;
import org.jspecify.annotations.Nullable;

/**
 * Tester of subtyping relationships between two types.
 *
 * <p>Tests should inherit from this class, and declare subtyping relationship with public methods
 * annotated by {@link TestSubtype}.
 *
 * <p>These declaration methods rely on Java static type checking to make sure what we want to

Muchos desarrolladores y equipos ya dependen de **FastAPI** para sus proyectos (incluyéndome a mí y a mi equipo).

Pero aún así, hay muchas mejoras y funcionalidades por venir.

**FastAPI** tiene un gran futuro por delante.

        // The request should be properly created
    }

    public void test_delete() {
        setupMockConfig("localhost:9200", "", "");

        curlHelper.init();
        CurlRequest request = curlHelper.delete("/test");

        assertNotNull(request);
        // The request should be properly created
    }

    public void test_request_withMethodAndPath() {
        setupMockConfig("localhost:9200", "", "");

Note that in this case, we are declaring a path parameter beside the request parameter.

So, the path parameter will be extracted, validated, converted to the specified type and annotated with OpenAPI.

The same way, you can declare any other parameter as normally, and additionally, get the `Request` too.

///

## `Request` documentation { #request-documentation }

You can easily use the same Pydantic settings to configure your generated OpenAPI and the docs UIs.

For example:

{* ../../docs_src/conditional_openapi/tutorial001.py hl[6,11] *}

Here we declare the setting `openapi_url` with the same default of `"/openapi.json"`.

And then we use it when creating the `FastAPI` app.

import org.codelibs.fess.crawler.exception.MaxLengthExceededException;
import org.codelibs.fess.crawler.extractor.ExtractorFactory;
import org.codelibs.fess.crawler.helper.impl.MimeTypeHelperImpl;
import org.dbflute.utflute.core.PlainTestCase;

/**
 * @author shinsuke
 *
 */
public class TarExtractorTest extends PlainTestCase {
    private static final Logger logger = LogManager.getLogger(TarExtractorTest.class);

		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)
}

// UpdateReplicaStat updates in-memory replica statistics with new values.