From 991c21c7e3086254eb0f053cd1f6753405af4cd1 Mon Sep 17 00:00:00 2001 From: Gabriel Fonseca Date: Fri, 9 Oct 2026 14:52:56 +0100 Subject: [PATCH 01/11] feat(sandbox)!: remove sandbox service endpoints Remove the sandbox clients, route constants, and public accessor, and update the contract inventory and API docs. BREAKING CHANGE: remove Frontal.sandbox() and the SandboxClient and SandboxLanguagesClient APIs. --- contracts/reports/conformance.json | 8 +- contracts/reports/migration-matrix.md | 6 +- contracts/sdk-endpoints.json | 14 -- .../dev/frontal/sdk/models/ApiService.java | 1 - docs/api/README.md | 1 - docs/api/methods-as-code.md | 8 -- docs/api/sandbox.md | 22 --- scripts/check_contracts.py | 8 +- scripts/generate_endpoints.py | 1 - .../java/dev/frontal/sdk/api/Frontal.java | 5 - .../dev/frontal/sdk/resources/Endpoints.java | 14 -- .../frontal/sdk/resources/SandboxClient.java | 133 ------------------ .../sdk/resources/SandboxLanguagesClient.java | 62 -------- 13 files changed, 11 insertions(+), 272 deletions(-) delete mode 100644 docs/api/sandbox.md delete mode 100644 services/src/main/java/dev/frontal/sdk/resources/SandboxClient.java delete mode 100644 services/src/main/java/dev/frontal/sdk/resources/SandboxLanguagesClient.java diff --git a/contracts/reports/conformance.json b/contracts/reports/conformance.json index 2375227..3e13ad9 100644 --- a/contracts/reports/conformance.json +++ b/contracts/reports/conformance.json @@ -2,9 +2,9 @@ "repository": "sdk-java", "language": "Java", "status": "named-operations", - "contractEndpointEntries": 622, - "generatedEndpointConstants": 611, - "namedOperationMethods": 611, - "supportedRouteCoverage": "611/622", + "contractEndpointEntries": 619, + "generatedEndpointConstants": 608, + "namedOperationMethods": 608, + "supportedRouteCoverage": "608/619", "note": "Endpoint constants and named operations cover SDK service routes. Payloads without usable schemas retain caller-provided JSON and response types." } diff --git a/contracts/reports/migration-matrix.md b/contracts/reports/migration-matrix.md index c006549..576e9aa 100644 --- a/contracts/reports/migration-matrix.md +++ b/contracts/reports/migration-matrix.md @@ -4,9 +4,9 @@ _Status: generated route catalog and named operation surface complete. Typed mod | Metric | Value | | --- | ---: | -| Contract endpoint entries | 622 | -| Generated endpoint constants | 611 | -| Named operation methods for supported routes | 611 | +| Contract endpoint entries | 619 | +| Generated endpoint constants | 608 | +| Named operation methods for supported routes | 608 | | Contract routes omitted from the SDK surface | 11 | | Operation-specific payload schemas usable | Limited by committed contract snapshots | diff --git a/contracts/sdk-endpoints.json b/contracts/sdk-endpoints.json index e040f12..6f75ded 100644 --- a/contracts/sdk-endpoints.json +++ b/contracts/sdk-endpoints.json @@ -2146,20 +2146,6 @@ } ], "react": [], - "sandbox": [ - { - "method": "GET", - "path": "/sandbox/languages" - }, - { - "method": "POST", - "path": "/sandbox/self-test" - }, - { - "method": "POST", - "path": "/sandbox/submit" - } - ], "schedules": [ { "method": "DELETE", diff --git a/core/src/main/java/dev/frontal/sdk/models/ApiService.java b/core/src/main/java/dev/frontal/sdk/models/ApiService.java index 74246aa..babcfd6 100644 --- a/core/src/main/java/dev/frontal/sdk/models/ApiService.java +++ b/core/src/main/java/dev/frontal/sdk/models/ApiService.java @@ -16,7 +16,6 @@ public enum ApiService { ONTOLOGY("ontology"), PIPELINES("pipelines"), REACT("react"), - SANDBOX("sandbox"), SCHEDULES("schedules"), WEBHOOKS("webhooks"), WORKFLOWS("workflows"), diff --git a/docs/api/README.md b/docs/api/README.md index 8e9215f..e1d401d 100644 --- a/docs/api/README.md +++ b/docs/api/README.md @@ -24,7 +24,6 @@ Call-shaped listing of every operation: [methods as code](./methods-as-code.md). | pipelines | 11 | [pipelines](./pipelines.md) | | providers | 1 | [providers](./providers.md) | | react | 0 | [react](./react.md) | -| sandbox | 3 | [sandbox](./sandbox.md) | | schedules | 10 | [schedules](./schedules.md) | | webhook-endpoints | 7 | [webhook-endpoints](./webhook-endpoints.md) | | webhooks | 10 | [webhooks](./webhooks.md) | diff --git a/docs/api/methods-as-code.md b/docs/api/methods-as-code.md index 28c2f55..fbc1076 100644 --- a/docs/api/methods-as-code.md +++ b/docs/api/methods-as-code.md @@ -646,14 +646,6 @@ client.providers().get(providerSlug, responseType); ```java ``` -## sandbox - -```java -client.sandbox().createSelfTest(body, responseType); -client.sandbox().submit(body, responseType); -client.sandbox().languages().list(responseType); -``` - ## schedules ```java diff --git a/docs/api/sandbox.md b/docs/api/sandbox.md deleted file mode 100644 index bddf2ec..0000000 --- a/docs/api/sandbox.md +++ /dev/null @@ -1,22 +0,0 @@ -# Sandbox API - -Service accessor: `frontal.sandbox()` (`SandboxClient`). - -Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. - -| Method | HTTP | Route | Parameters | Response | -| --- | --- | --- | --- | --- | -| `sandbox().createSelfTest(...)` | `POST` | `/sandbox/self-test` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `sandbox().createSelfTest(...)` | `POST` | `/sandbox/self-test` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `sandbox().createSelfTest(...)` | `POST` | `/sandbox/self-test` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `sandbox().createSelfTest(...)` | `POST` | `/sandbox/self-test` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `sandbox().submit(...)` | `POST` | `/sandbox/submit` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `sandbox().submit(...)` | `POST` | `/sandbox/submit` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `sandbox().submit(...)` | `POST` | `/sandbox/submit` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `sandbox().submit(...)` | `POST` | `/sandbox/submit` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `sandbox().languages().list(...)` | `GET` | `/sandbox/languages` | `QueryParams query, Class responseType` | `@Nullable T` | -| `sandbox().languages().list(...)` | `GET` | `/sandbox/languages` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `sandbox().languages().list(...)` | `GET` | `/sandbox/languages` | `Class responseType` | `@Nullable T` | -| `sandbox().languages().list(...)` | `GET` | `/sandbox/languages` | `TypeReference responseType` | `@Nullable T` | - -The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/scripts/check_contracts.py b/scripts/check_contracts.py index ed915d4..719190e 100644 --- a/scripts/check_contracts.py +++ b/scripts/check_contracts.py @@ -169,10 +169,10 @@ def main() -> None: snapshots = {path.name: load_json(path) for path in SNAPSHOTS} inventory = snapshots["sdk-endpoints.json"] expected_services = { - "agents", "ai", "audit", "auth", "billing", "blob", "connectors", "data", - "governance", "lineage", "observability", "ontology", "pipelines", "react", - "sandbox", "schedules", "webhooks", "workflows", "action-runs", "connection-tests", - "events", "integrations", "invocations", "providers", "webhook-endpoints", + "action-runs", "agents", "ai", "audit", "auth", "billing", "blob", "connection-tests", + "connectors", "data", "events", "governance", "integrations", "invocations", "lineage", + "observability", "ontology", "pipelines", "providers", "react", "schedules", "webhook-endpoints", + "webhooks", "workflows", } if set(inventory) != expected_services: raise SystemExit("SDK endpoint inventory service list drifted") diff --git a/scripts/generate_endpoints.py b/scripts/generate_endpoints.py index 7f72c19..26d2c17 100644 --- a/scripts/generate_endpoints.py +++ b/scripts/generate_endpoints.py @@ -31,7 +31,6 @@ "pipelines": "PIPELINES", "providers": "PROVIDERS", "react": "REACT", - "sandbox": "SANDBOX", "schedules": "SCHEDULES", "webhooks": "WEBHOOKS", "webhook-endpoints": "WEBHOOK_ENDPOINTS", diff --git a/sdk/src/main/java/dev/frontal/sdk/api/Frontal.java b/sdk/src/main/java/dev/frontal/sdk/api/Frontal.java index 93e9fe8..8c8f53b 100644 --- a/sdk/src/main/java/dev/frontal/sdk/api/Frontal.java +++ b/sdk/src/main/java/dev/frontal/sdk/api/Frontal.java @@ -51,7 +51,6 @@ public Frontal(ApiClient apiClient) { case PIPELINES -> new PipelinesClient(apiClient); case PROVIDERS -> new ProvidersClient(apiClient); case REACT -> new ReactClient(apiClient); - case SANDBOX -> new SandboxClient(apiClient); case SCHEDULES -> new SchedulesClient(apiClient); case WEBHOOKS -> new WebhooksClient(apiClient); case WEBHOOK_ENDPOINTS -> new WebhookEndpointsClient(apiClient); @@ -153,10 +152,6 @@ public ReactClient react() { return (ReactClient) service(ApiService.REACT); } - public SandboxClient sandbox() { - return (SandboxClient) service(ApiService.SANDBOX); - } - public SchedulesClient schedules() { return (SchedulesClient) service(ApiService.SCHEDULES); } diff --git a/services/src/main/java/dev/frontal/sdk/resources/Endpoints.java b/services/src/main/java/dev/frontal/sdk/resources/Endpoints.java index 10ca367..68666a9 100644 --- a/services/src/main/java/dev/frontal/sdk/resources/Endpoints.java +++ b/services/src/main/java/dev/frontal/sdk/resources/Endpoints.java @@ -1725,20 +1725,6 @@ public static final class React { private React() {} } - public static final class Sandbox { - private Sandbox() {} - - /** Endpoint for {@code GET /sandbox/languages}. */ - public static final Endpoint GET_SANDBOX_LANGUAGES = - new Endpoint(ApiService.SANDBOX, HttpMethod.GET, "/sandbox/languages"); - /** Endpoint for {@code POST /sandbox/self-test}. */ - public static final Endpoint POST_SANDBOX_SELF_TEST = - new Endpoint(ApiService.SANDBOX, HttpMethod.POST, "/sandbox/self-test"); - /** Endpoint for {@code POST /sandbox/submit}. */ - public static final Endpoint POST_SANDBOX_SUBMIT = - new Endpoint(ApiService.SANDBOX, HttpMethod.POST, "/sandbox/submit"); - } - public static final class Schedules { private Schedules() {} diff --git a/services/src/main/java/dev/frontal/sdk/resources/SandboxClient.java b/services/src/main/java/dev/frontal/sdk/resources/SandboxClient.java deleted file mode 100644 index 7fe0e44..0000000 --- a/services/src/main/java/dev/frontal/sdk/resources/SandboxClient.java +++ /dev/null @@ -1,133 +0,0 @@ -package dev.frontal.sdk; - -import com.fasterxml.jackson.core.type.TypeReference; -import com.fasterxml.jackson.databind.JsonNode; -import java.io.IOException; -import java.util.List; -import org.jspecify.annotations.Nullable; - -/** Contract operations for sandbox. Generated by scripts/generate_endpoints.py. */ -public final class SandboxClient extends ServiceClient { - SandboxClient(ApiClient client) { - super(ApiService.SANDBOX, client); - } - - /** Returns the client for the nested resource. - * @return the languages resource client - */ - public SandboxLanguagesClient languages() { - return new SandboxLanguagesClient(client()); - } - - /** - * Calls the contract route {@code POST /sandbox/self-test}. - * @param decoded response type - * @param query query supplied to the operation - * @param body body supplied to the operation - * @param responseType responseType supplied to the operation - * @return the decoded response, or null when the response body is empty - * @throws IOException if the operation fails - * @throws InterruptedException if the operation fails - */ - @SdkOperation("sandbox|POST|/sandbox/self-test") - public @Nullable T createSelfTest(QueryParams query, @Nullable JsonNode body, Class responseType) - throws IOException, InterruptedException { - return request(Endpoints.Sandbox.POST_SANDBOX_SELF_TEST, List.of(), query, body, responseType); - } - /** - * Calls the contract route {@code POST /sandbox/self-test} using a generic response type. - * @param decoded response type - * @param query query supplied to the operation - * @param body body supplied to the operation - * @param responseType responseType supplied to the operation - * @return the decoded response, or null when the response body is empty - * @throws IOException if the operation fails - * @throws InterruptedException if the operation fails - */ - public @Nullable T createSelfTest(QueryParams query, @Nullable JsonNode body, TypeReference responseType) - throws IOException, InterruptedException { - return request(Endpoints.Sandbox.POST_SANDBOX_SELF_TEST, List.of(), query, body, responseType); - } - /** - * Calls the contract route {@code POST /sandbox/self-test} without query parameters. - * @param decoded response type - * @param body body supplied to the operation - * @param responseType responseType supplied to the operation - * @return the decoded response, or null when the response body is empty - * @throws IOException if the operation fails - * @throws InterruptedException if the operation fails - */ - public @Nullable T createSelfTest(@Nullable JsonNode body, Class responseType) - throws IOException, InterruptedException { - return createSelfTest(QueryParams.empty(), body, responseType); - } - /** - * Calls the contract route {@code POST /sandbox/self-test} without query parameters using a generic response type. - * @param decoded response type - * @param body body supplied to the operation - * @param responseType responseType supplied to the operation - * @return the decoded response, or null when the response body is empty - * @throws IOException if the operation fails - * @throws InterruptedException if the operation fails - */ - public @Nullable T createSelfTest(@Nullable JsonNode body, TypeReference responseType) - throws IOException, InterruptedException { - return createSelfTest(QueryParams.empty(), body, responseType); - } - - /** - * Calls the contract route {@code POST /sandbox/submit}. - * @param decoded response type - * @param query query supplied to the operation - * @param body body supplied to the operation - * @param responseType responseType supplied to the operation - * @return the decoded response, or null when the response body is empty - * @throws IOException if the operation fails - * @throws InterruptedException if the operation fails - */ - @SdkOperation("sandbox|POST|/sandbox/submit") - public @Nullable T submit(QueryParams query, @Nullable JsonNode body, Class responseType) - throws IOException, InterruptedException { - return request(Endpoints.Sandbox.POST_SANDBOX_SUBMIT, List.of(), query, body, responseType); - } - /** - * Calls the contract route {@code POST /sandbox/submit} using a generic response type. - * @param decoded response type - * @param query query supplied to the operation - * @param body body supplied to the operation - * @param responseType responseType supplied to the operation - * @return the decoded response, or null when the response body is empty - * @throws IOException if the operation fails - * @throws InterruptedException if the operation fails - */ - public @Nullable T submit(QueryParams query, @Nullable JsonNode body, TypeReference responseType) - throws IOException, InterruptedException { - return request(Endpoints.Sandbox.POST_SANDBOX_SUBMIT, List.of(), query, body, responseType); - } - /** - * Calls the contract route {@code POST /sandbox/submit} without query parameters. - * @param decoded response type - * @param body body supplied to the operation - * @param responseType responseType supplied to the operation - * @return the decoded response, or null when the response body is empty - * @throws IOException if the operation fails - * @throws InterruptedException if the operation fails - */ - public @Nullable T submit(@Nullable JsonNode body, Class responseType) - throws IOException, InterruptedException { - return submit(QueryParams.empty(), body, responseType); - } - /** - * Calls the contract route {@code POST /sandbox/submit} without query parameters using a generic response type. - * @param decoded response type - * @param body body supplied to the operation - * @param responseType responseType supplied to the operation - * @return the decoded response, or null when the response body is empty - * @throws IOException if the operation fails - * @throws InterruptedException if the operation fails - */ - public @Nullable T submit(@Nullable JsonNode body, TypeReference responseType) - throws IOException, InterruptedException { - return submit(QueryParams.empty(), body, responseType); - } -} diff --git a/services/src/main/java/dev/frontal/sdk/resources/SandboxLanguagesClient.java b/services/src/main/java/dev/frontal/sdk/resources/SandboxLanguagesClient.java deleted file mode 100644 index 1b64b1e..0000000 --- a/services/src/main/java/dev/frontal/sdk/resources/SandboxLanguagesClient.java +++ /dev/null @@ -1,62 +0,0 @@ -package dev.frontal.sdk; - -import com.fasterxml.jackson.core.type.TypeReference; -import java.io.IOException; -import java.util.List; -import org.jspecify.annotations.Nullable; - -/** Contract operations for sandbox/languages. Generated by scripts/generate_endpoints.py. */ -public final class SandboxLanguagesClient extends ServiceClient { - SandboxLanguagesClient(ApiClient client) { - super(ApiService.SANDBOX, client); - } - - /** - * Calls the contract route {@code GET /sandbox/languages}. - * @param decoded response type - * @param query query supplied to the operation - * @param responseType responseType supplied to the operation - * @return the decoded response, or null when the response body is empty - * @throws IOException if the operation fails - * @throws InterruptedException if the operation fails - */ - @SdkOperation("sandbox|GET|/sandbox/languages") - public @Nullable T list(QueryParams query, Class responseType) throws IOException, InterruptedException { - return request(Endpoints.Sandbox.GET_SANDBOX_LANGUAGES, List.of(), query, null, responseType); - } - /** - * Calls the contract route {@code GET /sandbox/languages} using a generic response type. - * @param decoded response type - * @param query query supplied to the operation - * @param responseType responseType supplied to the operation - * @return the decoded response, or null when the response body is empty - * @throws IOException if the operation fails - * @throws InterruptedException if the operation fails - */ - public @Nullable T list(QueryParams query, TypeReference responseType) - throws IOException, InterruptedException { - return request(Endpoints.Sandbox.GET_SANDBOX_LANGUAGES, List.of(), query, null, responseType); - } - /** - * Calls the contract route {@code GET /sandbox/languages} without query parameters. - * @param decoded response type - * @param responseType responseType supplied to the operation - * @return the decoded response, or null when the response body is empty - * @throws IOException if the operation fails - * @throws InterruptedException if the operation fails - */ - public @Nullable T list(Class responseType) throws IOException, InterruptedException { - return list(QueryParams.empty(), responseType); - } - /** - * Calls the contract route {@code GET /sandbox/languages} without query parameters using a generic response type. - * @param decoded response type - * @param responseType responseType supplied to the operation - * @return the decoded response, or null when the response body is empty - * @throws IOException if the operation fails - * @throws InterruptedException if the operation fails - */ - public @Nullable T list(TypeReference responseType) throws IOException, InterruptedException { - return list(QueryParams.empty(), responseType); - } -} From 8f3285b1de7db3e04cfaeb913fc3cca837201960 Mon Sep 17 00:00:00 2001 From: Gabriel Fonseca Date: Fri, 9 Oct 2026 15:44:30 +0100 Subject: [PATCH 02/11] feat(core): add new service enum constants and per-service retry config --- .../main/java/dev/frontal/sdk/api/ApiClient.java | 4 ++-- .../dev/frontal/sdk/config/ClientConfig.java | 16 +++++++++++++++- .../java/dev/frontal/sdk/models/ApiService.java | 1 + 3 files changed, 18 insertions(+), 3 deletions(-) diff --git a/core/src/main/java/dev/frontal/sdk/api/ApiClient.java b/core/src/main/java/dev/frontal/sdk/api/ApiClient.java index e3329ea..faf63f1 100644 --- a/core/src/main/java/dev/frontal/sdk/api/ApiClient.java +++ b/core/src/main/java/dev/frontal/sdk/api/ApiClient.java @@ -178,7 +178,7 @@ public ApiStream streamBody(Endpoint endpoint, List pathParams, QueryPar String requestId = UUID.randomUUID().toString(); RequestBody requestBody = requestBody(endpoint.method(), body); String contentType = contentType(body); - int attempts = endpoint.method().wireMethod().equals("GET") ? config.maxRetries() + 1 : 1; + int attempts = endpoint.method().wireMethod().equals("GET") ? config.maxRetriesFor(endpoint.service()) + 1 : 1; for (int attempt = 0; attempt < attempts; attempt++) { Request request = buildRequest(endpoint, pathParams, query, requestBody, contentType, "*/*", requestId); Response response; @@ -369,7 +369,7 @@ private ApiResponse exchange( String accept) throws IOException, InterruptedException { String requestId = UUID.randomUUID().toString(); - int attempts = endpoint.method().wireMethod().equals("GET") ? config.maxRetries() + 1 : 1; + int attempts = endpoint.method().wireMethod().equals("GET") ? config.maxRetriesFor(endpoint.service()) + 1 : 1; for (int attempt = 0; attempt < attempts; attempt++) { Request request = buildRequest(endpoint, pathParams, query, requestBody, contentType, accept, requestId); Response response; diff --git a/core/src/main/java/dev/frontal/sdk/config/ClientConfig.java b/core/src/main/java/dev/frontal/sdk/config/ClientConfig.java index 641b91c..c0232d6 100644 --- a/core/src/main/java/dev/frontal/sdk/config/ClientConfig.java +++ b/core/src/main/java/dev/frontal/sdk/config/ClientConfig.java @@ -12,6 +12,8 @@ public final class ClientConfig { public static final URI DEFAULT_API_BASE_URL = URI.create("https://api.frontal.dev/v1"); public static final URI DEFAULT_AI_BASE_URL = URI.create("https://ai.frontal.dev"); + private static final int DEFAULT_MAX_RETRIES = 2; + private static final int DEFAULT_FUNCTIONS_MAX_RETRIES = 3; private final @Nullable String apiKey; private final URI apiBaseUrl; @@ -19,6 +21,7 @@ public final class ClientConfig { private final Duration connectTimeout; private final Duration requestTimeout; private final int maxRetries; + private final boolean maxRetriesExplicit; private final long maxResponseBytes; private final int maxErrorBodyBytes; private final String userAgent; @@ -42,6 +45,7 @@ private ClientConfig(Builder builder) { throw new IllegalArgumentException("maxErrorBodyBytes must be positive"); } maxRetries = builder.maxRetries; + maxRetriesExplicit = builder.maxRetriesExplicit; maxResponseBytes = builder.maxResponseBytes; maxErrorBodyBytes = builder.maxErrorBodyBytes; userAgent = requireText(builder.userAgent, "userAgent"); @@ -131,6 +135,14 @@ public int maxRetries() { return maxRetries; } + int maxRetriesFor(ApiService service) { + Objects.requireNonNull(service, "service"); + if (!maxRetriesExplicit && service == ApiService.FUNCTIONS) { + return DEFAULT_FUNCTIONS_MAX_RETRIES; + } + return maxRetries; + } + public long maxResponseBytes() { return maxResponseBytes; } @@ -213,7 +225,8 @@ public static final class Builder { private URI aiBaseUrl = DEFAULT_AI_BASE_URL; private Duration connectTimeout = Duration.ofSeconds(10); private Duration requestTimeout = Duration.ofSeconds(30); - private int maxRetries = 2; + private int maxRetries = DEFAULT_MAX_RETRIES; + private boolean maxRetriesExplicit; private long maxResponseBytes = 64L * 1024 * 1024; private int maxErrorBodyBytes = 16 * 1024; private String userAgent = "frontal-java-sdk/2.0.0"; @@ -259,6 +272,7 @@ public Builder requestTimeout(Duration requestTimeout) { public Builder maxRetries(int maxRetries) { this.maxRetries = maxRetries; + this.maxRetriesExplicit = true; return this; } diff --git a/core/src/main/java/dev/frontal/sdk/models/ApiService.java b/core/src/main/java/dev/frontal/sdk/models/ApiService.java index babcfd6..18f5eb4 100644 --- a/core/src/main/java/dev/frontal/sdk/models/ApiService.java +++ b/core/src/main/java/dev/frontal/sdk/models/ApiService.java @@ -21,6 +21,7 @@ public enum ApiService { WORKFLOWS("workflows"), CONNECTION_TESTS("connection-tests"), EVENTS("events"), + FUNCTIONS("functions"), INVOCATIONS("invocations"), PROVIDERS("providers"), WEBHOOK_ENDPOINTS("webhook-endpoints"); From 733442a87bdd4ff0a33b682ec16d601d9542c38f Mon Sep 17 00:00:00 2001 From: Gabriel Fonseca Date: Fri, 9 Oct 2026 15:44:45 +0100 Subject: [PATCH 03/11] feat(sdk): add FUNCTIONS, INVOCATIONS, PROVIDERS, WEBHOOK_ENDPOINTS service accessors --- sdk/src/main/java/dev/frontal/sdk/api/Frontal.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/sdk/src/main/java/dev/frontal/sdk/api/Frontal.java b/sdk/src/main/java/dev/frontal/sdk/api/Frontal.java index 8c8f53b..80f6db1 100644 --- a/sdk/src/main/java/dev/frontal/sdk/api/Frontal.java +++ b/sdk/src/main/java/dev/frontal/sdk/api/Frontal.java @@ -43,6 +43,7 @@ public Frontal(ApiClient apiClient) { case CONNECTION_TESTS -> new ConnectionTestsClient(apiClient); case DATA -> new DataClient(apiClient); case EVENTS -> new EventsClient(apiClient); + case FUNCTIONS -> new FunctionsClient(apiClient); case GOVERNANCE -> new GovernanceClient(apiClient); case INVOCATIONS -> new InvocationsClient(apiClient); case LINEAGE -> new LineageClient(apiClient); @@ -120,6 +121,11 @@ public EventsClient events() { return (EventsClient) service(ApiService.EVENTS); } + /** Returns the Functions API client. */ + public FunctionsClient functions() { + return (FunctionsClient) service(ApiService.FUNCTIONS); + } + public GovernanceClient governance() { return (GovernanceClient) service(ApiService.GOVERNANCE); } From cf54364c354c7d317a8cc3e8c318c48fe27410b9 Mon Sep 17 00:00:00 2001 From: Gabriel Fonseca Date: Fri, 9 Oct 2026 15:44:58 +0100 Subject: [PATCH 04/11] feat(models): add Functions API model classes --- .../sdk/models/FunctionAsyncInvocation.java | 9 + .../sdk/models/FunctionDefinition.java | 154 ++++++++++++++++++ .../sdk/models/FunctionDeploymentStatus.java | 14 ++ .../frontal/sdk/models/FunctionExecution.java | 22 +++ .../models/FunctionExecutionListResponse.java | 17 ++ .../sdk/models/FunctionInvocationInput.java | 29 ++++ .../sdk/models/FunctionInvocationResult.java | 16 ++ .../sdk/models/FunctionListResponse.java | 17 ++ .../sdk/models/FunctionPagination.java | 13 ++ .../sdk/models/FunctionPermission.java | 14 ++ .../frontal/sdk/models/FunctionResource.java | 24 +++ .../frontal/sdk/models/FunctionRuntime.java | 32 ++++ .../frontal/sdk/models/FunctionStatus.java | 33 ++++ .../frontal/sdk/models/FunctionVersion.java | 15 ++ .../models/FunctionVersionListResponse.java | 17 ++ 15 files changed, 426 insertions(+) create mode 100644 services/src/main/java/dev/frontal/sdk/models/FunctionAsyncInvocation.java create mode 100644 services/src/main/java/dev/frontal/sdk/models/FunctionDefinition.java create mode 100644 services/src/main/java/dev/frontal/sdk/models/FunctionDeploymentStatus.java create mode 100644 services/src/main/java/dev/frontal/sdk/models/FunctionExecution.java create mode 100644 services/src/main/java/dev/frontal/sdk/models/FunctionExecutionListResponse.java create mode 100644 services/src/main/java/dev/frontal/sdk/models/FunctionInvocationInput.java create mode 100644 services/src/main/java/dev/frontal/sdk/models/FunctionInvocationResult.java create mode 100644 services/src/main/java/dev/frontal/sdk/models/FunctionListResponse.java create mode 100644 services/src/main/java/dev/frontal/sdk/models/FunctionPagination.java create mode 100644 services/src/main/java/dev/frontal/sdk/models/FunctionPermission.java create mode 100644 services/src/main/java/dev/frontal/sdk/models/FunctionResource.java create mode 100644 services/src/main/java/dev/frontal/sdk/models/FunctionRuntime.java create mode 100644 services/src/main/java/dev/frontal/sdk/models/FunctionStatus.java create mode 100644 services/src/main/java/dev/frontal/sdk/models/FunctionVersion.java create mode 100644 services/src/main/java/dev/frontal/sdk/models/FunctionVersionListResponse.java diff --git a/services/src/main/java/dev/frontal/sdk/models/FunctionAsyncInvocation.java b/services/src/main/java/dev/frontal/sdk/models/FunctionAsyncInvocation.java new file mode 100644 index 0000000..8856de8 --- /dev/null +++ b/services/src/main/java/dev/frontal/sdk/models/FunctionAsyncInvocation.java @@ -0,0 +1,9 @@ +package dev.frontal.sdk; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; + +/** Identifier returned when an asynchronous function invocation is started. */ +@JsonIgnoreProperties(ignoreUnknown = true) +public record FunctionAsyncInvocation( + @JsonProperty("executionId") String executionId) {} diff --git a/services/src/main/java/dev/frontal/sdk/models/FunctionDefinition.java b/services/src/main/java/dev/frontal/sdk/models/FunctionDefinition.java new file mode 100644 index 0000000..2ea4a10 --- /dev/null +++ b/services/src/main/java/dev/frontal/sdk/models/FunctionDefinition.java @@ -0,0 +1,154 @@ +package dev.frontal.sdk; + +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.databind.JsonNode; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import org.jspecify.annotations.Nullable; + +/** Create or update payload for a function. JSON schemas remain caller-defined JSON values. */ +@JsonInclude(JsonInclude.Include.NON_NULL) +public record FunctionDefinition( + @JsonProperty("name") String name, + @JsonProperty("description") @Nullable String description, + @JsonProperty("runtime") FunctionRuntime runtime, + @JsonProperty("entrypoint") String entrypoint, + @JsonProperty("source") @Nullable String source, + @JsonProperty("inputSchema") @Nullable JsonNode inputSchema, + @JsonProperty("outputSchema") @Nullable JsonNode outputSchema, + @JsonProperty("dependencies") @Nullable List dependencies, + @JsonProperty("envVars") @Nullable Map envVars, + @JsonProperty("secrets") @Nullable List secrets, + @JsonProperty("memory") @Nullable Integer memory, + @JsonProperty("timeout") @Nullable Integer timeout, + @JsonProperty("permissions") @Nullable FunctionPermission permissions) { + + public FunctionDefinition { + Objects.requireNonNull(name, "name"); + Objects.requireNonNull(runtime, "runtime"); + Objects.requireNonNull(entrypoint, "entrypoint"); + if (name.isBlank()) { + throw new IllegalArgumentException("name must not be blank"); + } + if (memory != null && memory <= 0) { + throw new IllegalArgumentException("memory must be positive"); + } + if (timeout != null && timeout <= 0) { + throw new IllegalArgumentException("timeout must be positive"); + } + if (dependencies != null) { + dependencies = List.copyOf(dependencies); + } + if (envVars != null) { + envVars = Map.copyOf(envVars); + } + if (secrets != null) { + secrets = List.copyOf(secrets); + } + } + + /** Starts a builder with the required function name. */ + public static Builder builder(String name) { + return new Builder(name); + } + + /** Builder for a function definition with the required fields called out explicitly. */ + public static final class Builder { + private final String name; + private @Nullable String description; + private @Nullable FunctionRuntime runtime; + private @Nullable String entrypoint; + private @Nullable String source; + private @Nullable JsonNode inputSchema; + private @Nullable JsonNode outputSchema; + private @Nullable List dependencies; + private @Nullable Map envVars; + private @Nullable List secrets; + private @Nullable Integer memory; + private @Nullable Integer timeout; + private @Nullable FunctionPermission permissions; + + private Builder(String name) { + this.name = Objects.requireNonNull(name, "name"); + } + + public Builder description(String description) { + this.description = description; + return this; + } + + public Builder runtime(FunctionRuntime runtime) { + this.runtime = runtime; + return this; + } + + public Builder entrypoint(String entrypoint) { + this.entrypoint = entrypoint; + return this; + } + + public Builder source(String source) { + this.source = source; + return this; + } + + public Builder inputSchema(JsonNode inputSchema) { + this.inputSchema = inputSchema; + return this; + } + + public Builder outputSchema(JsonNode outputSchema) { + this.outputSchema = outputSchema; + return this; + } + + public Builder dependencies(List dependencies) { + this.dependencies = dependencies; + return this; + } + + public Builder envVars(Map envVars) { + this.envVars = envVars; + return this; + } + + public Builder secrets(List secrets) { + this.secrets = secrets; + return this; + } + + public Builder memory(int memory) { + this.memory = memory; + return this; + } + + public Builder timeout(int timeout) { + this.timeout = timeout; + return this; + } + + public Builder permissions(FunctionPermission permissions) { + this.permissions = permissions; + return this; + } + + public FunctionDefinition build() { + return new FunctionDefinition( + name, + description, + Objects.requireNonNull(runtime, "runtime"), + Objects.requireNonNull(entrypoint, "entrypoint"), + source, + inputSchema, + outputSchema, + dependencies, + envVars, + secrets, + memory, + timeout, + permissions); + } + } +} diff --git a/services/src/main/java/dev/frontal/sdk/models/FunctionDeploymentStatus.java b/services/src/main/java/dev/frontal/sdk/models/FunctionDeploymentStatus.java new file mode 100644 index 0000000..763f5a2 --- /dev/null +++ b/services/src/main/java/dev/frontal/sdk/models/FunctionDeploymentStatus.java @@ -0,0 +1,14 @@ +package dev.frontal.sdk; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.databind.JsonNode; +import org.jspecify.annotations.Nullable; + +/** Deployment state and optional JSON details for a function version. */ +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonIgnoreProperties(ignoreUnknown = true) +public record FunctionDeploymentStatus( + @JsonProperty("status") String status, + @JsonProperty("details") @Nullable JsonNode details) {} diff --git a/services/src/main/java/dev/frontal/sdk/models/FunctionExecution.java b/services/src/main/java/dev/frontal/sdk/models/FunctionExecution.java new file mode 100644 index 0000000..42a1885 --- /dev/null +++ b/services/src/main/java/dev/frontal/sdk/models/FunctionExecution.java @@ -0,0 +1,22 @@ +package dev.frontal.sdk; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.databind.JsonNode; +import org.jspecify.annotations.Nullable; + +/** Current status and output of a function execution. */ +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonIgnoreProperties(ignoreUnknown = true) +public record FunctionExecution( + @JsonProperty("id") String id, + @JsonProperty("functionId") String functionId, + @JsonProperty("version") int version, + @JsonProperty("status") FunctionStatus status, + @JsonProperty("input") @Nullable JsonNode input, + @JsonProperty("output") @Nullable JsonNode output, + @JsonProperty("error") @Nullable String error, + @JsonProperty("startedAt") @Nullable String startedAt, + @JsonProperty("completedAt") @Nullable String completedAt, + @JsonProperty("durationMs") @Nullable Long durationMs) {} diff --git a/services/src/main/java/dev/frontal/sdk/models/FunctionExecutionListResponse.java b/services/src/main/java/dev/frontal/sdk/models/FunctionExecutionListResponse.java new file mode 100644 index 0000000..462587d --- /dev/null +++ b/services/src/main/java/dev/frontal/sdk/models/FunctionExecutionListResponse.java @@ -0,0 +1,17 @@ +package dev.frontal.sdk; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import java.util.List; +import java.util.Objects; + +/** First page of executions returned by the Functions API. */ +@JsonIgnoreProperties(ignoreUnknown = true) +public record FunctionExecutionListResponse( + @JsonProperty("executions") List executions, + @JsonProperty("pagination") FunctionPagination pagination) { + public FunctionExecutionListResponse { + executions = List.copyOf(Objects.requireNonNull(executions, "executions")); + Objects.requireNonNull(pagination, "pagination"); + } +} diff --git a/services/src/main/java/dev/frontal/sdk/models/FunctionInvocationInput.java b/services/src/main/java/dev/frontal/sdk/models/FunctionInvocationInput.java new file mode 100644 index 0000000..91ba9be --- /dev/null +++ b/services/src/main/java/dev/frontal/sdk/models/FunctionInvocationInput.java @@ -0,0 +1,29 @@ +package dev.frontal.sdk; + +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.databind.JsonNode; +import java.util.Objects; +import org.jspecify.annotations.Nullable; + +/** Input accepted by synchronous and asynchronous invocation operations. */ +@JsonInclude(JsonInclude.Include.NON_NULL) +public record FunctionInvocationInput( + @JsonProperty("functionId") String functionId, + @JsonProperty("version") @Nullable Integer version, + @JsonProperty("input") @Nullable JsonNode input) { + public FunctionInvocationInput { + Objects.requireNonNull(functionId, "functionId"); + if (version != null && version <= 0) { + throw new IllegalArgumentException("version must be positive"); + } + } + + public FunctionInvocationInput(String functionId, JsonNode input) { + this(functionId, null, input); + } + + public FunctionInvocationInput(String functionId) { + this(functionId, null, null); + } +} diff --git a/services/src/main/java/dev/frontal/sdk/models/FunctionInvocationResult.java b/services/src/main/java/dev/frontal/sdk/models/FunctionInvocationResult.java new file mode 100644 index 0000000..57d641d --- /dev/null +++ b/services/src/main/java/dev/frontal/sdk/models/FunctionInvocationResult.java @@ -0,0 +1,16 @@ +package dev.frontal.sdk; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.databind.JsonNode; +import org.jspecify.annotations.Nullable; + +/** Result of a function invocation. The result retains arbitrary caller-defined JSON. */ +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonIgnoreProperties(ignoreUnknown = true) +public record FunctionInvocationResult( + @JsonProperty("executionId") String executionId, + @JsonProperty("result") @Nullable JsonNode result, + @JsonProperty("error") @Nullable String error, + @JsonProperty("status") @Nullable FunctionStatus status) {} diff --git a/services/src/main/java/dev/frontal/sdk/models/FunctionListResponse.java b/services/src/main/java/dev/frontal/sdk/models/FunctionListResponse.java new file mode 100644 index 0000000..b218bec --- /dev/null +++ b/services/src/main/java/dev/frontal/sdk/models/FunctionListResponse.java @@ -0,0 +1,17 @@ +package dev.frontal.sdk; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import java.util.List; +import java.util.Objects; + +/** First page of functions returned by the Functions API. */ +@JsonIgnoreProperties(ignoreUnknown = true) +public record FunctionListResponse( + @JsonProperty("functions") List functions, + @JsonProperty("pagination") FunctionPagination pagination) { + public FunctionListResponse { + functions = List.copyOf(Objects.requireNonNull(functions, "functions")); + Objects.requireNonNull(pagination, "pagination"); + } +} diff --git a/services/src/main/java/dev/frontal/sdk/models/FunctionPagination.java b/services/src/main/java/dev/frontal/sdk/models/FunctionPagination.java new file mode 100644 index 0000000..d793c5f --- /dev/null +++ b/services/src/main/java/dev/frontal/sdk/models/FunctionPagination.java @@ -0,0 +1,13 @@ +package dev.frontal.sdk; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import org.jspecify.annotations.Nullable; + +/** Cursor metadata returned with a Functions API list response. */ +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonIgnoreProperties(ignoreUnknown = true) +public record FunctionPagination( + @JsonProperty("cursor") @Nullable String cursor, + @JsonProperty("hasMore") boolean hasMore) {} diff --git a/services/src/main/java/dev/frontal/sdk/models/FunctionPermission.java b/services/src/main/java/dev/frontal/sdk/models/FunctionPermission.java new file mode 100644 index 0000000..eb588d1 --- /dev/null +++ b/services/src/main/java/dev/frontal/sdk/models/FunctionPermission.java @@ -0,0 +1,14 @@ +package dev.frontal.sdk; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import java.util.List; +import org.jspecify.annotations.Nullable; + +/** Permission declarations attached to a function definition. */ +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonIgnoreProperties(ignoreUnknown = true) +public record FunctionPermission( + @JsonProperty("ontology") @Nullable List ontology, + @JsonProperty("actions") @Nullable List actions) {} diff --git a/services/src/main/java/dev/frontal/sdk/models/FunctionResource.java b/services/src/main/java/dev/frontal/sdk/models/FunctionResource.java new file mode 100644 index 0000000..9ee4c75 --- /dev/null +++ b/services/src/main/java/dev/frontal/sdk/models/FunctionResource.java @@ -0,0 +1,24 @@ +package dev.frontal.sdk; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import org.jspecify.annotations.Nullable; + +/** A function returned by the Functions API. Timestamps are ISO-8601 strings. */ +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonIgnoreProperties(ignoreUnknown = true) +public record FunctionResource( + @JsonProperty("id") String id, + @JsonProperty("name") String name, + @JsonProperty("description") @Nullable String description, + @JsonProperty("runtime") FunctionRuntime runtime, + @JsonProperty("entrypoint") String entrypoint, + @JsonProperty("status") FunctionStatus status, + @JsonProperty("version") int version, + @JsonProperty("latestVersion") @Nullable Integer latestVersion, + @JsonProperty("memory") @Nullable Integer memory, + @JsonProperty("timeout") @Nullable Integer timeout, + @JsonProperty("permissions") @Nullable FunctionPermission permissions, + @JsonProperty("createdAt") String createdAt, + @JsonProperty("updatedAt") String updatedAt) {} diff --git a/services/src/main/java/dev/frontal/sdk/models/FunctionRuntime.java b/services/src/main/java/dev/frontal/sdk/models/FunctionRuntime.java new file mode 100644 index 0000000..6fb9738 --- /dev/null +++ b/services/src/main/java/dev/frontal/sdk/models/FunctionRuntime.java @@ -0,0 +1,32 @@ +package dev.frontal.sdk; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonValue; + +/** Runtime supported by the Frontal Functions API. */ +public enum FunctionRuntime { + NODEJS20("nodejs20"), + NODEJS22("nodejs22"), + PYTHON311("python311"); + + private final String wireValue; + + FunctionRuntime(String wireValue) { + this.wireValue = wireValue; + } + + @JsonValue + public String wireValue() { + return wireValue; + } + + @JsonCreator + public static FunctionRuntime fromWireValue(String value) { + for (FunctionRuntime runtime : values()) { + if (runtime.wireValue.equals(value)) { + return runtime; + } + } + throw new IllegalArgumentException("Unsupported Functions runtime: " + value); + } +} diff --git a/services/src/main/java/dev/frontal/sdk/models/FunctionStatus.java b/services/src/main/java/dev/frontal/sdk/models/FunctionStatus.java new file mode 100644 index 0000000..b1dd635 --- /dev/null +++ b/services/src/main/java/dev/frontal/sdk/models/FunctionStatus.java @@ -0,0 +1,33 @@ +package dev.frontal.sdk; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonValue; + +/** Status values used by function and execution resources. */ +public enum FunctionStatus { + DRAFT("draft"), + ACTIVE("active"), + DEPRECATED("deprecated"), + FAILED("failed"); + + private final String wireValue; + + FunctionStatus(String wireValue) { + this.wireValue = wireValue; + } + + @JsonValue + public String wireValue() { + return wireValue; + } + + @JsonCreator + public static FunctionStatus fromWireValue(String value) { + for (FunctionStatus status : values()) { + if (status.wireValue.equals(value)) { + return status; + } + } + throw new IllegalArgumentException("Unsupported Functions status: " + value); + } +} diff --git a/services/src/main/java/dev/frontal/sdk/models/FunctionVersion.java b/services/src/main/java/dev/frontal/sdk/models/FunctionVersion.java new file mode 100644 index 0000000..65b81d6 --- /dev/null +++ b/services/src/main/java/dev/frontal/sdk/models/FunctionVersion.java @@ -0,0 +1,15 @@ +package dev.frontal.sdk; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import org.jspecify.annotations.Nullable; + +/** Immutable source version of a function. */ +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonIgnoreProperties(ignoreUnknown = true) +public record FunctionVersion( + @JsonProperty("version") int version, + @JsonProperty("source") String source, + @JsonProperty("createdAt") String createdAt, + @JsonProperty("publishedBy") @Nullable String publishedBy) {} diff --git a/services/src/main/java/dev/frontal/sdk/models/FunctionVersionListResponse.java b/services/src/main/java/dev/frontal/sdk/models/FunctionVersionListResponse.java new file mode 100644 index 0000000..db48195 --- /dev/null +++ b/services/src/main/java/dev/frontal/sdk/models/FunctionVersionListResponse.java @@ -0,0 +1,17 @@ +package dev.frontal.sdk; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import java.util.List; +import java.util.Objects; + +/** First page of versions returned for a function. */ +@JsonIgnoreProperties(ignoreUnknown = true) +public record FunctionVersionListResponse( + @JsonProperty("versions") List versions, + @JsonProperty("pagination") FunctionPagination pagination) { + public FunctionVersionListResponse { + versions = List.copyOf(Objects.requireNonNull(versions, "versions")); + Objects.requireNonNull(pagination, "pagination"); + } +} From f25a86d11bf2f908f3a4cea5b6fd4c2b81d1b076 Mon Sep 17 00:00:00 2001 From: Gabriel Fonseca Date: Fri, 9 Oct 2026 15:45:15 +0100 Subject: [PATCH 05/11] feat(resources): add resource clients for Functions, Invocations, Providers, WebhookEndpoints services --- .../sdk/resources/FunctionsClient.java | 84 +++++++++++++++++++ .../resources/FunctionsDeploymentsClient.java | 31 +++++++ .../sdk/resources/FunctionsEndpoints.java | 28 +++++++ .../resources/FunctionsExecutionsClient.java | 82 ++++++++++++++++++ .../resources/FunctionsVersionsClient.java | 51 +++++++++++ 5 files changed, 276 insertions(+) create mode 100644 services/src/main/java/dev/frontal/sdk/resources/FunctionsClient.java create mode 100644 services/src/main/java/dev/frontal/sdk/resources/FunctionsDeploymentsClient.java create mode 100644 services/src/main/java/dev/frontal/sdk/resources/FunctionsEndpoints.java create mode 100644 services/src/main/java/dev/frontal/sdk/resources/FunctionsExecutionsClient.java create mode 100644 services/src/main/java/dev/frontal/sdk/resources/FunctionsVersionsClient.java diff --git a/services/src/main/java/dev/frontal/sdk/resources/FunctionsClient.java b/services/src/main/java/dev/frontal/sdk/resources/FunctionsClient.java new file mode 100644 index 0000000..855dbd4 --- /dev/null +++ b/services/src/main/java/dev/frontal/sdk/resources/FunctionsClient.java @@ -0,0 +1,84 @@ +package dev.frontal.sdk; + +import com.fasterxml.jackson.databind.JsonNode; +import java.io.IOException; +import java.util.List; +import java.util.Objects; +import org.jspecify.annotations.Nullable; + +/** Client for creating and managing user-defined Functions. */ +public final class FunctionsClient extends ServiceClient { + FunctionsClient(ApiClient client) { + super(ApiService.FUNCTIONS, client); + } + + /** Creates a function and its initial version. */ + public FunctionResource create(FunctionDefinition definition) throws IOException, InterruptedException { + JsonNode body = client().objectMapper().valueToTree(Objects.requireNonNull(definition, "definition")); + return required( + request(FunctionsEndpoints.CREATE, List.of(), QueryParams.empty(), body, FunctionResource.class)); + } + + /** Lists functions, optionally using {@code cursor} and {@code limit}. */ + public FunctionListResponse list(QueryParams query) throws IOException, InterruptedException { + return required(request( + FunctionsEndpoints.LIST, + List.of(), + Objects.requireNonNull(query, "query"), + null, + FunctionListResponse.class)); + } + + /** Lists the first page of functions. */ + public FunctionListResponse list() throws IOException, InterruptedException { + return list(QueryParams.empty()); + } + + /** Retrieves a function by ID. */ + public FunctionResource get(String functionId) throws IOException, InterruptedException { + return required(request( + FunctionsEndpoints.GET, + List.of(Objects.requireNonNull(functionId, "functionId")), + FunctionResource.class)); + } + + /** Updates a function, creating a new version. */ + public FunctionResource update(String functionId, FunctionDefinition definition) + throws IOException, InterruptedException { + JsonNode body = client().objectMapper().valueToTree(Objects.requireNonNull(definition, "definition")); + return required(request( + FunctionsEndpoints.UPDATE, + List.of(Objects.requireNonNull(functionId, "functionId")), + QueryParams.empty(), + body, + FunctionResource.class)); + } + + /** Deletes a function. */ + public void delete(String functionId) throws IOException, InterruptedException { + execute( + FunctionsEndpoints.DELETE, + List.of(Objects.requireNonNull(functionId, "functionId")), + QueryParams.empty(), + null); + } + + /** Returns the function-version operations. */ + public FunctionsVersionsClient versions() { + return new FunctionsVersionsClient(client()); + } + + /** Returns the deployment operations. */ + public FunctionsDeploymentsClient deployments() { + return new FunctionsDeploymentsClient(client()); + } + + /** Returns function-execution operations. */ + public FunctionsExecutionsClient executions() { + return new FunctionsExecutionsClient(client()); + } + + private static T required(@Nullable T value) { + return Objects.requireNonNull(value, "Functions API returned an empty response body"); + } +} diff --git a/services/src/main/java/dev/frontal/sdk/resources/FunctionsDeploymentsClient.java b/services/src/main/java/dev/frontal/sdk/resources/FunctionsDeploymentsClient.java new file mode 100644 index 0000000..1abf8e3 --- /dev/null +++ b/services/src/main/java/dev/frontal/sdk/resources/FunctionsDeploymentsClient.java @@ -0,0 +1,31 @@ +package dev.frontal.sdk; + +import java.io.IOException; +import java.util.List; +import java.util.Objects; + +/** Operations for deploying function versions. */ +public final class FunctionsDeploymentsClient extends ServiceClient { + FunctionsDeploymentsClient(ApiClient client) { + super(ApiService.FUNCTIONS, client); + } + + /** Deploys a function version. */ + public void deploy(String functionId, int version) throws IOException, InterruptedException { + execute( + FunctionsEndpoints.DEPLOY_VERSION, + List.of(Objects.requireNonNull(functionId, "functionId"), Integer.toString(version)), + QueryParams.empty(), + client().objectMapper().createObjectNode()); + } + + /** Reads deployment status and any server-provided details. */ + public FunctionDeploymentStatus status(String functionId, int version) throws IOException, InterruptedException { + return Objects.requireNonNull( + request( + FunctionsEndpoints.DEPLOYMENT_STATUS, + List.of(Objects.requireNonNull(functionId, "functionId"), Integer.toString(version)), + FunctionDeploymentStatus.class), + "Functions API returned an empty response body"); + } +} diff --git a/services/src/main/java/dev/frontal/sdk/resources/FunctionsEndpoints.java b/services/src/main/java/dev/frontal/sdk/resources/FunctionsEndpoints.java new file mode 100644 index 0000000..f655b7b --- /dev/null +++ b/services/src/main/java/dev/frontal/sdk/resources/FunctionsEndpoints.java @@ -0,0 +1,28 @@ +package dev.frontal.sdk; + +/** Routes for the Functions API, which is not present in the checked-in OpenAPI snapshots. */ +final class FunctionsEndpoints { + static final Endpoint CREATE = endpoint(HttpMethod.POST, "/functions"); + static final Endpoint LIST = endpoint(HttpMethod.GET, "/functions"); + static final Endpoint GET = endpoint(HttpMethod.GET, "/functions/{param}"); + static final Endpoint UPDATE = endpoint(HttpMethod.PATCH, "/functions/{param}"); + static final Endpoint DELETE = endpoint(HttpMethod.DELETE, "/functions/{param}"); + static final Endpoint LIST_VERSIONS = endpoint(HttpMethod.GET, "/functions/{param}/versions"); + static final Endpoint GET_VERSION = endpoint(HttpMethod.GET, "/functions/{param}/versions/{param}"); + static final Endpoint PUBLISH_VERSION = endpoint(HttpMethod.POST, "/functions/{param}/versions/{param}/publish"); + static final Endpoint DEPLOY_VERSION = endpoint(HttpMethod.POST, "/functions/{param}/versions/{param}/deploy"); + static final Endpoint DEPLOYMENT_STATUS = + endpoint(HttpMethod.GET, "/functions/{param}/versions/{param}/deployment/status"); + static final Endpoint INVOKE = endpoint(HttpMethod.POST, "/functions/invoke"); + static final Endpoint INVOKE_ASYNC = endpoint(HttpMethod.POST, "/functions/invoke-async"); + static final Endpoint GET_EXECUTION = endpoint(HttpMethod.GET, "/functions/executions/{param}"); + static final Endpoint GET_RESULT = endpoint(HttpMethod.GET, "/functions/executions/{param}/result"); + static final Endpoint LIST_EXECUTIONS = endpoint(HttpMethod.GET, "/functions/executions"); + static final Endpoint CANCEL_EXECUTION = endpoint(HttpMethod.POST, "/functions/executions/{param}/cancel"); + + private FunctionsEndpoints() {} + + private static Endpoint endpoint(HttpMethod method, String path) { + return new Endpoint(ApiService.FUNCTIONS, method, path); + } +} diff --git a/services/src/main/java/dev/frontal/sdk/resources/FunctionsExecutionsClient.java b/services/src/main/java/dev/frontal/sdk/resources/FunctionsExecutionsClient.java new file mode 100644 index 0000000..591f465 --- /dev/null +++ b/services/src/main/java/dev/frontal/sdk/resources/FunctionsExecutionsClient.java @@ -0,0 +1,82 @@ +package dev.frontal.sdk; + +import com.fasterxml.jackson.databind.JsonNode; +import java.io.IOException; +import java.util.List; +import java.util.Objects; +import org.jspecify.annotations.Nullable; + +/** Operations for invoking and tracking function executions. */ +public final class FunctionsExecutionsClient extends ServiceClient { + FunctionsExecutionsClient(ApiClient client) { + super(ApiService.FUNCTIONS, client); + } + + /** Invokes a function and waits for its result. */ + public FunctionInvocationResult invoke(FunctionInvocationInput input) throws IOException, InterruptedException { + return required(request( + FunctionsEndpoints.INVOKE, + List.of(), + QueryParams.empty(), + body(input), + FunctionInvocationResult.class)); + } + + /** Starts an asynchronous invocation and returns its execution ID. */ + public FunctionAsyncInvocation invokeAsync(FunctionInvocationInput input) throws IOException, InterruptedException { + return required(request( + FunctionsEndpoints.INVOKE_ASYNC, + List.of(), + QueryParams.empty(), + body(input), + FunctionAsyncInvocation.class)); + } + + /** Retrieves an execution's current status. */ + public FunctionExecution getExecution(String executionId) throws IOException, InterruptedException { + return required(request( + FunctionsEndpoints.GET_EXECUTION, + List.of(Objects.requireNonNull(executionId, "executionId")), + FunctionExecution.class)); + } + + /** Retrieves an execution result. */ + public FunctionInvocationResult getResult(String executionId) throws IOException, InterruptedException { + return required(request( + FunctionsEndpoints.GET_RESULT, + List.of(Objects.requireNonNull(executionId, "executionId")), + FunctionInvocationResult.class)); + } + + /** Lists executions and supports {@code cursor}, {@code limit}, {@code functionId}, and {@code status}. */ + public FunctionExecutionListResponse listExecutions(QueryParams query) throws IOException, InterruptedException { + return required(request( + FunctionsEndpoints.LIST_EXECUTIONS, + List.of(), + Objects.requireNonNull(query, "query"), + null, + FunctionExecutionListResponse.class)); + } + + /** Lists the first page of executions. */ + public FunctionExecutionListResponse listExecutions() throws IOException, InterruptedException { + return listExecutions(QueryParams.empty()); + } + + /** Cancels an execution. */ + public void cancelExecution(String executionId) throws IOException, InterruptedException { + execute( + FunctionsEndpoints.CANCEL_EXECUTION, + List.of(Objects.requireNonNull(executionId, "executionId")), + QueryParams.empty(), + client().objectMapper().createObjectNode()); + } + + private JsonNode body(Object value) { + return client().objectMapper().valueToTree(Objects.requireNonNull(value, "input")); + } + + private static T required(@Nullable T value) { + return Objects.requireNonNull(value, "Functions API returned an empty response body"); + } +} diff --git a/services/src/main/java/dev/frontal/sdk/resources/FunctionsVersionsClient.java b/services/src/main/java/dev/frontal/sdk/resources/FunctionsVersionsClient.java new file mode 100644 index 0000000..55c5453 --- /dev/null +++ b/services/src/main/java/dev/frontal/sdk/resources/FunctionsVersionsClient.java @@ -0,0 +1,51 @@ +package dev.frontal.sdk; + +import java.io.IOException; +import java.util.List; +import java.util.Objects; +import org.jspecify.annotations.Nullable; + +/** Operations for function versions. */ +public final class FunctionsVersionsClient extends ServiceClient { + FunctionsVersionsClient(ApiClient client) { + super(ApiService.FUNCTIONS, client); + } + + /** Lists versions for a function, optionally using {@code cursor} and {@code limit}. */ + public FunctionVersionListResponse list(String functionId, QueryParams query) + throws IOException, InterruptedException { + return required(request( + FunctionsEndpoints.LIST_VERSIONS, + List.of(Objects.requireNonNull(functionId, "functionId")), + Objects.requireNonNull(query, "query"), + null, + FunctionVersionListResponse.class)); + } + + /** Lists the first page of versions for a function. */ + public FunctionVersionListResponse list(String functionId) throws IOException, InterruptedException { + return list(functionId, QueryParams.empty()); + } + + /** Retrieves a specific function version. */ + public FunctionVersion get(String functionId, int version) throws IOException, InterruptedException { + return required(request( + FunctionsEndpoints.GET_VERSION, + List.of(Objects.requireNonNull(functionId, "functionId"), Integer.toString(version)), + FunctionVersion.class)); + } + + /** Publishes a specific function version. */ + public FunctionVersion publish(String functionId, int version) throws IOException, InterruptedException { + return required(request( + FunctionsEndpoints.PUBLISH_VERSION, + List.of(Objects.requireNonNull(functionId, "functionId"), Integer.toString(version)), + QueryParams.empty(), + client().objectMapper().createObjectNode(), + FunctionVersion.class)); + } + + private static T required(@Nullable T value) { + return Objects.requireNonNull(value, "Functions API returned an empty response body"); + } +} From 31beea2524d7673adb155d994992aa623fcbd720 Mon Sep 17 00:00:00 2001 From: Gabriel Fonseca Date: Fri, 9 Oct 2026 15:45:56 +0100 Subject: [PATCH 06/11] feat(tests): add Functions API unit and integration tests --- .../examples/FunctionsQuickstartTest.java | 57 ++++ .../dev/frontal/sdk/FunctionsClientTest.java | 287 ++++++++++++++++++ 2 files changed, 344 insertions(+) create mode 100644 examples/src/test/java/dev/frontal/examples/FunctionsQuickstartTest.java create mode 100644 sdk/src/test/java/dev/frontal/sdk/FunctionsClientTest.java diff --git a/examples/src/test/java/dev/frontal/examples/FunctionsQuickstartTest.java b/examples/src/test/java/dev/frontal/examples/FunctionsQuickstartTest.java new file mode 100644 index 0000000..68b19dd --- /dev/null +++ b/examples/src/test/java/dev/frontal/examples/FunctionsQuickstartTest.java @@ -0,0 +1,57 @@ +package dev.frontal.examples; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import com.fasterxml.jackson.databind.JsonNode; +import dev.frontal.sdk.Frontal; +import dev.frontal.sdk.FunctionDefinition; +import dev.frontal.sdk.FunctionInvocationInput; +import dev.frontal.sdk.FunctionPermission; +import dev.frontal.sdk.FunctionRuntime; +import java.time.Duration; +import java.util.List; +import java.util.Map; +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.MockWebServer; +import org.junit.jupiter.api.Test; + +class FunctionsQuickstartTest { + @Test + void definesAndInvokesAFunctionWithThePublicClient() throws Exception { + try (MockWebServer mock = new MockWebServer()) { + mock.start(); + mock.enqueue(new MockResponse() + .setBody("{\"id\":\"fn_123\",\"name\":\"hello\"," + + "\"runtime\":\"nodejs22\",\"entrypoint\":\"index.handler\"," + + "\"status\":\"active\",\"version\":1,\"createdAt\":\"2026-10-09T10:00:00Z\"," + + "\"updatedAt\":\"2026-10-09T10:00:00Z\"}")); + mock.enqueue(new MockResponse() + .setBody("{\"executionId\":\"exec_123\",\"result\":{\"message\":\"hello, Ada\"}}")); + + try (Frontal frontal = Frontal.builder() + .apiKey(System.getenv().getOrDefault("FRONTAL_API_KEY", "frt_example_key")) + .apiBaseUrl(mock.url("/v1").toString()) + .requestTimeout(Duration.ofSeconds(5)) + .maxRetries(0) + .build()) { + FunctionDefinition definition = FunctionDefinition.builder("hello") + .description("Greets a person") + .runtime(FunctionRuntime.NODEJS22) + .entrypoint("index.handler") + .source("blob://functions/hello") + .dependencies(List.of("zod")) + .envVars(Map.of("GREETING", "hello")) + .permissions(new FunctionPermission(List.of(), List.of("read:name"))) + .build(); + var created = frontal.functions().create(definition); + JsonNode input = + frontal.apiClient().objectMapper().createObjectNode().put("name", "Ada"); + var invocation = + frontal.functions().executions().invoke(new FunctionInvocationInput(created.id(), input)); + + assertEquals("fn_123", created.id()); + assertEquals("hello, Ada", invocation.result().path("message").asText()); + } + } + } +} diff --git a/sdk/src/test/java/dev/frontal/sdk/FunctionsClientTest.java b/sdk/src/test/java/dev/frontal/sdk/FunctionsClientTest.java new file mode 100644 index 0000000..355ced1 --- /dev/null +++ b/sdk/src/test/java/dev/frontal/sdk/FunctionsClientTest.java @@ -0,0 +1,287 @@ +package dev.frontal.sdk; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import java.time.Duration; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.concurrent.TimeUnit; +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.MockWebServer; +import okhttp3.mockwebserver.RecordedRequest; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class FunctionsClientTest { + private static final ObjectMapper JSON = new ObjectMapper(); + private static final String FUNCTION = "{\"id\":\"fn_1\",\"name\":\"calculate\",\"runtime\":\"nodejs22\"," + + "\"entrypoint\":\"index.handler\",\"status\":\"active\",\"version\":1," + + "\"createdAt\":\"2026-10-09T10:00:00Z\",\"updatedAt\":\"2026-10-09T10:00:00Z\"}"; + + private MockWebServer server; + + @BeforeEach + void startServer() throws Exception { + server = new MockWebServer(); + server.start(); + } + + @AfterEach + void stopServer() throws Exception { + server.shutdown(); + } + + @Test + void exposesAllFunctionsRoutesWithExpectedMethodsAndBearerAuthentication() throws Exception { + enqueue(FUNCTION); + enqueue("{\"functions\":[],\"pagination\":{\"hasMore\":false}}"); + enqueue(FUNCTION); + enqueue(FUNCTION); + enqueue(""); + enqueue("{\"versions\":[],\"pagination\":{\"cursor\":\"v1\",\"hasMore\":true}}"); + enqueue("{\"version\":1,\"source\":\"blob://fn/1\",\"createdAt\":\"2026-10-09T10:00:00Z\"}"); + enqueue("{\"version\":1,\"source\":\"blob://fn/1\",\"createdAt\":\"2026-10-09T10:00:00Z\"}"); + enqueue(""); + enqueue("{\"status\":\"ready\",\"details\":{\"region\":\"eu\"}}"); + enqueue("{\"executionId\":\"exec_1\",\"result\":{\"ok\":true}}"); + enqueue("{\"executionId\":\"exec_2\"}"); + enqueue("{\"id\":\"exec_1\",\"functionId\":\"fn_1\",\"version\":1,\"status\":\"active\"}"); + enqueue("{\"executionId\":\"exec_1\",\"result\":{\"ok\":true}}"); + enqueue("{\"executions\":[],\"pagination\":{\"hasMore\":false}}"); + enqueue(""); + + try (Frontal frontal = client()) { + FunctionDefinition definition = definition(JSON.createObjectNode().put("type", "object")); + frontal.functions().create(definition); + frontal.functions() + .list(QueryParams.builder() + .add("cursor", "c 1") + .add("limit", 10) + .build()); + frontal.functions().get("fn_1"); + frontal.functions().update("fn_1", definition); + frontal.functions().delete("fn_1"); + frontal.functions().versions().list("fn_1", QueryParams.of("limit", "5")); + frontal.functions().versions().get("fn_1", 1); + frontal.functions().versions().publish("fn_1", 1); + frontal.functions().deployments().deploy("fn_1", 1); + assertEquals( + "ready", frontal.functions().deployments().status("fn_1", 1).status()); + frontal.functions().executions().invoke(new FunctionInvocationInput("fn_1")); + frontal.functions().executions().invokeAsync(new FunctionInvocationInput("fn_1")); + frontal.functions().executions().getExecution("exec_1"); + frontal.functions().executions().getResult("exec_1"); + frontal.functions() + .executions() + .listExecutions(QueryParams.builder() + .add("cursor", "c1") + .add("limit", 20) + .add("functionId", "fn_1") + .add("status", "active") + .build()); + frontal.functions().executions().cancelExecution("exec_1"); + } + + List expected = List.of( + "POST /v1/functions", + "GET /v1/functions?cursor=c%201&limit=10", + "GET /v1/functions/fn_1", + "PATCH /v1/functions/fn_1", + "DELETE /v1/functions/fn_1", + "GET /v1/functions/fn_1/versions?limit=5", + "GET /v1/functions/fn_1/versions/1", + "POST /v1/functions/fn_1/versions/1/publish", + "POST /v1/functions/fn_1/versions/1/deploy", + "GET /v1/functions/fn_1/versions/1/deployment/status", + "POST /v1/functions/invoke", + "POST /v1/functions/invoke-async", + "GET /v1/functions/executions/exec_1", + "GET /v1/functions/executions/exec_1/result", + "GET /v1/functions/executions?cursor=c1&limit=20&functionId=fn_1&status=active", + "POST /v1/functions/executions/exec_1/cancel"); + for (String route : expected) { + RecordedRequest request = server.takeRequest(1, TimeUnit.SECONDS); + assertNotNull(request); + assertEquals(route.split(" ", 2)[0], request.getMethod()); + assertEquals(route.split(" ", 2)[1], request.getPath()); + assertEquals("Bearer frt_test_key", request.getHeader("Authorization")); + } + } + + @Test + void serializesCamelCaseDefinitionFieldsAndPreservesNestedJsonKeys() throws Exception { + enqueue(FUNCTION); + JsonNode schema = JSON.readTree("{\"type\":\"object\",\"properties\":{\"camelCase\":{\"type\":\"string\"}}}"); + FunctionDefinition definition = FunctionDefinition.builder("calculate") + .description("Calculates a value") + .runtime(FunctionRuntime.NODEJS22) + .entrypoint("index.handler") + .inputSchema(schema) + .envVars(Map.of("MODE_NAME", "test")) + .permissions(new FunctionPermission(List.of("entities"), List.of("read:data"))) + .build(); + + try (Frontal frontal = client()) { + FunctionResource result = frontal.functions().create(definition); + assertEquals(FunctionRuntime.NODEJS22, result.runtime()); + RecordedRequest request = server.takeRequest(1, TimeUnit.SECONDS); + JsonNode body = JSON.readTree(request.getBody().readUtf8()); + assertEquals("nodejs22", body.path("runtime").asText()); + assertTrue(body.has("inputSchema")); + assertEquals( + "string", + body.path("inputSchema") + .path("properties") + .path("camelCase") + .path("type") + .asText()); + assertEquals("test", body.path("envVars").path("MODE_NAME").asText()); + assertEquals( + "read:data", body.path("permissions").path("actions").get(0).asText()); + assertTrue(!body.has("input_schema")); + assertTrue(!body.has("env_vars")); + assertTrue(!body.has("source")); + } + } + + @Test + void serializesArbitraryInvocationJsonAndDecodesNestedResultWithoutRenamingKeys() throws Exception { + enqueue("{\"executionId\":\"exec_1\",\"result\":{\"camelCase\":{\"user-key\":[1,{\"keepMe\":true}]}}}"); + JsonNode input = JSON.readTree("{\"camelCase\":{\"user-key\":[1,{\"keepMe\":true}]}}"); + try (Frontal frontal = client()) { + FunctionInvocationResult response = + frontal.functions().executions().invoke(new FunctionInvocationInput("fn_1", 2, input)); + assertEquals("exec_1", response.executionId()); + assertEquals(input, response.result()); + RecordedRequest request = server.takeRequest(1, TimeUnit.SECONDS); + JsonNode body = JSON.readTree(request.getBody().readUtf8()); + assertEquals("fn_1", body.path("functionId").asText()); + assertEquals(2, body.path("version").asInt()); + assertEquals(input, body.path("input")); + assertTrue(body.has("functionId")); + assertTrue(!body.has("function_id")); + } + } + + @Test + void ignoresAdditionalPropertiesInResourceListAndNestedPermissionResponses() throws Exception { + enqueue("{\"id\":\"fn_1\",\"name\":\"calculate\",\"runtime\":\"nodejs22\"," + + "\"entrypoint\":\"index.handler\",\"status\":\"active\",\"version\":1," + + "\"permissions\":{\"actions\":[\"read\"],\"futurePermissionField\":true}," + + "\"futureResourceField\":{\"enabled\":true}," + + "\"createdAt\":\"2026-10-09T10:00:00Z\",\"updatedAt\":\"2026-10-09T10:00:00Z\"}"); + enqueue("{\"functions\":[" + FUNCTION.substring(0, FUNCTION.length() - 1) + + ",\"futureResourceField\":true}],\"pagination\":{\"hasMore\":false," + + "\"futurePaginationField\":\"ignored\"},\"futureEnvelopeField\":1}"); + + try (Frontal frontal = client()) { + FunctionResource function = frontal.functions().get("fn_1"); + FunctionListResponse response = frontal.functions().list(); + assertEquals("fn_1", function.id()); + FunctionPermission permissions = Objects.requireNonNull(function.permissions()); + assertEquals(List.of("read"), permissions.actions()); + assertEquals("fn_1", response.functions().get(0).id()); + assertEquals(false, response.pagination().hasMore()); + } + } + + @Test + void encodesReservedPathIdsAsOnePathSegment() throws Exception { + enqueue(FUNCTION); + try (Frontal frontal = client()) { + frontal.functions().get("fn/a b"); + RecordedRequest request = server.takeRequest(1, TimeUnit.SECONDS); + assertEquals("/v1/functions/fn%2Fa%20b", request.getRequestUrl().encodedPath()); + } + } + + @Test + void mapsValidationErrorsThroughTheSharedExceptionHierarchy() { + enqueue(new MockResponse() + .setResponseCode(422) + .addHeader("x-request-id", "req_fn_1") + .setBody("{\"error\":{\"code\":\"INVALID_FUNCTION\",\"message\":\"runtime is required\"}}")); + try (Frontal frontal = client()) { + ValidationException exception = assertThrows( + ValidationException.class, + () -> frontal.functions() + .create(FunctionDefinition.builder("calculate") + .runtime(FunctionRuntime.PYTHON311) + .entrypoint("main.handler") + .build())); + assertEquals("INVALID_FUNCTION", exception.code()); + assertEquals("req_fn_1", exception.requestId()); + } + } + + @Test + void retriesFunctionGetAccordingToExplicitSharedConfiguration() throws Exception { + enqueue(new MockResponse().setResponseCode(503).setBody("temporary")); + enqueue(FUNCTION); + try (Frontal frontal = Frontal.builder() + .apiKey("frt_test_key") + .apiBaseUrl(server.url("/v1").toString()) + .requestTimeout(Duration.ofSeconds(3)) + .maxRetries(1) + .build()) { + assertEquals("fn_1", frontal.functions().get("fn_1").id()); + assertEquals(2, server.getRequestCount()); + } + } + + @Test + void usesThreeRetriesForFunctionsByDefault() throws Exception { + enqueue(new MockResponse() + .setResponseCode(503) + .addHeader("Retry-After", "0") + .setBody("temporary")); + enqueue(new MockResponse() + .setResponseCode(503) + .addHeader("Retry-After", "0") + .setBody("temporary")); + enqueue(new MockResponse() + .setResponseCode(503) + .addHeader("Retry-After", "0") + .setBody("temporary")); + enqueue(FUNCTION); + try (Frontal frontal = Frontal.builder() + .apiKey("frt_test_key") + .apiBaseUrl(server.url("/v1").toString()) + .build()) { + assertEquals("fn_1", frontal.functions().get("fn_1").id()); + assertEquals(4, server.getRequestCount()); + } + } + + private Frontal client() { + return Frontal.builder() + .apiKey("frt_test_key") + .apiBaseUrl(server.url("/v1").toString()) + .requestTimeout(Duration.ofSeconds(3)) + .maxRetries(0) + .build(); + } + + private FunctionDefinition definition(JsonNode schema) { + return FunctionDefinition.builder("calculate") + .runtime(FunctionRuntime.NODEJS22) + .entrypoint("index.handler") + .inputSchema(schema) + .build(); + } + + private void enqueue(String body) { + enqueue(new MockResponse().setBody(body)); + } + + private void enqueue(MockResponse response) { + server.enqueue(response); + } +} From bbc226fbf1aafc2fc8063b117429aa5e3ce91e29 Mon Sep 17 00:00:00 2001 From: Gabriel Fonseca Date: Fri, 9 Oct 2026 15:46:50 +0100 Subject: [PATCH 07/11] docs: update CHANGELOG with Functions API release and update README to mention Functions guide --- CHANGELOG.md | 4 ++++ README.md | 1 + 2 files changed, 5 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1636f1a..ce4d814 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,9 @@ # Changelog +## Unreleased + +- Add the typed Functions API client, execution and deployment operations, and examples. + ## 2.0.0 - Establish the initial SDK release with the multi-module build, shared transport, typed failures, pagination, polling, and SSE support. diff --git a/README.md b/README.md index e75e70d..fdf542e 100644 --- a/README.md +++ b/README.md @@ -94,6 +94,7 @@ The configured request timeout applies to each ordinary call attempt and `stream Browse the [service API reference](./docs/api/README.md) for all named operations and route signatures. +Functions endpoints are not in the current OpenAPI snapshot; see the [Functions API guide](./docs/api/functions.md) for its typed client and example. ## Build and verify From 97a295795639f9f2dbc6b8ce12b0b2754f8145c4 Mon Sep 17 00:00:00 2001 From: Gabriel Fonseca Date: Fri, 9 Oct 2026 15:49:29 +0100 Subject: [PATCH 08/11] docs: add Functions API guide and update docs/api/README.md to note Functions come from TypeScript SDK --- docs/README.md | 2 +- docs/api/README.md | 1 + docs/api/functions.md | 60 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 62 insertions(+), 1 deletion(-) create mode 100644 docs/api/functions.md diff --git a/docs/README.md b/docs/README.md index fd99a1d..cf66699 100644 --- a/docs/README.md +++ b/docs/README.md @@ -1,3 +1,3 @@ # Java documentation -Read `OVERVIEW.md` for the SDK surface, `ARCHITECTURE.md` for the module and request flow, and `ONBOARDING.md` to set up the toolchain. Browse [the service API reference](./api/README.md) for the generated operation catalog. See the root README for pagination, error handling, streaming, and serialization examples. Use `TESTING.md` for verification and `PUBLISHING.md` for release steps. +Read `OVERVIEW.md` for the SDK surface, `ARCHITECTURE.md` for the module and request flow, and `ONBOARDING.md` to set up the toolchain. Browse [the service API reference](./api/README.md) for the generated operation catalog and the [Functions API guide](./api/functions.md) for the Functions routes, which are not in the current contract snapshot. See the root README for pagination, error handling, streaming, and serialization examples. Use `TESTING.md` for verification and `PUBLISHING.md` for release steps. diff --git a/docs/api/README.md b/docs/api/README.md index e1d401d..fc50a50 100644 --- a/docs/api/README.md +++ b/docs/api/README.md @@ -3,6 +3,7 @@ Generated from the committed route catalog for SDK service clients. Call-shaped listing of every operation: [methods as code](./methods-as-code.md). +The Functions endpoints currently come from the TypeScript SDK because they are not in the committed contract inventory. See the [Functions API guide](./functions.md) for their Java client methods and models. | Service | Routes | Reference | | --- | ---: | --- | diff --git a/docs/api/functions.md b/docs/api/functions.md new file mode 100644 index 0000000..f7a3ca1 --- /dev/null +++ b/docs/api/functions.md @@ -0,0 +1,60 @@ +# Functions API + +The Java Functions client follows the operation and payload shapes in the [TypeScript Functions package](https://github.com/frontal-labs/sdk-typescript/blob/master/packages/functions/src/namespace.ts). These routes are not present in the checked-in OpenAPI snapshots or `contracts/sdk-endpoints.json` yet, so Functions uses the shared Java transport with a local route catalog. + +## Client and configuration + +Use `Frontal.functions()` to access this API. It shares the configured bearer API key, API base URL, timeout, retry behavior, environment header, and Jackson mapper with the rest of the SDK. + +```java +try (Frontal frontal = Frontal.builder() + .apiKey(System.getenv("FRONTAL_API_KEY")) + .apiBaseUrl("https://api.frontal.dev/v1") + .requestTimeout(Duration.ofSeconds(30)) + .maxRetries(3) + .build()) { + FunctionDefinition definition = FunctionDefinition.builder("hello") + .runtime(FunctionRuntime.NODEJS22) + .entrypoint("index.handler") + .build(); + FunctionResource function = frontal.functions().create(definition); + FunctionInvocationResult result = frontal.functions() + .executions() + .invoke(new FunctionInvocationInput(function.id())); +} +``` + +The default API URL is `https://api.frontal.dev/v1`, request timeout is 30 seconds, and Functions GET requests retry up to three times by default, matching the TypeScript package. Setting `maxRetries` on the builder explicitly overrides the retry count for Functions and other services. Other Java services retain the shared default of two retries. + +## Operations + +| Java call | HTTP operation | +| --- | --- | +| `functions.create(definition)` | `POST /functions` | +| `functions.list(query)` | `GET /functions?cursor=&limit=` | +| `functions.get(functionId)` | `GET /functions/{functionId}` | +| `functions.update(functionId, definition)` | `PATCH /functions/{functionId}` | +| `functions.delete(functionId)` | `DELETE /functions/{functionId}` | +| `functions.versions().list(functionId, query)` | `GET /functions/{functionId}/versions?cursor=&limit=` | +| `functions.versions().get(functionId, version)` | `GET /functions/{functionId}/versions/{version}` | +| `functions.versions().publish(functionId, version)` | `POST /functions/{functionId}/versions/{version}/publish` | +| `functions.deployments().deploy(functionId, version)` | `POST /functions/{functionId}/versions/{version}/deploy` | +| `functions.deployments().status(functionId, version)` | `GET /functions/{functionId}/versions/{version}/deployment/status` | +| `functions.executions().invoke(input)` | `POST /functions/invoke` | +| `functions.executions().invokeAsync(input)` | `POST /functions/invoke-async` | +| `functions.executions().getExecution(executionId)` | `GET /functions/executions/{executionId}` | +| `functions.executions().getResult(executionId)` | `GET /functions/executions/{executionId}/result` | +| `functions.executions().listExecutions(query)` | `GET /functions/executions?cursor=&limit=&functionId=&status=` | +| `functions.executions().cancelExecution(executionId)` | `POST /functions/executions/{executionId}/cancel` | + +List query values are provided with `QueryParams.builder()`. IDs are encoded as individual URL path segments. Service calls are synchronous and report transport/API failures through the SDK's `IOException` hierarchy. + +## Models and JSON values + +`FunctionDefinition` requires `name`, `runtime`, and `entrypoint`. Its builder accepts optional `description`, `source`, `inputSchema`, `outputSchema`, `dependencies`, `envVars`, `secrets`, `memory` (MB), `timeout` (seconds), and `permissions` (`ontology` and `actions` string lists). Runtime values are `NODEJS20`, `NODEJS22`, and `PYTHON311`; their JSON forms are `nodejs20`, `nodejs22`, and `python311`. + +Schemas and invocation inputs/results use Jackson `JsonNode`, so nested object keys and arbitrary JSON values remain under caller control. Resource statuses use `FunctionStatus` (`DRAFT`, `ACTIVE`, `DEPRECATED`, `FAILED`) with the corresponding lowercase wire values. List models expose their `functions`, `versions`, or `executions` collection and `FunctionPagination` metadata. + +## Runnable example + +See [`FunctionsQuickstartTest`](../../examples/src/test/java/dev/frontal/examples/FunctionsQuickstartTest.java) for an executable example that constructs a configured client, defines a function, and invokes it against MockWebServer. \ No newline at end of file From be587606a5fa62f9ef875eac92b00bc53ee24e4a Mon Sep 17 00:00:00 2001 From: Gabriel Fonseca Date: Fri, 9 Oct 2026 16:01:18 +0100 Subject: [PATCH 09/11] docs: remove outdated API documentation files --- docs/ENTERPRISE_READINESS.md | 19 - docs/api/agents.md | 66 ---- docs/api/ai.md | 46 --- docs/api/audit.md | 26 -- docs/api/auth.md | 274 ------------- docs/api/billing.md | 102 ----- docs/api/blob.md | 42 -- docs/api/connection-tests.md | 14 - docs/api/connectors.md | 58 --- docs/api/data.md | 614 ---------------------------- docs/api/events.md | 78 ---- docs/api/governance.md | 106 ----- docs/api/invocations.md | 14 - docs/api/lineage.md | 38 -- docs/api/methods-as-code.md | 724 ---------------------------------- docs/api/observability.md | 134 ------- docs/api/ontology.md | 694 -------------------------------- docs/api/pipelines.md | 54 --- docs/api/providers.md | 14 - docs/api/react.md | 10 - docs/api/schedules.md | 50 --- docs/api/webhook-endpoints.md | 38 -- docs/api/webhooks.md | 50 --- docs/api/workflows.md | 130 ------ 24 files changed, 3395 deletions(-) delete mode 100644 docs/ENTERPRISE_READINESS.md delete mode 100644 docs/api/agents.md delete mode 100644 docs/api/ai.md delete mode 100644 docs/api/audit.md delete mode 100644 docs/api/auth.md delete mode 100644 docs/api/billing.md delete mode 100644 docs/api/blob.md delete mode 100644 docs/api/connection-tests.md delete mode 100644 docs/api/connectors.md delete mode 100644 docs/api/data.md delete mode 100644 docs/api/events.md delete mode 100644 docs/api/governance.md delete mode 100644 docs/api/invocations.md delete mode 100644 docs/api/lineage.md delete mode 100644 docs/api/methods-as-code.md delete mode 100644 docs/api/observability.md delete mode 100644 docs/api/ontology.md delete mode 100644 docs/api/pipelines.md delete mode 100644 docs/api/providers.md delete mode 100644 docs/api/react.md delete mode 100644 docs/api/schedules.md delete mode 100644 docs/api/webhook-endpoints.md delete mode 100644 docs/api/webhooks.md delete mode 100644 docs/api/workflows.md diff --git a/docs/ENTERPRISE_READINESS.md b/docs/ENTERPRISE_READINESS.md deleted file mode 100644 index f26950a..0000000 --- a/docs/ENTERPRISE_READINESS.md +++ /dev/null @@ -1,19 +0,0 @@ -# Java SDK enterprise readiness - -This page summarizes the controls in the Java SDK and the work required before a production release. - -## Current controls - -- Java 17 baseline with CI on JDK 17 and 21 using Gradle. -- Shared OkHttp transport with bounded responses, request IDs, safe-read retries, and typed errors. -- MockWebServer coverage for request handling, retries, pagination, error mapping, and SSE streams. -- Contract checks that map all public and AI OpenAPI operations to Java endpoints. -- Generated named operation methods and per-service references for supported routes. Agent run lookup is grouped under agents. -- Central Portal release workflow with GPG signing required for publication. - -## Remaining release work - -- Configure Central Portal and GPG credentials as protected GitHub secrets. -- Complete a security review of transport, credential handling, and logging. -- Add operation-specific request and response models as upstream contracts provide complete schemas. -- Configure dependency scanning and release provenance for the repository. diff --git a/docs/api/agents.md b/docs/api/agents.md deleted file mode 100644 index 314cafa..0000000 --- a/docs/api/agents.md +++ /dev/null @@ -1,66 +0,0 @@ -# Agents API - -Service accessor: `frontal.agents()` (`AgentsServiceClient`). - -Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. - -| Method | HTTP | Route | Parameters | Response | -| --- | --- | --- | --- | --- | -| `agents().delete(...)` | `DELETE` | `/agents/{param}` | `String agentId, QueryParams query, Class responseType` | `@Nullable T` | -| `agents().delete(...)` | `DELETE` | `/agents/{param}` | `String agentId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `agents().delete(...)` | `DELETE` | `/agents/{param}` | `String agentId, Class responseType` | `@Nullable T` | -| `agents().delete(...)` | `DELETE` | `/agents/{param}` | `String agentId, TypeReference responseType` | `@Nullable T` | -| `agents().list(...)` | `GET` | `/agents` | `QueryParams query, Class responseType` | `@Nullable T` | -| `agents().list(...)` | `GET` | `/agents` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `agents().list(...)` | `GET` | `/agents` | `Class responseType` | `@Nullable T` | -| `agents().list(...)` | `GET` | `/agents` | `TypeReference responseType` | `@Nullable T` | -| `agents().health(...)` | `GET` | `/agents/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `agents().health(...)` | `GET` | `/agents/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `agents().health(...)` | `GET` | `/agents/health` | `Class responseType` | `@Nullable T` | -| `agents().health(...)` | `GET` | `/agents/health` | `TypeReference responseType` | `@Nullable T` | -| `agents().get(...)` | `GET` | `/agents/{param}` | `String agentId, QueryParams query, Class responseType` | `@Nullable T` | -| `agents().get(...)` | `GET` | `/agents/{param}` | `String agentId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `agents().get(...)` | `GET` | `/agents/{param}` | `String agentId, Class responseType` | `@Nullable T` | -| `agents().get(...)` | `GET` | `/agents/{param}` | `String agentId, TypeReference responseType` | `@Nullable T` | -| `agents().create(...)` | `POST` | `/agents` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `agents().create(...)` | `POST` | `/agents` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `agents().create(...)` | `POST` | `/agents` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `agents().create(...)` | `POST` | `/agents` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `agents().rollback(...)` | `POST` | `/agents/{param}/rollback` | `String agentId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `agents().rollback(...)` | `POST` | `/agents/{param}/rollback` | `String agentId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `agents().rollback(...)` | `POST` | `/agents/{param}/rollback` | `String agentId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `agents().rollback(...)` | `POST` | `/agents/{param}/rollback` | `String agentId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `agents().update(...)` | `PUT` | `/agents/{param}` | `String agentId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `agents().update(...)` | `PUT` | `/agents/{param}` | `String agentId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `agents().update(...)` | `PUT` | `/agents/{param}` | `String agentId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `agents().update(...)` | `PUT` | `/agents/{param}` | `String agentId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `agents().runs().getByActionRunId(...)` | `GET` | `/action-runs/{param}` | `String actionRunId, QueryParams query, Class responseType` | `@Nullable T` | -| `agents().runs().getByActionRunId(...)` | `GET` | `/action-runs/{param}` | `String actionRunId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `agents().runs().getByActionRunId(...)` | `GET` | `/action-runs/{param}` | `String actionRunId, Class responseType` | `@Nullable T` | -| `agents().runs().getByActionRunId(...)` | `GET` | `/action-runs/{param}` | `String actionRunId, TypeReference responseType` | `@Nullable T` | -| `agents().runs().get(...)` | `GET` | `/agents/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `agents().runs().get(...)` | `GET` | `/agents/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `agents().runs().get(...)` | `GET` | `/agents/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `agents().runs().get(...)` | `GET` | `/agents/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `agents().runs().conversation(...)` | `GET` | `/agents/runs/{param}/conversation` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `agents().runs().conversation(...)` | `GET` | `/agents/runs/{param}/conversation` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `agents().runs().conversation(...)` | `GET` | `/agents/runs/{param}/conversation` | `String runId, Class responseType` | `@Nullable T` | -| `agents().runs().conversation(...)` | `GET` | `/agents/runs/{param}/conversation` | `String runId, TypeReference responseType` | `@Nullable T` | -| `agents().runs().list(...)` | `GET` | `/agents/{param}/runs` | `String agentId, QueryParams query, Class responseType` | `@Nullable T` | -| `agents().runs().list(...)` | `GET` | `/agents/{param}/runs` | `String agentId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `agents().runs().list(...)` | `GET` | `/agents/{param}/runs` | `String agentId, Class responseType` | `@Nullable T` | -| `agents().runs().list(...)` | `GET` | `/agents/{param}/runs` | `String agentId, TypeReference responseType` | `@Nullable T` | -| `agents().runs().create(...)` | `POST` | `/agents/{param}/runs` | `String agentId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `agents().runs().create(...)` | `POST` | `/agents/{param}/runs` | `String agentId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `agents().runs().create(...)` | `POST` | `/agents/{param}/runs` | `String agentId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `agents().runs().create(...)` | `POST` | `/agents/{param}/runs` | `String agentId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `agents().runs().stream(...)` | `STREAM` | `/agents/runs/{param}/stream` | `String runId, QueryParams query` | `Flow.Publisher` | -| `agents().runs().stream(...)` | `STREAM` | `/agents/runs/{param}/stream` | `String runId` | `Flow.Publisher` | -| `agents().runs().streamBlocking(...)` | `STREAM` | `/agents/runs/{param}/stream` | `String runId, QueryParams query` | `SseEventIterator` | -| `agents().runs().streamBlocking(...)` | `STREAM` | `/agents/runs/{param}/stream` | `String runId` | `SseEventIterator` | -| `agents().versions().list(...)` | `GET` | `/agents/{param}/versions` | `String agentId, QueryParams query, Class responseType` | `@Nullable T` | -| `agents().versions().list(...)` | `GET` | `/agents/{param}/versions` | `String agentId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `agents().versions().list(...)` | `GET` | `/agents/{param}/versions` | `String agentId, Class responseType` | `@Nullable T` | -| `agents().versions().list(...)` | `GET` | `/agents/{param}/versions` | `String agentId, TypeReference responseType` | `@Nullable T` | - -The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/ai.md b/docs/api/ai.md deleted file mode 100644 index 8213353..0000000 --- a/docs/api/ai.md +++ /dev/null @@ -1,46 +0,0 @@ -# Ai API - -Service accessor: `frontal.ai()` (`AiServiceClient`). - -Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. - -| Method | HTTP | Route | Parameters | Response | -| --- | --- | --- | --- | --- | -| `ai().health(...)` | `GET` | `/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ai().health(...)` | `GET` | `/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ai().health(...)` | `GET` | `/health` | `Class responseType` | `@Nullable T` | -| `ai().health(...)` | `GET` | `/health` | `TypeReference responseType` | `@Nullable T` | -| `ai().internal().embed(...)` | `POST` | `/internal/embeddings` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ai().internal().embed(...)` | `POST` | `/internal/embeddings` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ai().internal().embed(...)` | `POST` | `/internal/embeddings` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ai().internal().embed(...)` | `POST` | `/internal/embeddings` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ai().internal().predict(...)` | `POST` | `/internal/predictions` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ai().internal().predict(...)` | `POST` | `/internal/predictions` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ai().internal().predict(...)` | `POST` | `/internal/predictions` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ai().internal().predict(...)` | `POST` | `/internal/predictions` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ai().internal().rerank(...)` | `POST` | `/internal/rerank` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ai().internal().rerank(...)` | `POST` | `/internal/rerank` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ai().internal().rerank(...)` | `POST` | `/internal/rerank` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ai().internal().rerank(...)` | `POST` | `/internal/rerank` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ai().internal().predictForm(...)` | `POSTFORMDATA` | `/internal/predictions` | `QueryParams query, Map fields, Map files, Class responseType` | `@Nullable T` | -| `ai().internal().predictForm(...)` | `POSTFORMDATA` | `/internal/predictions` | `QueryParams query, Map fields, Map files, TypeReference responseType` | `@Nullable T` | -| `ai().internal().predictForm(...)` | `POSTFORMDATA` | `/internal/predictions` | `Map fields, Map files, Class responseType` | `@Nullable T` | -| `ai().internal().predictForm(...)` | `POSTFORMDATA` | `/internal/predictions` | `Map fields, Map files, TypeReference responseType` | `@Nullable T` | -| `ai().internal().predictRaw(...)` | `POSTRAW` | `/internal/predictions` | `QueryParams query, byte[] body, Class responseType` | `@Nullable T` | -| `ai().internal().predictRaw(...)` | `POSTRAW` | `/internal/predictions` | `QueryParams query, byte[] body, TypeReference responseType` | `@Nullable T` | -| `ai().internal().predictRaw(...)` | `POSTRAW` | `/internal/predictions` | `byte[] body, Class responseType` | `@Nullable T` | -| `ai().internal().predictRaw(...)` | `POSTRAW` | `/internal/predictions` | `byte[] body, TypeReference responseType` | `@Nullable T` | -| `ai().chat().completions().create(...)` | `POST` | `/ai/chat/completions` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ai().chat().completions().create(...)` | `POST` | `/ai/chat/completions` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ai().chat().completions().create(...)` | `POST` | `/ai/chat/completions` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ai().chat().completions().create(...)` | `POST` | `/ai/chat/completions` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ai().internal().models().list(...)` | `GET` | `/internal/models` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ai().internal().models().list(...)` | `GET` | `/internal/models` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ai().internal().models().list(...)` | `GET` | `/internal/models` | `Class responseType` | `@Nullable T` | -| `ai().internal().models().list(...)` | `GET` | `/internal/models` | `TypeReference responseType` | `@Nullable T` | -| `ai().internal().models().defaults(...)` | `GET` | `/internal/models/defaults` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ai().internal().models().defaults(...)` | `GET` | `/internal/models/defaults` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ai().internal().models().defaults(...)` | `GET` | `/internal/models/defaults` | `Class responseType` | `@Nullable T` | -| `ai().internal().models().defaults(...)` | `GET` | `/internal/models/defaults` | `TypeReference responseType` | `@Nullable T` | - -The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/audit.md b/docs/api/audit.md deleted file mode 100644 index 3a8584b..0000000 --- a/docs/api/audit.md +++ /dev/null @@ -1,26 +0,0 @@ -# Audit API - -Service accessor: `frontal.audit()` (`AuditClient`). - -Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. - -| Method | HTTP | Route | Parameters | Response | -| --- | --- | --- | --- | --- | -| `audit().events().list(...)` | `GET` | `/audit/events` | `QueryParams query, Class responseType` | `@Nullable T` | -| `audit().events().list(...)` | `GET` | `/audit/events` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `audit().events().list(...)` | `GET` | `/audit/events` | `Class responseType` | `@Nullable T` | -| `audit().events().list(...)` | `GET` | `/audit/events` | `TypeReference responseType` | `@Nullable T` | -| `audit().events().get(...)` | `GET` | `/audit/events/{param}` | `String eventId, QueryParams query, Class responseType` | `@Nullable T` | -| `audit().events().get(...)` | `GET` | `/audit/events/{param}` | `String eventId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `audit().events().get(...)` | `GET` | `/audit/events/{param}` | `String eventId, Class responseType` | `@Nullable T` | -| `audit().events().get(...)` | `GET` | `/audit/events/{param}` | `String eventId, TypeReference responseType` | `@Nullable T` | -| `audit().events().create(...)` | `POST` | `/audit/events` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `audit().events().create(...)` | `POST` | `/audit/events` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `audit().events().create(...)` | `POST` | `/audit/events` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `audit().events().create(...)` | `POST` | `/audit/events` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `audit().events().batch(...)` | `POST` | `/audit/events/batch` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `audit().events().batch(...)` | `POST` | `/audit/events/batch` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `audit().events().batch(...)` | `POST` | `/audit/events/batch` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `audit().events().batch(...)` | `POST` | `/audit/events/batch` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | - -The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/auth.md b/docs/api/auth.md deleted file mode 100644 index bf9e443..0000000 --- a/docs/api/auth.md +++ /dev/null @@ -1,274 +0,0 @@ -# Auth API - -Service accessor: `frontal.auth()` (`AuthClient`). - -Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. - -| Method | HTTP | Route | Parameters | Response | -| --- | --- | --- | --- | --- | -| `auth().getUser(...)` | `GET` | `/auth/user` | `QueryParams query, Class responseType` | `@Nullable T` | -| `auth().getUser(...)` | `GET` | `/auth/user` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().getUser(...)` | `GET` | `/auth/user` | `Class responseType` | `@Nullable T` | -| `auth().getUser(...)` | `GET` | `/auth/user` | `TypeReference responseType` | `@Nullable T` | -| `auth().createAuthorize(...)` | `POST` | `/auth/authorize` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createAuthorize(...)` | `POST` | `/auth/authorize` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().createAuthorize(...)` | `POST` | `/auth/authorize` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createAuthorize(...)` | `POST` | `/auth/authorize` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().createInvite(...)` | `POST` | `/auth/invite` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createInvite(...)` | `POST` | `/auth/invite` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().createInvite(...)` | `POST` | `/auth/invite` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createInvite(...)` | `POST` | `/auth/invite` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().login(...)` | `POST` | `/auth/login` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().login(...)` | `POST` | `/auth/login` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().login(...)` | `POST` | `/auth/login` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().login(...)` | `POST` | `/auth/login` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().logout(...)` | `POST` | `/auth/logout` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().logout(...)` | `POST` | `/auth/logout` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().logout(...)` | `POST` | `/auth/logout` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().logout(...)` | `POST` | `/auth/logout` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().createOtp(...)` | `POST` | `/auth/otp` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createOtp(...)` | `POST` | `/auth/otp` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().createOtp(...)` | `POST` | `/auth/otp` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createOtp(...)` | `POST` | `/auth/otp` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().createReauthenticate(...)` | `POST` | `/auth/reauthenticate` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createReauthenticate(...)` | `POST` | `/auth/reauthenticate` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().createReauthenticate(...)` | `POST` | `/auth/reauthenticate` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createReauthenticate(...)` | `POST` | `/auth/reauthenticate` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().createRecover(...)` | `POST` | `/auth/recover` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createRecover(...)` | `POST` | `/auth/recover` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().createRecover(...)` | `POST` | `/auth/recover` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createRecover(...)` | `POST` | `/auth/recover` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().createResend(...)` | `POST` | `/auth/resend` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createResend(...)` | `POST` | `/auth/resend` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().createResend(...)` | `POST` | `/auth/resend` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createResend(...)` | `POST` | `/auth/resend` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().createSignup(...)` | `POST` | `/auth/signup` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createSignup(...)` | `POST` | `/auth/signup` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().createSignup(...)` | `POST` | `/auth/signup` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createSignup(...)` | `POST` | `/auth/signup` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().createSso(...)` | `POST` | `/auth/sso` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createSso(...)` | `POST` | `/auth/sso` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().createSso(...)` | `POST` | `/auth/sso` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createSso(...)` | `POST` | `/auth/sso` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().createTokenGrantTypeIdToken(...)` | `POST` | `/auth/token?grant_type=id_token` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createTokenGrantTypeIdToken(...)` | `POST` | `/auth/token?grant_type=id_token` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().createTokenGrantTypeIdToken(...)` | `POST` | `/auth/token?grant_type=id_token` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createTokenGrantTypeIdToken(...)` | `POST` | `/auth/token?grant_type=id_token` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().createTokenGrantTypePassword(...)` | `POST` | `/auth/token?grant_type=password` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createTokenGrantTypePassword(...)` | `POST` | `/auth/token?grant_type=password` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().createTokenGrantTypePassword(...)` | `POST` | `/auth/token?grant_type=password` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createTokenGrantTypePassword(...)` | `POST` | `/auth/token?grant_type=password` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().createTokenGrantTypePkce(...)` | `POST` | `/auth/token?grant_type=pkce` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createTokenGrantTypePkce(...)` | `POST` | `/auth/token?grant_type=pkce` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().createTokenGrantTypePkce(...)` | `POST` | `/auth/token?grant_type=pkce` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createTokenGrantTypePkce(...)` | `POST` | `/auth/token?grant_type=pkce` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().createTokenGrantTypeRefreshToken(...)` | `POST` | `/auth/token?grant_type=refresh_token` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createTokenGrantTypeRefreshToken(...)` | `POST` | `/auth/token?grant_type=refresh_token` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().createTokenGrantTypeRefreshToken(...)` | `POST` | `/auth/token?grant_type=refresh_token` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().createTokenGrantTypeRefreshToken(...)` | `POST` | `/auth/token?grant_type=refresh_token` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().verify(...)` | `POST` | `/auth/verify` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().verify(...)` | `POST` | `/auth/verify` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().verify(...)` | `POST` | `/auth/verify` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().verify(...)` | `POST` | `/auth/verify` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().updateUser(...)` | `PUT` | `/auth/user` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().updateUser(...)` | `PUT` | `/auth/user` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().updateUser(...)` | `PUT` | `/auth/user` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().updateUser(...)` | `PUT` | `/auth/user` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().account().deleteProfile(...)` | `DELETE` | `/auth/account/profile` | `QueryParams query, Class responseType` | `@Nullable T` | -| `auth().account().deleteProfile(...)` | `DELETE` | `/auth/account/profile` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().account().deleteProfile(...)` | `DELETE` | `/auth/account/profile` | `Class responseType` | `@Nullable T` | -| `auth().account().deleteProfile(...)` | `DELETE` | `/auth/account/profile` | `TypeReference responseType` | `@Nullable T` | -| `auth().account().getAuditLog(...)` | `GET` | `/auth/account/audit-log` | `QueryParams query, Class responseType` | `@Nullable T` | -| `auth().account().getAuditLog(...)` | `GET` | `/auth/account/audit-log` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().account().getAuditLog(...)` | `GET` | `/auth/account/audit-log` | `Class responseType` | `@Nullable T` | -| `auth().account().getAuditLog(...)` | `GET` | `/auth/account/audit-log` | `TypeReference responseType` | `@Nullable T` | -| `auth().account().getMfa(...)` | `GET` | `/auth/account/mfa` | `QueryParams query, Class responseType` | `@Nullable T` | -| `auth().account().getMfa(...)` | `GET` | `/auth/account/mfa` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().account().getMfa(...)` | `GET` | `/auth/account/mfa` | `Class responseType` | `@Nullable T` | -| `auth().account().getMfa(...)` | `GET` | `/auth/account/mfa` | `TypeReference responseType` | `@Nullable T` | -| `auth().account().getProfile(...)` | `GET` | `/auth/account/profile` | `QueryParams query, Class responseType` | `@Nullable T` | -| `auth().account().getProfile(...)` | `GET` | `/auth/account/profile` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().account().getProfile(...)` | `GET` | `/auth/account/profile` | `Class responseType` | `@Nullable T` | -| `auth().account().getProfile(...)` | `GET` | `/auth/account/profile` | `TypeReference responseType` | `@Nullable T` | -| `auth().account().createMfa(...)` | `POST` | `/auth/account/mfa` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().account().createMfa(...)` | `POST` | `/auth/account/mfa` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().account().createMfa(...)` | `POST` | `/auth/account/mfa` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().account().createMfa(...)` | `POST` | `/auth/account/mfa` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().account().createPassword(...)` | `POST` | `/auth/account/password` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().account().createPassword(...)` | `POST` | `/auth/account/password` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().account().createPassword(...)` | `POST` | `/auth/account/password` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().account().createPassword(...)` | `POST` | `/auth/account/password` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().account().updateProfile(...)` | `PUT` | `/auth/account/profile` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().account().updateProfile(...)` | `PUT` | `/auth/account/profile` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().account().updateProfile(...)` | `PUT` | `/auth/account/profile` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().account().updateProfile(...)` | `PUT` | `/auth/account/profile` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().admin().createGenerateLink(...)` | `POST` | `/auth/admin/generate_link` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().admin().createGenerateLink(...)` | `POST` | `/auth/admin/generate_link` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().admin().createGenerateLink(...)` | `POST` | `/auth/admin/generate_link` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().admin().createGenerateLink(...)` | `POST` | `/auth/admin/generate_link` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().admin().logout(...)` | `POST` | `/auth/admin/logout` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().admin().logout(...)` | `POST` | `/auth/admin/logout` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().admin().logout(...)` | `POST` | `/auth/admin/logout` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().admin().logout(...)` | `POST` | `/auth/admin/logout` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().auth().getSession(...)` | `GET` | `/auth/auth/session` | `QueryParams query, Class responseType` | `@Nullable T` | -| `auth().auth().getSession(...)` | `GET` | `/auth/auth/session` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().auth().getSession(...)` | `GET` | `/auth/auth/session` | `Class responseType` | `@Nullable T` | -| `auth().auth().getSession(...)` | `GET` | `/auth/auth/session` | `TypeReference responseType` | `@Nullable T` | -| `auth().auth().createSession(...)` | `POST` | `/auth/auth/session` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().auth().createSession(...)` | `POST` | `/auth/auth/session` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().auth().createSession(...)` | `POST` | `/auth/auth/session` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().auth().createSession(...)` | `POST` | `/auth/auth/session` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().factors().delete(...)` | `DELETE` | `/auth/factors/{param}` | `String factorId, QueryParams query, Class responseType` | `@Nullable T` | -| `auth().factors().delete(...)` | `DELETE` | `/auth/factors/{param}` | `String factorId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().factors().delete(...)` | `DELETE` | `/auth/factors/{param}` | `String factorId, Class responseType` | `@Nullable T` | -| `auth().factors().delete(...)` | `DELETE` | `/auth/factors/{param}` | `String factorId, TypeReference responseType` | `@Nullable T` | -| `auth().factors().list(...)` | `GET` | `/auth/factors` | `QueryParams query, Class responseType` | `@Nullable T` | -| `auth().factors().list(...)` | `GET` | `/auth/factors` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().factors().list(...)` | `GET` | `/auth/factors` | `Class responseType` | `@Nullable T` | -| `auth().factors().list(...)` | `GET` | `/auth/factors` | `TypeReference responseType` | `@Nullable T` | -| `auth().factors().create(...)` | `POST` | `/auth/factors` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().factors().create(...)` | `POST` | `/auth/factors` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().factors().create(...)` | `POST` | `/auth/factors` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().factors().create(...)` | `POST` | `/auth/factors` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().factors().createChallenge(...)` | `POST` | `/auth/factors/{param}/challenge` | `String factorId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().factors().createChallenge(...)` | `POST` | `/auth/factors/{param}/challenge` | `String factorId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().factors().createChallenge(...)` | `POST` | `/auth/factors/{param}/challenge` | `String factorId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().factors().createChallenge(...)` | `POST` | `/auth/factors/{param}/challenge` | `String factorId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().factors().verify(...)` | `POST` | `/auth/factors/{param}/verify` | `String factorId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().factors().verify(...)` | `POST` | `/auth/factors/{param}/verify` | `String factorId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().factors().verify(...)` | `POST` | `/auth/factors/{param}/verify` | `String factorId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().factors().verify(...)` | `POST` | `/auth/factors/{param}/verify` | `String factorId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().mfa().status(...)` | `GET` | `/auth/mfa/status` | `QueryParams query, Class responseType` | `@Nullable T` | -| `auth().mfa().status(...)` | `GET` | `/auth/mfa/status` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().mfa().status(...)` | `GET` | `/auth/mfa/status` | `Class responseType` | `@Nullable T` | -| `auth().mfa().status(...)` | `GET` | `/auth/mfa/status` | `TypeReference responseType` | `@Nullable T` | -| `auth().mfa().disable(...)` | `POST` | `/auth/mfa/disable` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().mfa().disable(...)` | `POST` | `/auth/mfa/disable` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().mfa().disable(...)` | `POST` | `/auth/mfa/disable` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().mfa().disable(...)` | `POST` | `/auth/mfa/disable` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().mfa().enable(...)` | `POST` | `/auth/mfa/enable` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().mfa().enable(...)` | `POST` | `/auth/mfa/enable` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().mfa().enable(...)` | `POST` | `/auth/mfa/enable` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().mfa().enable(...)` | `POST` | `/auth/mfa/enable` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().mfa().setup(...)` | `POST` | `/auth/mfa/setup` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().mfa().setup(...)` | `POST` | `/auth/mfa/setup` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().mfa().setup(...)` | `POST` | `/auth/mfa/setup` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().mfa().setup(...)` | `POST` | `/auth/mfa/setup` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().mfa().verify(...)` | `POST` | `/auth/mfa/verify` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().mfa().verify(...)` | `POST` | `/auth/mfa/verify` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().mfa().verify(...)` | `POST` | `/auth/mfa/verify` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().mfa().verify(...)` | `POST` | `/auth/mfa/verify` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().account().mfa().delete(...)` | `DELETE` | `/auth/account/mfa/{param}` | `String mfaId, QueryParams query, Class responseType` | `@Nullable T` | -| `auth().account().mfa().delete(...)` | `DELETE` | `/auth/account/mfa/{param}` | `String mfaId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().account().mfa().delete(...)` | `DELETE` | `/auth/account/mfa/{param}` | `String mfaId, Class responseType` | `@Nullable T` | -| `auth().account().mfa().delete(...)` | `DELETE` | `/auth/account/mfa/{param}` | `String mfaId, TypeReference responseType` | `@Nullable T` | -| `auth().account().mfa().get(...)` | `GET` | `/auth/account/mfa/{param}` | `String mfaId, QueryParams query, Class responseType` | `@Nullable T` | -| `auth().account().mfa().get(...)` | `GET` | `/auth/account/mfa/{param}` | `String mfaId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().account().mfa().get(...)` | `GET` | `/auth/account/mfa/{param}` | `String mfaId, Class responseType` | `@Nullable T` | -| `auth().account().mfa().get(...)` | `GET` | `/auth/account/mfa/{param}` | `String mfaId, TypeReference responseType` | `@Nullable T` | -| `auth().account().mfa().createChallenge(...)` | `POST` | `/auth/account/mfa/{param}/challenge` | `String mfaId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().account().mfa().createChallenge(...)` | `POST` | `/auth/account/mfa/{param}/challenge` | `String mfaId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().account().mfa().createChallenge(...)` | `POST` | `/auth/account/mfa/{param}/challenge` | `String mfaId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().account().mfa().createChallenge(...)` | `POST` | `/auth/account/mfa/{param}/challenge` | `String mfaId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().account().mfa().verify(...)` | `POST` | `/auth/account/mfa/{param}/verify` | `String mfaId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().account().mfa().verify(...)` | `POST` | `/auth/account/mfa/{param}/verify` | `String mfaId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().account().mfa().verify(...)` | `POST` | `/auth/account/mfa/{param}/verify` | `String mfaId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().account().mfa().verify(...)` | `POST` | `/auth/account/mfa/{param}/verify` | `String mfaId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().account().sessions().delete(...)` | `DELETE` | `/auth/account/sessions/{param}` | `String sessionId, QueryParams query, Class responseType` | `@Nullable T` | -| `auth().account().sessions().delete(...)` | `DELETE` | `/auth/account/sessions/{param}` | `String sessionId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().account().sessions().delete(...)` | `DELETE` | `/auth/account/sessions/{param}` | `String sessionId, Class responseType` | `@Nullable T` | -| `auth().account().sessions().delete(...)` | `DELETE` | `/auth/account/sessions/{param}` | `String sessionId, TypeReference responseType` | `@Nullable T` | -| `auth().account().sessions().list(...)` | `GET` | `/auth/account/sessions` | `QueryParams query, Class responseType` | `@Nullable T` | -| `auth().account().sessions().list(...)` | `GET` | `/auth/account/sessions` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().account().sessions().list(...)` | `GET` | `/auth/account/sessions` | `Class responseType` | `@Nullable T` | -| `auth().account().sessions().list(...)` | `GET` | `/auth/account/sessions` | `TypeReference responseType` | `@Nullable T` | -| `auth().account().sessions().extend(...)` | `POST` | `/auth/account/sessions/{param}/extend` | `String sessionId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().account().sessions().extend(...)` | `POST` | `/auth/account/sessions/{param}/extend` | `String sessionId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().account().sessions().extend(...)` | `POST` | `/auth/account/sessions/{param}/extend` | `String sessionId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().account().sessions().extend(...)` | `POST` | `/auth/account/sessions/{param}/extend` | `String sessionId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().admin().users().delete(...)` | `DELETE` | `/auth/admin/users/{param}` | `String userId, QueryParams query, Class responseType` | `@Nullable T` | -| `auth().admin().users().delete(...)` | `DELETE` | `/auth/admin/users/{param}` | `String userId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().admin().users().delete(...)` | `DELETE` | `/auth/admin/users/{param}` | `String userId, Class responseType` | `@Nullable T` | -| `auth().admin().users().delete(...)` | `DELETE` | `/auth/admin/users/{param}` | `String userId, TypeReference responseType` | `@Nullable T` | -| `auth().admin().users().list(...)` | `GET` | `/auth/admin/users` | `QueryParams query, Class responseType` | `@Nullable T` | -| `auth().admin().users().list(...)` | `GET` | `/auth/admin/users` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().admin().users().list(...)` | `GET` | `/auth/admin/users` | `Class responseType` | `@Nullable T` | -| `auth().admin().users().list(...)` | `GET` | `/auth/admin/users` | `TypeReference responseType` | `@Nullable T` | -| `auth().admin().users().get(...)` | `GET` | `/auth/admin/users/{param}` | `String userId, QueryParams query, Class responseType` | `@Nullable T` | -| `auth().admin().users().get(...)` | `GET` | `/auth/admin/users/{param}` | `String userId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().admin().users().get(...)` | `GET` | `/auth/admin/users/{param}` | `String userId, Class responseType` | `@Nullable T` | -| `auth().admin().users().get(...)` | `GET` | `/auth/admin/users/{param}` | `String userId, TypeReference responseType` | `@Nullable T` | -| `auth().admin().users().create(...)` | `POST` | `/auth/admin/users` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().admin().users().create(...)` | `POST` | `/auth/admin/users` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().admin().users().create(...)` | `POST` | `/auth/admin/users` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().admin().users().create(...)` | `POST` | `/auth/admin/users` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().admin().users().update(...)` | `PUT` | `/auth/admin/users/{param}` | `String userId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().admin().users().update(...)` | `PUT` | `/auth/admin/users/{param}` | `String userId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().admin().users().update(...)` | `PUT` | `/auth/admin/users/{param}` | `String userId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().admin().users().update(...)` | `PUT` | `/auth/admin/users/{param}` | `String userId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().mfa().backupCodes().createRegenerate(...)` | `POST` | `/auth/mfa/backup-codes/regenerate` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().mfa().backupCodes().createRegenerate(...)` | `POST` | `/auth/mfa/backup-codes/regenerate` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().mfa().backupCodes().createRegenerate(...)` | `POST` | `/auth/mfa/backup-codes/regenerate` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().mfa().backupCodes().createRegenerate(...)` | `POST` | `/auth/mfa/backup-codes/regenerate` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().user().identities().delete(...)` | `DELETE` | `/auth/user/identities/{param}` | `String identityId, QueryParams query, Class responseType` | `@Nullable T` | -| `auth().user().identities().delete(...)` | `DELETE` | `/auth/user/identities/{param}` | `String identityId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().user().identities().delete(...)` | `DELETE` | `/auth/user/identities/{param}` | `String identityId, Class responseType` | `@Nullable T` | -| `auth().user().identities().delete(...)` | `DELETE` | `/auth/user/identities/{param}` | `String identityId, TypeReference responseType` | `@Nullable T` | -| `auth().user().identities().list(...)` | `GET` | `/auth/user/identities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `auth().user().identities().list(...)` | `GET` | `/auth/user/identities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().user().identities().list(...)` | `GET` | `/auth/user/identities` | `Class responseType` | `@Nullable T` | -| `auth().user().identities().list(...)` | `GET` | `/auth/user/identities` | `TypeReference responseType` | `@Nullable T` | -| `auth().user().identities().create(...)` | `POST` | `/auth/user/identities` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().user().identities().create(...)` | `POST` | `/auth/user/identities` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().user().identities().create(...)` | `POST` | `/auth/user/identities` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().user().identities().create(...)` | `POST` | `/auth/user/identities` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().account().security().apiKeys().delete(...)` | `DELETE` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, QueryParams query, Class responseType` | `@Nullable T` | -| `auth().account().security().apiKeys().delete(...)` | `DELETE` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().account().security().apiKeys().delete(...)` | `DELETE` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, Class responseType` | `@Nullable T` | -| `auth().account().security().apiKeys().delete(...)` | `DELETE` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, TypeReference responseType` | `@Nullable T` | -| `auth().account().security().apiKeys().list(...)` | `GET` | `/auth/account/security/api-keys` | `QueryParams query, Class responseType` | `@Nullable T` | -| `auth().account().security().apiKeys().list(...)` | `GET` | `/auth/account/security/api-keys` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().account().security().apiKeys().list(...)` | `GET` | `/auth/account/security/api-keys` | `Class responseType` | `@Nullable T` | -| `auth().account().security().apiKeys().list(...)` | `GET` | `/auth/account/security/api-keys` | `TypeReference responseType` | `@Nullable T` | -| `auth().account().security().apiKeys().get(...)` | `GET` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, QueryParams query, Class responseType` | `@Nullable T` | -| `auth().account().security().apiKeys().get(...)` | `GET` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().account().security().apiKeys().get(...)` | `GET` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, Class responseType` | `@Nullable T` | -| `auth().account().security().apiKeys().get(...)` | `GET` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, TypeReference responseType` | `@Nullable T` | -| `auth().account().security().apiKeys().create(...)` | `POST` | `/auth/account/security/api-keys` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().account().security().apiKeys().create(...)` | `POST` | `/auth/account/security/api-keys` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().account().security().apiKeys().create(...)` | `POST` | `/auth/account/security/api-keys` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().account().security().apiKeys().create(...)` | `POST` | `/auth/account/security/api-keys` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().account().security().apiKeys().update(...)` | `PUT` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().account().security().apiKeys().update(...)` | `PUT` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().account().security().apiKeys().update(...)` | `PUT` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().account().security().apiKeys().update(...)` | `PUT` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().account().security().devices().delete(...)` | `DELETE` | `/auth/account/security/devices/{param}` | `String deviceId, QueryParams query, Class responseType` | `@Nullable T` | -| `auth().account().security().devices().delete(...)` | `DELETE` | `/auth/account/security/devices/{param}` | `String deviceId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().account().security().devices().delete(...)` | `DELETE` | `/auth/account/security/devices/{param}` | `String deviceId, Class responseType` | `@Nullable T` | -| `auth().account().security().devices().delete(...)` | `DELETE` | `/auth/account/security/devices/{param}` | `String deviceId, TypeReference responseType` | `@Nullable T` | -| `auth().account().security().devices().list(...)` | `GET` | `/auth/account/security/devices` | `QueryParams query, Class responseType` | `@Nullable T` | -| `auth().account().security().devices().list(...)` | `GET` | `/auth/account/security/devices` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().account().security().devices().list(...)` | `GET` | `/auth/account/security/devices` | `Class responseType` | `@Nullable T` | -| `auth().account().security().devices().list(...)` | `GET` | `/auth/account/security/devices` | `TypeReference responseType` | `@Nullable T` | -| `auth().account().security().devices().get(...)` | `GET` | `/auth/account/security/devices/{param}` | `String deviceId, QueryParams query, Class responseType` | `@Nullable T` | -| `auth().account().security().devices().get(...)` | `GET` | `/auth/account/security/devices/{param}` | `String deviceId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().account().security().devices().get(...)` | `GET` | `/auth/account/security/devices/{param}` | `String deviceId, Class responseType` | `@Nullable T` | -| `auth().account().security().devices().get(...)` | `GET` | `/auth/account/security/devices/{param}` | `String deviceId, TypeReference responseType` | `@Nullable T` | -| `auth().account().security().devices().create(...)` | `POST` | `/auth/account/security/devices` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().account().security().devices().create(...)` | `POST` | `/auth/account/security/devices` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().account().security().devices().create(...)` | `POST` | `/auth/account/security/devices` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().account().security().devices().create(...)` | `POST` | `/auth/account/security/devices` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().account().security().devices().trust(...)` | `POST` | `/auth/account/security/devices/{param}/trust` | `String deviceId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().account().security().devices().trust(...)` | `POST` | `/auth/account/security/devices/{param}/trust` | `String deviceId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().account().security().devices().trust(...)` | `POST` | `/auth/account/security/devices/{param}/trust` | `String deviceId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `auth().account().security().devices().trust(...)` | `POST` | `/auth/account/security/devices/{param}/trust` | `String deviceId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `auth().admin().users().factors().delete(...)` | `DELETE` | `/auth/admin/users/{param}/factors/{param}` | `String userId, String factorId, QueryParams query, Class responseType` | `@Nullable T` | -| `auth().admin().users().factors().delete(...)` | `DELETE` | `/auth/admin/users/{param}/factors/{param}` | `String userId, String factorId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().admin().users().factors().delete(...)` | `DELETE` | `/auth/admin/users/{param}/factors/{param}` | `String userId, String factorId, Class responseType` | `@Nullable T` | -| `auth().admin().users().factors().delete(...)` | `DELETE` | `/auth/admin/users/{param}/factors/{param}` | `String userId, String factorId, TypeReference responseType` | `@Nullable T` | -| `auth().admin().users().factors().list(...)` | `GET` | `/auth/admin/users/{param}/factors` | `String userId, QueryParams query, Class responseType` | `@Nullable T` | -| `auth().admin().users().factors().list(...)` | `GET` | `/auth/admin/users/{param}/factors` | `String userId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `auth().admin().users().factors().list(...)` | `GET` | `/auth/admin/users/{param}/factors` | `String userId, Class responseType` | `@Nullable T` | -| `auth().admin().users().factors().list(...)` | `GET` | `/auth/admin/users/{param}/factors` | `String userId, TypeReference responseType` | `@Nullable T` | - -The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/billing.md b/docs/api/billing.md deleted file mode 100644 index c9b8b06..0000000 --- a/docs/api/billing.md +++ /dev/null @@ -1,102 +0,0 @@ -# Billing API - -Service accessor: `frontal.billing()` (`BillingClient`). - -Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. - -| Method | HTTP | Route | Parameters | Response | -| --- | --- | --- | --- | --- | -| `billing().customers().usage(...)` | `GET` | `/billing/customers/{param}/usage` | `String customerId, QueryParams query, Class responseType` | `@Nullable T` | -| `billing().customers().usage(...)` | `GET` | `/billing/customers/{param}/usage` | `String customerId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `billing().customers().usage(...)` | `GET` | `/billing/customers/{param}/usage` | `String customerId, Class responseType` | `@Nullable T` | -| `billing().customers().usage(...)` | `GET` | `/billing/customers/{param}/usage` | `String customerId, TypeReference responseType` | `@Nullable T` | -| `billing().invoices().getPdf(...)` | `GETRAW` | `/billing/invoices/{param}/pdf` | `String invoiceId, QueryParams query, Class responseType` | `@Nullable T` | -| `billing().invoices().getPdf(...)` | `GETRAW` | `/billing/invoices/{param}/pdf` | `String invoiceId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `billing().invoices().getPdf(...)` | `GETRAW` | `/billing/invoices/{param}/pdf` | `String invoiceId, Class responseType` | `@Nullable T` | -| `billing().invoices().getPdf(...)` | `GETRAW` | `/billing/invoices/{param}/pdf` | `String invoiceId, TypeReference responseType` | `@Nullable T` | -| `billing().invoices().preview(...)` | `POST` | `/billing/invoices/preview` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `billing().invoices().preview(...)` | `POST` | `/billing/invoices/preview` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `billing().invoices().preview(...)` | `POST` | `/billing/invoices/preview` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `billing().invoices().preview(...)` | `POST` | `/billing/invoices/preview` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `billing().invoices().finalize(...)` | `POST` | `/billing/invoices/{param}/finalize` | `String invoiceId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `billing().invoices().finalize(...)` | `POST` | `/billing/invoices/{param}/finalize` | `String invoiceId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `billing().invoices().finalize(...)` | `POST` | `/billing/invoices/{param}/finalize` | `String invoiceId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `billing().invoices().finalize(...)` | `POST` | `/billing/invoices/{param}/finalize` | `String invoiceId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `billing().invoices().resourceVoid(...)` | `POST` | `/billing/invoices/{param}/void` | `String invoiceId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `billing().invoices().resourceVoid(...)` | `POST` | `/billing/invoices/{param}/void` | `String invoiceId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `billing().invoices().resourceVoid(...)` | `POST` | `/billing/invoices/{param}/void` | `String invoiceId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `billing().invoices().resourceVoid(...)` | `POST` | `/billing/invoices/{param}/void` | `String invoiceId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `billing().meters().disable(...)` | `POST` | `/billing/meters/{param}/disable` | `String meterId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `billing().meters().disable(...)` | `POST` | `/billing/meters/{param}/disable` | `String meterId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `billing().meters().disable(...)` | `POST` | `/billing/meters/{param}/disable` | `String meterId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `billing().meters().disable(...)` | `POST` | `/billing/meters/{param}/disable` | `String meterId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `billing().plans().clone(...)` | `POST` | `/billing/plans/{param}/clone` | `String planId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `billing().plans().clone(...)` | `POST` | `/billing/plans/{param}/clone` | `String planId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `billing().plans().clone(...)` | `POST` | `/billing/plans/{param}/clone` | `String planId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `billing().plans().clone(...)` | `POST` | `/billing/plans/{param}/clone` | `String planId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `billing().subscriptions().activate(...)` | `POST` | `/billing/subscriptions/{param}/activate` | `String subscriptionId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `billing().subscriptions().activate(...)` | `POST` | `/billing/subscriptions/{param}/activate` | `String subscriptionId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `billing().subscriptions().activate(...)` | `POST` | `/billing/subscriptions/{param}/activate` | `String subscriptionId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `billing().subscriptions().activate(...)` | `POST` | `/billing/subscriptions/{param}/activate` | `String subscriptionId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `billing().subscriptions().cancel(...)` | `POST` | `/billing/subscriptions/{param}/cancel` | `String subscriptionId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `billing().subscriptions().cancel(...)` | `POST` | `/billing/subscriptions/{param}/cancel` | `String subscriptionId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `billing().subscriptions().cancel(...)` | `POST` | `/billing/subscriptions/{param}/cancel` | `String subscriptionId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `billing().subscriptions().cancel(...)` | `POST` | `/billing/subscriptions/{param}/cancel` | `String subscriptionId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `billing().subscriptions().pause(...)` | `POST` | `/billing/subscriptions/{param}/pause` | `String subscriptionId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `billing().subscriptions().pause(...)` | `POST` | `/billing/subscriptions/{param}/pause` | `String subscriptionId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `billing().subscriptions().pause(...)` | `POST` | `/billing/subscriptions/{param}/pause` | `String subscriptionId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `billing().subscriptions().pause(...)` | `POST` | `/billing/subscriptions/{param}/pause` | `String subscriptionId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `billing().subscriptions().resume(...)` | `POST` | `/billing/subscriptions/{param}/resume` | `String subscriptionId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `billing().subscriptions().resume(...)` | `POST` | `/billing/subscriptions/{param}/resume` | `String subscriptionId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `billing().subscriptions().resume(...)` | `POST` | `/billing/subscriptions/{param}/resume` | `String subscriptionId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `billing().subscriptions().resume(...)` | `POST` | `/billing/subscriptions/{param}/resume` | `String subscriptionId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `billing().wallets().createTerminate(...)` | `POST` | `/billing/wallets/{param}/terminate` | `String walletId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `billing().wallets().createTerminate(...)` | `POST` | `/billing/wallets/{param}/terminate` | `String walletId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `billing().wallets().createTerminate(...)` | `POST` | `/billing/wallets/{param}/terminate` | `String walletId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `billing().wallets().createTerminate(...)` | `POST` | `/billing/wallets/{param}/terminate` | `String walletId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `billing().wallets().topUp(...)` | `POST` | `/billing/wallets/{param}/top-up` | `String walletId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `billing().wallets().topUp(...)` | `POST` | `/billing/wallets/{param}/top-up` | `String walletId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `billing().wallets().topUp(...)` | `POST` | `/billing/wallets/{param}/top-up` | `String walletId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `billing().wallets().topUp(...)` | `POST` | `/billing/wallets/{param}/top-up` | `String walletId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `billing().addons().entitlements().list(...)` | `GET` | `/billing/addons/{param}/entitlements` | `String addonId, QueryParams query, Class responseType` | `@Nullable T` | -| `billing().addons().entitlements().list(...)` | `GET` | `/billing/addons/{param}/entitlements` | `String addonId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `billing().addons().entitlements().list(...)` | `GET` | `/billing/addons/{param}/entitlements` | `String addonId, Class responseType` | `@Nullable T` | -| `billing().addons().entitlements().list(...)` | `GET` | `/billing/addons/{param}/entitlements` | `String addonId, TypeReference responseType` | `@Nullable T` | -| `billing().customers().entitlements().list(...)` | `GET` | `/billing/customers/{param}/entitlements` | `String customerId, QueryParams query, Class responseType` | `@Nullable T` | -| `billing().customers().entitlements().list(...)` | `GET` | `/billing/customers/{param}/entitlements` | `String customerId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `billing().customers().entitlements().list(...)` | `GET` | `/billing/customers/{param}/entitlements` | `String customerId, Class responseType` | `@Nullable T` | -| `billing().customers().entitlements().list(...)` | `GET` | `/billing/customers/{param}/entitlements` | `String customerId, TypeReference responseType` | `@Nullable T` | -| `billing().customers().invoices().summary(...)` | `GET` | `/billing/customers/{param}/invoices/summary` | `String customerId, QueryParams query, Class responseType` | `@Nullable T` | -| `billing().customers().invoices().summary(...)` | `GET` | `/billing/customers/{param}/invoices/summary` | `String customerId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `billing().customers().invoices().summary(...)` | `GET` | `/billing/customers/{param}/invoices/summary` | `String customerId, Class responseType` | `@Nullable T` | -| `billing().customers().invoices().summary(...)` | `GET` | `/billing/customers/{param}/invoices/summary` | `String customerId, TypeReference responseType` | `@Nullable T` | -| `billing().customers().portal().get(...)` | `GET` | `/billing/customers/portal/{param}` | `String portalId, QueryParams query, Class responseType` | `@Nullable T` | -| `billing().customers().portal().get(...)` | `GET` | `/billing/customers/portal/{param}` | `String portalId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `billing().customers().portal().get(...)` | `GET` | `/billing/customers/portal/{param}` | `String portalId, Class responseType` | `@Nullable T` | -| `billing().customers().portal().get(...)` | `GET` | `/billing/customers/portal/{param}` | `String portalId, TypeReference responseType` | `@Nullable T` | -| `billing().customers().wallets().list(...)` | `GET` | `/billing/customers/{param}/wallets` | `String customerId, QueryParams query, Class responseType` | `@Nullable T` | -| `billing().customers().wallets().list(...)` | `GET` | `/billing/customers/{param}/wallets` | `String customerId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `billing().customers().wallets().list(...)` | `GET` | `/billing/customers/{param}/wallets` | `String customerId, Class responseType` | `@Nullable T` | -| `billing().customers().wallets().list(...)` | `GET` | `/billing/customers/{param}/wallets` | `String customerId, TypeReference responseType` | `@Nullable T` | -| `billing().plans().entitlements().list(...)` | `GET` | `/billing/plans/{param}/entitlements` | `String planId, QueryParams query, Class responseType` | `@Nullable T` | -| `billing().plans().entitlements().list(...)` | `GET` | `/billing/plans/{param}/entitlements` | `String planId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `billing().plans().entitlements().list(...)` | `GET` | `/billing/plans/{param}/entitlements` | `String planId, Class responseType` | `@Nullable T` | -| `billing().plans().entitlements().list(...)` | `GET` | `/billing/plans/{param}/entitlements` | `String planId, TypeReference responseType` | `@Nullable T` | -| `billing().prices().lookup().get(...)` | `GET` | `/billing/prices/lookup/{param}` | `String lookupId, QueryParams query, Class responseType` | `@Nullable T` | -| `billing().prices().lookup().get(...)` | `GET` | `/billing/prices/lookup/{param}` | `String lookupId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `billing().prices().lookup().get(...)` | `GET` | `/billing/prices/lookup/{param}` | `String lookupId, Class responseType` | `@Nullable T` | -| `billing().prices().lookup().get(...)` | `GET` | `/billing/prices/lookup/{param}` | `String lookupId, TypeReference responseType` | `@Nullable T` | -| `billing().subscriptions().entitlements().list(...)` | `GET` | `/billing/subscriptions/{param}/entitlements` | `String subscriptionId, QueryParams query, Class responseType` | `@Nullable T` | -| `billing().subscriptions().entitlements().list(...)` | `GET` | `/billing/subscriptions/{param}/entitlements` | `String subscriptionId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `billing().subscriptions().entitlements().list(...)` | `GET` | `/billing/subscriptions/{param}/entitlements` | `String subscriptionId, Class responseType` | `@Nullable T` | -| `billing().subscriptions().entitlements().list(...)` | `GET` | `/billing/subscriptions/{param}/entitlements` | `String subscriptionId, TypeReference responseType` | `@Nullable T` | -| `billing().wallets().balance().getRealTime(...)` | `GET` | `/billing/wallets/{param}/balance/real-time` | `String walletId, QueryParams query, Class responseType` | `@Nullable T` | -| `billing().wallets().balance().getRealTime(...)` | `GET` | `/billing/wallets/{param}/balance/real-time` | `String walletId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `billing().wallets().balance().getRealTime(...)` | `GET` | `/billing/wallets/{param}/balance/real-time` | `String walletId, Class responseType` | `@Nullable T` | -| `billing().wallets().balance().getRealTime(...)` | `GET` | `/billing/wallets/{param}/balance/real-time` | `String walletId, TypeReference responseType` | `@Nullable T` | -| `billing().wallets().transactions().list(...)` | `GET` | `/billing/wallets/{param}/transactions` | `String walletId, QueryParams query, Class responseType` | `@Nullable T` | -| `billing().wallets().transactions().list(...)` | `GET` | `/billing/wallets/{param}/transactions` | `String walletId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `billing().wallets().transactions().list(...)` | `GET` | `/billing/wallets/{param}/transactions` | `String walletId, Class responseType` | `@Nullable T` | -| `billing().wallets().transactions().list(...)` | `GET` | `/billing/wallets/{param}/transactions` | `String walletId, TypeReference responseType` | `@Nullable T` | - -The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/blob.md b/docs/api/blob.md deleted file mode 100644 index 17251f0..0000000 --- a/docs/api/blob.md +++ /dev/null @@ -1,42 +0,0 @@ -# Blob API - -Service accessor: `frontal.blob()` (`BlobClient`). - -Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. - -| Method | HTTP | Route | Parameters | Response | -| --- | --- | --- | --- | --- | -| `blob().object().delete(...)` | `DELETE` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, QueryParams query, Class responseType` | `@Nullable T` | -| `blob().object().delete(...)` | `DELETE` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `blob().object().delete(...)` | `DELETE` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, Class responseType` | `@Nullable T` | -| `blob().object().delete(...)` | `DELETE` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, TypeReference responseType` | `@Nullable T` | -| `blob().object().get(...)` | `GET` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, QueryParams query, Class responseType` | `@Nullable T` | -| `blob().object().get(...)` | `GET` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `blob().object().get(...)` | `GET` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, Class responseType` | `@Nullable T` | -| `blob().object().get(...)` | `GET` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, TypeReference responseType` | `@Nullable T` | -| `blob().object().copy(...)` | `POST` | `/blob/object/copy` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `blob().object().copy(...)` | `POST` | `/blob/object/copy` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `blob().object().copy(...)` | `POST` | `/blob/object/copy` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `blob().object().copy(...)` | `POST` | `/blob/object/copy` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `blob().object().move(...)` | `POST` | `/blob/object/move` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `blob().object().move(...)` | `POST` | `/blob/object/move` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `blob().object().move(...)` | `POST` | `/blob/object/move` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `blob().object().move(...)` | `POST` | `/blob/object/move` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `blob().object().get2(...)` | `POSTFORMDATA` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, QueryParams query, Map fields, Map files, Class responseType` | `@Nullable T` | -| `blob().object().get2(...)` | `POSTFORMDATA` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, QueryParams query, Map fields, Map files, TypeReference responseType` | `@Nullable T` | -| `blob().object().get2(...)` | `POSTFORMDATA` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, Map fields, Map files, Class responseType` | `@Nullable T` | -| `blob().object().get2(...)` | `POSTFORMDATA` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, Map fields, Map files, TypeReference responseType` | `@Nullable T` | -| `blob().object().info().get(...)` | `GET` | `/blob/object/info/{param}/{param}` | `String infoId, String infoId2, QueryParams query, Class responseType` | `@Nullable T` | -| `blob().object().info().get(...)` | `GET` | `/blob/object/info/{param}/{param}` | `String infoId, String infoId2, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `blob().object().info().get(...)` | `GET` | `/blob/object/info/{param}/{param}` | `String infoId, String infoId2, Class responseType` | `@Nullable T` | -| `blob().object().info().get(...)` | `GET` | `/blob/object/info/{param}/{param}` | `String infoId, String infoId2, TypeReference responseType` | `@Nullable T` | -| `blob().object().list().get(...)` | `POST` | `/blob/object/list/{param}` | `String listId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `blob().object().list().get(...)` | `POST` | `/blob/object/list/{param}` | `String listId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `blob().object().list().get(...)` | `POST` | `/blob/object/list/{param}` | `String listId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `blob().object().list().get(...)` | `POST` | `/blob/object/list/{param}` | `String listId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `blob().object().sign().get(...)` | `POST` | `/blob/object/sign/{param}/{param}` | `String signId, String signId2, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `blob().object().sign().get(...)` | `POST` | `/blob/object/sign/{param}/{param}` | `String signId, String signId2, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `blob().object().sign().get(...)` | `POST` | `/blob/object/sign/{param}/{param}` | `String signId, String signId2, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `blob().object().sign().get(...)` | `POST` | `/blob/object/sign/{param}/{param}` | `String signId, String signId2, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | - -The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/connection-tests.md b/docs/api/connection-tests.md deleted file mode 100644 index f5fd7a1..0000000 --- a/docs/api/connection-tests.md +++ /dev/null @@ -1,14 +0,0 @@ -# ConnectionTests API - -Service accessor: `frontal.connectionTests()` (`ConnectionTestsClient`). - -Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. - -| Method | HTTP | Route | Parameters | Response | -| --- | --- | --- | --- | --- | -| `connectionTests().get(...)` | `GET` | `/connection-tests/{param}` | `String connectionTestId, QueryParams query, Class responseType` | `@Nullable T` | -| `connectionTests().get(...)` | `GET` | `/connection-tests/{param}` | `String connectionTestId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `connectionTests().get(...)` | `GET` | `/connection-tests/{param}` | `String connectionTestId, Class responseType` | `@Nullable T` | -| `connectionTests().get(...)` | `GET` | `/connection-tests/{param}` | `String connectionTestId, TypeReference responseType` | `@Nullable T` | - -The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/connectors.md b/docs/api/connectors.md deleted file mode 100644 index d640857..0000000 --- a/docs/api/connectors.md +++ /dev/null @@ -1,58 +0,0 @@ -# Connectors API - -Service accessor: `frontal.connectors()` (`ConnectorsClient`). - -Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. - -| Method | HTTP | Route | Parameters | Response | -| --- | --- | --- | --- | --- | -| `connectors().getCatalog(...)` | `GET` | `/connectors/catalog` | `QueryParams query, Class responseType` | `@Nullable T` | -| `connectors().getCatalog(...)` | `GET` | `/connectors/catalog` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `connectors().getCatalog(...)` | `GET` | `/connectors/catalog` | `Class responseType` | `@Nullable T` | -| `connectors().getCatalog(...)` | `GET` | `/connectors/catalog` | `TypeReference responseType` | `@Nullable T` | -| `connectors().catalog().get(...)` | `GET` | `/connectors/catalog/{param}` | `String catalogId, QueryParams query, Class responseType` | `@Nullable T` | -| `connectors().catalog().get(...)` | `GET` | `/connectors/catalog/{param}` | `String catalogId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `connectors().catalog().get(...)` | `GET` | `/connectors/catalog/{param}` | `String catalogId, Class responseType` | `@Nullable T` | -| `connectors().catalog().get(...)` | `GET` | `/connectors/catalog/{param}` | `String catalogId, TypeReference responseType` | `@Nullable T` | -| `connectors().connectionTests().get(...)` | `GET` | `/connectors/connection-tests/{param}` | `String connectionTestId, QueryParams query, Class responseType` | `@Nullable T` | -| `connectors().connectionTests().get(...)` | `GET` | `/connectors/connection-tests/{param}` | `String connectionTestId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `connectors().connectionTests().get(...)` | `GET` | `/connectors/connection-tests/{param}` | `String connectionTestId, Class responseType` | `@Nullable T` | -| `connectors().connectionTests().get(...)` | `GET` | `/connectors/connection-tests/{param}` | `String connectionTestId, TypeReference responseType` | `@Nullable T` | -| `connectors().diagnostics().list(...)` | `GET` | `/diagnostics` | `QueryParams query, Class responseType` | `@Nullable T` | -| `connectors().diagnostics().list(...)` | `GET` | `/diagnostics` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `connectors().diagnostics().list(...)` | `GET` | `/diagnostics` | `Class responseType` | `@Nullable T` | -| `connectors().diagnostics().list(...)` | `GET` | `/diagnostics` | `TypeReference responseType` | `@Nullable T` | -| `connectors().installations().delete(...)` | `DELETE` | `/connectors/installations/{param}` | `String installationId, QueryParams query, Class responseType` | `@Nullable T` | -| `connectors().installations().delete(...)` | `DELETE` | `/connectors/installations/{param}` | `String installationId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `connectors().installations().delete(...)` | `DELETE` | `/connectors/installations/{param}` | `String installationId, Class responseType` | `@Nullable T` | -| `connectors().installations().delete(...)` | `DELETE` | `/connectors/installations/{param}` | `String installationId, TypeReference responseType` | `@Nullable T` | -| `connectors().installations().list(...)` | `GET` | `/connectors/installations` | `QueryParams query, Class responseType` | `@Nullable T` | -| `connectors().installations().list(...)` | `GET` | `/connectors/installations` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `connectors().installations().list(...)` | `GET` | `/connectors/installations` | `Class responseType` | `@Nullable T` | -| `connectors().installations().list(...)` | `GET` | `/connectors/installations` | `TypeReference responseType` | `@Nullable T` | -| `connectors().installations().get(...)` | `GET` | `/connectors/installations/{param}` | `String installationId, QueryParams query, Class responseType` | `@Nullable T` | -| `connectors().installations().get(...)` | `GET` | `/connectors/installations/{param}` | `String installationId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `connectors().installations().get(...)` | `GET` | `/connectors/installations/{param}` | `String installationId, Class responseType` | `@Nullable T` | -| `connectors().installations().get(...)` | `GET` | `/connectors/installations/{param}` | `String installationId, TypeReference responseType` | `@Nullable T` | -| `connectors().installations().update(...)` | `PATCH` | `/connectors/installations/{param}` | `String installationId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `connectors().installations().update(...)` | `PATCH` | `/connectors/installations/{param}` | `String installationId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `connectors().installations().update(...)` | `PATCH` | `/connectors/installations/{param}` | `String installationId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `connectors().installations().update(...)` | `PATCH` | `/connectors/installations/{param}` | `String installationId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `connectors().installations().create(...)` | `POST` | `/connectors/installations` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `connectors().installations().create(...)` | `POST` | `/connectors/installations` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `connectors().installations().create(...)` | `POST` | `/connectors/installations` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `connectors().installations().create(...)` | `POST` | `/connectors/installations` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `connectors().installations().pause(...)` | `POST` | `/connectors/installations/{param}/pause` | `String installationId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `connectors().installations().pause(...)` | `POST` | `/connectors/installations/{param}/pause` | `String installationId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `connectors().installations().pause(...)` | `POST` | `/connectors/installations/{param}/pause` | `String installationId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `connectors().installations().pause(...)` | `POST` | `/connectors/installations/{param}/pause` | `String installationId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `connectors().installations().resume(...)` | `POST` | `/connectors/installations/{param}/resume` | `String installationId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `connectors().installations().resume(...)` | `POST` | `/connectors/installations/{param}/resume` | `String installationId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `connectors().installations().resume(...)` | `POST` | `/connectors/installations/{param}/resume` | `String installationId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `connectors().installations().resume(...)` | `POST` | `/connectors/installations/{param}/resume` | `String installationId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `connectors().syncRuns().replay(...)` | `POST` | `/connectors/sync-runs/{param}/replay` | `String syncRunId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `connectors().syncRuns().replay(...)` | `POST` | `/connectors/sync-runs/{param}/replay` | `String syncRunId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `connectors().syncRuns().replay(...)` | `POST` | `/connectors/sync-runs/{param}/replay` | `String syncRunId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `connectors().syncRuns().replay(...)` | `POST` | `/connectors/sync-runs/{param}/replay` | `String syncRunId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | - -The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/data.md b/docs/api/data.md deleted file mode 100644 index c3a2e49..0000000 --- a/docs/api/data.md +++ /dev/null @@ -1,614 +0,0 @@ -# Data API - -Service accessor: `frontal.data()` (`DataClient`). - -Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. - -| Method | HTTP | Route | Parameters | Response | -| --- | --- | --- | --- | --- | -| `data().aggregations().health(...)` | `GET` | `/data/aggregations/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().aggregations().health(...)` | `GET` | `/data/aggregations/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().aggregations().health(...)` | `GET` | `/data/aggregations/health` | `Class responseType` | `@Nullable T` | -| `data().aggregations().health(...)` | `GET` | `/data/aggregations/health` | `TypeReference responseType` | `@Nullable T` | -| `data().aggregations().getInfo(...)` | `GET` | `/data/aggregations/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().aggregations().getInfo(...)` | `GET` | `/data/aggregations/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().aggregations().getInfo(...)` | `GET` | `/data/aggregations/info` | `Class responseType` | `@Nullable T` | -| `data().aggregations().getInfo(...)` | `GET` | `/data/aggregations/info` | `TypeReference responseType` | `@Nullable T` | -| `data().archival().health(...)` | `GET` | `/data/archival/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().archival().health(...)` | `GET` | `/data/archival/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().archival().health(...)` | `GET` | `/data/archival/health` | `Class responseType` | `@Nullable T` | -| `data().archival().health(...)` | `GET` | `/data/archival/health` | `TypeReference responseType` | `@Nullable T` | -| `data().archival().getInfo(...)` | `GET` | `/data/archival/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().archival().getInfo(...)` | `GET` | `/data/archival/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().archival().getInfo(...)` | `GET` | `/data/archival/info` | `Class responseType` | `@Nullable T` | -| `data().archival().getInfo(...)` | `GET` | `/data/archival/info` | `TypeReference responseType` | `@Nullable T` | -| `data().catalog().health(...)` | `GET` | `/data/catalog/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().catalog().health(...)` | `GET` | `/data/catalog/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().catalog().health(...)` | `GET` | `/data/catalog/health` | `Class responseType` | `@Nullable T` | -| `data().catalog().health(...)` | `GET` | `/data/catalog/health` | `TypeReference responseType` | `@Nullable T` | -| `data().catalog().getInfo(...)` | `GET` | `/data/catalog/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().catalog().getInfo(...)` | `GET` | `/data/catalog/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().catalog().getInfo(...)` | `GET` | `/data/catalog/info` | `Class responseType` | `@Nullable T` | -| `data().catalog().getInfo(...)` | `GET` | `/data/catalog/info` | `TypeReference responseType` | `@Nullable T` | -| `data().enrichment().health(...)` | `GET` | `/data/enrichment/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().enrichment().health(...)` | `GET` | `/data/enrichment/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().enrichment().health(...)` | `GET` | `/data/enrichment/health` | `Class responseType` | `@Nullable T` | -| `data().enrichment().health(...)` | `GET` | `/data/enrichment/health` | `TypeReference responseType` | `@Nullable T` | -| `data().enrichment().getInfo(...)` | `GET` | `/data/enrichment/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().enrichment().getInfo(...)` | `GET` | `/data/enrichment/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().enrichment().getInfo(...)` | `GET` | `/data/enrichment/info` | `Class responseType` | `@Nullable T` | -| `data().enrichment().getInfo(...)` | `GET` | `/data/enrichment/info` | `TypeReference responseType` | `@Nullable T` | -| `data().exports().health(...)` | `GET` | `/data/exports/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().exports().health(...)` | `GET` | `/data/exports/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().exports().health(...)` | `GET` | `/data/exports/health` | `Class responseType` | `@Nullable T` | -| `data().exports().health(...)` | `GET` | `/data/exports/health` | `TypeReference responseType` | `@Nullable T` | -| `data().exports().getInfo(...)` | `GET` | `/data/exports/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().exports().getInfo(...)` | `GET` | `/data/exports/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().exports().getInfo(...)` | `GET` | `/data/exports/info` | `Class responseType` | `@Nullable T` | -| `data().exports().getInfo(...)` | `GET` | `/data/exports/info` | `TypeReference responseType` | `@Nullable T` | -| `data().ingest().health(...)` | `GET` | `/data/ingest/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().ingest().health(...)` | `GET` | `/data/ingest/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().ingest().health(...)` | `GET` | `/data/ingest/health` | `Class responseType` | `@Nullable T` | -| `data().ingest().health(...)` | `GET` | `/data/ingest/health` | `TypeReference responseType` | `@Nullable T` | -| `data().ingest().getInfo(...)` | `GET` | `/data/ingest/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().ingest().getInfo(...)` | `GET` | `/data/ingest/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().ingest().getInfo(...)` | `GET` | `/data/ingest/info` | `Class responseType` | `@Nullable T` | -| `data().ingest().getInfo(...)` | `GET` | `/data/ingest/info` | `TypeReference responseType` | `@Nullable T` | -| `data().normalization().health(...)` | `GET` | `/data/normalization/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().normalization().health(...)` | `GET` | `/data/normalization/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().normalization().health(...)` | `GET` | `/data/normalization/health` | `Class responseType` | `@Nullable T` | -| `data().normalization().health(...)` | `GET` | `/data/normalization/health` | `TypeReference responseType` | `@Nullable T` | -| `data().normalization().getInfo(...)` | `GET` | `/data/normalization/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().normalization().getInfo(...)` | `GET` | `/data/normalization/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().normalization().getInfo(...)` | `GET` | `/data/normalization/info` | `Class responseType` | `@Nullable T` | -| `data().normalization().getInfo(...)` | `GET` | `/data/normalization/info` | `TypeReference responseType` | `@Nullable T` | -| `data().pipelines().health(...)` | `GET` | `/data/pipelines/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().pipelines().health(...)` | `GET` | `/data/pipelines/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().pipelines().health(...)` | `GET` | `/data/pipelines/health` | `Class responseType` | `@Nullable T` | -| `data().pipelines().health(...)` | `GET` | `/data/pipelines/health` | `TypeReference responseType` | `@Nullable T` | -| `data().pipelines().getInfo(...)` | `GET` | `/data/pipelines/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().pipelines().getInfo(...)` | `GET` | `/data/pipelines/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().pipelines().getInfo(...)` | `GET` | `/data/pipelines/info` | `Class responseType` | `@Nullable T` | -| `data().pipelines().getInfo(...)` | `GET` | `/data/pipelines/info` | `TypeReference responseType` | `@Nullable T` | -| `data().quality().health(...)` | `GET` | `/data/quality/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().quality().health(...)` | `GET` | `/data/quality/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().quality().health(...)` | `GET` | `/data/quality/health` | `Class responseType` | `@Nullable T` | -| `data().quality().health(...)` | `GET` | `/data/quality/health` | `TypeReference responseType` | `@Nullable T` | -| `data().quality().getInfo(...)` | `GET` | `/data/quality/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().quality().getInfo(...)` | `GET` | `/data/quality/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().quality().getInfo(...)` | `GET` | `/data/quality/info` | `Class responseType` | `@Nullable T` | -| `data().quality().getInfo(...)` | `GET` | `/data/quality/info` | `TypeReference responseType` | `@Nullable T` | -| `data().query().health(...)` | `GET` | `/data/query/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().query().health(...)` | `GET` | `/data/query/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().query().health(...)` | `GET` | `/data/query/health` | `Class responseType` | `@Nullable T` | -| `data().query().health(...)` | `GET` | `/data/query/health` | `TypeReference responseType` | `@Nullable T` | -| `data().query().getInfo(...)` | `GET` | `/data/query/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().query().getInfo(...)` | `GET` | `/data/query/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().query().getInfo(...)` | `GET` | `/data/query/info` | `Class responseType` | `@Nullable T` | -| `data().query().getInfo(...)` | `GET` | `/data/query/info` | `TypeReference responseType` | `@Nullable T` | -| `data().schemas().health(...)` | `GET` | `/data/schemas/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().schemas().health(...)` | `GET` | `/data/schemas/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().schemas().health(...)` | `GET` | `/data/schemas/health` | `Class responseType` | `@Nullable T` | -| `data().schemas().health(...)` | `GET` | `/data/schemas/health` | `TypeReference responseType` | `@Nullable T` | -| `data().schemas().getInfo(...)` | `GET` | `/data/schemas/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().schemas().getInfo(...)` | `GET` | `/data/schemas/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().schemas().getInfo(...)` | `GET` | `/data/schemas/info` | `Class responseType` | `@Nullable T` | -| `data().schemas().getInfo(...)` | `GET` | `/data/schemas/info` | `TypeReference responseType` | `@Nullable T` | -| `data().serving().health(...)` | `GET` | `/data/serving/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().serving().health(...)` | `GET` | `/data/serving/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().serving().health(...)` | `GET` | `/data/serving/health` | `Class responseType` | `@Nullable T` | -| `data().serving().health(...)` | `GET` | `/data/serving/health` | `TypeReference responseType` | `@Nullable T` | -| `data().serving().getInfo(...)` | `GET` | `/data/serving/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().serving().getInfo(...)` | `GET` | `/data/serving/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().serving().getInfo(...)` | `GET` | `/data/serving/info` | `Class responseType` | `@Nullable T` | -| `data().serving().getInfo(...)` | `GET` | `/data/serving/info` | `TypeReference responseType` | `@Nullable T` | -| `data().streams().health(...)` | `GET` | `/data/streams/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().streams().health(...)` | `GET` | `/data/streams/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().streams().health(...)` | `GET` | `/data/streams/health` | `Class responseType` | `@Nullable T` | -| `data().streams().health(...)` | `GET` | `/data/streams/health` | `TypeReference responseType` | `@Nullable T` | -| `data().streams().getInfo(...)` | `GET` | `/data/streams/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().streams().getInfo(...)` | `GET` | `/data/streams/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().streams().getInfo(...)` | `GET` | `/data/streams/info` | `Class responseType` | `@Nullable T` | -| `data().streams().getInfo(...)` | `GET` | `/data/streams/info` | `TypeReference responseType` | `@Nullable T` | -| `data().sync().health(...)` | `GET` | `/data/sync/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().sync().health(...)` | `GET` | `/data/sync/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().sync().health(...)` | `GET` | `/data/sync/health` | `Class responseType` | `@Nullable T` | -| `data().sync().health(...)` | `GET` | `/data/sync/health` | `TypeReference responseType` | `@Nullable T` | -| `data().sync().getInfo(...)` | `GET` | `/data/sync/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().sync().getInfo(...)` | `GET` | `/data/sync/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().sync().getInfo(...)` | `GET` | `/data/sync/info` | `Class responseType` | `@Nullable T` | -| `data().sync().getInfo(...)` | `GET` | `/data/sync/info` | `TypeReference responseType` | `@Nullable T` | -| `data().transformations().health(...)` | `GET` | `/data/transformations/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().transformations().health(...)` | `GET` | `/data/transformations/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().transformations().health(...)` | `GET` | `/data/transformations/health` | `Class responseType` | `@Nullable T` | -| `data().transformations().health(...)` | `GET` | `/data/transformations/health` | `TypeReference responseType` | `@Nullable T` | -| `data().transformations().getInfo(...)` | `GET` | `/data/transformations/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().transformations().getInfo(...)` | `GET` | `/data/transformations/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().transformations().getInfo(...)` | `GET` | `/data/transformations/info` | `Class responseType` | `@Nullable T` | -| `data().transformations().getInfo(...)` | `GET` | `/data/transformations/info` | `TypeReference responseType` | `@Nullable T` | -| `data().aggregations().aggregations().list(...)` | `GET` | `/data/aggregations/aggregations` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().aggregations().aggregations().list(...)` | `GET` | `/data/aggregations/aggregations` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().aggregations().aggregations().list(...)` | `GET` | `/data/aggregations/aggregations` | `Class responseType` | `@Nullable T` | -| `data().aggregations().aggregations().list(...)` | `GET` | `/data/aggregations/aggregations` | `TypeReference responseType` | `@Nullable T` | -| `data().aggregations().aggregations().get(...)` | `GET` | `/data/aggregations/aggregations/{param}` | `String aggregationId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().aggregations().aggregations().get(...)` | `GET` | `/data/aggregations/aggregations/{param}` | `String aggregationId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().aggregations().aggregations().get(...)` | `GET` | `/data/aggregations/aggregations/{param}` | `String aggregationId, Class responseType` | `@Nullable T` | -| `data().aggregations().aggregations().get(...)` | `GET` | `/data/aggregations/aggregations/{param}` | `String aggregationId, TypeReference responseType` | `@Nullable T` | -| `data().aggregations().aggregations().create(...)` | `POST` | `/data/aggregations/aggregations` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().aggregations().aggregations().create(...)` | `POST` | `/data/aggregations/aggregations` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().aggregations().aggregations().create(...)` | `POST` | `/data/aggregations/aggregations` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().aggregations().aggregations().create(...)` | `POST` | `/data/aggregations/aggregations` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().aggregations().capabilities().list(...)` | `GET` | `/data/aggregations/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().aggregations().capabilities().list(...)` | `GET` | `/data/aggregations/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().aggregations().capabilities().list(...)` | `GET` | `/data/aggregations/capabilities` | `Class responseType` | `@Nullable T` | -| `data().aggregations().capabilities().list(...)` | `GET` | `/data/aggregations/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `data().aggregations().runs().list(...)` | `GET` | `/data/aggregations/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().aggregations().runs().list(...)` | `GET` | `/data/aggregations/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().aggregations().runs().list(...)` | `GET` | `/data/aggregations/runs` | `Class responseType` | `@Nullable T` | -| `data().aggregations().runs().list(...)` | `GET` | `/data/aggregations/runs` | `TypeReference responseType` | `@Nullable T` | -| `data().aggregations().runs().get(...)` | `GET` | `/data/aggregations/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().aggregations().runs().get(...)` | `GET` | `/data/aggregations/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().aggregations().runs().get(...)` | `GET` | `/data/aggregations/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `data().aggregations().runs().get(...)` | `GET` | `/data/aggregations/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `data().aggregations().runs().create(...)` | `POST` | `/data/aggregations/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().aggregations().runs().create(...)` | `POST` | `/data/aggregations/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().aggregations().runs().create(...)` | `POST` | `/data/aggregations/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().aggregations().runs().create(...)` | `POST` | `/data/aggregations/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().archival().capabilities().list(...)` | `GET` | `/data/archival/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().archival().capabilities().list(...)` | `GET` | `/data/archival/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().archival().capabilities().list(...)` | `GET` | `/data/archival/capabilities` | `Class responseType` | `@Nullable T` | -| `data().archival().capabilities().list(...)` | `GET` | `/data/archival/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `data().archival().runs().list(...)` | `GET` | `/data/archival/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().archival().runs().list(...)` | `GET` | `/data/archival/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().archival().runs().list(...)` | `GET` | `/data/archival/runs` | `Class responseType` | `@Nullable T` | -| `data().archival().runs().list(...)` | `GET` | `/data/archival/runs` | `TypeReference responseType` | `@Nullable T` | -| `data().archival().runs().get(...)` | `GET` | `/data/archival/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().archival().runs().get(...)` | `GET` | `/data/archival/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().archival().runs().get(...)` | `GET` | `/data/archival/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `data().archival().runs().get(...)` | `GET` | `/data/archival/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `data().archival().runs().create(...)` | `POST` | `/data/archival/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().archival().runs().create(...)` | `POST` | `/data/archival/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().archival().runs().create(...)` | `POST` | `/data/archival/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().archival().runs().create(...)` | `POST` | `/data/archival/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().catalog().capabilities().list(...)` | `GET` | `/data/catalog/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().catalog().capabilities().list(...)` | `GET` | `/data/catalog/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().catalog().capabilities().list(...)` | `GET` | `/data/catalog/capabilities` | `Class responseType` | `@Nullable T` | -| `data().catalog().capabilities().list(...)` | `GET` | `/data/catalog/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `data().catalog().runs().list(...)` | `GET` | `/data/catalog/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().catalog().runs().list(...)` | `GET` | `/data/catalog/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().catalog().runs().list(...)` | `GET` | `/data/catalog/runs` | `Class responseType` | `@Nullable T` | -| `data().catalog().runs().list(...)` | `GET` | `/data/catalog/runs` | `TypeReference responseType` | `@Nullable T` | -| `data().catalog().runs().get(...)` | `GET` | `/data/catalog/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().catalog().runs().get(...)` | `GET` | `/data/catalog/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().catalog().runs().get(...)` | `GET` | `/data/catalog/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `data().catalog().runs().get(...)` | `GET` | `/data/catalog/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `data().catalog().runs().create(...)` | `POST` | `/data/catalog/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().catalog().runs().create(...)` | `POST` | `/data/catalog/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().catalog().runs().create(...)` | `POST` | `/data/catalog/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().catalog().runs().create(...)` | `POST` | `/data/catalog/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().enrichment().capabilities().list(...)` | `GET` | `/data/enrichment/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().enrichment().capabilities().list(...)` | `GET` | `/data/enrichment/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().enrichment().capabilities().list(...)` | `GET` | `/data/enrichment/capabilities` | `Class responseType` | `@Nullable T` | -| `data().enrichment().capabilities().list(...)` | `GET` | `/data/enrichment/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `data().enrichment().runs().list(...)` | `GET` | `/data/enrichment/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().enrichment().runs().list(...)` | `GET` | `/data/enrichment/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().enrichment().runs().list(...)` | `GET` | `/data/enrichment/runs` | `Class responseType` | `@Nullable T` | -| `data().enrichment().runs().list(...)` | `GET` | `/data/enrichment/runs` | `TypeReference responseType` | `@Nullable T` | -| `data().enrichment().runs().get(...)` | `GET` | `/data/enrichment/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().enrichment().runs().get(...)` | `GET` | `/data/enrichment/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().enrichment().runs().get(...)` | `GET` | `/data/enrichment/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `data().enrichment().runs().get(...)` | `GET` | `/data/enrichment/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `data().enrichment().runs().create(...)` | `POST` | `/data/enrichment/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().enrichment().runs().create(...)` | `POST` | `/data/enrichment/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().enrichment().runs().create(...)` | `POST` | `/data/enrichment/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().enrichment().runs().create(...)` | `POST` | `/data/enrichment/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().exports().capabilities().list(...)` | `GET` | `/data/exports/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().exports().capabilities().list(...)` | `GET` | `/data/exports/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().exports().capabilities().list(...)` | `GET` | `/data/exports/capabilities` | `Class responseType` | `@Nullable T` | -| `data().exports().capabilities().list(...)` | `GET` | `/data/exports/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `data().exports().exports().list(...)` | `GET` | `/data/exports/exports` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().exports().exports().list(...)` | `GET` | `/data/exports/exports` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().exports().exports().list(...)` | `GET` | `/data/exports/exports` | `Class responseType` | `@Nullable T` | -| `data().exports().exports().list(...)` | `GET` | `/data/exports/exports` | `TypeReference responseType` | `@Nullable T` | -| `data().exports().exports().get(...)` | `GET` | `/data/exports/exports/{param}` | `String exportId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().exports().exports().get(...)` | `GET` | `/data/exports/exports/{param}` | `String exportId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().exports().exports().get(...)` | `GET` | `/data/exports/exports/{param}` | `String exportId, Class responseType` | `@Nullable T` | -| `data().exports().exports().get(...)` | `GET` | `/data/exports/exports/{param}` | `String exportId, TypeReference responseType` | `@Nullable T` | -| `data().exports().exports().create(...)` | `POST` | `/data/exports/exports` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().exports().exports().create(...)` | `POST` | `/data/exports/exports` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().exports().exports().create(...)` | `POST` | `/data/exports/exports` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().exports().exports().create(...)` | `POST` | `/data/exports/exports` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().exports().runs().list(...)` | `GET` | `/data/exports/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().exports().runs().list(...)` | `GET` | `/data/exports/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().exports().runs().list(...)` | `GET` | `/data/exports/runs` | `Class responseType` | `@Nullable T` | -| `data().exports().runs().list(...)` | `GET` | `/data/exports/runs` | `TypeReference responseType` | `@Nullable T` | -| `data().exports().runs().get(...)` | `GET` | `/data/exports/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().exports().runs().get(...)` | `GET` | `/data/exports/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().exports().runs().get(...)` | `GET` | `/data/exports/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `data().exports().runs().get(...)` | `GET` | `/data/exports/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `data().exports().runs().create(...)` | `POST` | `/data/exports/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().exports().runs().create(...)` | `POST` | `/data/exports/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().exports().runs().create(...)` | `POST` | `/data/exports/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().exports().runs().create(...)` | `POST` | `/data/exports/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().ingest().capabilities().list(...)` | `GET` | `/data/ingest/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().ingest().capabilities().list(...)` | `GET` | `/data/ingest/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().ingest().capabilities().list(...)` | `GET` | `/data/ingest/capabilities` | `Class responseType` | `@Nullable T` | -| `data().ingest().capabilities().list(...)` | `GET` | `/data/ingest/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `data().ingest().datasets().list(...)` | `GET` | `/data/ingest/datasets` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().ingest().datasets().list(...)` | `GET` | `/data/ingest/datasets` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().ingest().datasets().list(...)` | `GET` | `/data/ingest/datasets` | `Class responseType` | `@Nullable T` | -| `data().ingest().datasets().list(...)` | `GET` | `/data/ingest/datasets` | `TypeReference responseType` | `@Nullable T` | -| `data().ingest().datasets().get(...)` | `GET` | `/data/ingest/datasets/{param}` | `String datasetId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().ingest().datasets().get(...)` | `GET` | `/data/ingest/datasets/{param}` | `String datasetId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().ingest().datasets().get(...)` | `GET` | `/data/ingest/datasets/{param}` | `String datasetId, Class responseType` | `@Nullable T` | -| `data().ingest().datasets().get(...)` | `GET` | `/data/ingest/datasets/{param}` | `String datasetId, TypeReference responseType` | `@Nullable T` | -| `data().ingest().datasets().ingest(...)` | `POST` | `/data/ingest/datasets/ingest` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().ingest().datasets().ingest(...)` | `POST` | `/data/ingest/datasets/ingest` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().ingest().datasets().ingest(...)` | `POST` | `/data/ingest/datasets/ingest` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().ingest().datasets().ingest(...)` | `POST` | `/data/ingest/datasets/ingest` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().ingest().runs().list(...)` | `GET` | `/data/ingest/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().ingest().runs().list(...)` | `GET` | `/data/ingest/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().ingest().runs().list(...)` | `GET` | `/data/ingest/runs` | `Class responseType` | `@Nullable T` | -| `data().ingest().runs().list(...)` | `GET` | `/data/ingest/runs` | `TypeReference responseType` | `@Nullable T` | -| `data().ingest().runs().get(...)` | `GET` | `/data/ingest/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().ingest().runs().get(...)` | `GET` | `/data/ingest/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().ingest().runs().get(...)` | `GET` | `/data/ingest/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `data().ingest().runs().get(...)` | `GET` | `/data/ingest/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `data().ingest().runs().create(...)` | `POST` | `/data/ingest/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().ingest().runs().create(...)` | `POST` | `/data/ingest/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().ingest().runs().create(...)` | `POST` | `/data/ingest/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().ingest().runs().create(...)` | `POST` | `/data/ingest/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().ingest().schemas().list(...)` | `GET` | `/data/ingest/schemas` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().ingest().schemas().list(...)` | `GET` | `/data/ingest/schemas` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().ingest().schemas().list(...)` | `GET` | `/data/ingest/schemas` | `Class responseType` | `@Nullable T` | -| `data().ingest().schemas().list(...)` | `GET` | `/data/ingest/schemas` | `TypeReference responseType` | `@Nullable T` | -| `data().ingest().schemas().get(...)` | `GET` | `/data/ingest/schemas/{param}` | `String schemaRef, QueryParams query, Class responseType` | `@Nullable T` | -| `data().ingest().schemas().get(...)` | `GET` | `/data/ingest/schemas/{param}` | `String schemaRef, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().ingest().schemas().get(...)` | `GET` | `/data/ingest/schemas/{param}` | `String schemaRef, Class responseType` | `@Nullable T` | -| `data().ingest().schemas().get(...)` | `GET` | `/data/ingest/schemas/{param}` | `String schemaRef, TypeReference responseType` | `@Nullable T` | -| `data().normalization().capabilities().list(...)` | `GET` | `/data/normalization/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().normalization().capabilities().list(...)` | `GET` | `/data/normalization/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().normalization().capabilities().list(...)` | `GET` | `/data/normalization/capabilities` | `Class responseType` | `@Nullable T` | -| `data().normalization().capabilities().list(...)` | `GET` | `/data/normalization/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `data().normalization().runs().list(...)` | `GET` | `/data/normalization/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().normalization().runs().list(...)` | `GET` | `/data/normalization/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().normalization().runs().list(...)` | `GET` | `/data/normalization/runs` | `Class responseType` | `@Nullable T` | -| `data().normalization().runs().list(...)` | `GET` | `/data/normalization/runs` | `TypeReference responseType` | `@Nullable T` | -| `data().normalization().runs().get(...)` | `GET` | `/data/normalization/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().normalization().runs().get(...)` | `GET` | `/data/normalization/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().normalization().runs().get(...)` | `GET` | `/data/normalization/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `data().normalization().runs().get(...)` | `GET` | `/data/normalization/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `data().normalization().runs().create(...)` | `POST` | `/data/normalization/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().normalization().runs().create(...)` | `POST` | `/data/normalization/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().normalization().runs().create(...)` | `POST` | `/data/normalization/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().normalization().runs().create(...)` | `POST` | `/data/normalization/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().pipelines().capabilities().list(...)` | `GET` | `/data/pipelines/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().pipelines().capabilities().list(...)` | `GET` | `/data/pipelines/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().pipelines().capabilities().list(...)` | `GET` | `/data/pipelines/capabilities` | `Class responseType` | `@Nullable T` | -| `data().pipelines().capabilities().list(...)` | `GET` | `/data/pipelines/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `data().pipelines().pipelineRuns().list(...)` | `GET` | `/data/pipelines/pipeline-runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().pipelines().pipelineRuns().list(...)` | `GET` | `/data/pipelines/pipeline-runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().pipelines().pipelineRuns().list(...)` | `GET` | `/data/pipelines/pipeline-runs` | `Class responseType` | `@Nullable T` | -| `data().pipelines().pipelineRuns().list(...)` | `GET` | `/data/pipelines/pipeline-runs` | `TypeReference responseType` | `@Nullable T` | -| `data().pipelines().pipelineRuns().get(...)` | `GET` | `/data/pipelines/pipeline-runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().pipelines().pipelineRuns().get(...)` | `GET` | `/data/pipelines/pipeline-runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().pipelines().pipelineRuns().get(...)` | `GET` | `/data/pipelines/pipeline-runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `data().pipelines().pipelineRuns().get(...)` | `GET` | `/data/pipelines/pipeline-runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `data().pipelines().pipelines().list(...)` | `GET` | `/data/pipelines/pipelines` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().pipelines().pipelines().list(...)` | `GET` | `/data/pipelines/pipelines` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().pipelines().pipelines().list(...)` | `GET` | `/data/pipelines/pipelines` | `Class responseType` | `@Nullable T` | -| `data().pipelines().pipelines().list(...)` | `GET` | `/data/pipelines/pipelines` | `TypeReference responseType` | `@Nullable T` | -| `data().pipelines().pipelines().get(...)` | `GET` | `/data/pipelines/pipelines/{param}` | `String definitionId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().pipelines().pipelines().get(...)` | `GET` | `/data/pipelines/pipelines/{param}` | `String definitionId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().pipelines().pipelines().get(...)` | `GET` | `/data/pipelines/pipelines/{param}` | `String definitionId, Class responseType` | `@Nullable T` | -| `data().pipelines().pipelines().get(...)` | `GET` | `/data/pipelines/pipelines/{param}` | `String definitionId, TypeReference responseType` | `@Nullable T` | -| `data().pipelines().pipelines().create(...)` | `POST` | `/data/pipelines/pipelines` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().pipelines().pipelines().create(...)` | `POST` | `/data/pipelines/pipelines` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().pipelines().pipelines().create(...)` | `POST` | `/data/pipelines/pipelines` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().pipelines().pipelines().create(...)` | `POST` | `/data/pipelines/pipelines` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().pipelines().runs().list(...)` | `GET` | `/data/pipelines/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().pipelines().runs().list(...)` | `GET` | `/data/pipelines/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().pipelines().runs().list(...)` | `GET` | `/data/pipelines/runs` | `Class responseType` | `@Nullable T` | -| `data().pipelines().runs().list(...)` | `GET` | `/data/pipelines/runs` | `TypeReference responseType` | `@Nullable T` | -| `data().pipelines().runs().get(...)` | `GET` | `/data/pipelines/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().pipelines().runs().get(...)` | `GET` | `/data/pipelines/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().pipelines().runs().get(...)` | `GET` | `/data/pipelines/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `data().pipelines().runs().get(...)` | `GET` | `/data/pipelines/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `data().pipelines().runs().create(...)` | `POST` | `/data/pipelines/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().pipelines().runs().create(...)` | `POST` | `/data/pipelines/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().pipelines().runs().create(...)` | `POST` | `/data/pipelines/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().pipelines().runs().create(...)` | `POST` | `/data/pipelines/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().quality().capabilities().list(...)` | `GET` | `/data/quality/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().quality().capabilities().list(...)` | `GET` | `/data/quality/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().quality().capabilities().list(...)` | `GET` | `/data/quality/capabilities` | `Class responseType` | `@Nullable T` | -| `data().quality().capabilities().list(...)` | `GET` | `/data/quality/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `data().quality().runs().list(...)` | `GET` | `/data/quality/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().quality().runs().list(...)` | `GET` | `/data/quality/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().quality().runs().list(...)` | `GET` | `/data/quality/runs` | `Class responseType` | `@Nullable T` | -| `data().quality().runs().list(...)` | `GET` | `/data/quality/runs` | `TypeReference responseType` | `@Nullable T` | -| `data().quality().runs().get(...)` | `GET` | `/data/quality/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().quality().runs().get(...)` | `GET` | `/data/quality/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().quality().runs().get(...)` | `GET` | `/data/quality/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `data().quality().runs().get(...)` | `GET` | `/data/quality/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `data().quality().runs().create(...)` | `POST` | `/data/quality/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().quality().runs().create(...)` | `POST` | `/data/quality/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().quality().runs().create(...)` | `POST` | `/data/quality/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().quality().runs().create(...)` | `POST` | `/data/quality/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().query().capabilities().list(...)` | `GET` | `/data/query/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().query().capabilities().list(...)` | `GET` | `/data/query/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().query().capabilities().list(...)` | `GET` | `/data/query/capabilities` | `Class responseType` | `@Nullable T` | -| `data().query().capabilities().list(...)` | `GET` | `/data/query/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `data().query().query().federated(...)` | `POST` | `/data/query/query/federated` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().query().query().federated(...)` | `POST` | `/data/query/query/federated` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().query().query().federated(...)` | `POST` | `/data/query/query/federated` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().query().query().federated(...)` | `POST` | `/data/query/query/federated` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().query().runs().list(...)` | `GET` | `/data/query/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().query().runs().list(...)` | `GET` | `/data/query/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().query().runs().list(...)` | `GET` | `/data/query/runs` | `Class responseType` | `@Nullable T` | -| `data().query().runs().list(...)` | `GET` | `/data/query/runs` | `TypeReference responseType` | `@Nullable T` | -| `data().query().runs().get(...)` | `GET` | `/data/query/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().query().runs().get(...)` | `GET` | `/data/query/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().query().runs().get(...)` | `GET` | `/data/query/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `data().query().runs().get(...)` | `GET` | `/data/query/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `data().query().runs().create(...)` | `POST` | `/data/query/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().query().runs().create(...)` | `POST` | `/data/query/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().query().runs().create(...)` | `POST` | `/data/query/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().query().runs().create(...)` | `POST` | `/data/query/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().schemas().capabilities().list(...)` | `GET` | `/data/schemas/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().schemas().capabilities().list(...)` | `GET` | `/data/schemas/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().schemas().capabilities().list(...)` | `GET` | `/data/schemas/capabilities` | `Class responseType` | `@Nullable T` | -| `data().schemas().capabilities().list(...)` | `GET` | `/data/schemas/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `data().schemas().runs().list(...)` | `GET` | `/data/schemas/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().schemas().runs().list(...)` | `GET` | `/data/schemas/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().schemas().runs().list(...)` | `GET` | `/data/schemas/runs` | `Class responseType` | `@Nullable T` | -| `data().schemas().runs().list(...)` | `GET` | `/data/schemas/runs` | `TypeReference responseType` | `@Nullable T` | -| `data().schemas().runs().get(...)` | `GET` | `/data/schemas/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().schemas().runs().get(...)` | `GET` | `/data/schemas/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().schemas().runs().get(...)` | `GET` | `/data/schemas/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `data().schemas().runs().get(...)` | `GET` | `/data/schemas/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `data().schemas().runs().create(...)` | `POST` | `/data/schemas/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().schemas().runs().create(...)` | `POST` | `/data/schemas/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().schemas().runs().create(...)` | `POST` | `/data/schemas/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().schemas().runs().create(...)` | `POST` | `/data/schemas/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().schemas().schemas().list(...)` | `GET` | `/data/schemas/schemas` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().schemas().schemas().list(...)` | `GET` | `/data/schemas/schemas` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().schemas().schemas().list(...)` | `GET` | `/data/schemas/schemas` | `Class responseType` | `@Nullable T` | -| `data().schemas().schemas().list(...)` | `GET` | `/data/schemas/schemas` | `TypeReference responseType` | `@Nullable T` | -| `data().schemas().schemas().get(...)` | `GET` | `/data/schemas/schemas/{param}` | `String schemaRef, QueryParams query, Class responseType` | `@Nullable T` | -| `data().schemas().schemas().get(...)` | `GET` | `/data/schemas/schemas/{param}` | `String schemaRef, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().schemas().schemas().get(...)` | `GET` | `/data/schemas/schemas/{param}` | `String schemaRef, Class responseType` | `@Nullable T` | -| `data().schemas().schemas().get(...)` | `GET` | `/data/schemas/schemas/{param}` | `String schemaRef, TypeReference responseType` | `@Nullable T` | -| `data().schemas().schemas().create(...)` | `POST` | `/data/schemas/schemas` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().schemas().schemas().create(...)` | `POST` | `/data/schemas/schemas` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().schemas().schemas().create(...)` | `POST` | `/data/schemas/schemas` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().schemas().schemas().create(...)` | `POST` | `/data/schemas/schemas` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().schemas().schemas().resolve(...)` | `POST` | `/data/schemas/schemas/resolve` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().schemas().schemas().resolve(...)` | `POST` | `/data/schemas/schemas/resolve` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().schemas().schemas().resolve(...)` | `POST` | `/data/schemas/schemas/resolve` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().schemas().schemas().resolve(...)` | `POST` | `/data/schemas/schemas/resolve` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().serving().capabilities().list(...)` | `GET` | `/data/serving/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().serving().capabilities().list(...)` | `GET` | `/data/serving/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().serving().capabilities().list(...)` | `GET` | `/data/serving/capabilities` | `Class responseType` | `@Nullable T` | -| `data().serving().capabilities().list(...)` | `GET` | `/data/serving/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `data().serving().runs().list(...)` | `GET` | `/data/serving/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().serving().runs().list(...)` | `GET` | `/data/serving/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().serving().runs().list(...)` | `GET` | `/data/serving/runs` | `Class responseType` | `@Nullable T` | -| `data().serving().runs().list(...)` | `GET` | `/data/serving/runs` | `TypeReference responseType` | `@Nullable T` | -| `data().serving().runs().get(...)` | `GET` | `/data/serving/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().serving().runs().get(...)` | `GET` | `/data/serving/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().serving().runs().get(...)` | `GET` | `/data/serving/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `data().serving().runs().get(...)` | `GET` | `/data/serving/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `data().serving().runs().create(...)` | `POST` | `/data/serving/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().serving().runs().create(...)` | `POST` | `/data/serving/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().serving().runs().create(...)` | `POST` | `/data/serving/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().serving().runs().create(...)` | `POST` | `/data/serving/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().streams().capabilities().list(...)` | `GET` | `/data/streams/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().streams().capabilities().list(...)` | `GET` | `/data/streams/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().streams().capabilities().list(...)` | `GET` | `/data/streams/capabilities` | `Class responseType` | `@Nullable T` | -| `data().streams().capabilities().list(...)` | `GET` | `/data/streams/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `data().streams().runs().list(...)` | `GET` | `/data/streams/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().streams().runs().list(...)` | `GET` | `/data/streams/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().streams().runs().list(...)` | `GET` | `/data/streams/runs` | `Class responseType` | `@Nullable T` | -| `data().streams().runs().list(...)` | `GET` | `/data/streams/runs` | `TypeReference responseType` | `@Nullable T` | -| `data().streams().runs().get(...)` | `GET` | `/data/streams/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().streams().runs().get(...)` | `GET` | `/data/streams/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().streams().runs().get(...)` | `GET` | `/data/streams/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `data().streams().runs().get(...)` | `GET` | `/data/streams/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `data().streams().runs().create(...)` | `POST` | `/data/streams/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().streams().runs().create(...)` | `POST` | `/data/streams/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().streams().runs().create(...)` | `POST` | `/data/streams/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().streams().runs().create(...)` | `POST` | `/data/streams/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().streams().streams().list(...)` | `GET` | `/data/streams/streams` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().streams().streams().list(...)` | `GET` | `/data/streams/streams` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().streams().streams().list(...)` | `GET` | `/data/streams/streams` | `Class responseType` | `@Nullable T` | -| `data().streams().streams().list(...)` | `GET` | `/data/streams/streams` | `TypeReference responseType` | `@Nullable T` | -| `data().streams().streams().get(...)` | `GET` | `/data/streams/streams/{param}` | `String streamId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().streams().streams().get(...)` | `GET` | `/data/streams/streams/{param}` | `String streamId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().streams().streams().get(...)` | `GET` | `/data/streams/streams/{param}` | `String streamId, Class responseType` | `@Nullable T` | -| `data().streams().streams().get(...)` | `GET` | `/data/streams/streams/{param}` | `String streamId, TypeReference responseType` | `@Nullable T` | -| `data().streams().streams().create(...)` | `POST` | `/data/streams/streams` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().streams().streams().create(...)` | `POST` | `/data/streams/streams` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().streams().streams().create(...)` | `POST` | `/data/streams/streams` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().streams().streams().create(...)` | `POST` | `/data/streams/streams` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().sync().capabilities().list(...)` | `GET` | `/data/sync/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().sync().capabilities().list(...)` | `GET` | `/data/sync/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().sync().capabilities().list(...)` | `GET` | `/data/sync/capabilities` | `Class responseType` | `@Nullable T` | -| `data().sync().capabilities().list(...)` | `GET` | `/data/sync/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `data().sync().runs().list(...)` | `GET` | `/data/sync/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().sync().runs().list(...)` | `GET` | `/data/sync/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().sync().runs().list(...)` | `GET` | `/data/sync/runs` | `Class responseType` | `@Nullable T` | -| `data().sync().runs().list(...)` | `GET` | `/data/sync/runs` | `TypeReference responseType` | `@Nullable T` | -| `data().sync().runs().get(...)` | `GET` | `/data/sync/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().sync().runs().get(...)` | `GET` | `/data/sync/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().sync().runs().get(...)` | `GET` | `/data/sync/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `data().sync().runs().get(...)` | `GET` | `/data/sync/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `data().sync().runs().create(...)` | `POST` | `/data/sync/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().sync().runs().create(...)` | `POST` | `/data/sync/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().sync().runs().create(...)` | `POST` | `/data/sync/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().sync().runs().create(...)` | `POST` | `/data/sync/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().transformations().capabilities().list(...)` | `GET` | `/data/transformations/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().transformations().capabilities().list(...)` | `GET` | `/data/transformations/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().transformations().capabilities().list(...)` | `GET` | `/data/transformations/capabilities` | `Class responseType` | `@Nullable T` | -| `data().transformations().capabilities().list(...)` | `GET` | `/data/transformations/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `data().transformations().runs().list(...)` | `GET` | `/data/transformations/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().transformations().runs().list(...)` | `GET` | `/data/transformations/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().transformations().runs().list(...)` | `GET` | `/data/transformations/runs` | `Class responseType` | `@Nullable T` | -| `data().transformations().runs().list(...)` | `GET` | `/data/transformations/runs` | `TypeReference responseType` | `@Nullable T` | -| `data().transformations().runs().get(...)` | `GET` | `/data/transformations/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().transformations().runs().get(...)` | `GET` | `/data/transformations/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().transformations().runs().get(...)` | `GET` | `/data/transformations/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `data().transformations().runs().get(...)` | `GET` | `/data/transformations/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `data().transformations().runs().create(...)` | `POST` | `/data/transformations/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().transformations().runs().create(...)` | `POST` | `/data/transformations/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().transformations().runs().create(...)` | `POST` | `/data/transformations/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().transformations().runs().create(...)` | `POST` | `/data/transformations/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().transformations().transformations().list(...)` | `GET` | `/data/transformations/transformations` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().transformations().transformations().list(...)` | `GET` | `/data/transformations/transformations` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().transformations().transformations().list(...)` | `GET` | `/data/transformations/transformations` | `Class responseType` | `@Nullable T` | -| `data().transformations().transformations().list(...)` | `GET` | `/data/transformations/transformations` | `TypeReference responseType` | `@Nullable T` | -| `data().transformations().transformations().get(...)` | `GET` | `/data/transformations/transformations/{param}` | `String transformationId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().transformations().transformations().get(...)` | `GET` | `/data/transformations/transformations/{param}` | `String transformationId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().transformations().transformations().get(...)` | `GET` | `/data/transformations/transformations/{param}` | `String transformationId, Class responseType` | `@Nullable T` | -| `data().transformations().transformations().get(...)` | `GET` | `/data/transformations/transformations/{param}` | `String transformationId, TypeReference responseType` | `@Nullable T` | -| `data().transformations().transformations().create(...)` | `POST` | `/data/transformations/transformations` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().transformations().transformations().create(...)` | `POST` | `/data/transformations/transformations` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().transformations().transformations().create(...)` | `POST` | `/data/transformations/transformations` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().transformations().transformations().create(...)` | `POST` | `/data/transformations/transformations` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().aggregations().aggregations().executions().create(...)` | `POST` | `/data/aggregations/aggregations/{param}/executions` | `String aggregationId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().aggregations().aggregations().executions().create(...)` | `POST` | `/data/aggregations/aggregations/{param}/executions` | `String aggregationId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().aggregations().aggregations().executions().create(...)` | `POST` | `/data/aggregations/aggregations/{param}/executions` | `String aggregationId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().aggregations().aggregations().executions().create(...)` | `POST` | `/data/aggregations/aggregations/{param}/executions` | `String aggregationId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().archival().archival().policies().list(...)` | `GET` | `/data/archival/archival/policies` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().archival().archival().policies().list(...)` | `GET` | `/data/archival/archival/policies` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().archival().archival().policies().list(...)` | `GET` | `/data/archival/archival/policies` | `Class responseType` | `@Nullable T` | -| `data().archival().archival().policies().list(...)` | `GET` | `/data/archival/archival/policies` | `TypeReference responseType` | `@Nullable T` | -| `data().archival().archival().policies().get(...)` | `GET` | `/data/archival/archival/policies/{param}` | `String policyId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().archival().archival().policies().get(...)` | `GET` | `/data/archival/archival/policies/{param}` | `String policyId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().archival().archival().policies().get(...)` | `GET` | `/data/archival/archival/policies/{param}` | `String policyId, Class responseType` | `@Nullable T` | -| `data().archival().archival().policies().get(...)` | `GET` | `/data/archival/archival/policies/{param}` | `String policyId, TypeReference responseType` | `@Nullable T` | -| `data().archival().archival().policies().create(...)` | `POST` | `/data/archival/archival/policies` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().archival().archival().policies().create(...)` | `POST` | `/data/archival/archival/policies` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().archival().archival().policies().create(...)` | `POST` | `/data/archival/archival/policies` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().archival().archival().policies().create(...)` | `POST` | `/data/archival/archival/policies` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().catalog().catalog().datasets().list(...)` | `GET` | `/data/catalog/catalog/datasets` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().catalog().catalog().datasets().list(...)` | `GET` | `/data/catalog/catalog/datasets` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().catalog().catalog().datasets().list(...)` | `GET` | `/data/catalog/catalog/datasets` | `Class responseType` | `@Nullable T` | -| `data().catalog().catalog().datasets().list(...)` | `GET` | `/data/catalog/catalog/datasets` | `TypeReference responseType` | `@Nullable T` | -| `data().catalog().catalog().datasets().get(...)` | `GET` | `/data/catalog/catalog/datasets/{param}` | `String datasetId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().catalog().catalog().datasets().get(...)` | `GET` | `/data/catalog/catalog/datasets/{param}` | `String datasetId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().catalog().catalog().datasets().get(...)` | `GET` | `/data/catalog/catalog/datasets/{param}` | `String datasetId, Class responseType` | `@Nullable T` | -| `data().catalog().catalog().datasets().get(...)` | `GET` | `/data/catalog/catalog/datasets/{param}` | `String datasetId, TypeReference responseType` | `@Nullable T` | -| `data().catalog().catalog().sources().list(...)` | `GET` | `/data/catalog/catalog/sources` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().catalog().catalog().sources().list(...)` | `GET` | `/data/catalog/catalog/sources` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().catalog().catalog().sources().list(...)` | `GET` | `/data/catalog/catalog/sources` | `Class responseType` | `@Nullable T` | -| `data().catalog().catalog().sources().list(...)` | `GET` | `/data/catalog/catalog/sources` | `TypeReference responseType` | `@Nullable T` | -| `data().catalog().catalog().sources().get(...)` | `GET` | `/data/catalog/catalog/sources/{param}` | `String sourceId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().catalog().catalog().sources().get(...)` | `GET` | `/data/catalog/catalog/sources/{param}` | `String sourceId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().catalog().catalog().sources().get(...)` | `GET` | `/data/catalog/catalog/sources/{param}` | `String sourceId, Class responseType` | `@Nullable T` | -| `data().catalog().catalog().sources().get(...)` | `GET` | `/data/catalog/catalog/sources/{param}` | `String sourceId, TypeReference responseType` | `@Nullable T` | -| `data().enrichment().enrichment().profiles().list(...)` | `GET` | `/data/enrichment/enrichment/profiles` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().enrichment().enrichment().profiles().list(...)` | `GET` | `/data/enrichment/enrichment/profiles` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().enrichment().enrichment().profiles().list(...)` | `GET` | `/data/enrichment/enrichment/profiles` | `Class responseType` | `@Nullable T` | -| `data().enrichment().enrichment().profiles().list(...)` | `GET` | `/data/enrichment/enrichment/profiles` | `TypeReference responseType` | `@Nullable T` | -| `data().enrichment().enrichment().profiles().get(...)` | `GET` | `/data/enrichment/enrichment/profiles/{param}` | `String profileId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().enrichment().enrichment().profiles().get(...)` | `GET` | `/data/enrichment/enrichment/profiles/{param}` | `String profileId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().enrichment().enrichment().profiles().get(...)` | `GET` | `/data/enrichment/enrichment/profiles/{param}` | `String profileId, Class responseType` | `@Nullable T` | -| `data().enrichment().enrichment().profiles().get(...)` | `GET` | `/data/enrichment/enrichment/profiles/{param}` | `String profileId, TypeReference responseType` | `@Nullable T` | -| `data().enrichment().enrichment().profiles().create(...)` | `POST` | `/data/enrichment/enrichment/profiles` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().enrichment().enrichment().profiles().create(...)` | `POST` | `/data/enrichment/enrichment/profiles` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().enrichment().enrichment().profiles().create(...)` | `POST` | `/data/enrichment/enrichment/profiles` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().enrichment().enrichment().profiles().create(...)` | `POST` | `/data/enrichment/enrichment/profiles` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().exports().exports().executions().create(...)` | `POST` | `/data/exports/exports/{param}/executions` | `String exportId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().exports().exports().executions().create(...)` | `POST` | `/data/exports/exports/{param}/executions` | `String exportId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().exports().exports().executions().create(...)` | `POST` | `/data/exports/exports/{param}/executions` | `String exportId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().exports().exports().executions().create(...)` | `POST` | `/data/exports/exports/{param}/executions` | `String exportId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().ingest().datasets().artifacts().getContent(...)` | `GET` | `/data/ingest/datasets/{param}/artifacts/{param}/content` | `String datasetId, String manifestId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().ingest().datasets().artifacts().getContent(...)` | `GET` | `/data/ingest/datasets/{param}/artifacts/{param}/content` | `String datasetId, String manifestId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().ingest().datasets().artifacts().getContent(...)` | `GET` | `/data/ingest/datasets/{param}/artifacts/{param}/content` | `String datasetId, String manifestId, Class responseType` | `@Nullable T` | -| `data().ingest().datasets().artifacts().getContent(...)` | `GET` | `/data/ingest/datasets/{param}/artifacts/{param}/content` | `String datasetId, String manifestId, TypeReference responseType` | `@Nullable T` | -| `data().normalization().normalization().profiles().list(...)` | `GET` | `/data/normalization/normalization/profiles` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().normalization().normalization().profiles().list(...)` | `GET` | `/data/normalization/normalization/profiles` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().normalization().normalization().profiles().list(...)` | `GET` | `/data/normalization/normalization/profiles` | `Class responseType` | `@Nullable T` | -| `data().normalization().normalization().profiles().list(...)` | `GET` | `/data/normalization/normalization/profiles` | `TypeReference responseType` | `@Nullable T` | -| `data().normalization().normalization().profiles().get(...)` | `GET` | `/data/normalization/normalization/profiles/{param}` | `String profileId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().normalization().normalization().profiles().get(...)` | `GET` | `/data/normalization/normalization/profiles/{param}` | `String profileId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().normalization().normalization().profiles().get(...)` | `GET` | `/data/normalization/normalization/profiles/{param}` | `String profileId, Class responseType` | `@Nullable T` | -| `data().normalization().normalization().profiles().get(...)` | `GET` | `/data/normalization/normalization/profiles/{param}` | `String profileId, TypeReference responseType` | `@Nullable T` | -| `data().normalization().normalization().profiles().create(...)` | `POST` | `/data/normalization/normalization/profiles` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().normalization().normalization().profiles().create(...)` | `POST` | `/data/normalization/normalization/profiles` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().normalization().normalization().profiles().create(...)` | `POST` | `/data/normalization/normalization/profiles` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().normalization().normalization().profiles().create(...)` | `POST` | `/data/normalization/normalization/profiles` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().quality().quality().rulesets().list(...)` | `GET` | `/data/quality/quality/rulesets` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().quality().quality().rulesets().list(...)` | `GET` | `/data/quality/quality/rulesets` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().quality().quality().rulesets().list(...)` | `GET` | `/data/quality/quality/rulesets` | `Class responseType` | `@Nullable T` | -| `data().quality().quality().rulesets().list(...)` | `GET` | `/data/quality/quality/rulesets` | `TypeReference responseType` | `@Nullable T` | -| `data().quality().quality().rulesets().get(...)` | `GET` | `/data/quality/quality/rulesets/{param}` | `String rulesetId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().quality().quality().rulesets().get(...)` | `GET` | `/data/quality/quality/rulesets/{param}` | `String rulesetId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().quality().quality().rulesets().get(...)` | `GET` | `/data/quality/quality/rulesets/{param}` | `String rulesetId, Class responseType` | `@Nullable T` | -| `data().quality().quality().rulesets().get(...)` | `GET` | `/data/quality/quality/rulesets/{param}` | `String rulesetId, TypeReference responseType` | `@Nullable T` | -| `data().quality().quality().rulesets().create(...)` | `POST` | `/data/quality/quality/rulesets` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().quality().quality().rulesets().create(...)` | `POST` | `/data/quality/quality/rulesets` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().quality().quality().rulesets().create(...)` | `POST` | `/data/quality/quality/rulesets` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().quality().quality().rulesets().create(...)` | `POST` | `/data/quality/quality/rulesets` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().serving().serving().products().list(...)` | `GET` | `/data/serving/serving/products` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().serving().serving().products().list(...)` | `GET` | `/data/serving/serving/products` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().serving().serving().products().list(...)` | `GET` | `/data/serving/serving/products` | `Class responseType` | `@Nullable T` | -| `data().serving().serving().products().list(...)` | `GET` | `/data/serving/serving/products` | `TypeReference responseType` | `@Nullable T` | -| `data().serving().serving().products().get(...)` | `GET` | `/data/serving/serving/products/{param}` | `String productId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().serving().serving().products().get(...)` | `GET` | `/data/serving/serving/products/{param}` | `String productId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().serving().serving().products().get(...)` | `GET` | `/data/serving/serving/products/{param}` | `String productId, Class responseType` | `@Nullable T` | -| `data().serving().serving().products().get(...)` | `GET` | `/data/serving/serving/products/{param}` | `String productId, TypeReference responseType` | `@Nullable T` | -| `data().serving().serving().products().create(...)` | `POST` | `/data/serving/serving/products` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().serving().serving().products().create(...)` | `POST` | `/data/serving/serving/products` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().serving().serving().products().create(...)` | `POST` | `/data/serving/serving/products` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().serving().serving().products().create(...)` | `POST` | `/data/serving/serving/products` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().streams().streams().deliveries().create(...)` | `POST` | `/data/streams/streams/{param}/deliveries` | `String streamId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().streams().streams().deliveries().create(...)` | `POST` | `/data/streams/streams/{param}/deliveries` | `String streamId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().streams().streams().deliveries().create(...)` | `POST` | `/data/streams/streams/{param}/deliveries` | `String streamId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().streams().streams().deliveries().create(...)` | `POST` | `/data/streams/streams/{param}/deliveries` | `String streamId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().sync().sync().jobs().list(...)` | `GET` | `/data/sync/sync/jobs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `data().sync().sync().jobs().list(...)` | `GET` | `/data/sync/sync/jobs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().sync().sync().jobs().list(...)` | `GET` | `/data/sync/sync/jobs` | `Class responseType` | `@Nullable T` | -| `data().sync().sync().jobs().list(...)` | `GET` | `/data/sync/sync/jobs` | `TypeReference responseType` | `@Nullable T` | -| `data().sync().sync().jobs().get(...)` | `GET` | `/data/sync/sync/jobs/{param}` | `String jobId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().sync().sync().jobs().get(...)` | `GET` | `/data/sync/sync/jobs/{param}` | `String jobId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().sync().sync().jobs().get(...)` | `GET` | `/data/sync/sync/jobs/{param}` | `String jobId, Class responseType` | `@Nullable T` | -| `data().sync().sync().jobs().get(...)` | `GET` | `/data/sync/sync/jobs/{param}` | `String jobId, TypeReference responseType` | `@Nullable T` | -| `data().sync().sync().jobs().create(...)` | `POST` | `/data/sync/sync/jobs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().sync().sync().jobs().create(...)` | `POST` | `/data/sync/sync/jobs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().sync().sync().jobs().create(...)` | `POST` | `/data/sync/sync/jobs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().sync().sync().jobs().create(...)` | `POST` | `/data/sync/sync/jobs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().transformations().transformations().executions().create(...)` | `POST` | `/data/transformations/transformations/{param}/executions` | `String transformationId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().transformations().transformations().executions().create(...)` | `POST` | `/data/transformations/transformations/{param}/executions` | `String transformationId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().transformations().transformations().executions().create(...)` | `POST` | `/data/transformations/transformations/{param}/executions` | `String transformationId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().transformations().transformations().executions().create(...)` | `POST` | `/data/transformations/transformations/{param}/executions` | `String transformationId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().archival().archival().policies().executions().create(...)` | `POST` | `/data/archival/archival/policies/{param}/executions` | `String policyId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().archival().archival().policies().executions().create(...)` | `POST` | `/data/archival/archival/policies/{param}/executions` | `String policyId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().archival().archival().policies().executions().create(...)` | `POST` | `/data/archival/archival/policies/{param}/executions` | `String policyId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().archival().archival().policies().executions().create(...)` | `POST` | `/data/archival/archival/policies/{param}/executions` | `String policyId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().catalog().catalog().datasets().artifacts().getContent(...)` | `GET` | `/data/catalog/catalog/datasets/{param}/artifacts/{param}/content` | `String datasetId, String manifestId, QueryParams query, Class responseType` | `@Nullable T` | -| `data().catalog().catalog().datasets().artifacts().getContent(...)` | `GET` | `/data/catalog/catalog/datasets/{param}/artifacts/{param}/content` | `String datasetId, String manifestId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `data().catalog().catalog().datasets().artifacts().getContent(...)` | `GET` | `/data/catalog/catalog/datasets/{param}/artifacts/{param}/content` | `String datasetId, String manifestId, Class responseType` | `@Nullable T` | -| `data().catalog().catalog().datasets().artifacts().getContent(...)` | `GET` | `/data/catalog/catalog/datasets/{param}/artifacts/{param}/content` | `String datasetId, String manifestId, TypeReference responseType` | `@Nullable T` | -| `data().enrichment().enrichment().profiles().executions().create(...)` | `POST` | `/data/enrichment/enrichment/profiles/{param}/executions` | `String profileId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().enrichment().enrichment().profiles().executions().create(...)` | `POST` | `/data/enrichment/enrichment/profiles/{param}/executions` | `String profileId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().enrichment().enrichment().profiles().executions().create(...)` | `POST` | `/data/enrichment/enrichment/profiles/{param}/executions` | `String profileId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().enrichment().enrichment().profiles().executions().create(...)` | `POST` | `/data/enrichment/enrichment/profiles/{param}/executions` | `String profileId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().normalization().normalization().profiles().executions().create(...)` | `POST` | `/data/normalization/normalization/profiles/{param}/executions` | `String profileId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().normalization().normalization().profiles().executions().create(...)` | `POST` | `/data/normalization/normalization/profiles/{param}/executions` | `String profileId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().normalization().normalization().profiles().executions().create(...)` | `POST` | `/data/normalization/normalization/profiles/{param}/executions` | `String profileId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().normalization().normalization().profiles().executions().create(...)` | `POST` | `/data/normalization/normalization/profiles/{param}/executions` | `String profileId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().quality().quality().rulesets().evaluations().create(...)` | `POST` | `/data/quality/quality/rulesets/{param}/evaluations` | `String rulesetId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().quality().quality().rulesets().evaluations().create(...)` | `POST` | `/data/quality/quality/rulesets/{param}/evaluations` | `String rulesetId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().quality().quality().rulesets().evaluations().create(...)` | `POST` | `/data/quality/quality/rulesets/{param}/evaluations` | `String rulesetId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().quality().quality().rulesets().evaluations().create(...)` | `POST` | `/data/quality/quality/rulesets/{param}/evaluations` | `String rulesetId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().serving().serving().products().refreshes().create(...)` | `POST` | `/data/serving/serving/products/{param}/refreshes` | `String productId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().serving().serving().products().refreshes().create(...)` | `POST` | `/data/serving/serving/products/{param}/refreshes` | `String productId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().serving().serving().products().refreshes().create(...)` | `POST` | `/data/serving/serving/products/{param}/refreshes` | `String productId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().serving().serving().products().refreshes().create(...)` | `POST` | `/data/serving/serving/products/{param}/refreshes` | `String productId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().sync().sync().jobs().executions().create(...)` | `POST` | `/data/sync/sync/jobs/{param}/executions` | `String jobId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().sync().sync().jobs().executions().create(...)` | `POST` | `/data/sync/sync/jobs/{param}/executions` | `String jobId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `data().sync().sync().jobs().executions().create(...)` | `POST` | `/data/sync/sync/jobs/{param}/executions` | `String jobId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `data().sync().sync().jobs().executions().create(...)` | `POST` | `/data/sync/sync/jobs/{param}/executions` | `String jobId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | - -The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/events.md b/docs/api/events.md deleted file mode 100644 index 70a8aa0..0000000 --- a/docs/api/events.md +++ /dev/null @@ -1,78 +0,0 @@ -# Events API - -Service accessor: `frontal.events()` (`EventsClient`). - -Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. - -| Method | HTTP | Route | Parameters | Response | -| --- | --- | --- | --- | --- | -| `events().list(...)` | `GET` | `/events` | `QueryParams query, Class responseType` | `@Nullable T` | -| `events().list(...)` | `GET` | `/events` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `events().list(...)` | `GET` | `/events` | `Class responseType` | `@Nullable T` | -| `events().list(...)` | `GET` | `/events` | `TypeReference responseType` | `@Nullable T` | -| `events().getMonitoring(...)` | `GET` | `/events/monitoring` | `QueryParams query, Class responseType` | `@Nullable T` | -| `events().getMonitoring(...)` | `GET` | `/events/monitoring` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `events().getMonitoring(...)` | `GET` | `/events/monitoring` | `Class responseType` | `@Nullable T` | -| `events().getMonitoring(...)` | `GET` | `/events/monitoring` | `TypeReference responseType` | `@Nullable T` | -| `events().get(...)` | `GET` | `/events/{param}` | `String id, QueryParams query, Class responseType` | `@Nullable T` | -| `events().get(...)` | `GET` | `/events/{param}` | `String id, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `events().get(...)` | `GET` | `/events/{param}` | `String id, Class responseType` | `@Nullable T` | -| `events().get(...)` | `GET` | `/events/{param}` | `String id, TypeReference responseType` | `@Nullable T` | -| `events().create(...)` | `POST` | `/events` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().create(...)` | `POST` | `/events` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().create(...)` | `POST` | `/events` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().create(...)` | `POST` | `/events` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().analytics(...)` | `POST` | `/events/analytics` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().analytics(...)` | `POST` | `/events/analytics` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().analytics(...)` | `POST` | `/events/analytics` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().analytics(...)` | `POST` | `/events/analytics` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().createAnalyticsV2(...)` | `POST` | `/events/analytics-v2` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().createAnalyticsV2(...)` | `POST` | `/events/analytics-v2` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().createAnalyticsV2(...)` | `POST` | `/events/analytics-v2` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().createAnalyticsV2(...)` | `POST` | `/events/analytics-v2` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().bulk(...)` | `POST` | `/events/bulk` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().bulk(...)` | `POST` | `/events/bulk` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().bulk(...)` | `POST` | `/events/bulk` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().bulk(...)` | `POST` | `/events/bulk` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().createHuggingfaceBilling(...)` | `POST` | `/events/huggingface-billing` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().createHuggingfaceBilling(...)` | `POST` | `/events/huggingface-billing` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().createHuggingfaceBilling(...)` | `POST` | `/events/huggingface-billing` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().createHuggingfaceBilling(...)` | `POST` | `/events/huggingface-billing` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().query(...)` | `POST` | `/events/query` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().query(...)` | `POST` | `/events/query` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().query(...)` | `POST` | `/events/query` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().query(...)` | `POST` | `/events/query` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().reprocess(...)` | `POST` | `/events/reprocess` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().reprocess(...)` | `POST` | `/events/reprocess` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().reprocess(...)` | `POST` | `/events/reprocess` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().reprocess(...)` | `POST` | `/events/reprocess` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().usage(...)` | `POST` | `/events/usage` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().usage(...)` | `POST` | `/events/usage` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().usage(...)` | `POST` | `/events/usage` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().usage(...)` | `POST` | `/events/usage` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().benchmark().createV1(...)` | `POST` | `/events/benchmark/v1` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().benchmark().createV1(...)` | `POST` | `/events/benchmark/v1` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().benchmark().createV1(...)` | `POST` | `/events/benchmark/v1` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().benchmark().createV1(...)` | `POST` | `/events/benchmark/v1` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().benchmark().createV2(...)` | `POST` | `/events/benchmark/v2` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().benchmark().createV2(...)` | `POST` | `/events/benchmark/v2` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().benchmark().createV2(...)` | `POST` | `/events/benchmark/v2` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().benchmark().createV2(...)` | `POST` | `/events/benchmark/v2` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().reprocess().createInternal(...)` | `POST` | `/events/reprocess/internal` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().reprocess().createInternal(...)` | `POST` | `/events/reprocess/internal` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().reprocess().createInternal(...)` | `POST` | `/events/reprocess/internal` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().reprocess().createInternal(...)` | `POST` | `/events/reprocess/internal` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().usage().createMeter(...)` | `POST` | `/events/usage/meter` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().usage().createMeter(...)` | `POST` | `/events/usage/meter` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().usage().createMeter(...)` | `POST` | `/events/usage/meter` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().usage().createMeter(...)` | `POST` | `/events/usage/meter` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().raw().reprocess().createAll(...)` | `POST` | `/events/raw/reprocess/all` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().raw().reprocess().createAll(...)` | `POST` | `/events/raw/reprocess/all` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().raw().reprocess().createAll(...)` | `POST` | `/events/raw/reprocess/all` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().raw().reprocess().createAll(...)` | `POST` | `/events/raw/reprocess/all` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().raw().reprocess().createPending(...)` | `POST` | `/events/raw/reprocess/pending` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().raw().reprocess().createPending(...)` | `POST` | `/events/raw/reprocess/pending` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `events().raw().reprocess().createPending(...)` | `POST` | `/events/raw/reprocess/pending` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `events().raw().reprocess().createPending(...)` | `POST` | `/events/raw/reprocess/pending` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | - -The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/governance.md b/docs/api/governance.md deleted file mode 100644 index c312085..0000000 --- a/docs/api/governance.md +++ /dev/null @@ -1,106 +0,0 @@ -# Governance API - -Service accessor: `frontal.governance()` (`GovernanceClient`). - -Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. - -| Method | HTTP | Route | Parameters | Response | -| --- | --- | --- | --- | --- | -| `governance().access().check(...)` | `POST` | `/access/check` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `governance().access().check(...)` | `POST` | `/access/check` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `governance().access().check(...)` | `POST` | `/access/check` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `governance().access().check(...)` | `POST` | `/access/check` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `governance().compliance().getScore(...)` | `GET` | `/compliance/score` | `QueryParams query, Class responseType` | `@Nullable T` | -| `governance().compliance().getScore(...)` | `GET` | `/compliance/score` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `governance().compliance().getScore(...)` | `GET` | `/compliance/score` | `Class responseType` | `@Nullable T` | -| `governance().compliance().getScore(...)` | `GET` | `/compliance/score` | `TypeReference responseType` | `@Nullable T` | -| `governance().permissions().list(...)` | `GET` | `/permissions` | `QueryParams query, Class responseType` | `@Nullable T` | -| `governance().permissions().list(...)` | `GET` | `/permissions` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `governance().permissions().list(...)` | `GET` | `/permissions` | `Class responseType` | `@Nullable T` | -| `governance().permissions().list(...)` | `GET` | `/permissions` | `TypeReference responseType` | `@Nullable T` | -| `governance().permissions().get(...)` | `GET` | `/permissions/{param}` | `String permissionId, QueryParams query, Class responseType` | `@Nullable T` | -| `governance().permissions().get(...)` | `GET` | `/permissions/{param}` | `String permissionId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `governance().permissions().get(...)` | `GET` | `/permissions/{param}` | `String permissionId, Class responseType` | `@Nullable T` | -| `governance().permissions().get(...)` | `GET` | `/permissions/{param}` | `String permissionId, TypeReference responseType` | `@Nullable T` | -| `governance().permissions().create(...)` | `POST` | `/permissions` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `governance().permissions().create(...)` | `POST` | `/permissions` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `governance().permissions().create(...)` | `POST` | `/permissions` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `governance().permissions().create(...)` | `POST` | `/permissions` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `governance().policies().delete(...)` | `DELETE` | `/policies/{param}` | `String policyId, QueryParams query, Class responseType` | `@Nullable T` | -| `governance().policies().delete(...)` | `DELETE` | `/policies/{param}` | `String policyId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `governance().policies().delete(...)` | `DELETE` | `/policies/{param}` | `String policyId, Class responseType` | `@Nullable T` | -| `governance().policies().delete(...)` | `DELETE` | `/policies/{param}` | `String policyId, TypeReference responseType` | `@Nullable T` | -| `governance().policies().list(...)` | `GET` | `/policies` | `QueryParams query, Class responseType` | `@Nullable T` | -| `governance().policies().list(...)` | `GET` | `/policies` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `governance().policies().list(...)` | `GET` | `/policies` | `Class responseType` | `@Nullable T` | -| `governance().policies().list(...)` | `GET` | `/policies` | `TypeReference responseType` | `@Nullable T` | -| `governance().policies().get(...)` | `GET` | `/policies/{param}` | `String policyId, QueryParams query, Class responseType` | `@Nullable T` | -| `governance().policies().get(...)` | `GET` | `/policies/{param}` | `String policyId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `governance().policies().get(...)` | `GET` | `/policies/{param}` | `String policyId, Class responseType` | `@Nullable T` | -| `governance().policies().get(...)` | `GET` | `/policies/{param}` | `String policyId, TypeReference responseType` | `@Nullable T` | -| `governance().policies().create(...)` | `POST` | `/policies` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `governance().policies().create(...)` | `POST` | `/policies` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `governance().policies().create(...)` | `POST` | `/policies` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `governance().policies().create(...)` | `POST` | `/policies` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `governance().policies().createFromTemplate(...)` | `POST` | `/policies/from-template` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `governance().policies().createFromTemplate(...)` | `POST` | `/policies/from-template` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `governance().policies().createFromTemplate(...)` | `POST` | `/policies/from-template` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `governance().policies().createFromTemplate(...)` | `POST` | `/policies/from-template` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `governance().policies().validate(...)` | `POST` | `/policies/validate` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `governance().policies().validate(...)` | `POST` | `/policies/validate` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `governance().policies().validate(...)` | `POST` | `/policies/validate` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `governance().policies().validate(...)` | `POST` | `/policies/validate` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `governance().policies().update(...)` | `PUT` | `/policies/{param}` | `String policyId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `governance().policies().update(...)` | `PUT` | `/policies/{param}` | `String policyId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `governance().policies().update(...)` | `PUT` | `/policies/{param}` | `String policyId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `governance().policies().update(...)` | `PUT` | `/policies/{param}` | `String policyId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `governance().roles().delete(...)` | `DELETE` | `/roles/{param}` | `String roleId, QueryParams query, Class responseType` | `@Nullable T` | -| `governance().roles().delete(...)` | `DELETE` | `/roles/{param}` | `String roleId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `governance().roles().delete(...)` | `DELETE` | `/roles/{param}` | `String roleId, Class responseType` | `@Nullable T` | -| `governance().roles().delete(...)` | `DELETE` | `/roles/{param}` | `String roleId, TypeReference responseType` | `@Nullable T` | -| `governance().roles().list(...)` | `GET` | `/roles` | `QueryParams query, Class responseType` | `@Nullable T` | -| `governance().roles().list(...)` | `GET` | `/roles` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `governance().roles().list(...)` | `GET` | `/roles` | `Class responseType` | `@Nullable T` | -| `governance().roles().list(...)` | `GET` | `/roles` | `TypeReference responseType` | `@Nullable T` | -| `governance().roles().get(...)` | `GET` | `/roles/{param}` | `String roleId, QueryParams query, Class responseType` | `@Nullable T` | -| `governance().roles().get(...)` | `GET` | `/roles/{param}` | `String roleId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `governance().roles().get(...)` | `GET` | `/roles/{param}` | `String roleId, Class responseType` | `@Nullable T` | -| `governance().roles().get(...)` | `GET` | `/roles/{param}` | `String roleId, TypeReference responseType` | `@Nullable T` | -| `governance().roles().create(...)` | `POST` | `/roles` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `governance().roles().create(...)` | `POST` | `/roles` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `governance().roles().create(...)` | `POST` | `/roles` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `governance().roles().create(...)` | `POST` | `/roles` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `governance().compliance().assessments().list(...)` | `GET` | `/compliance/assessments` | `QueryParams query, Class responseType` | `@Nullable T` | -| `governance().compliance().assessments().list(...)` | `GET` | `/compliance/assessments` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `governance().compliance().assessments().list(...)` | `GET` | `/compliance/assessments` | `Class responseType` | `@Nullable T` | -| `governance().compliance().assessments().list(...)` | `GET` | `/compliance/assessments` | `TypeReference responseType` | `@Nullable T` | -| `governance().compliance().assessments().get(...)` | `GET` | `/compliance/assessments/{param}` | `String assessmentId, QueryParams query, Class responseType` | `@Nullable T` | -| `governance().compliance().assessments().get(...)` | `GET` | `/compliance/assessments/{param}` | `String assessmentId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `governance().compliance().assessments().get(...)` | `GET` | `/compliance/assessments/{param}` | `String assessmentId, Class responseType` | `@Nullable T` | -| `governance().compliance().assessments().get(...)` | `GET` | `/compliance/assessments/{param}` | `String assessmentId, TypeReference responseType` | `@Nullable T` | -| `governance().compliance().assessments().create(...)` | `POST` | `/compliance/assessments` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `governance().compliance().assessments().create(...)` | `POST` | `/compliance/assessments` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `governance().compliance().assessments().create(...)` | `POST` | `/compliance/assessments` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `governance().compliance().assessments().create(...)` | `POST` | `/compliance/assessments` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `governance().compliance().frameworks().list(...)` | `GET` | `/compliance/frameworks` | `QueryParams query, Class responseType` | `@Nullable T` | -| `governance().compliance().frameworks().list(...)` | `GET` | `/compliance/frameworks` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `governance().compliance().frameworks().list(...)` | `GET` | `/compliance/frameworks` | `Class responseType` | `@Nullable T` | -| `governance().compliance().frameworks().list(...)` | `GET` | `/compliance/frameworks` | `TypeReference responseType` | `@Nullable T` | -| `governance().compliance().violations().list(...)` | `GET` | `/compliance/violations` | `QueryParams query, Class responseType` | `@Nullable T` | -| `governance().compliance().violations().list(...)` | `GET` | `/compliance/violations` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `governance().compliance().violations().list(...)` | `GET` | `/compliance/violations` | `Class responseType` | `@Nullable T` | -| `governance().compliance().violations().list(...)` | `GET` | `/compliance/violations` | `TypeReference responseType` | `@Nullable T` | -| `governance().compliance().violations().resolve(...)` | `POST` | `/compliance/violations/{param}/resolve` | `String violationId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `governance().compliance().violations().resolve(...)` | `POST` | `/compliance/violations/{param}/resolve` | `String violationId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `governance().compliance().violations().resolve(...)` | `POST` | `/compliance/violations/{param}/resolve` | `String violationId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `governance().compliance().violations().resolve(...)` | `POST` | `/compliance/violations/{param}/resolve` | `String violationId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `governance().policies().templates().list(...)` | `GET` | `/policies/templates` | `QueryParams query, Class responseType` | `@Nullable T` | -| `governance().policies().templates().list(...)` | `GET` | `/policies/templates` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `governance().policies().templates().list(...)` | `GET` | `/policies/templates` | `Class responseType` | `@Nullable T` | -| `governance().policies().templates().list(...)` | `GET` | `/policies/templates` | `TypeReference responseType` | `@Nullable T` | -| `governance().policies().versions().list(...)` | `GET` | `/policies/{param}/versions` | `String policyId, QueryParams query, Class responseType` | `@Nullable T` | -| `governance().policies().versions().list(...)` | `GET` | `/policies/{param}/versions` | `String policyId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `governance().policies().versions().list(...)` | `GET` | `/policies/{param}/versions` | `String policyId, Class responseType` | `@Nullable T` | -| `governance().policies().versions().list(...)` | `GET` | `/policies/{param}/versions` | `String policyId, TypeReference responseType` | `@Nullable T` | - -The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/invocations.md b/docs/api/invocations.md deleted file mode 100644 index 05b04b0..0000000 --- a/docs/api/invocations.md +++ /dev/null @@ -1,14 +0,0 @@ -# Invocations API - -Service accessor: `frontal.invocations()` (`InvocationsClient`). - -Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. - -| Method | HTTP | Route | Parameters | Response | -| --- | --- | --- | --- | --- | -| `invocations().create(...)` | `POST` | `/invocations` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `invocations().create(...)` | `POST` | `/invocations` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `invocations().create(...)` | `POST` | `/invocations` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `invocations().create(...)` | `POST` | `/invocations` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | - -The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/lineage.md b/docs/api/lineage.md deleted file mode 100644 index b1a38e2..0000000 --- a/docs/api/lineage.md +++ /dev/null @@ -1,38 +0,0 @@ -# Lineage API - -Service accessor: `frontal.lineage()` (`LineageClient`). - -Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. - -| Method | HTTP | Route | Parameters | Response | -| --- | --- | --- | --- | --- | -| `lineage().getGraph(...)` | `GET` | `/lineage/graph` | `QueryParams query, Class responseType` | `@Nullable T` | -| `lineage().getGraph(...)` | `GET` | `/lineage/graph` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `lineage().getGraph(...)` | `GET` | `/lineage/graph` | `Class responseType` | `@Nullable T` | -| `lineage().getGraph(...)` | `GET` | `/lineage/graph` | `TypeReference responseType` | `@Nullable T` | -| `lineage().createImpact(...)` | `POST` | `/lineage/impact` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `lineage().createImpact(...)` | `POST` | `/lineage/impact` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `lineage().createImpact(...)` | `POST` | `/lineage/impact` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `lineage().createImpact(...)` | `POST` | `/lineage/impact` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `lineage().edges().list(...)` | `GET` | `/lineage/edges` | `QueryParams query, Class responseType` | `@Nullable T` | -| `lineage().edges().list(...)` | `GET` | `/lineage/edges` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `lineage().edges().list(...)` | `GET` | `/lineage/edges` | `Class responseType` | `@Nullable T` | -| `lineage().edges().list(...)` | `GET` | `/lineage/edges` | `TypeReference responseType` | `@Nullable T` | -| `lineage().edges().get(...)` | `GET` | `/lineage/edges/{param}` | `String edgeId, QueryParams query, Class responseType` | `@Nullable T` | -| `lineage().edges().get(...)` | `GET` | `/lineage/edges/{param}` | `String edgeId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `lineage().edges().get(...)` | `GET` | `/lineage/edges/{param}` | `String edgeId, Class responseType` | `@Nullable T` | -| `lineage().edges().get(...)` | `GET` | `/lineage/edges/{param}` | `String edgeId, TypeReference responseType` | `@Nullable T` | -| `lineage().nodes().list(...)` | `GET` | `/lineage/nodes` | `QueryParams query, Class responseType` | `@Nullable T` | -| `lineage().nodes().list(...)` | `GET` | `/lineage/nodes` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `lineage().nodes().list(...)` | `GET` | `/lineage/nodes` | `Class responseType` | `@Nullable T` | -| `lineage().nodes().list(...)` | `GET` | `/lineage/nodes` | `TypeReference responseType` | `@Nullable T` | -| `lineage().nodes().get(...)` | `GET` | `/lineage/nodes/{param}` | `String nodeId, QueryParams query, Class responseType` | `@Nullable T` | -| `lineage().nodes().get(...)` | `GET` | `/lineage/nodes/{param}` | `String nodeId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `lineage().nodes().get(...)` | `GET` | `/lineage/nodes/{param}` | `String nodeId, Class responseType` | `@Nullable T` | -| `lineage().nodes().get(...)` | `GET` | `/lineage/nodes/{param}` | `String nodeId, TypeReference responseType` | `@Nullable T` | -| `lineage().nodes().getTrace(...)` | `GET` | `/lineage/nodes/{param}/trace` | `String nodeId, QueryParams query, Class responseType` | `@Nullable T` | -| `lineage().nodes().getTrace(...)` | `GET` | `/lineage/nodes/{param}/trace` | `String nodeId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `lineage().nodes().getTrace(...)` | `GET` | `/lineage/nodes/{param}/trace` | `String nodeId, Class responseType` | `@Nullable T` | -| `lineage().nodes().getTrace(...)` | `GET` | `/lineage/nodes/{param}/trace` | `String nodeId, TypeReference responseType` | `@Nullable T` | - -The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/methods-as-code.md b/docs/api/methods-as-code.md deleted file mode 100644 index fbc1076..0000000 --- a/docs/api/methods-as-code.md +++ /dev/null @@ -1,724 +0,0 @@ -# Canonical Java calls - -Generated from the contract route catalog. Query parameters are optional; use `QueryParams` when required by the endpoint. - -## agents - -```java -client.agents().delete(agentId, responseType); -client.agents().list(responseType); -client.agents().health(responseType); -client.agents().get(agentId, responseType); -client.agents().create(body, responseType); -client.agents().rollback(agentId, body, responseType); -client.agents().update(agentId, body, responseType); -client.agents().runs().getByActionRunId(actionRunId, responseType); -client.agents().runs().get(runId, responseType); -client.agents().runs().conversation(runId, responseType); -client.agents().runs().list(agentId, responseType); -client.agents().runs().create(agentId, body, responseType); -client.agents().runs().stream(runId); -client.agents().runs().streamBlocking(runId); -client.agents().versions().list(agentId, responseType); -``` - -## ai - -```java -client.ai().health(responseType); -client.ai().internal().embed(body, responseType); -client.ai().internal().predict(body, responseType); -client.ai().internal().rerank(body, responseType); -client.ai().internal().predictForm(fields, files, responseType); -client.ai().internal().predictRaw(body, responseType); -client.ai().chat().completions().create(body, responseType); -client.ai().internal().models().list(responseType); -client.ai().internal().models().defaults(responseType); -``` - -## audit - -```java -client.audit().events().list(responseType); -client.audit().events().get(eventId, responseType); -client.audit().events().create(body, responseType); -client.audit().events().batch(body, responseType); -``` - -## auth - -```java -client.auth().getUser(responseType); -client.auth().createAuthorize(body, responseType); -client.auth().createInvite(body, responseType); -client.auth().login(body, responseType); -client.auth().logout(body, responseType); -client.auth().createOtp(body, responseType); -client.auth().createReauthenticate(body, responseType); -client.auth().createRecover(body, responseType); -client.auth().createResend(body, responseType); -client.auth().createSignup(body, responseType); -client.auth().createSso(body, responseType); -client.auth().createTokenGrantTypeIdToken(body, responseType); -client.auth().createTokenGrantTypePassword(body, responseType); -client.auth().createTokenGrantTypePkce(body, responseType); -client.auth().createTokenGrantTypeRefreshToken(body, responseType); -client.auth().verify(body, responseType); -client.auth().updateUser(body, responseType); -client.auth().account().deleteProfile(responseType); -client.auth().account().getAuditLog(responseType); -client.auth().account().getMfa(responseType); -client.auth().account().getProfile(responseType); -client.auth().account().createMfa(body, responseType); -client.auth().account().createPassword(body, responseType); -client.auth().account().updateProfile(body, responseType); -client.auth().admin().createGenerateLink(body, responseType); -client.auth().admin().logout(body, responseType); -client.auth().auth().getSession(responseType); -client.auth().auth().createSession(body, responseType); -client.auth().factors().delete(factorId, responseType); -client.auth().factors().list(responseType); -client.auth().factors().create(body, responseType); -client.auth().factors().createChallenge(factorId, body, responseType); -client.auth().factors().verify(factorId, body, responseType); -client.auth().mfa().status(responseType); -client.auth().mfa().disable(body, responseType); -client.auth().mfa().enable(body, responseType); -client.auth().mfa().setup(body, responseType); -client.auth().mfa().verify(body, responseType); -client.auth().account().mfa().delete(mfaId, responseType); -client.auth().account().mfa().get(mfaId, responseType); -client.auth().account().mfa().createChallenge(mfaId, body, responseType); -client.auth().account().mfa().verify(mfaId, body, responseType); -client.auth().account().sessions().delete(sessionId, responseType); -client.auth().account().sessions().list(responseType); -client.auth().account().sessions().extend(sessionId, body, responseType); -client.auth().admin().users().delete(userId, responseType); -client.auth().admin().users().list(responseType); -client.auth().admin().users().get(userId, responseType); -client.auth().admin().users().create(body, responseType); -client.auth().admin().users().update(userId, body, responseType); -client.auth().mfa().backupCodes().createRegenerate(body, responseType); -client.auth().user().identities().delete(identityId, responseType); -client.auth().user().identities().list(responseType); -client.auth().user().identities().create(body, responseType); -client.auth().account().security().apiKeys().delete(apiKeyId, responseType); -client.auth().account().security().apiKeys().list(responseType); -client.auth().account().security().apiKeys().get(apiKeyId, responseType); -client.auth().account().security().apiKeys().create(body, responseType); -client.auth().account().security().apiKeys().update(apiKeyId, body, responseType); -client.auth().account().security().devices().delete(deviceId, responseType); -client.auth().account().security().devices().list(responseType); -client.auth().account().security().devices().get(deviceId, responseType); -client.auth().account().security().devices().create(body, responseType); -client.auth().account().security().devices().trust(deviceId, body, responseType); -client.auth().admin().users().factors().delete(userId, factorId, responseType); -client.auth().admin().users().factors().list(userId, responseType); -``` - -## billing - -```java -client.billing().customers().usage(customerId, responseType); -client.billing().invoices().getPdf(invoiceId, responseType); -client.billing().invoices().preview(body, responseType); -client.billing().invoices().finalize(invoiceId, body, responseType); -client.billing().invoices().resourceVoid(invoiceId, body, responseType); -client.billing().meters().disable(meterId, body, responseType); -client.billing().plans().clone(planId, body, responseType); -client.billing().subscriptions().activate(subscriptionId, body, responseType); -client.billing().subscriptions().cancel(subscriptionId, body, responseType); -client.billing().subscriptions().pause(subscriptionId, body, responseType); -client.billing().subscriptions().resume(subscriptionId, body, responseType); -client.billing().wallets().createTerminate(walletId, body, responseType); -client.billing().wallets().topUp(walletId, body, responseType); -client.billing().addons().entitlements().list(addonId, responseType); -client.billing().customers().entitlements().list(customerId, responseType); -client.billing().customers().invoices().summary(customerId, responseType); -client.billing().customers().portal().get(portalId, responseType); -client.billing().customers().wallets().list(customerId, responseType); -client.billing().plans().entitlements().list(planId, responseType); -client.billing().prices().lookup().get(lookupId, responseType); -client.billing().subscriptions().entitlements().list(subscriptionId, responseType); -client.billing().wallets().balance().getRealTime(walletId, responseType); -client.billing().wallets().transactions().list(walletId, responseType); -``` - -## blob - -```java -client.blob().object().delete(objectId, objectId2, responseType); -client.blob().object().get(objectId, objectId2, responseType); -client.blob().object().copy(body, responseType); -client.blob().object().move(body, responseType); -client.blob().object().get2(objectId, objectId2, fields, files, responseType); -client.blob().object().info().get(infoId, infoId2, responseType); -client.blob().object().list().get(listId, body, responseType); -client.blob().object().sign().get(signId, signId2, body, responseType); -``` - -## connection-tests - -```java -client.connectionTests().get(connectionTestId, responseType); -``` - -## connectors - -```java -client.connectors().getCatalog(responseType); -client.connectors().catalog().get(catalogId, responseType); -client.connectors().connectionTests().get(connectionTestId, responseType); -client.connectors().diagnostics().list(responseType); -client.connectors().installations().delete(installationId, responseType); -client.connectors().installations().list(responseType); -client.connectors().installations().get(installationId, responseType); -client.connectors().installations().update(installationId, body, responseType); -client.connectors().installations().create(body, responseType); -client.connectors().installations().pause(installationId, body, responseType); -client.connectors().installations().resume(installationId, body, responseType); -client.connectors().syncRuns().replay(syncRunId, body, responseType); -``` - -## data - -```java -client.data().aggregations().health(responseType); -client.data().aggregations().getInfo(responseType); -client.data().archival().health(responseType); -client.data().archival().getInfo(responseType); -client.data().catalog().health(responseType); -client.data().catalog().getInfo(responseType); -client.data().enrichment().health(responseType); -client.data().enrichment().getInfo(responseType); -client.data().exports().health(responseType); -client.data().exports().getInfo(responseType); -client.data().ingest().health(responseType); -client.data().ingest().getInfo(responseType); -client.data().normalization().health(responseType); -client.data().normalization().getInfo(responseType); -client.data().pipelines().health(responseType); -client.data().pipelines().getInfo(responseType); -client.data().quality().health(responseType); -client.data().quality().getInfo(responseType); -client.data().query().health(responseType); -client.data().query().getInfo(responseType); -client.data().schemas().health(responseType); -client.data().schemas().getInfo(responseType); -client.data().serving().health(responseType); -client.data().serving().getInfo(responseType); -client.data().streams().health(responseType); -client.data().streams().getInfo(responseType); -client.data().sync().health(responseType); -client.data().sync().getInfo(responseType); -client.data().transformations().health(responseType); -client.data().transformations().getInfo(responseType); -client.data().aggregations().aggregations().list(responseType); -client.data().aggregations().aggregations().get(aggregationId, responseType); -client.data().aggregations().aggregations().create(body, responseType); -client.data().aggregations().capabilities().list(responseType); -client.data().aggregations().runs().list(responseType); -client.data().aggregations().runs().get(runId, responseType); -client.data().aggregations().runs().create(body, responseType); -client.data().archival().capabilities().list(responseType); -client.data().archival().runs().list(responseType); -client.data().archival().runs().get(runId, responseType); -client.data().archival().runs().create(body, responseType); -client.data().catalog().capabilities().list(responseType); -client.data().catalog().runs().list(responseType); -client.data().catalog().runs().get(runId, responseType); -client.data().catalog().runs().create(body, responseType); -client.data().enrichment().capabilities().list(responseType); -client.data().enrichment().runs().list(responseType); -client.data().enrichment().runs().get(runId, responseType); -client.data().enrichment().runs().create(body, responseType); -client.data().exports().capabilities().list(responseType); -client.data().exports().exports().list(responseType); -client.data().exports().exports().get(exportId, responseType); -client.data().exports().exports().create(body, responseType); -client.data().exports().runs().list(responseType); -client.data().exports().runs().get(runId, responseType); -client.data().exports().runs().create(body, responseType); -client.data().ingest().capabilities().list(responseType); -client.data().ingest().datasets().list(responseType); -client.data().ingest().datasets().get(datasetId, responseType); -client.data().ingest().datasets().ingest(body, responseType); -client.data().ingest().runs().list(responseType); -client.data().ingest().runs().get(runId, responseType); -client.data().ingest().runs().create(body, responseType); -client.data().ingest().schemas().list(responseType); -client.data().ingest().schemas().get(schemaRef, responseType); -client.data().normalization().capabilities().list(responseType); -client.data().normalization().runs().list(responseType); -client.data().normalization().runs().get(runId, responseType); -client.data().normalization().runs().create(body, responseType); -client.data().pipelines().capabilities().list(responseType); -client.data().pipelines().pipelineRuns().list(responseType); -client.data().pipelines().pipelineRuns().get(runId, responseType); -client.data().pipelines().pipelines().list(responseType); -client.data().pipelines().pipelines().get(definitionId, responseType); -client.data().pipelines().pipelines().create(body, responseType); -client.data().pipelines().runs().list(responseType); -client.data().pipelines().runs().get(runId, responseType); -client.data().pipelines().runs().create(body, responseType); -client.data().quality().capabilities().list(responseType); -client.data().quality().runs().list(responseType); -client.data().quality().runs().get(runId, responseType); -client.data().quality().runs().create(body, responseType); -client.data().query().capabilities().list(responseType); -client.data().query().query().federated(body, responseType); -client.data().query().runs().list(responseType); -client.data().query().runs().get(runId, responseType); -client.data().query().runs().create(body, responseType); -client.data().schemas().capabilities().list(responseType); -client.data().schemas().runs().list(responseType); -client.data().schemas().runs().get(runId, responseType); -client.data().schemas().runs().create(body, responseType); -client.data().schemas().schemas().list(responseType); -client.data().schemas().schemas().get(schemaRef, responseType); -client.data().schemas().schemas().create(body, responseType); -client.data().schemas().schemas().resolve(body, responseType); -client.data().serving().capabilities().list(responseType); -client.data().serving().runs().list(responseType); -client.data().serving().runs().get(runId, responseType); -client.data().serving().runs().create(body, responseType); -client.data().streams().capabilities().list(responseType); -client.data().streams().runs().list(responseType); -client.data().streams().runs().get(runId, responseType); -client.data().streams().runs().create(body, responseType); -client.data().streams().streams().list(responseType); -client.data().streams().streams().get(streamId, responseType); -client.data().streams().streams().create(body, responseType); -client.data().sync().capabilities().list(responseType); -client.data().sync().runs().list(responseType); -client.data().sync().runs().get(runId, responseType); -client.data().sync().runs().create(body, responseType); -client.data().transformations().capabilities().list(responseType); -client.data().transformations().runs().list(responseType); -client.data().transformations().runs().get(runId, responseType); -client.data().transformations().runs().create(body, responseType); -client.data().transformations().transformations().list(responseType); -client.data().transformations().transformations().get(transformationId, responseType); -client.data().transformations().transformations().create(body, responseType); -client.data().aggregations().aggregations().executions().create(aggregationId, body, responseType); -client.data().archival().archival().policies().list(responseType); -client.data().archival().archival().policies().get(policyId, responseType); -client.data().archival().archival().policies().create(body, responseType); -client.data().catalog().catalog().datasets().list(responseType); -client.data().catalog().catalog().datasets().get(datasetId, responseType); -client.data().catalog().catalog().sources().list(responseType); -client.data().catalog().catalog().sources().get(sourceId, responseType); -client.data().enrichment().enrichment().profiles().list(responseType); -client.data().enrichment().enrichment().profiles().get(profileId, responseType); -client.data().enrichment().enrichment().profiles().create(body, responseType); -client.data().exports().exports().executions().create(exportId, body, responseType); -client.data().ingest().datasets().artifacts().getContent(datasetId, manifestId, responseType); -client.data().normalization().normalization().profiles().list(responseType); -client.data().normalization().normalization().profiles().get(profileId, responseType); -client.data().normalization().normalization().profiles().create(body, responseType); -client.data().quality().quality().rulesets().list(responseType); -client.data().quality().quality().rulesets().get(rulesetId, responseType); -client.data().quality().quality().rulesets().create(body, responseType); -client.data().serving().serving().products().list(responseType); -client.data().serving().serving().products().get(productId, responseType); -client.data().serving().serving().products().create(body, responseType); -client.data().streams().streams().deliveries().create(streamId, body, responseType); -client.data().sync().sync().jobs().list(responseType); -client.data().sync().sync().jobs().get(jobId, responseType); -client.data().sync().sync().jobs().create(body, responseType); -client.data().transformations().transformations().executions().create(transformationId, body, responseType); -client.data().archival().archival().policies().executions().create(policyId, body, responseType); -client.data().catalog().catalog().datasets().artifacts().getContent(datasetId, manifestId, responseType); -client.data().enrichment().enrichment().profiles().executions().create(profileId, body, responseType); -client.data().normalization().normalization().profiles().executions().create(profileId, body, responseType); -client.data().quality().quality().rulesets().evaluations().create(rulesetId, body, responseType); -client.data().serving().serving().products().refreshes().create(productId, body, responseType); -client.data().sync().sync().jobs().executions().create(jobId, body, responseType); -``` - -## events - -```java -client.events().list(responseType); -client.events().getMonitoring(responseType); -client.events().get(id, responseType); -client.events().create(body, responseType); -client.events().analytics(body, responseType); -client.events().createAnalyticsV2(body, responseType); -client.events().bulk(body, responseType); -client.events().createHuggingfaceBilling(body, responseType); -client.events().query(body, responseType); -client.events().reprocess(body, responseType); -client.events().usage(body, responseType); -client.events().benchmark().createV1(body, responseType); -client.events().benchmark().createV2(body, responseType); -client.events().reprocess().createInternal(body, responseType); -client.events().usage().createMeter(body, responseType); -client.events().raw().reprocess().createAll(body, responseType); -client.events().raw().reprocess().createPending(body, responseType); -``` - -## governance - -```java -client.governance().access().check(body, responseType); -client.governance().compliance().getScore(responseType); -client.governance().permissions().list(responseType); -client.governance().permissions().get(permissionId, responseType); -client.governance().permissions().create(body, responseType); -client.governance().policies().delete(policyId, responseType); -client.governance().policies().list(responseType); -client.governance().policies().get(policyId, responseType); -client.governance().policies().create(body, responseType); -client.governance().policies().createFromTemplate(body, responseType); -client.governance().policies().validate(body, responseType); -client.governance().policies().update(policyId, body, responseType); -client.governance().roles().delete(roleId, responseType); -client.governance().roles().list(responseType); -client.governance().roles().get(roleId, responseType); -client.governance().roles().create(body, responseType); -client.governance().compliance().assessments().list(responseType); -client.governance().compliance().assessments().get(assessmentId, responseType); -client.governance().compliance().assessments().create(body, responseType); -client.governance().compliance().frameworks().list(responseType); -client.governance().compliance().violations().list(responseType); -client.governance().compliance().violations().resolve(violationId, body, responseType); -client.governance().policies().templates().list(responseType); -client.governance().policies().versions().list(policyId, responseType); -``` - -## invocations - -```java -client.invocations().create(body, responseType); -``` - -## lineage - -```java -client.lineage().getGraph(responseType); -client.lineage().createImpact(body, responseType); -client.lineage().edges().list(responseType); -client.lineage().edges().get(edgeId, responseType); -client.lineage().nodes().list(responseType); -client.lineage().nodes().get(nodeId, responseType); -client.lineage().nodes().getTrace(nodeId, responseType); -``` - -## observability - -```java -client.observability().alerts().delete(alertId, responseType); -client.observability().alerts().list(responseType); -client.observability().alerts().create(body, responseType); -client.observability().alerts().disable(alertId, body, responseType); -client.observability().alerts().enable(alertId, body, responseType); -client.observability().alerts().update(alertId, body, responseType); -client.observability().dashboards().delete(dashboardId, responseType); -client.observability().dashboards().list(responseType); -client.observability().dashboards().get(dashboardId, responseType); -client.observability().dashboards().create(body, responseType); -client.observability().dashboards().share(dashboardId, body, responseType); -client.observability().dashboards().update(dashboardId, body, responseType); -client.observability().events().create(body, responseType); -client.observability().events().batch(body, responseType); -client.observability().logs().ingest(body, responseType); -client.observability().logs().query(body, responseType); -client.observability().logs().stream(); -client.observability().logs().streamBlocking(); -client.observability().metrics().list(responseType); -client.observability().metrics().getList(responseType); -client.observability().metrics().ingest(body, responseType); -client.observability().traces().list(responseType); -client.observability().traces().get(traceId, responseType); -client.observability().traces().query(body, responseType); -client.observability().alerts().incidents().list(responseType); -client.observability().alerts().rules().delete(ruleId, responseType); -client.observability().alerts().rules().list(responseType); -client.observability().alerts().rules().get(ruleId, responseType); -client.observability().alerts().rules().create(body, responseType); -client.observability().alerts().rules().toggle(ruleId, body, responseType); -client.observability().alerts().rules().update(ruleId, body, responseType); -client.observability().events().stats().list(responseType); -``` - -## ontology - -```java -client.ontology().engine().health(responseType); -client.ontology().engine().getInfo(responseType); -client.ontology().events().health(responseType); -client.ontology().events().getInfo(responseType); -client.ontology().extract().health(responseType); -client.ontology().extract().getInfo(responseType); -client.ontology().graph().health(responseType); -client.ontology().graph().getInfo(responseType); -client.ontology().objects().health(responseType); -client.ontology().objects().getInfo(responseType); -client.ontology().reasoning().health(responseType); -client.ontology().reasoning().getInfo(responseType); -client.ontology().reasoning().createExplain(body, responseType); -client.ontology().relationships().health(responseType); -client.ontology().relationships().getInfo(responseType); -client.ontology().rollouts().health(responseType); -client.ontology().rollouts().getInfo(responseType); -client.ontology().rollups().health(responseType); -client.ontology().rollups().getInfo(responseType); -client.ontology().schemas().health(responseType); -client.ontology().schemas().getInfo(responseType); -client.ontology().transformations().health(responseType); -client.ontology().transformations().getInfo(responseType); -client.ontology().validation().health(responseType); -client.ontology().validation().getInfo(responseType); -client.ontology().versions().health(responseType); -client.ontology().versions().getInfo(responseType); -client.ontology().engine().capabilities().list(responseType); -client.ontology().engine().ontologies().export(body, responseType); -client.ontology().engine().ontologies().createExportShacl(body, responseType); -client.ontology().engine().ontologies().generate(body, responseType); -client.ontology().engine().ontologies().validate(body, responseType); -client.ontology().engine().runs().list(responseType); -client.ontology().engine().runs().get(runId, responseType); -client.ontology().engine().runs().create(body, responseType); -client.ontology().events().capabilities().list(responseType); -client.ontology().events().events().list(responseType); -client.ontology().events().events().get(eventId, responseType); -client.ontology().events().events().create(body, responseType); -client.ontology().events().runs().list(responseType); -client.ontology().events().runs().get(runId, responseType); -client.ontology().events().runs().create(body, responseType); -client.ontology().extract().capabilities().list(responseType); -client.ontology().extract().extract().analyze(body, responseType); -client.ontology().extract().extract().createArchitecture(body, responseType); -client.ontology().extract().runs().list(responseType); -client.ontology().extract().runs().get(runId, responseType); -client.ontology().extract().runs().create(body, responseType); -client.ontology().graph().capabilities().list(responseType); -client.ontology().graph().entities().get(entityId, responseType); -client.ontology().graph().entities().getProvenance(entityId, responseType); -client.ontology().graph().entities().update(entityId, body, responseType); -client.ontology().graph().graph().analyze(body, responseType); -client.ontology().graph().graph().createBuild(body, responseType); -client.ontology().graph().graph().createBulkRead(body, responseType); -client.ontology().graph().graph().createNeighborhood(body, responseType); -client.ontology().graph().graph().createPath(body, responseType); -client.ontology().graph().graph().query(body, responseType); -client.ontology().graph().relationships().get(relationshipId, responseType); -client.ontology().graph().relationships().update(relationshipId, body, responseType); -client.ontology().graph().runs().list(responseType); -client.ontology().graph().runs().get(runId, responseType); -client.ontology().graph().runs().create(body, responseType); -client.ontology().objects().capabilities().list(responseType); -client.ontology().objects().objectTypes().delete(objectTypeId, responseType); -client.ontology().objects().objectTypes().list(responseType); -client.ontology().objects().objectTypes().get(objectTypeId, responseType); -client.ontology().objects().objectTypes().update(objectTypeId, body, responseType); -client.ontology().objects().objects().delete(objectId, responseType); -client.ontology().objects().objects().list(responseType); -client.ontology().objects().objects().get(objectId, responseType); -client.ontology().objects().objects().update(objectId, body, responseType); -client.ontology().objects().runs().list(responseType); -client.ontology().objects().runs().get(runId, responseType); -client.ontology().objects().runs().create(body, responseType); -client.ontology().reasoning().capabilities().list(responseType); -client.ontology().reasoning().facts().create(body, responseType); -client.ontology().reasoning().facts().createLoadGraph(body, responseType); -client.ontology().reasoning().reason().createBackward(body, responseType); -client.ontology().reasoning().reason().createForward(body, responseType); -client.ontology().reasoning().rules().delete(ruleId, responseType); -client.ontology().reasoning().rules().list(responseType); -client.ontology().reasoning().rules().create(body, responseType); -client.ontology().reasoning().rules().update(ruleId, body, responseType); -client.ontology().reasoning().runs().list(responseType); -client.ontology().reasoning().runs().get(runId, responseType); -client.ontology().reasoning().runs().create(body, responseType); -client.ontology().relationships().capabilities().list(responseType); -client.ontology().relationships().relationshipTypes().delete(relationshipTypeId, responseType); -client.ontology().relationships().relationshipTypes().list(responseType); -client.ontology().relationships().relationships().delete(relationshipId, responseType); -client.ontology().relationships().relationships().list(responseType); -client.ontology().relationships().relationships().get(relationshipId, responseType); -client.ontology().relationships().relationships().update(relationshipId, body, responseType); -client.ontology().relationships().runs().list(responseType); -client.ontology().relationships().runs().get(runId, responseType); -client.ontology().relationships().runs().create(body, responseType); -client.ontology().rollouts().capabilities().list(responseType); -client.ontology().rollouts().rollouts().delete(rolloutId, responseType); -client.ontology().rollouts().rollouts().list(responseType); -client.ontology().rollouts().rollouts().get(rolloutId, responseType); -client.ontology().rollouts().rollouts().status(rolloutId, responseType); -client.ontology().rollouts().rollouts().create(body, responseType); -client.ontology().rollouts().rollouts().pause(rolloutId, body, responseType); -client.ontology().rollouts().rollouts().resume(rolloutId, body, responseType); -client.ontology().rollouts().rollouts().rollback(rolloutId, body, responseType); -client.ontology().rollouts().rollouts().createStart(rolloutId, body, responseType); -client.ontology().rollouts().rollouts().update(rolloutId, body, responseType); -client.ontology().rollouts().runs().list(responseType); -client.ontology().rollouts().runs().get(runId, responseType); -client.ontology().rollouts().runs().create(body, responseType); -client.ontology().rollups().capabilities().list(responseType); -client.ontology().rollups().rollupResults().get(executionId, responseType); -client.ontology().rollups().rollups().delete(rollupId, responseType); -client.ontology().rollups().rollups().list(responseType); -client.ontology().rollups().rollups().get(rollupId, responseType); -client.ontology().rollups().rollups().getResult(rollupId, responseType); -client.ontology().rollups().rollups().create(body, responseType); -client.ontology().rollups().rollups().execute(rollupId, body, responseType); -client.ontology().rollups().rollups().preview(rollupId, body, responseType); -client.ontology().rollups().rollups().update(rollupId, body, responseType); -client.ontology().rollups().runs().list(responseType); -client.ontology().rollups().runs().get(runId, responseType); -client.ontology().rollups().runs().create(body, responseType); -client.ontology().schemas().capabilities().list(responseType); -client.ontology().schemas().runs().list(responseType); -client.ontology().schemas().runs().get(runId, responseType); -client.ontology().schemas().runs().create(body, responseType); -client.ontology().schemas().schemas().delete(schemaId, responseType); -client.ontology().schemas().schemas().list(responseType); -client.ontology().schemas().schemas().get(schemaId, responseType); -client.ontology().schemas().schemas().create(body, responseType); -client.ontology().schemas().schemas().validate(body, responseType); -client.ontology().transformations().capabilities().list(responseType); -client.ontology().transformations().runs().list(responseType); -client.ontology().transformations().runs().get(runId, responseType); -client.ontology().transformations().runs().create(body, responseType); -client.ontology().transformations().transformations().create(body, responseType); -client.ontology().validation().capabilities().list(responseType); -client.ontology().validation().payloads().validate(body, responseType); -client.ontology().validation().rules().delete(ruleId, responseType); -client.ontology().validation().rules().list(responseType); -client.ontology().validation().rules().get(ruleId, responseType); -client.ontology().validation().rules().create(body, responseType); -client.ontology().validation().runs().list(responseType); -client.ontology().validation().runs().get(runId, responseType); -client.ontology().validation().runs().create(body, responseType); -client.ontology().versions().audit().verify(body, responseType); -client.ontology().versions().capabilities().list(responseType); -client.ontology().versions().releaseBundles().list(responseType); -client.ontology().versions().releaseBundles().get(bundleId, responseType); -client.ontology().versions().releaseBundles().create(body, responseType); -client.ontology().versions().runs().list(responseType); -client.ontology().versions().runs().get(runId, responseType); -client.ontology().versions().runs().create(body, responseType); -client.ontology().versions().versions().delete(versionId, responseType); -client.ontology().versions().versions().get(versionId, responseType); -client.ontology().versions().versions().create(body, responseType); -client.ontology().versions().versions().compare(body, responseType); -client.ontology().engine().ontologies().compareVersions().create(body, responseType); -client.ontology().engine().ontologies().inferClasses().create(body, responseType); -client.ontology().engine().ontologies().inferProperties().create(body, responseType); -client.ontology().events().events().checkpoints().get(consumer, responseType); -client.ontology().events().events().checkpoints().create(body, responseType); -client.ontology().events().events().leases().acknowledge(body, responseType); -client.ontology().events().events().leases().acquire(body, responseType); -client.ontology().extract().extract().coreferences().create(body, responseType); -client.ontology().extract().extract().entities().create(body, responseType); -client.ontology().extract().extract().events().create(body, responseType); -client.ontology().extract().extract().relations().create(body, responseType); -client.ontology().extract().extract().triplets().create(body, responseType); -``` - -## pipelines - -```java -client.pipelines().data().pipelines().health(responseType); -client.pipelines().data().pipelines().getInfo(responseType); -client.pipelines().data().pipelines().capabilities().list(responseType); -client.pipelines().data().pipelines().pipelineRuns().list(responseType); -client.pipelines().data().pipelines().pipelineRuns().get(pipelineRunId, responseType); -client.pipelines().data().pipelines().pipelineRuns().get2(pipelineRunId); -client.pipelines().data().pipelines().pipelineRuns().get2Blocking(pipelineRunId); -client.pipelines().data().pipelines().pipelines().list(responseType); -client.pipelines().data().pipelines().pipelines().get(pipelineId, responseType); -client.pipelines().data().pipelines().pipelines().create(body, responseType); -client.pipelines().data().pipelines().runs().list(responseType); -client.pipelines().data().pipelines().runs().create(body, responseType); -``` - -## providers - -```java -client.providers().get(providerSlug, responseType); -``` - -## react - -```java -``` - -## schedules - -```java -client.schedules().workflows().cron().parse(body, responseType); -client.schedules().workflows().cron().validate(body, responseType); -client.schedules().workflows().schedules().delete(scheduleId, responseType); -client.schedules().workflows().schedules().list(responseType); -client.schedules().workflows().schedules().get(scheduleId, responseType); -client.schedules().workflows().schedules().update(scheduleId, body, responseType); -client.schedules().workflows().schedules().create(body, responseType); -client.schedules().workflows().schedules().pause(scheduleId, body, responseType); -client.schedules().workflows().schedules().resume(scheduleId, body, responseType); -client.schedules().workflows().schedules().trigger(scheduleId, body, responseType); -``` - -## webhook-endpoints - -```java -client.webhookEndpoints().delete(id, responseType); -client.webhookEndpoints().list(responseType); -client.webhookEndpoints().get(id, responseType); -client.webhookEndpoints().update(id, body, responseType); -client.webhookEndpoints().create(body, responseType); -client.webhookEndpoints().rotateSecret(id, body, responseType); -client.webhookEndpoints().deliveries().list(id, responseType); -``` - -## webhooks - -```java -client.webhooks().delete(webhookId, responseType); -client.webhooks().list(responseType); -client.webhooks().get(webhookId, responseType); -client.webhooks().create(body, responseType); -client.webhooks().rotateSecret(webhookId, body, responseType); -client.webhooks().update(webhookId, body, responseType); -client.webhooks().deliveries().list(responseType); -client.webhooks().deliveries().get(deliveryId, responseType); -client.webhooks().deliveries().retry(deliveryId, body, responseType); -client.webhooks().stats().list(responseType); -``` - -## workflows - -```java -client.workflows().delete(workflowId, responseType); -client.workflows().list(responseType); -client.workflows().get(workflowId, responseType); -client.workflows().get2(workflowId, runId, responseType); -client.workflows().summary(workflowId, runId, responseType); -client.workflows().timeline(workflowId, runId, responseType); -client.workflows().update(workflowId, body, responseType); -client.workflows().create(body, responseType); -client.workflows().batch(body, responseType); -client.workflows().search(body, responseType); -client.workflows().archive(workflowId, body, responseType); -client.workflows().publish(workflowId, body, responseType); -client.workflows().restore(workflowId, body, responseType); -client.workflows().approvals().list(responseType); -client.workflows().approvals().get(approvalId, responseType); -client.workflows().approvals().approve(approvalId, body, responseType); -client.workflows().approvals().reject(approvalId, body, responseType); -client.workflows().executions().list(responseType); -client.workflows().executions().get(executionId, responseType); -client.workflows().executions().create(body, responseType); -client.workflows().tasks().get(taskId, responseType); -client.workflows().tasks().cancel(taskId, body, responseType); -client.workflows().tasks().retry(taskId, body, responseType); -client.workflows().templates().list(responseType); -client.workflows().templates().get(templateId, responseType); -client.workflows().templates().create(body, responseType); -client.workflows().templates().instantiate(templateId, body, responseType); -client.workflows().versions().create(workflowId, body, responseType); -client.workflows().executions().tasks().list(executionId, responseType); -client.workflows().runs().steps().list(runId, responseType); -``` diff --git a/docs/api/observability.md b/docs/api/observability.md deleted file mode 100644 index f897601..0000000 --- a/docs/api/observability.md +++ /dev/null @@ -1,134 +0,0 @@ -# Observability API - -Service accessor: `frontal.observability()` (`ObservabilityClient`). - -Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. - -| Method | HTTP | Route | Parameters | Response | -| --- | --- | --- | --- | --- | -| `observability().alerts().delete(...)` | `DELETE` | `/observability/alerts/{param}` | `String alertId, QueryParams query, Class responseType` | `@Nullable T` | -| `observability().alerts().delete(...)` | `DELETE` | `/observability/alerts/{param}` | `String alertId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `observability().alerts().delete(...)` | `DELETE` | `/observability/alerts/{param}` | `String alertId, Class responseType` | `@Nullable T` | -| `observability().alerts().delete(...)` | `DELETE` | `/observability/alerts/{param}` | `String alertId, TypeReference responseType` | `@Nullable T` | -| `observability().alerts().list(...)` | `GET` | `/observability/alerts` | `QueryParams query, Class responseType` | `@Nullable T` | -| `observability().alerts().list(...)` | `GET` | `/observability/alerts` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `observability().alerts().list(...)` | `GET` | `/observability/alerts` | `Class responseType` | `@Nullable T` | -| `observability().alerts().list(...)` | `GET` | `/observability/alerts` | `TypeReference responseType` | `@Nullable T` | -| `observability().alerts().create(...)` | `POST` | `/observability/alerts` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().alerts().create(...)` | `POST` | `/observability/alerts` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().alerts().create(...)` | `POST` | `/observability/alerts` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().alerts().create(...)` | `POST` | `/observability/alerts` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().alerts().disable(...)` | `POST` | `/observability/alerts/{param}/disable` | `String alertId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().alerts().disable(...)` | `POST` | `/observability/alerts/{param}/disable` | `String alertId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().alerts().disable(...)` | `POST` | `/observability/alerts/{param}/disable` | `String alertId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().alerts().disable(...)` | `POST` | `/observability/alerts/{param}/disable` | `String alertId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().alerts().enable(...)` | `POST` | `/observability/alerts/{param}/enable` | `String alertId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().alerts().enable(...)` | `POST` | `/observability/alerts/{param}/enable` | `String alertId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().alerts().enable(...)` | `POST` | `/observability/alerts/{param}/enable` | `String alertId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().alerts().enable(...)` | `POST` | `/observability/alerts/{param}/enable` | `String alertId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().alerts().update(...)` | `PUT` | `/observability/alerts/{param}` | `String alertId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().alerts().update(...)` | `PUT` | `/observability/alerts/{param}` | `String alertId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().alerts().update(...)` | `PUT` | `/observability/alerts/{param}` | `String alertId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().alerts().update(...)` | `PUT` | `/observability/alerts/{param}` | `String alertId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().dashboards().delete(...)` | `DELETE` | `/observability/dashboards/{param}` | `String dashboardId, QueryParams query, Class responseType` | `@Nullable T` | -| `observability().dashboards().delete(...)` | `DELETE` | `/observability/dashboards/{param}` | `String dashboardId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `observability().dashboards().delete(...)` | `DELETE` | `/observability/dashboards/{param}` | `String dashboardId, Class responseType` | `@Nullable T` | -| `observability().dashboards().delete(...)` | `DELETE` | `/observability/dashboards/{param}` | `String dashboardId, TypeReference responseType` | `@Nullable T` | -| `observability().dashboards().list(...)` | `GET` | `/observability/dashboards` | `QueryParams query, Class responseType` | `@Nullable T` | -| `observability().dashboards().list(...)` | `GET` | `/observability/dashboards` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `observability().dashboards().list(...)` | `GET` | `/observability/dashboards` | `Class responseType` | `@Nullable T` | -| `observability().dashboards().list(...)` | `GET` | `/observability/dashboards` | `TypeReference responseType` | `@Nullable T` | -| `observability().dashboards().get(...)` | `GET` | `/observability/dashboards/{param}` | `String dashboardId, QueryParams query, Class responseType` | `@Nullable T` | -| `observability().dashboards().get(...)` | `GET` | `/observability/dashboards/{param}` | `String dashboardId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `observability().dashboards().get(...)` | `GET` | `/observability/dashboards/{param}` | `String dashboardId, Class responseType` | `@Nullable T` | -| `observability().dashboards().get(...)` | `GET` | `/observability/dashboards/{param}` | `String dashboardId, TypeReference responseType` | `@Nullable T` | -| `observability().dashboards().create(...)` | `POST` | `/observability/dashboards` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().dashboards().create(...)` | `POST` | `/observability/dashboards` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().dashboards().create(...)` | `POST` | `/observability/dashboards` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().dashboards().create(...)` | `POST` | `/observability/dashboards` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().dashboards().share(...)` | `POST` | `/observability/dashboards/{param}/share` | `String dashboardId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().dashboards().share(...)` | `POST` | `/observability/dashboards/{param}/share` | `String dashboardId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().dashboards().share(...)` | `POST` | `/observability/dashboards/{param}/share` | `String dashboardId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().dashboards().share(...)` | `POST` | `/observability/dashboards/{param}/share` | `String dashboardId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().dashboards().update(...)` | `PUT` | `/observability/dashboards/{param}` | `String dashboardId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().dashboards().update(...)` | `PUT` | `/observability/dashboards/{param}` | `String dashboardId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().dashboards().update(...)` | `PUT` | `/observability/dashboards/{param}` | `String dashboardId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().dashboards().update(...)` | `PUT` | `/observability/dashboards/{param}` | `String dashboardId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().events().create(...)` | `POST` | `/observability/events` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().events().create(...)` | `POST` | `/observability/events` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().events().create(...)` | `POST` | `/observability/events` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().events().create(...)` | `POST` | `/observability/events` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().events().batch(...)` | `POST` | `/observability/events/batch` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().events().batch(...)` | `POST` | `/observability/events/batch` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().events().batch(...)` | `POST` | `/observability/events/batch` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().events().batch(...)` | `POST` | `/observability/events/batch` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().logs().ingest(...)` | `POST` | `/observability/logs/ingest` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().logs().ingest(...)` | `POST` | `/observability/logs/ingest` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().logs().ingest(...)` | `POST` | `/observability/logs/ingest` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().logs().ingest(...)` | `POST` | `/observability/logs/ingest` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().logs().query(...)` | `POST` | `/observability/logs/query` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().logs().query(...)` | `POST` | `/observability/logs/query` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().logs().query(...)` | `POST` | `/observability/logs/query` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().logs().query(...)` | `POST` | `/observability/logs/query` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().logs().stream(...)` | `STREAM` | `/observability/logs/stream` | `QueryParams query` | `Flow.Publisher` | -| `observability().logs().stream(...)` | `STREAM` | `/observability/logs/stream` | `` | `Flow.Publisher` | -| `observability().logs().streamBlocking(...)` | `STREAM` | `/observability/logs/stream` | `QueryParams query` | `SseEventIterator` | -| `observability().logs().streamBlocking(...)` | `STREAM` | `/observability/logs/stream` | `` | `SseEventIterator` | -| `observability().metrics().list(...)` | `GET` | `/observability/metrics` | `QueryParams query, Class responseType` | `@Nullable T` | -| `observability().metrics().list(...)` | `GET` | `/observability/metrics` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `observability().metrics().list(...)` | `GET` | `/observability/metrics` | `Class responseType` | `@Nullable T` | -| `observability().metrics().list(...)` | `GET` | `/observability/metrics` | `TypeReference responseType` | `@Nullable T` | -| `observability().metrics().getList(...)` | `GET` | `/observability/metrics/list` | `QueryParams query, Class responseType` | `@Nullable T` | -| `observability().metrics().getList(...)` | `GET` | `/observability/metrics/list` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `observability().metrics().getList(...)` | `GET` | `/observability/metrics/list` | `Class responseType` | `@Nullable T` | -| `observability().metrics().getList(...)` | `GET` | `/observability/metrics/list` | `TypeReference responseType` | `@Nullable T` | -| `observability().metrics().ingest(...)` | `POST` | `/observability/metrics/ingest` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().metrics().ingest(...)` | `POST` | `/observability/metrics/ingest` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().metrics().ingest(...)` | `POST` | `/observability/metrics/ingest` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().metrics().ingest(...)` | `POST` | `/observability/metrics/ingest` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().traces().list(...)` | `GET` | `/observability/traces` | `QueryParams query, Class responseType` | `@Nullable T` | -| `observability().traces().list(...)` | `GET` | `/observability/traces` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `observability().traces().list(...)` | `GET` | `/observability/traces` | `Class responseType` | `@Nullable T` | -| `observability().traces().list(...)` | `GET` | `/observability/traces` | `TypeReference responseType` | `@Nullable T` | -| `observability().traces().get(...)` | `GET` | `/observability/traces/{param}` | `String traceId, QueryParams query, Class responseType` | `@Nullable T` | -| `observability().traces().get(...)` | `GET` | `/observability/traces/{param}` | `String traceId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `observability().traces().get(...)` | `GET` | `/observability/traces/{param}` | `String traceId, Class responseType` | `@Nullable T` | -| `observability().traces().get(...)` | `GET` | `/observability/traces/{param}` | `String traceId, TypeReference responseType` | `@Nullable T` | -| `observability().traces().query(...)` | `POST` | `/observability/traces/query` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().traces().query(...)` | `POST` | `/observability/traces/query` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().traces().query(...)` | `POST` | `/observability/traces/query` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().traces().query(...)` | `POST` | `/observability/traces/query` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().alerts().incidents().list(...)` | `GET` | `/observability/alerts/incidents` | `QueryParams query, Class responseType` | `@Nullable T` | -| `observability().alerts().incidents().list(...)` | `GET` | `/observability/alerts/incidents` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `observability().alerts().incidents().list(...)` | `GET` | `/observability/alerts/incidents` | `Class responseType` | `@Nullable T` | -| `observability().alerts().incidents().list(...)` | `GET` | `/observability/alerts/incidents` | `TypeReference responseType` | `@Nullable T` | -| `observability().alerts().rules().delete(...)` | `DELETE` | `/observability/alerts/rules/{param}` | `String ruleId, QueryParams query, Class responseType` | `@Nullable T` | -| `observability().alerts().rules().delete(...)` | `DELETE` | `/observability/alerts/rules/{param}` | `String ruleId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `observability().alerts().rules().delete(...)` | `DELETE` | `/observability/alerts/rules/{param}` | `String ruleId, Class responseType` | `@Nullable T` | -| `observability().alerts().rules().delete(...)` | `DELETE` | `/observability/alerts/rules/{param}` | `String ruleId, TypeReference responseType` | `@Nullable T` | -| `observability().alerts().rules().list(...)` | `GET` | `/observability/alerts/rules` | `QueryParams query, Class responseType` | `@Nullable T` | -| `observability().alerts().rules().list(...)` | `GET` | `/observability/alerts/rules` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `observability().alerts().rules().list(...)` | `GET` | `/observability/alerts/rules` | `Class responseType` | `@Nullable T` | -| `observability().alerts().rules().list(...)` | `GET` | `/observability/alerts/rules` | `TypeReference responseType` | `@Nullable T` | -| `observability().alerts().rules().get(...)` | `GET` | `/observability/alerts/rules/{param}` | `String ruleId, QueryParams query, Class responseType` | `@Nullable T` | -| `observability().alerts().rules().get(...)` | `GET` | `/observability/alerts/rules/{param}` | `String ruleId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `observability().alerts().rules().get(...)` | `GET` | `/observability/alerts/rules/{param}` | `String ruleId, Class responseType` | `@Nullable T` | -| `observability().alerts().rules().get(...)` | `GET` | `/observability/alerts/rules/{param}` | `String ruleId, TypeReference responseType` | `@Nullable T` | -| `observability().alerts().rules().create(...)` | `POST` | `/observability/alerts/rules` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().alerts().rules().create(...)` | `POST` | `/observability/alerts/rules` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().alerts().rules().create(...)` | `POST` | `/observability/alerts/rules` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().alerts().rules().create(...)` | `POST` | `/observability/alerts/rules` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().alerts().rules().toggle(...)` | `POST` | `/observability/alerts/rules/{param}/toggle` | `String ruleId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().alerts().rules().toggle(...)` | `POST` | `/observability/alerts/rules/{param}/toggle` | `String ruleId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().alerts().rules().toggle(...)` | `POST` | `/observability/alerts/rules/{param}/toggle` | `String ruleId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().alerts().rules().toggle(...)` | `POST` | `/observability/alerts/rules/{param}/toggle` | `String ruleId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().alerts().rules().update(...)` | `PUT` | `/observability/alerts/rules/{param}` | `String ruleId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().alerts().rules().update(...)` | `PUT` | `/observability/alerts/rules/{param}` | `String ruleId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().alerts().rules().update(...)` | `PUT` | `/observability/alerts/rules/{param}` | `String ruleId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `observability().alerts().rules().update(...)` | `PUT` | `/observability/alerts/rules/{param}` | `String ruleId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `observability().events().stats().list(...)` | `GET` | `/observability/events/stats` | `QueryParams query, Class responseType` | `@Nullable T` | -| `observability().events().stats().list(...)` | `GET` | `/observability/events/stats` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `observability().events().stats().list(...)` | `GET` | `/observability/events/stats` | `Class responseType` | `@Nullable T` | -| `observability().events().stats().list(...)` | `GET` | `/observability/events/stats` | `TypeReference responseType` | `@Nullable T` | - -The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/ontology.md b/docs/api/ontology.md deleted file mode 100644 index c431f90..0000000 --- a/docs/api/ontology.md +++ /dev/null @@ -1,694 +0,0 @@ -# Ontology API - -Service accessor: `frontal.ontology()` (`OntologyClient`). - -Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. - -| Method | HTTP | Route | Parameters | Response | -| --- | --- | --- | --- | --- | -| `ontology().engine().health(...)` | `GET` | `/ontology/engine/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().engine().health(...)` | `GET` | `/ontology/engine/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().engine().health(...)` | `GET` | `/ontology/engine/health` | `Class responseType` | `@Nullable T` | -| `ontology().engine().health(...)` | `GET` | `/ontology/engine/health` | `TypeReference responseType` | `@Nullable T` | -| `ontology().engine().getInfo(...)` | `GET` | `/ontology/engine/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().engine().getInfo(...)` | `GET` | `/ontology/engine/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().engine().getInfo(...)` | `GET` | `/ontology/engine/info` | `Class responseType` | `@Nullable T` | -| `ontology().engine().getInfo(...)` | `GET` | `/ontology/engine/info` | `TypeReference responseType` | `@Nullable T` | -| `ontology().events().health(...)` | `GET` | `/ontology/events/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().events().health(...)` | `GET` | `/ontology/events/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().events().health(...)` | `GET` | `/ontology/events/health` | `Class responseType` | `@Nullable T` | -| `ontology().events().health(...)` | `GET` | `/ontology/events/health` | `TypeReference responseType` | `@Nullable T` | -| `ontology().events().getInfo(...)` | `GET` | `/ontology/events/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().events().getInfo(...)` | `GET` | `/ontology/events/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().events().getInfo(...)` | `GET` | `/ontology/events/info` | `Class responseType` | `@Nullable T` | -| `ontology().events().getInfo(...)` | `GET` | `/ontology/events/info` | `TypeReference responseType` | `@Nullable T` | -| `ontology().extract().health(...)` | `GET` | `/ontology/extract/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().extract().health(...)` | `GET` | `/ontology/extract/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().extract().health(...)` | `GET` | `/ontology/extract/health` | `Class responseType` | `@Nullable T` | -| `ontology().extract().health(...)` | `GET` | `/ontology/extract/health` | `TypeReference responseType` | `@Nullable T` | -| `ontology().extract().getInfo(...)` | `GET` | `/ontology/extract/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().extract().getInfo(...)` | `GET` | `/ontology/extract/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().extract().getInfo(...)` | `GET` | `/ontology/extract/info` | `Class responseType` | `@Nullable T` | -| `ontology().extract().getInfo(...)` | `GET` | `/ontology/extract/info` | `TypeReference responseType` | `@Nullable T` | -| `ontology().graph().health(...)` | `GET` | `/ontology/graph/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().graph().health(...)` | `GET` | `/ontology/graph/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().health(...)` | `GET` | `/ontology/graph/health` | `Class responseType` | `@Nullable T` | -| `ontology().graph().health(...)` | `GET` | `/ontology/graph/health` | `TypeReference responseType` | `@Nullable T` | -| `ontology().graph().getInfo(...)` | `GET` | `/ontology/graph/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().graph().getInfo(...)` | `GET` | `/ontology/graph/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().getInfo(...)` | `GET` | `/ontology/graph/info` | `Class responseType` | `@Nullable T` | -| `ontology().graph().getInfo(...)` | `GET` | `/ontology/graph/info` | `TypeReference responseType` | `@Nullable T` | -| `ontology().objects().health(...)` | `GET` | `/ontology/objects/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().objects().health(...)` | `GET` | `/ontology/objects/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().objects().health(...)` | `GET` | `/ontology/objects/health` | `Class responseType` | `@Nullable T` | -| `ontology().objects().health(...)` | `GET` | `/ontology/objects/health` | `TypeReference responseType` | `@Nullable T` | -| `ontology().objects().getInfo(...)` | `GET` | `/ontology/objects/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().objects().getInfo(...)` | `GET` | `/ontology/objects/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().objects().getInfo(...)` | `GET` | `/ontology/objects/info` | `Class responseType` | `@Nullable T` | -| `ontology().objects().getInfo(...)` | `GET` | `/ontology/objects/info` | `TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().health(...)` | `GET` | `/ontology/reasoning/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().reasoning().health(...)` | `GET` | `/ontology/reasoning/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().health(...)` | `GET` | `/ontology/reasoning/health` | `Class responseType` | `@Nullable T` | -| `ontology().reasoning().health(...)` | `GET` | `/ontology/reasoning/health` | `TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().getInfo(...)` | `GET` | `/ontology/reasoning/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().reasoning().getInfo(...)` | `GET` | `/ontology/reasoning/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().getInfo(...)` | `GET` | `/ontology/reasoning/info` | `Class responseType` | `@Nullable T` | -| `ontology().reasoning().getInfo(...)` | `GET` | `/ontology/reasoning/info` | `TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().createExplain(...)` | `POST` | `/ontology/reasoning/explain` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().reasoning().createExplain(...)` | `POST` | `/ontology/reasoning/explain` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().createExplain(...)` | `POST` | `/ontology/reasoning/explain` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().reasoning().createExplain(...)` | `POST` | `/ontology/reasoning/explain` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().health(...)` | `GET` | `/ontology/relationships/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().relationships().health(...)` | `GET` | `/ontology/relationships/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().health(...)` | `GET` | `/ontology/relationships/health` | `Class responseType` | `@Nullable T` | -| `ontology().relationships().health(...)` | `GET` | `/ontology/relationships/health` | `TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().getInfo(...)` | `GET` | `/ontology/relationships/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().relationships().getInfo(...)` | `GET` | `/ontology/relationships/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().getInfo(...)` | `GET` | `/ontology/relationships/info` | `Class responseType` | `@Nullable T` | -| `ontology().relationships().getInfo(...)` | `GET` | `/ontology/relationships/info` | `TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().health(...)` | `GET` | `/ontology/rollouts/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().rollouts().health(...)` | `GET` | `/ontology/rollouts/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().health(...)` | `GET` | `/ontology/rollouts/health` | `Class responseType` | `@Nullable T` | -| `ontology().rollouts().health(...)` | `GET` | `/ontology/rollouts/health` | `TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().getInfo(...)` | `GET` | `/ontology/rollouts/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().rollouts().getInfo(...)` | `GET` | `/ontology/rollouts/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().getInfo(...)` | `GET` | `/ontology/rollouts/info` | `Class responseType` | `@Nullable T` | -| `ontology().rollouts().getInfo(...)` | `GET` | `/ontology/rollouts/info` | `TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().health(...)` | `GET` | `/ontology/rollups/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().rollups().health(...)` | `GET` | `/ontology/rollups/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().health(...)` | `GET` | `/ontology/rollups/health` | `Class responseType` | `@Nullable T` | -| `ontology().rollups().health(...)` | `GET` | `/ontology/rollups/health` | `TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().getInfo(...)` | `GET` | `/ontology/rollups/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().rollups().getInfo(...)` | `GET` | `/ontology/rollups/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().getInfo(...)` | `GET` | `/ontology/rollups/info` | `Class responseType` | `@Nullable T` | -| `ontology().rollups().getInfo(...)` | `GET` | `/ontology/rollups/info` | `TypeReference responseType` | `@Nullable T` | -| `ontology().schemas().health(...)` | `GET` | `/ontology/schemas/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().schemas().health(...)` | `GET` | `/ontology/schemas/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().schemas().health(...)` | `GET` | `/ontology/schemas/health` | `Class responseType` | `@Nullable T` | -| `ontology().schemas().health(...)` | `GET` | `/ontology/schemas/health` | `TypeReference responseType` | `@Nullable T` | -| `ontology().schemas().getInfo(...)` | `GET` | `/ontology/schemas/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().schemas().getInfo(...)` | `GET` | `/ontology/schemas/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().schemas().getInfo(...)` | `GET` | `/ontology/schemas/info` | `Class responseType` | `@Nullable T` | -| `ontology().schemas().getInfo(...)` | `GET` | `/ontology/schemas/info` | `TypeReference responseType` | `@Nullable T` | -| `ontology().transformations().health(...)` | `GET` | `/ontology/transformations/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().transformations().health(...)` | `GET` | `/ontology/transformations/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().transformations().health(...)` | `GET` | `/ontology/transformations/health` | `Class responseType` | `@Nullable T` | -| `ontology().transformations().health(...)` | `GET` | `/ontology/transformations/health` | `TypeReference responseType` | `@Nullable T` | -| `ontology().transformations().getInfo(...)` | `GET` | `/ontology/transformations/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().transformations().getInfo(...)` | `GET` | `/ontology/transformations/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().transformations().getInfo(...)` | `GET` | `/ontology/transformations/info` | `Class responseType` | `@Nullable T` | -| `ontology().transformations().getInfo(...)` | `GET` | `/ontology/transformations/info` | `TypeReference responseType` | `@Nullable T` | -| `ontology().validation().health(...)` | `GET` | `/ontology/validation/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().validation().health(...)` | `GET` | `/ontology/validation/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().validation().health(...)` | `GET` | `/ontology/validation/health` | `Class responseType` | `@Nullable T` | -| `ontology().validation().health(...)` | `GET` | `/ontology/validation/health` | `TypeReference responseType` | `@Nullable T` | -| `ontology().validation().getInfo(...)` | `GET` | `/ontology/validation/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().validation().getInfo(...)` | `GET` | `/ontology/validation/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().validation().getInfo(...)` | `GET` | `/ontology/validation/info` | `Class responseType` | `@Nullable T` | -| `ontology().validation().getInfo(...)` | `GET` | `/ontology/validation/info` | `TypeReference responseType` | `@Nullable T` | -| `ontology().versions().health(...)` | `GET` | `/ontology/versions/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().versions().health(...)` | `GET` | `/ontology/versions/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().versions().health(...)` | `GET` | `/ontology/versions/health` | `Class responseType` | `@Nullable T` | -| `ontology().versions().health(...)` | `GET` | `/ontology/versions/health` | `TypeReference responseType` | `@Nullable T` | -| `ontology().versions().getInfo(...)` | `GET` | `/ontology/versions/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().versions().getInfo(...)` | `GET` | `/ontology/versions/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().versions().getInfo(...)` | `GET` | `/ontology/versions/info` | `Class responseType` | `@Nullable T` | -| `ontology().versions().getInfo(...)` | `GET` | `/ontology/versions/info` | `TypeReference responseType` | `@Nullable T` | -| `ontology().engine().capabilities().list(...)` | `GET` | `/ontology/engine/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().engine().capabilities().list(...)` | `GET` | `/ontology/engine/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().engine().capabilities().list(...)` | `GET` | `/ontology/engine/capabilities` | `Class responseType` | `@Nullable T` | -| `ontology().engine().capabilities().list(...)` | `GET` | `/ontology/engine/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `ontology().engine().ontologies().export(...)` | `POST` | `/ontology/engine/ontologies/export` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().engine().ontologies().export(...)` | `POST` | `/ontology/engine/ontologies/export` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().engine().ontologies().export(...)` | `POST` | `/ontology/engine/ontologies/export` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().engine().ontologies().export(...)` | `POST` | `/ontology/engine/ontologies/export` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().engine().ontologies().createExportShacl(...)` | `POST` | `/ontology/engine/ontologies/export-shacl` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().engine().ontologies().createExportShacl(...)` | `POST` | `/ontology/engine/ontologies/export-shacl` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().engine().ontologies().createExportShacl(...)` | `POST` | `/ontology/engine/ontologies/export-shacl` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().engine().ontologies().createExportShacl(...)` | `POST` | `/ontology/engine/ontologies/export-shacl` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().engine().ontologies().generate(...)` | `POST` | `/ontology/engine/ontologies/generate` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().engine().ontologies().generate(...)` | `POST` | `/ontology/engine/ontologies/generate` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().engine().ontologies().generate(...)` | `POST` | `/ontology/engine/ontologies/generate` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().engine().ontologies().generate(...)` | `POST` | `/ontology/engine/ontologies/generate` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().engine().ontologies().validate(...)` | `POST` | `/ontology/engine/ontologies/validate` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().engine().ontologies().validate(...)` | `POST` | `/ontology/engine/ontologies/validate` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().engine().ontologies().validate(...)` | `POST` | `/ontology/engine/ontologies/validate` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().engine().ontologies().validate(...)` | `POST` | `/ontology/engine/ontologies/validate` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().engine().runs().list(...)` | `GET` | `/ontology/engine/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().engine().runs().list(...)` | `GET` | `/ontology/engine/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().engine().runs().list(...)` | `GET` | `/ontology/engine/runs` | `Class responseType` | `@Nullable T` | -| `ontology().engine().runs().list(...)` | `GET` | `/ontology/engine/runs` | `TypeReference responseType` | `@Nullable T` | -| `ontology().engine().runs().get(...)` | `GET` | `/ontology/engine/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().engine().runs().get(...)` | `GET` | `/ontology/engine/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().engine().runs().get(...)` | `GET` | `/ontology/engine/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `ontology().engine().runs().get(...)` | `GET` | `/ontology/engine/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `ontology().engine().runs().create(...)` | `POST` | `/ontology/engine/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().engine().runs().create(...)` | `POST` | `/ontology/engine/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().engine().runs().create(...)` | `POST` | `/ontology/engine/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().engine().runs().create(...)` | `POST` | `/ontology/engine/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().events().capabilities().list(...)` | `GET` | `/ontology/events/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().events().capabilities().list(...)` | `GET` | `/ontology/events/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().events().capabilities().list(...)` | `GET` | `/ontology/events/capabilities` | `Class responseType` | `@Nullable T` | -| `ontology().events().capabilities().list(...)` | `GET` | `/ontology/events/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `ontology().events().events().list(...)` | `GET` | `/ontology/events/events` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().events().events().list(...)` | `GET` | `/ontology/events/events` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().events().events().list(...)` | `GET` | `/ontology/events/events` | `Class responseType` | `@Nullable T` | -| `ontology().events().events().list(...)` | `GET` | `/ontology/events/events` | `TypeReference responseType` | `@Nullable T` | -| `ontology().events().events().get(...)` | `GET` | `/ontology/events/events/{param}` | `String eventId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().events().events().get(...)` | `GET` | `/ontology/events/events/{param}` | `String eventId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().events().events().get(...)` | `GET` | `/ontology/events/events/{param}` | `String eventId, Class responseType` | `@Nullable T` | -| `ontology().events().events().get(...)` | `GET` | `/ontology/events/events/{param}` | `String eventId, TypeReference responseType` | `@Nullable T` | -| `ontology().events().events().create(...)` | `POST` | `/ontology/events/events` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().events().events().create(...)` | `POST` | `/ontology/events/events` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().events().events().create(...)` | `POST` | `/ontology/events/events` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().events().events().create(...)` | `POST` | `/ontology/events/events` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().events().runs().list(...)` | `GET` | `/ontology/events/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().events().runs().list(...)` | `GET` | `/ontology/events/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().events().runs().list(...)` | `GET` | `/ontology/events/runs` | `Class responseType` | `@Nullable T` | -| `ontology().events().runs().list(...)` | `GET` | `/ontology/events/runs` | `TypeReference responseType` | `@Nullable T` | -| `ontology().events().runs().get(...)` | `GET` | `/ontology/events/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().events().runs().get(...)` | `GET` | `/ontology/events/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().events().runs().get(...)` | `GET` | `/ontology/events/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `ontology().events().runs().get(...)` | `GET` | `/ontology/events/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `ontology().events().runs().create(...)` | `POST` | `/ontology/events/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().events().runs().create(...)` | `POST` | `/ontology/events/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().events().runs().create(...)` | `POST` | `/ontology/events/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().events().runs().create(...)` | `POST` | `/ontology/events/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().extract().capabilities().list(...)` | `GET` | `/ontology/extract/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().extract().capabilities().list(...)` | `GET` | `/ontology/extract/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().extract().capabilities().list(...)` | `GET` | `/ontology/extract/capabilities` | `Class responseType` | `@Nullable T` | -| `ontology().extract().capabilities().list(...)` | `GET` | `/ontology/extract/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `ontology().extract().extract().analyze(...)` | `POST` | `/ontology/extract/extract/analyze` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().extract().extract().analyze(...)` | `POST` | `/ontology/extract/extract/analyze` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().extract().extract().analyze(...)` | `POST` | `/ontology/extract/extract/analyze` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().extract().extract().analyze(...)` | `POST` | `/ontology/extract/extract/analyze` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().extract().extract().createArchitecture(...)` | `POST` | `/ontology/extract/extract/architecture` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().extract().extract().createArchitecture(...)` | `POST` | `/ontology/extract/extract/architecture` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().extract().extract().createArchitecture(...)` | `POST` | `/ontology/extract/extract/architecture` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().extract().extract().createArchitecture(...)` | `POST` | `/ontology/extract/extract/architecture` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().extract().runs().list(...)` | `GET` | `/ontology/extract/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().extract().runs().list(...)` | `GET` | `/ontology/extract/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().extract().runs().list(...)` | `GET` | `/ontology/extract/runs` | `Class responseType` | `@Nullable T` | -| `ontology().extract().runs().list(...)` | `GET` | `/ontology/extract/runs` | `TypeReference responseType` | `@Nullable T` | -| `ontology().extract().runs().get(...)` | `GET` | `/ontology/extract/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().extract().runs().get(...)` | `GET` | `/ontology/extract/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().extract().runs().get(...)` | `GET` | `/ontology/extract/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `ontology().extract().runs().get(...)` | `GET` | `/ontology/extract/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `ontology().extract().runs().create(...)` | `POST` | `/ontology/extract/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().extract().runs().create(...)` | `POST` | `/ontology/extract/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().extract().runs().create(...)` | `POST` | `/ontology/extract/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().extract().runs().create(...)` | `POST` | `/ontology/extract/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().capabilities().list(...)` | `GET` | `/ontology/graph/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().graph().capabilities().list(...)` | `GET` | `/ontology/graph/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().capabilities().list(...)` | `GET` | `/ontology/graph/capabilities` | `Class responseType` | `@Nullable T` | -| `ontology().graph().capabilities().list(...)` | `GET` | `/ontology/graph/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `ontology().graph().entities().get(...)` | `GET` | `/ontology/graph/entities/{param}` | `String entityId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().graph().entities().get(...)` | `GET` | `/ontology/graph/entities/{param}` | `String entityId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().entities().get(...)` | `GET` | `/ontology/graph/entities/{param}` | `String entityId, Class responseType` | `@Nullable T` | -| `ontology().graph().entities().get(...)` | `GET` | `/ontology/graph/entities/{param}` | `String entityId, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().entities().getProvenance(...)` | `GET` | `/ontology/graph/entities/{param}/provenance` | `String entityId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().graph().entities().getProvenance(...)` | `GET` | `/ontology/graph/entities/{param}/provenance` | `String entityId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().entities().getProvenance(...)` | `GET` | `/ontology/graph/entities/{param}/provenance` | `String entityId, Class responseType` | `@Nullable T` | -| `ontology().graph().entities().getProvenance(...)` | `GET` | `/ontology/graph/entities/{param}/provenance` | `String entityId, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().entities().update(...)` | `PUT` | `/ontology/graph/entities/{param}` | `String entityId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().graph().entities().update(...)` | `PUT` | `/ontology/graph/entities/{param}` | `String entityId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().entities().update(...)` | `PUT` | `/ontology/graph/entities/{param}` | `String entityId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().graph().entities().update(...)` | `PUT` | `/ontology/graph/entities/{param}` | `String entityId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().graph().analyze(...)` | `POST` | `/ontology/graph/graph/analyze` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().graph().graph().analyze(...)` | `POST` | `/ontology/graph/graph/analyze` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().graph().analyze(...)` | `POST` | `/ontology/graph/graph/analyze` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().graph().graph().analyze(...)` | `POST` | `/ontology/graph/graph/analyze` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().graph().createBuild(...)` | `POST` | `/ontology/graph/graph/build` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().graph().graph().createBuild(...)` | `POST` | `/ontology/graph/graph/build` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().graph().createBuild(...)` | `POST` | `/ontology/graph/graph/build` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().graph().graph().createBuild(...)` | `POST` | `/ontology/graph/graph/build` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().graph().createBulkRead(...)` | `POST` | `/ontology/graph/graph/bulk-read` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().graph().graph().createBulkRead(...)` | `POST` | `/ontology/graph/graph/bulk-read` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().graph().createBulkRead(...)` | `POST` | `/ontology/graph/graph/bulk-read` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().graph().graph().createBulkRead(...)` | `POST` | `/ontology/graph/graph/bulk-read` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().graph().createNeighborhood(...)` | `POST` | `/ontology/graph/graph/neighborhood` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().graph().graph().createNeighborhood(...)` | `POST` | `/ontology/graph/graph/neighborhood` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().graph().createNeighborhood(...)` | `POST` | `/ontology/graph/graph/neighborhood` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().graph().graph().createNeighborhood(...)` | `POST` | `/ontology/graph/graph/neighborhood` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().graph().createPath(...)` | `POST` | `/ontology/graph/graph/path` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().graph().graph().createPath(...)` | `POST` | `/ontology/graph/graph/path` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().graph().createPath(...)` | `POST` | `/ontology/graph/graph/path` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().graph().graph().createPath(...)` | `POST` | `/ontology/graph/graph/path` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().graph().query(...)` | `POST` | `/ontology/graph/graph/query` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().graph().graph().query(...)` | `POST` | `/ontology/graph/graph/query` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().graph().query(...)` | `POST` | `/ontology/graph/graph/query` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().graph().graph().query(...)` | `POST` | `/ontology/graph/graph/query` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().relationships().get(...)` | `GET` | `/ontology/graph/relationships/{param}` | `String relationshipId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().graph().relationships().get(...)` | `GET` | `/ontology/graph/relationships/{param}` | `String relationshipId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().relationships().get(...)` | `GET` | `/ontology/graph/relationships/{param}` | `String relationshipId, Class responseType` | `@Nullable T` | -| `ontology().graph().relationships().get(...)` | `GET` | `/ontology/graph/relationships/{param}` | `String relationshipId, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().relationships().update(...)` | `PUT` | `/ontology/graph/relationships/{param}` | `String relationshipId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().graph().relationships().update(...)` | `PUT` | `/ontology/graph/relationships/{param}` | `String relationshipId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().relationships().update(...)` | `PUT` | `/ontology/graph/relationships/{param}` | `String relationshipId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().graph().relationships().update(...)` | `PUT` | `/ontology/graph/relationships/{param}` | `String relationshipId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().runs().list(...)` | `GET` | `/ontology/graph/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().graph().runs().list(...)` | `GET` | `/ontology/graph/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().runs().list(...)` | `GET` | `/ontology/graph/runs` | `Class responseType` | `@Nullable T` | -| `ontology().graph().runs().list(...)` | `GET` | `/ontology/graph/runs` | `TypeReference responseType` | `@Nullable T` | -| `ontology().graph().runs().get(...)` | `GET` | `/ontology/graph/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().graph().runs().get(...)` | `GET` | `/ontology/graph/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().runs().get(...)` | `GET` | `/ontology/graph/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `ontology().graph().runs().get(...)` | `GET` | `/ontology/graph/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().runs().create(...)` | `POST` | `/ontology/graph/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().graph().runs().create(...)` | `POST` | `/ontology/graph/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().graph().runs().create(...)` | `POST` | `/ontology/graph/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().graph().runs().create(...)` | `POST` | `/ontology/graph/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().objects().capabilities().list(...)` | `GET` | `/ontology/objects/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().objects().capabilities().list(...)` | `GET` | `/ontology/objects/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().objects().capabilities().list(...)` | `GET` | `/ontology/objects/capabilities` | `Class responseType` | `@Nullable T` | -| `ontology().objects().capabilities().list(...)` | `GET` | `/ontology/objects/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `ontology().objects().objectTypes().delete(...)` | `DELETE` | `/ontology/objects/object-types/{param}` | `String objectTypeId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().objects().objectTypes().delete(...)` | `DELETE` | `/ontology/objects/object-types/{param}` | `String objectTypeId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().objects().objectTypes().delete(...)` | `DELETE` | `/ontology/objects/object-types/{param}` | `String objectTypeId, Class responseType` | `@Nullable T` | -| `ontology().objects().objectTypes().delete(...)` | `DELETE` | `/ontology/objects/object-types/{param}` | `String objectTypeId, TypeReference responseType` | `@Nullable T` | -| `ontology().objects().objectTypes().list(...)` | `GET` | `/ontology/objects/object-types` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().objects().objectTypes().list(...)` | `GET` | `/ontology/objects/object-types` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().objects().objectTypes().list(...)` | `GET` | `/ontology/objects/object-types` | `Class responseType` | `@Nullable T` | -| `ontology().objects().objectTypes().list(...)` | `GET` | `/ontology/objects/object-types` | `TypeReference responseType` | `@Nullable T` | -| `ontology().objects().objectTypes().get(...)` | `GET` | `/ontology/objects/object-types/{param}` | `String objectTypeId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().objects().objectTypes().get(...)` | `GET` | `/ontology/objects/object-types/{param}` | `String objectTypeId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().objects().objectTypes().get(...)` | `GET` | `/ontology/objects/object-types/{param}` | `String objectTypeId, Class responseType` | `@Nullable T` | -| `ontology().objects().objectTypes().get(...)` | `GET` | `/ontology/objects/object-types/{param}` | `String objectTypeId, TypeReference responseType` | `@Nullable T` | -| `ontology().objects().objectTypes().update(...)` | `PUT` | `/ontology/objects/object-types/{param}` | `String objectTypeId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().objects().objectTypes().update(...)` | `PUT` | `/ontology/objects/object-types/{param}` | `String objectTypeId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().objects().objectTypes().update(...)` | `PUT` | `/ontology/objects/object-types/{param}` | `String objectTypeId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().objects().objectTypes().update(...)` | `PUT` | `/ontology/objects/object-types/{param}` | `String objectTypeId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().objects().objects().delete(...)` | `DELETE` | `/ontology/objects/objects/{param}` | `String objectId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().objects().objects().delete(...)` | `DELETE` | `/ontology/objects/objects/{param}` | `String objectId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().objects().objects().delete(...)` | `DELETE` | `/ontology/objects/objects/{param}` | `String objectId, Class responseType` | `@Nullable T` | -| `ontology().objects().objects().delete(...)` | `DELETE` | `/ontology/objects/objects/{param}` | `String objectId, TypeReference responseType` | `@Nullable T` | -| `ontology().objects().objects().list(...)` | `GET` | `/ontology/objects/objects` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().objects().objects().list(...)` | `GET` | `/ontology/objects/objects` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().objects().objects().list(...)` | `GET` | `/ontology/objects/objects` | `Class responseType` | `@Nullable T` | -| `ontology().objects().objects().list(...)` | `GET` | `/ontology/objects/objects` | `TypeReference responseType` | `@Nullable T` | -| `ontology().objects().objects().get(...)` | `GET` | `/ontology/objects/objects/{param}` | `String objectId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().objects().objects().get(...)` | `GET` | `/ontology/objects/objects/{param}` | `String objectId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().objects().objects().get(...)` | `GET` | `/ontology/objects/objects/{param}` | `String objectId, Class responseType` | `@Nullable T` | -| `ontology().objects().objects().get(...)` | `GET` | `/ontology/objects/objects/{param}` | `String objectId, TypeReference responseType` | `@Nullable T` | -| `ontology().objects().objects().update(...)` | `PUT` | `/ontology/objects/objects/{param}` | `String objectId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().objects().objects().update(...)` | `PUT` | `/ontology/objects/objects/{param}` | `String objectId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().objects().objects().update(...)` | `PUT` | `/ontology/objects/objects/{param}` | `String objectId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().objects().objects().update(...)` | `PUT` | `/ontology/objects/objects/{param}` | `String objectId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().objects().runs().list(...)` | `GET` | `/ontology/objects/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().objects().runs().list(...)` | `GET` | `/ontology/objects/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().objects().runs().list(...)` | `GET` | `/ontology/objects/runs` | `Class responseType` | `@Nullable T` | -| `ontology().objects().runs().list(...)` | `GET` | `/ontology/objects/runs` | `TypeReference responseType` | `@Nullable T` | -| `ontology().objects().runs().get(...)` | `GET` | `/ontology/objects/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().objects().runs().get(...)` | `GET` | `/ontology/objects/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().objects().runs().get(...)` | `GET` | `/ontology/objects/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `ontology().objects().runs().get(...)` | `GET` | `/ontology/objects/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `ontology().objects().runs().create(...)` | `POST` | `/ontology/objects/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().objects().runs().create(...)` | `POST` | `/ontology/objects/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().objects().runs().create(...)` | `POST` | `/ontology/objects/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().objects().runs().create(...)` | `POST` | `/ontology/objects/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().capabilities().list(...)` | `GET` | `/ontology/reasoning/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().reasoning().capabilities().list(...)` | `GET` | `/ontology/reasoning/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().capabilities().list(...)` | `GET` | `/ontology/reasoning/capabilities` | `Class responseType` | `@Nullable T` | -| `ontology().reasoning().capabilities().list(...)` | `GET` | `/ontology/reasoning/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().facts().create(...)` | `POST` | `/ontology/reasoning/facts` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().reasoning().facts().create(...)` | `POST` | `/ontology/reasoning/facts` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().facts().create(...)` | `POST` | `/ontology/reasoning/facts` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().reasoning().facts().create(...)` | `POST` | `/ontology/reasoning/facts` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().facts().createLoadGraph(...)` | `POST` | `/ontology/reasoning/facts/load-graph` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().reasoning().facts().createLoadGraph(...)` | `POST` | `/ontology/reasoning/facts/load-graph` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().facts().createLoadGraph(...)` | `POST` | `/ontology/reasoning/facts/load-graph` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().reasoning().facts().createLoadGraph(...)` | `POST` | `/ontology/reasoning/facts/load-graph` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().reason().createBackward(...)` | `POST` | `/ontology/reasoning/reason/backward` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().reasoning().reason().createBackward(...)` | `POST` | `/ontology/reasoning/reason/backward` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().reason().createBackward(...)` | `POST` | `/ontology/reasoning/reason/backward` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().reasoning().reason().createBackward(...)` | `POST` | `/ontology/reasoning/reason/backward` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().reason().createForward(...)` | `POST` | `/ontology/reasoning/reason/forward` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().reasoning().reason().createForward(...)` | `POST` | `/ontology/reasoning/reason/forward` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().reason().createForward(...)` | `POST` | `/ontology/reasoning/reason/forward` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().reasoning().reason().createForward(...)` | `POST` | `/ontology/reasoning/reason/forward` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().rules().delete(...)` | `DELETE` | `/ontology/reasoning/rules/{param}` | `String ruleId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().reasoning().rules().delete(...)` | `DELETE` | `/ontology/reasoning/rules/{param}` | `String ruleId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().rules().delete(...)` | `DELETE` | `/ontology/reasoning/rules/{param}` | `String ruleId, Class responseType` | `@Nullable T` | -| `ontology().reasoning().rules().delete(...)` | `DELETE` | `/ontology/reasoning/rules/{param}` | `String ruleId, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().rules().list(...)` | `GET` | `/ontology/reasoning/rules` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().reasoning().rules().list(...)` | `GET` | `/ontology/reasoning/rules` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().rules().list(...)` | `GET` | `/ontology/reasoning/rules` | `Class responseType` | `@Nullable T` | -| `ontology().reasoning().rules().list(...)` | `GET` | `/ontology/reasoning/rules` | `TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().rules().create(...)` | `POST` | `/ontology/reasoning/rules` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().reasoning().rules().create(...)` | `POST` | `/ontology/reasoning/rules` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().rules().create(...)` | `POST` | `/ontology/reasoning/rules` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().reasoning().rules().create(...)` | `POST` | `/ontology/reasoning/rules` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().rules().update(...)` | `PUT` | `/ontology/reasoning/rules/{param}` | `String ruleId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().reasoning().rules().update(...)` | `PUT` | `/ontology/reasoning/rules/{param}` | `String ruleId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().rules().update(...)` | `PUT` | `/ontology/reasoning/rules/{param}` | `String ruleId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().reasoning().rules().update(...)` | `PUT` | `/ontology/reasoning/rules/{param}` | `String ruleId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().runs().list(...)` | `GET` | `/ontology/reasoning/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().reasoning().runs().list(...)` | `GET` | `/ontology/reasoning/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().runs().list(...)` | `GET` | `/ontology/reasoning/runs` | `Class responseType` | `@Nullable T` | -| `ontology().reasoning().runs().list(...)` | `GET` | `/ontology/reasoning/runs` | `TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().runs().get(...)` | `GET` | `/ontology/reasoning/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().reasoning().runs().get(...)` | `GET` | `/ontology/reasoning/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().runs().get(...)` | `GET` | `/ontology/reasoning/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `ontology().reasoning().runs().get(...)` | `GET` | `/ontology/reasoning/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().runs().create(...)` | `POST` | `/ontology/reasoning/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().reasoning().runs().create(...)` | `POST` | `/ontology/reasoning/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().reasoning().runs().create(...)` | `POST` | `/ontology/reasoning/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().reasoning().runs().create(...)` | `POST` | `/ontology/reasoning/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().capabilities().list(...)` | `GET` | `/ontology/relationships/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().relationships().capabilities().list(...)` | `GET` | `/ontology/relationships/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().capabilities().list(...)` | `GET` | `/ontology/relationships/capabilities` | `Class responseType` | `@Nullable T` | -| `ontology().relationships().capabilities().list(...)` | `GET` | `/ontology/relationships/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().relationshipTypes().delete(...)` | `DELETE` | `/ontology/relationships/relationship-types/{param}` | `String relationshipTypeId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().relationships().relationshipTypes().delete(...)` | `DELETE` | `/ontology/relationships/relationship-types/{param}` | `String relationshipTypeId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().relationshipTypes().delete(...)` | `DELETE` | `/ontology/relationships/relationship-types/{param}` | `String relationshipTypeId, Class responseType` | `@Nullable T` | -| `ontology().relationships().relationshipTypes().delete(...)` | `DELETE` | `/ontology/relationships/relationship-types/{param}` | `String relationshipTypeId, TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().relationshipTypes().list(...)` | `GET` | `/ontology/relationships/relationship-types` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().relationships().relationshipTypes().list(...)` | `GET` | `/ontology/relationships/relationship-types` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().relationshipTypes().list(...)` | `GET` | `/ontology/relationships/relationship-types` | `Class responseType` | `@Nullable T` | -| `ontology().relationships().relationshipTypes().list(...)` | `GET` | `/ontology/relationships/relationship-types` | `TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().relationships().delete(...)` | `DELETE` | `/ontology/relationships/relationships/{param}` | `String relationshipId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().relationships().relationships().delete(...)` | `DELETE` | `/ontology/relationships/relationships/{param}` | `String relationshipId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().relationships().delete(...)` | `DELETE` | `/ontology/relationships/relationships/{param}` | `String relationshipId, Class responseType` | `@Nullable T` | -| `ontology().relationships().relationships().delete(...)` | `DELETE` | `/ontology/relationships/relationships/{param}` | `String relationshipId, TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().relationships().list(...)` | `GET` | `/ontology/relationships/relationships` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().relationships().relationships().list(...)` | `GET` | `/ontology/relationships/relationships` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().relationships().list(...)` | `GET` | `/ontology/relationships/relationships` | `Class responseType` | `@Nullable T` | -| `ontology().relationships().relationships().list(...)` | `GET` | `/ontology/relationships/relationships` | `TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().relationships().get(...)` | `GET` | `/ontology/relationships/relationships/{param}` | `String relationshipId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().relationships().relationships().get(...)` | `GET` | `/ontology/relationships/relationships/{param}` | `String relationshipId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().relationships().get(...)` | `GET` | `/ontology/relationships/relationships/{param}` | `String relationshipId, Class responseType` | `@Nullable T` | -| `ontology().relationships().relationships().get(...)` | `GET` | `/ontology/relationships/relationships/{param}` | `String relationshipId, TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().relationships().update(...)` | `PUT` | `/ontology/relationships/relationships/{param}` | `String relationshipId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().relationships().relationships().update(...)` | `PUT` | `/ontology/relationships/relationships/{param}` | `String relationshipId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().relationships().update(...)` | `PUT` | `/ontology/relationships/relationships/{param}` | `String relationshipId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().relationships().relationships().update(...)` | `PUT` | `/ontology/relationships/relationships/{param}` | `String relationshipId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().runs().list(...)` | `GET` | `/ontology/relationships/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().relationships().runs().list(...)` | `GET` | `/ontology/relationships/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().runs().list(...)` | `GET` | `/ontology/relationships/runs` | `Class responseType` | `@Nullable T` | -| `ontology().relationships().runs().list(...)` | `GET` | `/ontology/relationships/runs` | `TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().runs().get(...)` | `GET` | `/ontology/relationships/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().relationships().runs().get(...)` | `GET` | `/ontology/relationships/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().runs().get(...)` | `GET` | `/ontology/relationships/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `ontology().relationships().runs().get(...)` | `GET` | `/ontology/relationships/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().runs().create(...)` | `POST` | `/ontology/relationships/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().relationships().runs().create(...)` | `POST` | `/ontology/relationships/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().relationships().runs().create(...)` | `POST` | `/ontology/relationships/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().relationships().runs().create(...)` | `POST` | `/ontology/relationships/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().capabilities().list(...)` | `GET` | `/ontology/rollouts/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().rollouts().capabilities().list(...)` | `GET` | `/ontology/rollouts/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().capabilities().list(...)` | `GET` | `/ontology/rollouts/capabilities` | `Class responseType` | `@Nullable T` | -| `ontology().rollouts().capabilities().list(...)` | `GET` | `/ontology/rollouts/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().delete(...)` | `DELETE` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().delete(...)` | `DELETE` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().delete(...)` | `DELETE` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, Class responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().delete(...)` | `DELETE` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().list(...)` | `GET` | `/ontology/rollouts/rollouts` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().list(...)` | `GET` | `/ontology/rollouts/rollouts` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().list(...)` | `GET` | `/ontology/rollouts/rollouts` | `Class responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().list(...)` | `GET` | `/ontology/rollouts/rollouts` | `TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().get(...)` | `GET` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().get(...)` | `GET` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().get(...)` | `GET` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, Class responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().get(...)` | `GET` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().status(...)` | `GET` | `/ontology/rollouts/rollouts/{param}/status` | `String rolloutId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().status(...)` | `GET` | `/ontology/rollouts/rollouts/{param}/status` | `String rolloutId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().status(...)` | `GET` | `/ontology/rollouts/rollouts/{param}/status` | `String rolloutId, Class responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().status(...)` | `GET` | `/ontology/rollouts/rollouts/{param}/status` | `String rolloutId, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().create(...)` | `POST` | `/ontology/rollouts/rollouts` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().create(...)` | `POST` | `/ontology/rollouts/rollouts` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().create(...)` | `POST` | `/ontology/rollouts/rollouts` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().create(...)` | `POST` | `/ontology/rollouts/rollouts` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().pause(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/pause` | `String rolloutId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().pause(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/pause` | `String rolloutId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().pause(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/pause` | `String rolloutId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().pause(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/pause` | `String rolloutId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().resume(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/resume` | `String rolloutId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().resume(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/resume` | `String rolloutId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().resume(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/resume` | `String rolloutId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().resume(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/resume` | `String rolloutId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().rollback(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/rollback` | `String rolloutId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().rollback(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/rollback` | `String rolloutId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().rollback(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/rollback` | `String rolloutId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().rollback(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/rollback` | `String rolloutId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().createStart(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/start` | `String rolloutId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().createStart(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/start` | `String rolloutId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().createStart(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/start` | `String rolloutId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().createStart(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/start` | `String rolloutId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().update(...)` | `PUT` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().update(...)` | `PUT` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().update(...)` | `PUT` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollouts().rollouts().update(...)` | `PUT` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().runs().list(...)` | `GET` | `/ontology/rollouts/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().rollouts().runs().list(...)` | `GET` | `/ontology/rollouts/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().runs().list(...)` | `GET` | `/ontology/rollouts/runs` | `Class responseType` | `@Nullable T` | -| `ontology().rollouts().runs().list(...)` | `GET` | `/ontology/rollouts/runs` | `TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().runs().get(...)` | `GET` | `/ontology/rollouts/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().rollouts().runs().get(...)` | `GET` | `/ontology/rollouts/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().runs().get(...)` | `GET` | `/ontology/rollouts/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `ontology().rollouts().runs().get(...)` | `GET` | `/ontology/rollouts/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().runs().create(...)` | `POST` | `/ontology/rollouts/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollouts().runs().create(...)` | `POST` | `/ontology/rollouts/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollouts().runs().create(...)` | `POST` | `/ontology/rollouts/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollouts().runs().create(...)` | `POST` | `/ontology/rollouts/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().capabilities().list(...)` | `GET` | `/ontology/rollups/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().rollups().capabilities().list(...)` | `GET` | `/ontology/rollups/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().capabilities().list(...)` | `GET` | `/ontology/rollups/capabilities` | `Class responseType` | `@Nullable T` | -| `ontology().rollups().capabilities().list(...)` | `GET` | `/ontology/rollups/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().rollupResults().get(...)` | `GET` | `/ontology/rollups/rollup-results/{param}` | `String executionId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().rollups().rollupResults().get(...)` | `GET` | `/ontology/rollups/rollup-results/{param}` | `String executionId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().rollupResults().get(...)` | `GET` | `/ontology/rollups/rollup-results/{param}` | `String executionId, Class responseType` | `@Nullable T` | -| `ontology().rollups().rollupResults().get(...)` | `GET` | `/ontology/rollups/rollup-results/{param}` | `String executionId, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().rollups().delete(...)` | `DELETE` | `/ontology/rollups/rollups/{param}` | `String rollupId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().rollups().rollups().delete(...)` | `DELETE` | `/ontology/rollups/rollups/{param}` | `String rollupId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().rollups().delete(...)` | `DELETE` | `/ontology/rollups/rollups/{param}` | `String rollupId, Class responseType` | `@Nullable T` | -| `ontology().rollups().rollups().delete(...)` | `DELETE` | `/ontology/rollups/rollups/{param}` | `String rollupId, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().rollups().list(...)` | `GET` | `/ontology/rollups/rollups` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().rollups().rollups().list(...)` | `GET` | `/ontology/rollups/rollups` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().rollups().list(...)` | `GET` | `/ontology/rollups/rollups` | `Class responseType` | `@Nullable T` | -| `ontology().rollups().rollups().list(...)` | `GET` | `/ontology/rollups/rollups` | `TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().rollups().get(...)` | `GET` | `/ontology/rollups/rollups/{param}` | `String rollupId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().rollups().rollups().get(...)` | `GET` | `/ontology/rollups/rollups/{param}` | `String rollupId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().rollups().get(...)` | `GET` | `/ontology/rollups/rollups/{param}` | `String rollupId, Class responseType` | `@Nullable T` | -| `ontology().rollups().rollups().get(...)` | `GET` | `/ontology/rollups/rollups/{param}` | `String rollupId, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().rollups().getResult(...)` | `GET` | `/ontology/rollups/rollups/{param}/result` | `String rollupId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().rollups().rollups().getResult(...)` | `GET` | `/ontology/rollups/rollups/{param}/result` | `String rollupId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().rollups().getResult(...)` | `GET` | `/ontology/rollups/rollups/{param}/result` | `String rollupId, Class responseType` | `@Nullable T` | -| `ontology().rollups().rollups().getResult(...)` | `GET` | `/ontology/rollups/rollups/{param}/result` | `String rollupId, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().rollups().create(...)` | `POST` | `/ontology/rollups/rollups` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollups().rollups().create(...)` | `POST` | `/ontology/rollups/rollups` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().rollups().create(...)` | `POST` | `/ontology/rollups/rollups` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollups().rollups().create(...)` | `POST` | `/ontology/rollups/rollups` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().rollups().execute(...)` | `POST` | `/ontology/rollups/rollups/{param}/execute` | `String rollupId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollups().rollups().execute(...)` | `POST` | `/ontology/rollups/rollups/{param}/execute` | `String rollupId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().rollups().execute(...)` | `POST` | `/ontology/rollups/rollups/{param}/execute` | `String rollupId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollups().rollups().execute(...)` | `POST` | `/ontology/rollups/rollups/{param}/execute` | `String rollupId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().rollups().preview(...)` | `POST` | `/ontology/rollups/rollups/{param}/preview` | `String rollupId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollups().rollups().preview(...)` | `POST` | `/ontology/rollups/rollups/{param}/preview` | `String rollupId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().rollups().preview(...)` | `POST` | `/ontology/rollups/rollups/{param}/preview` | `String rollupId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollups().rollups().preview(...)` | `POST` | `/ontology/rollups/rollups/{param}/preview` | `String rollupId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().rollups().update(...)` | `PUT` | `/ontology/rollups/rollups/{param}` | `String rollupId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollups().rollups().update(...)` | `PUT` | `/ontology/rollups/rollups/{param}` | `String rollupId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().rollups().update(...)` | `PUT` | `/ontology/rollups/rollups/{param}` | `String rollupId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollups().rollups().update(...)` | `PUT` | `/ontology/rollups/rollups/{param}` | `String rollupId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().runs().list(...)` | `GET` | `/ontology/rollups/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().rollups().runs().list(...)` | `GET` | `/ontology/rollups/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().runs().list(...)` | `GET` | `/ontology/rollups/runs` | `Class responseType` | `@Nullable T` | -| `ontology().rollups().runs().list(...)` | `GET` | `/ontology/rollups/runs` | `TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().runs().get(...)` | `GET` | `/ontology/rollups/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().rollups().runs().get(...)` | `GET` | `/ontology/rollups/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().runs().get(...)` | `GET` | `/ontology/rollups/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `ontology().rollups().runs().get(...)` | `GET` | `/ontology/rollups/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().runs().create(...)` | `POST` | `/ontology/rollups/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollups().runs().create(...)` | `POST` | `/ontology/rollups/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().rollups().runs().create(...)` | `POST` | `/ontology/rollups/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().rollups().runs().create(...)` | `POST` | `/ontology/rollups/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().schemas().capabilities().list(...)` | `GET` | `/ontology/schemas/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().schemas().capabilities().list(...)` | `GET` | `/ontology/schemas/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().schemas().capabilities().list(...)` | `GET` | `/ontology/schemas/capabilities` | `Class responseType` | `@Nullable T` | -| `ontology().schemas().capabilities().list(...)` | `GET` | `/ontology/schemas/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `ontology().schemas().runs().list(...)` | `GET` | `/ontology/schemas/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().schemas().runs().list(...)` | `GET` | `/ontology/schemas/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().schemas().runs().list(...)` | `GET` | `/ontology/schemas/runs` | `Class responseType` | `@Nullable T` | -| `ontology().schemas().runs().list(...)` | `GET` | `/ontology/schemas/runs` | `TypeReference responseType` | `@Nullable T` | -| `ontology().schemas().runs().get(...)` | `GET` | `/ontology/schemas/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().schemas().runs().get(...)` | `GET` | `/ontology/schemas/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().schemas().runs().get(...)` | `GET` | `/ontology/schemas/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `ontology().schemas().runs().get(...)` | `GET` | `/ontology/schemas/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `ontology().schemas().runs().create(...)` | `POST` | `/ontology/schemas/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().schemas().runs().create(...)` | `POST` | `/ontology/schemas/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().schemas().runs().create(...)` | `POST` | `/ontology/schemas/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().schemas().runs().create(...)` | `POST` | `/ontology/schemas/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().schemas().schemas().delete(...)` | `DELETE` | `/ontology/schemas/schemas/{param}` | `String schemaId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().schemas().schemas().delete(...)` | `DELETE` | `/ontology/schemas/schemas/{param}` | `String schemaId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().schemas().schemas().delete(...)` | `DELETE` | `/ontology/schemas/schemas/{param}` | `String schemaId, Class responseType` | `@Nullable T` | -| `ontology().schemas().schemas().delete(...)` | `DELETE` | `/ontology/schemas/schemas/{param}` | `String schemaId, TypeReference responseType` | `@Nullable T` | -| `ontology().schemas().schemas().list(...)` | `GET` | `/ontology/schemas/schemas` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().schemas().schemas().list(...)` | `GET` | `/ontology/schemas/schemas` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().schemas().schemas().list(...)` | `GET` | `/ontology/schemas/schemas` | `Class responseType` | `@Nullable T` | -| `ontology().schemas().schemas().list(...)` | `GET` | `/ontology/schemas/schemas` | `TypeReference responseType` | `@Nullable T` | -| `ontology().schemas().schemas().get(...)` | `GET` | `/ontology/schemas/schemas/{param}` | `String schemaId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().schemas().schemas().get(...)` | `GET` | `/ontology/schemas/schemas/{param}` | `String schemaId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().schemas().schemas().get(...)` | `GET` | `/ontology/schemas/schemas/{param}` | `String schemaId, Class responseType` | `@Nullable T` | -| `ontology().schemas().schemas().get(...)` | `GET` | `/ontology/schemas/schemas/{param}` | `String schemaId, TypeReference responseType` | `@Nullable T` | -| `ontology().schemas().schemas().create(...)` | `POST` | `/ontology/schemas/schemas` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().schemas().schemas().create(...)` | `POST` | `/ontology/schemas/schemas` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().schemas().schemas().create(...)` | `POST` | `/ontology/schemas/schemas` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().schemas().schemas().create(...)` | `POST` | `/ontology/schemas/schemas` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().schemas().schemas().validate(...)` | `POST` | `/ontology/schemas/schemas/validate` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().schemas().schemas().validate(...)` | `POST` | `/ontology/schemas/schemas/validate` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().schemas().schemas().validate(...)` | `POST` | `/ontology/schemas/schemas/validate` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().schemas().schemas().validate(...)` | `POST` | `/ontology/schemas/schemas/validate` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().transformations().capabilities().list(...)` | `GET` | `/ontology/transformations/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().transformations().capabilities().list(...)` | `GET` | `/ontology/transformations/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().transformations().capabilities().list(...)` | `GET` | `/ontology/transformations/capabilities` | `Class responseType` | `@Nullable T` | -| `ontology().transformations().capabilities().list(...)` | `GET` | `/ontology/transformations/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `ontology().transformations().runs().list(...)` | `GET` | `/ontology/transformations/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().transformations().runs().list(...)` | `GET` | `/ontology/transformations/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().transformations().runs().list(...)` | `GET` | `/ontology/transformations/runs` | `Class responseType` | `@Nullable T` | -| `ontology().transformations().runs().list(...)` | `GET` | `/ontology/transformations/runs` | `TypeReference responseType` | `@Nullable T` | -| `ontology().transformations().runs().get(...)` | `GET` | `/ontology/transformations/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().transformations().runs().get(...)` | `GET` | `/ontology/transformations/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().transformations().runs().get(...)` | `GET` | `/ontology/transformations/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `ontology().transformations().runs().get(...)` | `GET` | `/ontology/transformations/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `ontology().transformations().runs().create(...)` | `POST` | `/ontology/transformations/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().transformations().runs().create(...)` | `POST` | `/ontology/transformations/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().transformations().runs().create(...)` | `POST` | `/ontology/transformations/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().transformations().runs().create(...)` | `POST` | `/ontology/transformations/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().transformations().transformations().create(...)` | `POST` | `/ontology/transformations/transformations` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().transformations().transformations().create(...)` | `POST` | `/ontology/transformations/transformations` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().transformations().transformations().create(...)` | `POST` | `/ontology/transformations/transformations` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().transformations().transformations().create(...)` | `POST` | `/ontology/transformations/transformations` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().validation().capabilities().list(...)` | `GET` | `/ontology/validation/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().validation().capabilities().list(...)` | `GET` | `/ontology/validation/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().validation().capabilities().list(...)` | `GET` | `/ontology/validation/capabilities` | `Class responseType` | `@Nullable T` | -| `ontology().validation().capabilities().list(...)` | `GET` | `/ontology/validation/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `ontology().validation().payloads().validate(...)` | `POST` | `/ontology/validation/payloads/validate` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().validation().payloads().validate(...)` | `POST` | `/ontology/validation/payloads/validate` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().validation().payloads().validate(...)` | `POST` | `/ontology/validation/payloads/validate` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().validation().payloads().validate(...)` | `POST` | `/ontology/validation/payloads/validate` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().validation().rules().delete(...)` | `DELETE` | `/ontology/validation/rules/{param}` | `String ruleId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().validation().rules().delete(...)` | `DELETE` | `/ontology/validation/rules/{param}` | `String ruleId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().validation().rules().delete(...)` | `DELETE` | `/ontology/validation/rules/{param}` | `String ruleId, Class responseType` | `@Nullable T` | -| `ontology().validation().rules().delete(...)` | `DELETE` | `/ontology/validation/rules/{param}` | `String ruleId, TypeReference responseType` | `@Nullable T` | -| `ontology().validation().rules().list(...)` | `GET` | `/ontology/validation/rules` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().validation().rules().list(...)` | `GET` | `/ontology/validation/rules` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().validation().rules().list(...)` | `GET` | `/ontology/validation/rules` | `Class responseType` | `@Nullable T` | -| `ontology().validation().rules().list(...)` | `GET` | `/ontology/validation/rules` | `TypeReference responseType` | `@Nullable T` | -| `ontology().validation().rules().get(...)` | `GET` | `/ontology/validation/rules/{param}` | `String ruleId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().validation().rules().get(...)` | `GET` | `/ontology/validation/rules/{param}` | `String ruleId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().validation().rules().get(...)` | `GET` | `/ontology/validation/rules/{param}` | `String ruleId, Class responseType` | `@Nullable T` | -| `ontology().validation().rules().get(...)` | `GET` | `/ontology/validation/rules/{param}` | `String ruleId, TypeReference responseType` | `@Nullable T` | -| `ontology().validation().rules().create(...)` | `POST` | `/ontology/validation/rules` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().validation().rules().create(...)` | `POST` | `/ontology/validation/rules` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().validation().rules().create(...)` | `POST` | `/ontology/validation/rules` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().validation().rules().create(...)` | `POST` | `/ontology/validation/rules` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().validation().runs().list(...)` | `GET` | `/ontology/validation/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().validation().runs().list(...)` | `GET` | `/ontology/validation/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().validation().runs().list(...)` | `GET` | `/ontology/validation/runs` | `Class responseType` | `@Nullable T` | -| `ontology().validation().runs().list(...)` | `GET` | `/ontology/validation/runs` | `TypeReference responseType` | `@Nullable T` | -| `ontology().validation().runs().get(...)` | `GET` | `/ontology/validation/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().validation().runs().get(...)` | `GET` | `/ontology/validation/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().validation().runs().get(...)` | `GET` | `/ontology/validation/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `ontology().validation().runs().get(...)` | `GET` | `/ontology/validation/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `ontology().validation().runs().create(...)` | `POST` | `/ontology/validation/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().validation().runs().create(...)` | `POST` | `/ontology/validation/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().validation().runs().create(...)` | `POST` | `/ontology/validation/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().validation().runs().create(...)` | `POST` | `/ontology/validation/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().versions().audit().verify(...)` | `POST` | `/ontology/versions/audit/verify` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().versions().audit().verify(...)` | `POST` | `/ontology/versions/audit/verify` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().versions().audit().verify(...)` | `POST` | `/ontology/versions/audit/verify` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().versions().audit().verify(...)` | `POST` | `/ontology/versions/audit/verify` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().versions().capabilities().list(...)` | `GET` | `/ontology/versions/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().versions().capabilities().list(...)` | `GET` | `/ontology/versions/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().versions().capabilities().list(...)` | `GET` | `/ontology/versions/capabilities` | `Class responseType` | `@Nullable T` | -| `ontology().versions().capabilities().list(...)` | `GET` | `/ontology/versions/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `ontology().versions().releaseBundles().list(...)` | `GET` | `/ontology/versions/release-bundles` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().versions().releaseBundles().list(...)` | `GET` | `/ontology/versions/release-bundles` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().versions().releaseBundles().list(...)` | `GET` | `/ontology/versions/release-bundles` | `Class responseType` | `@Nullable T` | -| `ontology().versions().releaseBundles().list(...)` | `GET` | `/ontology/versions/release-bundles` | `TypeReference responseType` | `@Nullable T` | -| `ontology().versions().releaseBundles().get(...)` | `GET` | `/ontology/versions/release-bundles/{param}` | `String bundleId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().versions().releaseBundles().get(...)` | `GET` | `/ontology/versions/release-bundles/{param}` | `String bundleId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().versions().releaseBundles().get(...)` | `GET` | `/ontology/versions/release-bundles/{param}` | `String bundleId, Class responseType` | `@Nullable T` | -| `ontology().versions().releaseBundles().get(...)` | `GET` | `/ontology/versions/release-bundles/{param}` | `String bundleId, TypeReference responseType` | `@Nullable T` | -| `ontology().versions().releaseBundles().create(...)` | `POST` | `/ontology/versions/release-bundles` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().versions().releaseBundles().create(...)` | `POST` | `/ontology/versions/release-bundles` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().versions().releaseBundles().create(...)` | `POST` | `/ontology/versions/release-bundles` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().versions().releaseBundles().create(...)` | `POST` | `/ontology/versions/release-bundles` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().versions().runs().list(...)` | `GET` | `/ontology/versions/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().versions().runs().list(...)` | `GET` | `/ontology/versions/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().versions().runs().list(...)` | `GET` | `/ontology/versions/runs` | `Class responseType` | `@Nullable T` | -| `ontology().versions().runs().list(...)` | `GET` | `/ontology/versions/runs` | `TypeReference responseType` | `@Nullable T` | -| `ontology().versions().runs().get(...)` | `GET` | `/ontology/versions/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().versions().runs().get(...)` | `GET` | `/ontology/versions/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().versions().runs().get(...)` | `GET` | `/ontology/versions/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | -| `ontology().versions().runs().get(...)` | `GET` | `/ontology/versions/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | -| `ontology().versions().runs().create(...)` | `POST` | `/ontology/versions/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().versions().runs().create(...)` | `POST` | `/ontology/versions/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().versions().runs().create(...)` | `POST` | `/ontology/versions/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().versions().runs().create(...)` | `POST` | `/ontology/versions/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().versions().versions().delete(...)` | `DELETE` | `/ontology/versions/versions/{param}` | `String versionId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().versions().versions().delete(...)` | `DELETE` | `/ontology/versions/versions/{param}` | `String versionId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().versions().versions().delete(...)` | `DELETE` | `/ontology/versions/versions/{param}` | `String versionId, Class responseType` | `@Nullable T` | -| `ontology().versions().versions().delete(...)` | `DELETE` | `/ontology/versions/versions/{param}` | `String versionId, TypeReference responseType` | `@Nullable T` | -| `ontology().versions().versions().get(...)` | `GET` | `/ontology/versions/versions/{param}` | `String versionId, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().versions().versions().get(...)` | `GET` | `/ontology/versions/versions/{param}` | `String versionId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().versions().versions().get(...)` | `GET` | `/ontology/versions/versions/{param}` | `String versionId, Class responseType` | `@Nullable T` | -| `ontology().versions().versions().get(...)` | `GET` | `/ontology/versions/versions/{param}` | `String versionId, TypeReference responseType` | `@Nullable T` | -| `ontology().versions().versions().create(...)` | `POST` | `/ontology/versions/versions` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().versions().versions().create(...)` | `POST` | `/ontology/versions/versions` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().versions().versions().create(...)` | `POST` | `/ontology/versions/versions` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().versions().versions().create(...)` | `POST` | `/ontology/versions/versions` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().versions().versions().compare(...)` | `POST` | `/ontology/versions/versions/compare` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().versions().versions().compare(...)` | `POST` | `/ontology/versions/versions/compare` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().versions().versions().compare(...)` | `POST` | `/ontology/versions/versions/compare` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().versions().versions().compare(...)` | `POST` | `/ontology/versions/versions/compare` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().engine().ontologies().compareVersions().create(...)` | `POST` | `/ontology/engine/ontologies/compare-versions` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().engine().ontologies().compareVersions().create(...)` | `POST` | `/ontology/engine/ontologies/compare-versions` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().engine().ontologies().compareVersions().create(...)` | `POST` | `/ontology/engine/ontologies/compare-versions` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().engine().ontologies().compareVersions().create(...)` | `POST` | `/ontology/engine/ontologies/compare-versions` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().engine().ontologies().inferClasses().create(...)` | `POST` | `/ontology/engine/ontologies/infer-classes` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().engine().ontologies().inferClasses().create(...)` | `POST` | `/ontology/engine/ontologies/infer-classes` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().engine().ontologies().inferClasses().create(...)` | `POST` | `/ontology/engine/ontologies/infer-classes` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().engine().ontologies().inferClasses().create(...)` | `POST` | `/ontology/engine/ontologies/infer-classes` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().engine().ontologies().inferProperties().create(...)` | `POST` | `/ontology/engine/ontologies/infer-properties` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().engine().ontologies().inferProperties().create(...)` | `POST` | `/ontology/engine/ontologies/infer-properties` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().engine().ontologies().inferProperties().create(...)` | `POST` | `/ontology/engine/ontologies/infer-properties` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().engine().ontologies().inferProperties().create(...)` | `POST` | `/ontology/engine/ontologies/infer-properties` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().events().events().checkpoints().get(...)` | `GET` | `/ontology/events/events/checkpoints/{param}` | `String consumer, QueryParams query, Class responseType` | `@Nullable T` | -| `ontology().events().events().checkpoints().get(...)` | `GET` | `/ontology/events/events/checkpoints/{param}` | `String consumer, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `ontology().events().events().checkpoints().get(...)` | `GET` | `/ontology/events/events/checkpoints/{param}` | `String consumer, Class responseType` | `@Nullable T` | -| `ontology().events().events().checkpoints().get(...)` | `GET` | `/ontology/events/events/checkpoints/{param}` | `String consumer, TypeReference responseType` | `@Nullable T` | -| `ontology().events().events().checkpoints().create(...)` | `POST` | `/ontology/events/events/checkpoints` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().events().events().checkpoints().create(...)` | `POST` | `/ontology/events/events/checkpoints` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().events().events().checkpoints().create(...)` | `POST` | `/ontology/events/events/checkpoints` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().events().events().checkpoints().create(...)` | `POST` | `/ontology/events/events/checkpoints` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().events().events().leases().acknowledge(...)` | `POST` | `/ontology/events/events/leases/acknowledge` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().events().events().leases().acknowledge(...)` | `POST` | `/ontology/events/events/leases/acknowledge` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().events().events().leases().acknowledge(...)` | `POST` | `/ontology/events/events/leases/acknowledge` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().events().events().leases().acknowledge(...)` | `POST` | `/ontology/events/events/leases/acknowledge` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().events().events().leases().acquire(...)` | `POST` | `/ontology/events/events/leases/acquire` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().events().events().leases().acquire(...)` | `POST` | `/ontology/events/events/leases/acquire` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().events().events().leases().acquire(...)` | `POST` | `/ontology/events/events/leases/acquire` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().events().events().leases().acquire(...)` | `POST` | `/ontology/events/events/leases/acquire` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().extract().extract().coreferences().create(...)` | `POST` | `/ontology/extract/extract/coreferences` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().extract().extract().coreferences().create(...)` | `POST` | `/ontology/extract/extract/coreferences` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().extract().extract().coreferences().create(...)` | `POST` | `/ontology/extract/extract/coreferences` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().extract().extract().coreferences().create(...)` | `POST` | `/ontology/extract/extract/coreferences` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().extract().extract().entities().create(...)` | `POST` | `/ontology/extract/extract/entities` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().extract().extract().entities().create(...)` | `POST` | `/ontology/extract/extract/entities` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().extract().extract().entities().create(...)` | `POST` | `/ontology/extract/extract/entities` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().extract().extract().entities().create(...)` | `POST` | `/ontology/extract/extract/entities` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().extract().extract().events().create(...)` | `POST` | `/ontology/extract/extract/events` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().extract().extract().events().create(...)` | `POST` | `/ontology/extract/extract/events` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().extract().extract().events().create(...)` | `POST` | `/ontology/extract/extract/events` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().extract().extract().events().create(...)` | `POST` | `/ontology/extract/extract/events` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().extract().extract().relations().create(...)` | `POST` | `/ontology/extract/extract/relations` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().extract().extract().relations().create(...)` | `POST` | `/ontology/extract/extract/relations` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().extract().extract().relations().create(...)` | `POST` | `/ontology/extract/extract/relations` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().extract().extract().relations().create(...)` | `POST` | `/ontology/extract/extract/relations` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().extract().extract().triplets().create(...)` | `POST` | `/ontology/extract/extract/triplets` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().extract().extract().triplets().create(...)` | `POST` | `/ontology/extract/extract/triplets` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `ontology().extract().extract().triplets().create(...)` | `POST` | `/ontology/extract/extract/triplets` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `ontology().extract().extract().triplets().create(...)` | `POST` | `/ontology/extract/extract/triplets` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | - -The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/pipelines.md b/docs/api/pipelines.md deleted file mode 100644 index fa36e66..0000000 --- a/docs/api/pipelines.md +++ /dev/null @@ -1,54 +0,0 @@ -# Pipelines API - -Service accessor: `frontal.pipelines()` (`PipelinesClient`). - -Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. - -| Method | HTTP | Route | Parameters | Response | -| --- | --- | --- | --- | --- | -| `pipelines().data().pipelines().health(...)` | `GET` | `/data/pipelines/health` | `QueryParams query, Class responseType` | `@Nullable T` | -| `pipelines().data().pipelines().health(...)` | `GET` | `/data/pipelines/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `pipelines().data().pipelines().health(...)` | `GET` | `/data/pipelines/health` | `Class responseType` | `@Nullable T` | -| `pipelines().data().pipelines().health(...)` | `GET` | `/data/pipelines/health` | `TypeReference responseType` | `@Nullable T` | -| `pipelines().data().pipelines().getInfo(...)` | `GET` | `/data/pipelines/info` | `QueryParams query, Class responseType` | `@Nullable T` | -| `pipelines().data().pipelines().getInfo(...)` | `GET` | `/data/pipelines/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `pipelines().data().pipelines().getInfo(...)` | `GET` | `/data/pipelines/info` | `Class responseType` | `@Nullable T` | -| `pipelines().data().pipelines().getInfo(...)` | `GET` | `/data/pipelines/info` | `TypeReference responseType` | `@Nullable T` | -| `pipelines().data().pipelines().capabilities().list(...)` | `GET` | `/data/pipelines/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | -| `pipelines().data().pipelines().capabilities().list(...)` | `GET` | `/data/pipelines/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `pipelines().data().pipelines().capabilities().list(...)` | `GET` | `/data/pipelines/capabilities` | `Class responseType` | `@Nullable T` | -| `pipelines().data().pipelines().capabilities().list(...)` | `GET` | `/data/pipelines/capabilities` | `TypeReference responseType` | `@Nullable T` | -| `pipelines().data().pipelines().pipelineRuns().list(...)` | `GET` | `/data/pipelines/pipeline-runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `pipelines().data().pipelines().pipelineRuns().list(...)` | `GET` | `/data/pipelines/pipeline-runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `pipelines().data().pipelines().pipelineRuns().list(...)` | `GET` | `/data/pipelines/pipeline-runs` | `Class responseType` | `@Nullable T` | -| `pipelines().data().pipelines().pipelineRuns().list(...)` | `GET` | `/data/pipelines/pipeline-runs` | `TypeReference responseType` | `@Nullable T` | -| `pipelines().data().pipelines().pipelineRuns().get(...)` | `GET` | `/data/pipelines/pipeline-runs/{param}` | `String pipelineRunId, QueryParams query, Class responseType` | `@Nullable T` | -| `pipelines().data().pipelines().pipelineRuns().get(...)` | `GET` | `/data/pipelines/pipeline-runs/{param}` | `String pipelineRunId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `pipelines().data().pipelines().pipelineRuns().get(...)` | `GET` | `/data/pipelines/pipeline-runs/{param}` | `String pipelineRunId, Class responseType` | `@Nullable T` | -| `pipelines().data().pipelines().pipelineRuns().get(...)` | `GET` | `/data/pipelines/pipeline-runs/{param}` | `String pipelineRunId, TypeReference responseType` | `@Nullable T` | -| `pipelines().data().pipelines().pipelineRuns().get2(...)` | `STREAM` | `/data/pipelines/pipeline-runs/{param}` | `String pipelineRunId, QueryParams query` | `Flow.Publisher` | -| `pipelines().data().pipelines().pipelineRuns().get2(...)` | `STREAM` | `/data/pipelines/pipeline-runs/{param}` | `String pipelineRunId` | `Flow.Publisher` | -| `pipelines().data().pipelines().pipelineRuns().get2Blocking(...)` | `STREAM` | `/data/pipelines/pipeline-runs/{param}` | `String pipelineRunId, QueryParams query` | `SseEventIterator` | -| `pipelines().data().pipelines().pipelineRuns().get2Blocking(...)` | `STREAM` | `/data/pipelines/pipeline-runs/{param}` | `String pipelineRunId` | `SseEventIterator` | -| `pipelines().data().pipelines().pipelines().list(...)` | `GET` | `/data/pipelines/pipelines` | `QueryParams query, Class responseType` | `@Nullable T` | -| `pipelines().data().pipelines().pipelines().list(...)` | `GET` | `/data/pipelines/pipelines` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `pipelines().data().pipelines().pipelines().list(...)` | `GET` | `/data/pipelines/pipelines` | `Class responseType` | `@Nullable T` | -| `pipelines().data().pipelines().pipelines().list(...)` | `GET` | `/data/pipelines/pipelines` | `TypeReference responseType` | `@Nullable T` | -| `pipelines().data().pipelines().pipelines().get(...)` | `GET` | `/data/pipelines/pipelines/{param}` | `String pipelineId, QueryParams query, Class responseType` | `@Nullable T` | -| `pipelines().data().pipelines().pipelines().get(...)` | `GET` | `/data/pipelines/pipelines/{param}` | `String pipelineId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `pipelines().data().pipelines().pipelines().get(...)` | `GET` | `/data/pipelines/pipelines/{param}` | `String pipelineId, Class responseType` | `@Nullable T` | -| `pipelines().data().pipelines().pipelines().get(...)` | `GET` | `/data/pipelines/pipelines/{param}` | `String pipelineId, TypeReference responseType` | `@Nullable T` | -| `pipelines().data().pipelines().pipelines().create(...)` | `POST` | `/data/pipelines/pipelines` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `pipelines().data().pipelines().pipelines().create(...)` | `POST` | `/data/pipelines/pipelines` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `pipelines().data().pipelines().pipelines().create(...)` | `POST` | `/data/pipelines/pipelines` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `pipelines().data().pipelines().pipelines().create(...)` | `POST` | `/data/pipelines/pipelines` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `pipelines().data().pipelines().runs().list(...)` | `GET` | `/data/pipelines/runs` | `QueryParams query, Class responseType` | `@Nullable T` | -| `pipelines().data().pipelines().runs().list(...)` | `GET` | `/data/pipelines/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `pipelines().data().pipelines().runs().list(...)` | `GET` | `/data/pipelines/runs` | `Class responseType` | `@Nullable T` | -| `pipelines().data().pipelines().runs().list(...)` | `GET` | `/data/pipelines/runs` | `TypeReference responseType` | `@Nullable T` | -| `pipelines().data().pipelines().runs().create(...)` | `POST` | `/data/pipelines/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `pipelines().data().pipelines().runs().create(...)` | `POST` | `/data/pipelines/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `pipelines().data().pipelines().runs().create(...)` | `POST` | `/data/pipelines/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `pipelines().data().pipelines().runs().create(...)` | `POST` | `/data/pipelines/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | - -The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/providers.md b/docs/api/providers.md deleted file mode 100644 index 406f7c8..0000000 --- a/docs/api/providers.md +++ /dev/null @@ -1,14 +0,0 @@ -# Providers API - -Service accessor: `frontal.providers()` (`ProvidersClient`). - -Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. - -| Method | HTTP | Route | Parameters | Response | -| --- | --- | --- | --- | --- | -| `providers().get(...)` | `GET` | `/providers/{param}` | `String providerSlug, QueryParams query, Class responseType` | `@Nullable T` | -| `providers().get(...)` | `GET` | `/providers/{param}` | `String providerSlug, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `providers().get(...)` | `GET` | `/providers/{param}` | `String providerSlug, Class responseType` | `@Nullable T` | -| `providers().get(...)` | `GET` | `/providers/{param}` | `String providerSlug, TypeReference responseType` | `@Nullable T` | - -The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/react.md b/docs/api/react.md deleted file mode 100644 index 2cbf34e..0000000 --- a/docs/api/react.md +++ /dev/null @@ -1,10 +0,0 @@ -# React API - -Service accessor: `frontal.react()` (`ReactClient`). - -Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. - -| Method | HTTP | Route | Parameters | Response | -| --- | --- | --- | --- | --- | - -The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/schedules.md b/docs/api/schedules.md deleted file mode 100644 index 5249f9d..0000000 --- a/docs/api/schedules.md +++ /dev/null @@ -1,50 +0,0 @@ -# Schedules API - -Service accessor: `frontal.schedules()` (`SchedulesClient`). - -Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. - -| Method | HTTP | Route | Parameters | Response | -| --- | --- | --- | --- | --- | -| `schedules().workflows().cron().parse(...)` | `POST` | `/workflows/cron/parse` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `schedules().workflows().cron().parse(...)` | `POST` | `/workflows/cron/parse` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `schedules().workflows().cron().parse(...)` | `POST` | `/workflows/cron/parse` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `schedules().workflows().cron().parse(...)` | `POST` | `/workflows/cron/parse` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `schedules().workflows().cron().validate(...)` | `POST` | `/workflows/cron/validate` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `schedules().workflows().cron().validate(...)` | `POST` | `/workflows/cron/validate` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `schedules().workflows().cron().validate(...)` | `POST` | `/workflows/cron/validate` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `schedules().workflows().cron().validate(...)` | `POST` | `/workflows/cron/validate` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `schedules().workflows().schedules().delete(...)` | `DELETE` | `/workflows/schedules/{param}` | `String scheduleId, QueryParams query, Class responseType` | `@Nullable T` | -| `schedules().workflows().schedules().delete(...)` | `DELETE` | `/workflows/schedules/{param}` | `String scheduleId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `schedules().workflows().schedules().delete(...)` | `DELETE` | `/workflows/schedules/{param}` | `String scheduleId, Class responseType` | `@Nullable T` | -| `schedules().workflows().schedules().delete(...)` | `DELETE` | `/workflows/schedules/{param}` | `String scheduleId, TypeReference responseType` | `@Nullable T` | -| `schedules().workflows().schedules().list(...)` | `GET` | `/workflows/schedules` | `QueryParams query, Class responseType` | `@Nullable T` | -| `schedules().workflows().schedules().list(...)` | `GET` | `/workflows/schedules` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `schedules().workflows().schedules().list(...)` | `GET` | `/workflows/schedules` | `Class responseType` | `@Nullable T` | -| `schedules().workflows().schedules().list(...)` | `GET` | `/workflows/schedules` | `TypeReference responseType` | `@Nullable T` | -| `schedules().workflows().schedules().get(...)` | `GET` | `/workflows/schedules/{param}` | `String scheduleId, QueryParams query, Class responseType` | `@Nullable T` | -| `schedules().workflows().schedules().get(...)` | `GET` | `/workflows/schedules/{param}` | `String scheduleId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `schedules().workflows().schedules().get(...)` | `GET` | `/workflows/schedules/{param}` | `String scheduleId, Class responseType` | `@Nullable T` | -| `schedules().workflows().schedules().get(...)` | `GET` | `/workflows/schedules/{param}` | `String scheduleId, TypeReference responseType` | `@Nullable T` | -| `schedules().workflows().schedules().update(...)` | `PATCH` | `/workflows/schedules/{param}` | `String scheduleId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `schedules().workflows().schedules().update(...)` | `PATCH` | `/workflows/schedules/{param}` | `String scheduleId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `schedules().workflows().schedules().update(...)` | `PATCH` | `/workflows/schedules/{param}` | `String scheduleId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `schedules().workflows().schedules().update(...)` | `PATCH` | `/workflows/schedules/{param}` | `String scheduleId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `schedules().workflows().schedules().create(...)` | `POST` | `/workflows/schedules` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `schedules().workflows().schedules().create(...)` | `POST` | `/workflows/schedules` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `schedules().workflows().schedules().create(...)` | `POST` | `/workflows/schedules` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `schedules().workflows().schedules().create(...)` | `POST` | `/workflows/schedules` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `schedules().workflows().schedules().pause(...)` | `POST` | `/workflows/schedules/{param}/pause` | `String scheduleId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `schedules().workflows().schedules().pause(...)` | `POST` | `/workflows/schedules/{param}/pause` | `String scheduleId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `schedules().workflows().schedules().pause(...)` | `POST` | `/workflows/schedules/{param}/pause` | `String scheduleId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `schedules().workflows().schedules().pause(...)` | `POST` | `/workflows/schedules/{param}/pause` | `String scheduleId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `schedules().workflows().schedules().resume(...)` | `POST` | `/workflows/schedules/{param}/resume` | `String scheduleId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `schedules().workflows().schedules().resume(...)` | `POST` | `/workflows/schedules/{param}/resume` | `String scheduleId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `schedules().workflows().schedules().resume(...)` | `POST` | `/workflows/schedules/{param}/resume` | `String scheduleId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `schedules().workflows().schedules().resume(...)` | `POST` | `/workflows/schedules/{param}/resume` | `String scheduleId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `schedules().workflows().schedules().trigger(...)` | `POST` | `/workflows/schedules/{param}/trigger` | `String scheduleId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `schedules().workflows().schedules().trigger(...)` | `POST` | `/workflows/schedules/{param}/trigger` | `String scheduleId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `schedules().workflows().schedules().trigger(...)` | `POST` | `/workflows/schedules/{param}/trigger` | `String scheduleId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `schedules().workflows().schedules().trigger(...)` | `POST` | `/workflows/schedules/{param}/trigger` | `String scheduleId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | - -The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/webhook-endpoints.md b/docs/api/webhook-endpoints.md deleted file mode 100644 index f7e03db..0000000 --- a/docs/api/webhook-endpoints.md +++ /dev/null @@ -1,38 +0,0 @@ -# WebhookEndpoints API - -Service accessor: `frontal.webhookEndpoints()` (`WebhookEndpointsClient`). - -Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. - -| Method | HTTP | Route | Parameters | Response | -| --- | --- | --- | --- | --- | -| `webhookEndpoints().delete(...)` | `DELETE` | `/webhook-endpoints/{param}` | `String id, QueryParams query, Class responseType` | `@Nullable T` | -| `webhookEndpoints().delete(...)` | `DELETE` | `/webhook-endpoints/{param}` | `String id, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `webhookEndpoints().delete(...)` | `DELETE` | `/webhook-endpoints/{param}` | `String id, Class responseType` | `@Nullable T` | -| `webhookEndpoints().delete(...)` | `DELETE` | `/webhook-endpoints/{param}` | `String id, TypeReference responseType` | `@Nullable T` | -| `webhookEndpoints().list(...)` | `GET` | `/webhook-endpoints` | `QueryParams query, Class responseType` | `@Nullable T` | -| `webhookEndpoints().list(...)` | `GET` | `/webhook-endpoints` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `webhookEndpoints().list(...)` | `GET` | `/webhook-endpoints` | `Class responseType` | `@Nullable T` | -| `webhookEndpoints().list(...)` | `GET` | `/webhook-endpoints` | `TypeReference responseType` | `@Nullable T` | -| `webhookEndpoints().get(...)` | `GET` | `/webhook-endpoints/{param}` | `String id, QueryParams query, Class responseType` | `@Nullable T` | -| `webhookEndpoints().get(...)` | `GET` | `/webhook-endpoints/{param}` | `String id, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `webhookEndpoints().get(...)` | `GET` | `/webhook-endpoints/{param}` | `String id, Class responseType` | `@Nullable T` | -| `webhookEndpoints().get(...)` | `GET` | `/webhook-endpoints/{param}` | `String id, TypeReference responseType` | `@Nullable T` | -| `webhookEndpoints().update(...)` | `PATCH` | `/webhook-endpoints/{param}` | `String id, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `webhookEndpoints().update(...)` | `PATCH` | `/webhook-endpoints/{param}` | `String id, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `webhookEndpoints().update(...)` | `PATCH` | `/webhook-endpoints/{param}` | `String id, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `webhookEndpoints().update(...)` | `PATCH` | `/webhook-endpoints/{param}` | `String id, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `webhookEndpoints().create(...)` | `POST` | `/webhook-endpoints` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `webhookEndpoints().create(...)` | `POST` | `/webhook-endpoints` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `webhookEndpoints().create(...)` | `POST` | `/webhook-endpoints` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `webhookEndpoints().create(...)` | `POST` | `/webhook-endpoints` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `webhookEndpoints().rotateSecret(...)` | `POST` | `/webhook-endpoints/{param}/rotate-secret` | `String id, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `webhookEndpoints().rotateSecret(...)` | `POST` | `/webhook-endpoints/{param}/rotate-secret` | `String id, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `webhookEndpoints().rotateSecret(...)` | `POST` | `/webhook-endpoints/{param}/rotate-secret` | `String id, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `webhookEndpoints().rotateSecret(...)` | `POST` | `/webhook-endpoints/{param}/rotate-secret` | `String id, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `webhookEndpoints().deliveries().list(...)` | `GET` | `/webhook-endpoints/{param}/deliveries` | `String id, QueryParams query, Class responseType` | `@Nullable T` | -| `webhookEndpoints().deliveries().list(...)` | `GET` | `/webhook-endpoints/{param}/deliveries` | `String id, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `webhookEndpoints().deliveries().list(...)` | `GET` | `/webhook-endpoints/{param}/deliveries` | `String id, Class responseType` | `@Nullable T` | -| `webhookEndpoints().deliveries().list(...)` | `GET` | `/webhook-endpoints/{param}/deliveries` | `String id, TypeReference responseType` | `@Nullable T` | - -The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/webhooks.md b/docs/api/webhooks.md deleted file mode 100644 index 3a38565..0000000 --- a/docs/api/webhooks.md +++ /dev/null @@ -1,50 +0,0 @@ -# Webhooks API - -Service accessor: `frontal.webhooks()` (`WebhooksClient`). - -Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. - -| Method | HTTP | Route | Parameters | Response | -| --- | --- | --- | --- | --- | -| `webhooks().delete(...)` | `DELETE` | `/webhooks/{param}` | `String webhookId, QueryParams query, Class responseType` | `@Nullable T` | -| `webhooks().delete(...)` | `DELETE` | `/webhooks/{param}` | `String webhookId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `webhooks().delete(...)` | `DELETE` | `/webhooks/{param}` | `String webhookId, Class responseType` | `@Nullable T` | -| `webhooks().delete(...)` | `DELETE` | `/webhooks/{param}` | `String webhookId, TypeReference responseType` | `@Nullable T` | -| `webhooks().list(...)` | `GET` | `/webhooks` | `QueryParams query, Class responseType` | `@Nullable T` | -| `webhooks().list(...)` | `GET` | `/webhooks` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `webhooks().list(...)` | `GET` | `/webhooks` | `Class responseType` | `@Nullable T` | -| `webhooks().list(...)` | `GET` | `/webhooks` | `TypeReference responseType` | `@Nullable T` | -| `webhooks().get(...)` | `GET` | `/webhooks/{param}` | `String webhookId, QueryParams query, Class responseType` | `@Nullable T` | -| `webhooks().get(...)` | `GET` | `/webhooks/{param}` | `String webhookId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `webhooks().get(...)` | `GET` | `/webhooks/{param}` | `String webhookId, Class responseType` | `@Nullable T` | -| `webhooks().get(...)` | `GET` | `/webhooks/{param}` | `String webhookId, TypeReference responseType` | `@Nullable T` | -| `webhooks().create(...)` | `POST` | `/webhooks` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `webhooks().create(...)` | `POST` | `/webhooks` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `webhooks().create(...)` | `POST` | `/webhooks` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `webhooks().create(...)` | `POST` | `/webhooks` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `webhooks().rotateSecret(...)` | `POST` | `/webhooks/{param}/rotate-secret` | `String webhookId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `webhooks().rotateSecret(...)` | `POST` | `/webhooks/{param}/rotate-secret` | `String webhookId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `webhooks().rotateSecret(...)` | `POST` | `/webhooks/{param}/rotate-secret` | `String webhookId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `webhooks().rotateSecret(...)` | `POST` | `/webhooks/{param}/rotate-secret` | `String webhookId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `webhooks().update(...)` | `PUT` | `/webhooks/{param}` | `String webhookId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `webhooks().update(...)` | `PUT` | `/webhooks/{param}` | `String webhookId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `webhooks().update(...)` | `PUT` | `/webhooks/{param}` | `String webhookId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `webhooks().update(...)` | `PUT` | `/webhooks/{param}` | `String webhookId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `webhooks().deliveries().list(...)` | `GET` | `/webhooks/deliveries` | `QueryParams query, Class responseType` | `@Nullable T` | -| `webhooks().deliveries().list(...)` | `GET` | `/webhooks/deliveries` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `webhooks().deliveries().list(...)` | `GET` | `/webhooks/deliveries` | `Class responseType` | `@Nullable T` | -| `webhooks().deliveries().list(...)` | `GET` | `/webhooks/deliveries` | `TypeReference responseType` | `@Nullable T` | -| `webhooks().deliveries().get(...)` | `GET` | `/webhooks/deliveries/{param}` | `String deliveryId, QueryParams query, Class responseType` | `@Nullable T` | -| `webhooks().deliveries().get(...)` | `GET` | `/webhooks/deliveries/{param}` | `String deliveryId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `webhooks().deliveries().get(...)` | `GET` | `/webhooks/deliveries/{param}` | `String deliveryId, Class responseType` | `@Nullable T` | -| `webhooks().deliveries().get(...)` | `GET` | `/webhooks/deliveries/{param}` | `String deliveryId, TypeReference responseType` | `@Nullable T` | -| `webhooks().deliveries().retry(...)` | `POST` | `/webhooks/deliveries/{param}/retry` | `String deliveryId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `webhooks().deliveries().retry(...)` | `POST` | `/webhooks/deliveries/{param}/retry` | `String deliveryId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `webhooks().deliveries().retry(...)` | `POST` | `/webhooks/deliveries/{param}/retry` | `String deliveryId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `webhooks().deliveries().retry(...)` | `POST` | `/webhooks/deliveries/{param}/retry` | `String deliveryId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `webhooks().stats().list(...)` | `GET` | `/webhooks/stats` | `QueryParams query, Class responseType` | `@Nullable T` | -| `webhooks().stats().list(...)` | `GET` | `/webhooks/stats` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `webhooks().stats().list(...)` | `GET` | `/webhooks/stats` | `Class responseType` | `@Nullable T` | -| `webhooks().stats().list(...)` | `GET` | `/webhooks/stats` | `TypeReference responseType` | `@Nullable T` | - -The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/workflows.md b/docs/api/workflows.md deleted file mode 100644 index 281d069..0000000 --- a/docs/api/workflows.md +++ /dev/null @@ -1,130 +0,0 @@ -# Workflows API - -Service accessor: `frontal.workflows()` (`WorkflowsServiceClient`). - -Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. - -| Method | HTTP | Route | Parameters | Response | -| --- | --- | --- | --- | --- | -| `workflows().delete(...)` | `DELETE` | `/workflows/{param}` | `String workflowId, QueryParams query, Class responseType` | `@Nullable T` | -| `workflows().delete(...)` | `DELETE` | `/workflows/{param}` | `String workflowId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `workflows().delete(...)` | `DELETE` | `/workflows/{param}` | `String workflowId, Class responseType` | `@Nullable T` | -| `workflows().delete(...)` | `DELETE` | `/workflows/{param}` | `String workflowId, TypeReference responseType` | `@Nullable T` | -| `workflows().list(...)` | `GET` | `/workflows` | `QueryParams query, Class responseType` | `@Nullable T` | -| `workflows().list(...)` | `GET` | `/workflows` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `workflows().list(...)` | `GET` | `/workflows` | `Class responseType` | `@Nullable T` | -| `workflows().list(...)` | `GET` | `/workflows` | `TypeReference responseType` | `@Nullable T` | -| `workflows().get(...)` | `GET` | `/workflows/{param}` | `String workflowId, QueryParams query, Class responseType` | `@Nullable T` | -| `workflows().get(...)` | `GET` | `/workflows/{param}` | `String workflowId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `workflows().get(...)` | `GET` | `/workflows/{param}` | `String workflowId, Class responseType` | `@Nullable T` | -| `workflows().get(...)` | `GET` | `/workflows/{param}` | `String workflowId, TypeReference responseType` | `@Nullable T` | -| `workflows().get2(...)` | `GET` | `/workflows/{param}/{param}` | `String workflowId, String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `workflows().get2(...)` | `GET` | `/workflows/{param}/{param}` | `String workflowId, String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `workflows().get2(...)` | `GET` | `/workflows/{param}/{param}` | `String workflowId, String runId, Class responseType` | `@Nullable T` | -| `workflows().get2(...)` | `GET` | `/workflows/{param}/{param}` | `String workflowId, String runId, TypeReference responseType` | `@Nullable T` | -| `workflows().summary(...)` | `GET` | `/workflows/{param}/{param}/summary` | `String workflowId, String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `workflows().summary(...)` | `GET` | `/workflows/{param}/{param}/summary` | `String workflowId, String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `workflows().summary(...)` | `GET` | `/workflows/{param}/{param}/summary` | `String workflowId, String runId, Class responseType` | `@Nullable T` | -| `workflows().summary(...)` | `GET` | `/workflows/{param}/{param}/summary` | `String workflowId, String runId, TypeReference responseType` | `@Nullable T` | -| `workflows().timeline(...)` | `GET` | `/workflows/{param}/{param}/timeline` | `String workflowId, String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `workflows().timeline(...)` | `GET` | `/workflows/{param}/{param}/timeline` | `String workflowId, String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `workflows().timeline(...)` | `GET` | `/workflows/{param}/{param}/timeline` | `String workflowId, String runId, Class responseType` | `@Nullable T` | -| `workflows().timeline(...)` | `GET` | `/workflows/{param}/{param}/timeline` | `String workflowId, String runId, TypeReference responseType` | `@Nullable T` | -| `workflows().update(...)` | `PATCH` | `/workflows/{param}` | `String workflowId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().update(...)` | `PATCH` | `/workflows/{param}` | `String workflowId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().update(...)` | `PATCH` | `/workflows/{param}` | `String workflowId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().update(...)` | `PATCH` | `/workflows/{param}` | `String workflowId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().create(...)` | `POST` | `/workflows` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().create(...)` | `POST` | `/workflows` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().create(...)` | `POST` | `/workflows` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().create(...)` | `POST` | `/workflows` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().batch(...)` | `POST` | `/workflows/batch` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().batch(...)` | `POST` | `/workflows/batch` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().batch(...)` | `POST` | `/workflows/batch` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().batch(...)` | `POST` | `/workflows/batch` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().search(...)` | `POST` | `/workflows/search` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().search(...)` | `POST` | `/workflows/search` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().search(...)` | `POST` | `/workflows/search` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().search(...)` | `POST` | `/workflows/search` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().archive(...)` | `POST` | `/workflows/{param}/archive` | `String workflowId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().archive(...)` | `POST` | `/workflows/{param}/archive` | `String workflowId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().archive(...)` | `POST` | `/workflows/{param}/archive` | `String workflowId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().archive(...)` | `POST` | `/workflows/{param}/archive` | `String workflowId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().publish(...)` | `POST` | `/workflows/{param}/publish` | `String workflowId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().publish(...)` | `POST` | `/workflows/{param}/publish` | `String workflowId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().publish(...)` | `POST` | `/workflows/{param}/publish` | `String workflowId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().publish(...)` | `POST` | `/workflows/{param}/publish` | `String workflowId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().restore(...)` | `POST` | `/workflows/{param}/restore` | `String workflowId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().restore(...)` | `POST` | `/workflows/{param}/restore` | `String workflowId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().restore(...)` | `POST` | `/workflows/{param}/restore` | `String workflowId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().restore(...)` | `POST` | `/workflows/{param}/restore` | `String workflowId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().approvals().list(...)` | `GET` | `/workflows/approvals` | `QueryParams query, Class responseType` | `@Nullable T` | -| `workflows().approvals().list(...)` | `GET` | `/workflows/approvals` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `workflows().approvals().list(...)` | `GET` | `/workflows/approvals` | `Class responseType` | `@Nullable T` | -| `workflows().approvals().list(...)` | `GET` | `/workflows/approvals` | `TypeReference responseType` | `@Nullable T` | -| `workflows().approvals().get(...)` | `GET` | `/workflows/approvals/{param}` | `String approvalId, QueryParams query, Class responseType` | `@Nullable T` | -| `workflows().approvals().get(...)` | `GET` | `/workflows/approvals/{param}` | `String approvalId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `workflows().approvals().get(...)` | `GET` | `/workflows/approvals/{param}` | `String approvalId, Class responseType` | `@Nullable T` | -| `workflows().approvals().get(...)` | `GET` | `/workflows/approvals/{param}` | `String approvalId, TypeReference responseType` | `@Nullable T` | -| `workflows().approvals().approve(...)` | `POST` | `/workflows/approvals/{param}/approve` | `String approvalId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().approvals().approve(...)` | `POST` | `/workflows/approvals/{param}/approve` | `String approvalId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().approvals().approve(...)` | `POST` | `/workflows/approvals/{param}/approve` | `String approvalId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().approvals().approve(...)` | `POST` | `/workflows/approvals/{param}/approve` | `String approvalId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().approvals().reject(...)` | `POST` | `/workflows/approvals/{param}/reject` | `String approvalId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().approvals().reject(...)` | `POST` | `/workflows/approvals/{param}/reject` | `String approvalId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().approvals().reject(...)` | `POST` | `/workflows/approvals/{param}/reject` | `String approvalId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().approvals().reject(...)` | `POST` | `/workflows/approvals/{param}/reject` | `String approvalId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().executions().list(...)` | `GET` | `/workflows/executions` | `QueryParams query, Class responseType` | `@Nullable T` | -| `workflows().executions().list(...)` | `GET` | `/workflows/executions` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `workflows().executions().list(...)` | `GET` | `/workflows/executions` | `Class responseType` | `@Nullable T` | -| `workflows().executions().list(...)` | `GET` | `/workflows/executions` | `TypeReference responseType` | `@Nullable T` | -| `workflows().executions().get(...)` | `GET` | `/workflows/executions/{param}` | `String executionId, QueryParams query, Class responseType` | `@Nullable T` | -| `workflows().executions().get(...)` | `GET` | `/workflows/executions/{param}` | `String executionId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `workflows().executions().get(...)` | `GET` | `/workflows/executions/{param}` | `String executionId, Class responseType` | `@Nullable T` | -| `workflows().executions().get(...)` | `GET` | `/workflows/executions/{param}` | `String executionId, TypeReference responseType` | `@Nullable T` | -| `workflows().executions().create(...)` | `POST` | `/workflows/executions` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().executions().create(...)` | `POST` | `/workflows/executions` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().executions().create(...)` | `POST` | `/workflows/executions` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().executions().create(...)` | `POST` | `/workflows/executions` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().tasks().get(...)` | `GET` | `/workflows/tasks/{param}` | `String taskId, QueryParams query, Class responseType` | `@Nullable T` | -| `workflows().tasks().get(...)` | `GET` | `/workflows/tasks/{param}` | `String taskId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `workflows().tasks().get(...)` | `GET` | `/workflows/tasks/{param}` | `String taskId, Class responseType` | `@Nullable T` | -| `workflows().tasks().get(...)` | `GET` | `/workflows/tasks/{param}` | `String taskId, TypeReference responseType` | `@Nullable T` | -| `workflows().tasks().cancel(...)` | `POST` | `/workflows/tasks/{param}/cancel` | `String taskId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().tasks().cancel(...)` | `POST` | `/workflows/tasks/{param}/cancel` | `String taskId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().tasks().cancel(...)` | `POST` | `/workflows/tasks/{param}/cancel` | `String taskId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().tasks().cancel(...)` | `POST` | `/workflows/tasks/{param}/cancel` | `String taskId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().tasks().retry(...)` | `POST` | `/workflows/tasks/{param}/retry` | `String taskId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().tasks().retry(...)` | `POST` | `/workflows/tasks/{param}/retry` | `String taskId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().tasks().retry(...)` | `POST` | `/workflows/tasks/{param}/retry` | `String taskId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().tasks().retry(...)` | `POST` | `/workflows/tasks/{param}/retry` | `String taskId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().templates().list(...)` | `GET` | `/workflows/templates` | `QueryParams query, Class responseType` | `@Nullable T` | -| `workflows().templates().list(...)` | `GET` | `/workflows/templates` | `QueryParams query, TypeReference responseType` | `@Nullable T` | -| `workflows().templates().list(...)` | `GET` | `/workflows/templates` | `Class responseType` | `@Nullable T` | -| `workflows().templates().list(...)` | `GET` | `/workflows/templates` | `TypeReference responseType` | `@Nullable T` | -| `workflows().templates().get(...)` | `GET` | `/workflows/templates/{param}` | `String templateId, QueryParams query, Class responseType` | `@Nullable T` | -| `workflows().templates().get(...)` | `GET` | `/workflows/templates/{param}` | `String templateId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `workflows().templates().get(...)` | `GET` | `/workflows/templates/{param}` | `String templateId, Class responseType` | `@Nullable T` | -| `workflows().templates().get(...)` | `GET` | `/workflows/templates/{param}` | `String templateId, TypeReference responseType` | `@Nullable T` | -| `workflows().templates().create(...)` | `POST` | `/workflows/templates` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().templates().create(...)` | `POST` | `/workflows/templates` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().templates().create(...)` | `POST` | `/workflows/templates` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().templates().create(...)` | `POST` | `/workflows/templates` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().templates().instantiate(...)` | `POST` | `/workflows/templates/{param}/instantiate` | `String templateId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().templates().instantiate(...)` | `POST` | `/workflows/templates/{param}/instantiate` | `String templateId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().templates().instantiate(...)` | `POST` | `/workflows/templates/{param}/instantiate` | `String templateId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().templates().instantiate(...)` | `POST` | `/workflows/templates/{param}/instantiate` | `String templateId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().versions().create(...)` | `POST` | `/workflows/{param}/versions` | `String workflowId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().versions().create(...)` | `POST` | `/workflows/{param}/versions` | `String workflowId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().versions().create(...)` | `POST` | `/workflows/{param}/versions` | `String workflowId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | -| `workflows().versions().create(...)` | `POST` | `/workflows/{param}/versions` | `String workflowId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | -| `workflows().executions().tasks().list(...)` | `GET` | `/workflows/executions/{param}/tasks` | `String executionId, QueryParams query, Class responseType` | `@Nullable T` | -| `workflows().executions().tasks().list(...)` | `GET` | `/workflows/executions/{param}/tasks` | `String executionId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `workflows().executions().tasks().list(...)` | `GET` | `/workflows/executions/{param}/tasks` | `String executionId, Class responseType` | `@Nullable T` | -| `workflows().executions().tasks().list(...)` | `GET` | `/workflows/executions/{param}/tasks` | `String executionId, TypeReference responseType` | `@Nullable T` | -| `workflows().runs().steps().list(...)` | `GET` | `/workflows/runs/{param}/steps` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | -| `workflows().runs().steps().list(...)` | `GET` | `/workflows/runs/{param}/steps` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | -| `workflows().runs().steps().list(...)` | `GET` | `/workflows/runs/{param}/steps` | `String runId, Class responseType` | `@Nullable T` | -| `workflows().runs().steps().list(...)` | `GET` | `/workflows/runs/{param}/steps` | `String runId, TypeReference responseType` | `@Nullable T` | - -The generic `request(...)` methods and `Endpoints` constants remain available. From 85103879a6d3838155ca0bbe49e1597bcd224912 Mon Sep 17 00:00:00 2001 From: Gabriel Fonseca Date: Fri, 9 Oct 2026 16:19:39 +0100 Subject: [PATCH 10/11] docs: restore API documentation files removed in error --- docs/api/agents.md | 66 ++++ docs/api/ai.md | 46 +++ docs/api/audit.md | 26 ++ docs/api/auth.md | 274 ++++++++++++++ docs/api/billing.md | 102 +++++ docs/api/blob.md | 42 ++ docs/api/connection-tests.md | 14 + docs/api/connectors.md | 58 +++ docs/api/data.md | 614 ++++++++++++++++++++++++++++++ docs/api/events.md | 78 ++++ docs/api/governance.md | 106 ++++++ docs/api/invocations.md | 14 + docs/api/lineage.md | 38 ++ docs/api/observability.md | 134 +++++++ docs/api/ontology.md | 694 ++++++++++++++++++++++++++++++++++ docs/api/pipelines.md | 54 +++ docs/api/providers.md | 14 + docs/api/react.md | 10 + docs/api/schedules.md | 50 +++ docs/api/webhook-endpoints.md | 38 ++ docs/api/webhooks.md | 50 +++ docs/api/workflows.md | 130 +++++++ 22 files changed, 2652 insertions(+) create mode 100644 docs/api/agents.md create mode 100644 docs/api/ai.md create mode 100644 docs/api/audit.md create mode 100644 docs/api/auth.md create mode 100644 docs/api/billing.md create mode 100644 docs/api/blob.md create mode 100644 docs/api/connection-tests.md create mode 100644 docs/api/connectors.md create mode 100644 docs/api/data.md create mode 100644 docs/api/events.md create mode 100644 docs/api/governance.md create mode 100644 docs/api/invocations.md create mode 100644 docs/api/lineage.md create mode 100644 docs/api/observability.md create mode 100644 docs/api/ontology.md create mode 100644 docs/api/pipelines.md create mode 100644 docs/api/providers.md create mode 100644 docs/api/react.md create mode 100644 docs/api/schedules.md create mode 100644 docs/api/webhook-endpoints.md create mode 100644 docs/api/webhooks.md create mode 100644 docs/api/workflows.md diff --git a/docs/api/agents.md b/docs/api/agents.md new file mode 100644 index 0000000..314cafa --- /dev/null +++ b/docs/api/agents.md @@ -0,0 +1,66 @@ +# Agents API + +Service accessor: `frontal.agents()` (`AgentsServiceClient`). + +Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. + +| Method | HTTP | Route | Parameters | Response | +| --- | --- | --- | --- | --- | +| `agents().delete(...)` | `DELETE` | `/agents/{param}` | `String agentId, QueryParams query, Class responseType` | `@Nullable T` | +| `agents().delete(...)` | `DELETE` | `/agents/{param}` | `String agentId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `agents().delete(...)` | `DELETE` | `/agents/{param}` | `String agentId, Class responseType` | `@Nullable T` | +| `agents().delete(...)` | `DELETE` | `/agents/{param}` | `String agentId, TypeReference responseType` | `@Nullable T` | +| `agents().list(...)` | `GET` | `/agents` | `QueryParams query, Class responseType` | `@Nullable T` | +| `agents().list(...)` | `GET` | `/agents` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `agents().list(...)` | `GET` | `/agents` | `Class responseType` | `@Nullable T` | +| `agents().list(...)` | `GET` | `/agents` | `TypeReference responseType` | `@Nullable T` | +| `agents().health(...)` | `GET` | `/agents/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `agents().health(...)` | `GET` | `/agents/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `agents().health(...)` | `GET` | `/agents/health` | `Class responseType` | `@Nullable T` | +| `agents().health(...)` | `GET` | `/agents/health` | `TypeReference responseType` | `@Nullable T` | +| `agents().get(...)` | `GET` | `/agents/{param}` | `String agentId, QueryParams query, Class responseType` | `@Nullable T` | +| `agents().get(...)` | `GET` | `/agents/{param}` | `String agentId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `agents().get(...)` | `GET` | `/agents/{param}` | `String agentId, Class responseType` | `@Nullable T` | +| `agents().get(...)` | `GET` | `/agents/{param}` | `String agentId, TypeReference responseType` | `@Nullable T` | +| `agents().create(...)` | `POST` | `/agents` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `agents().create(...)` | `POST` | `/agents` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `agents().create(...)` | `POST` | `/agents` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `agents().create(...)` | `POST` | `/agents` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `agents().rollback(...)` | `POST` | `/agents/{param}/rollback` | `String agentId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `agents().rollback(...)` | `POST` | `/agents/{param}/rollback` | `String agentId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `agents().rollback(...)` | `POST` | `/agents/{param}/rollback` | `String agentId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `agents().rollback(...)` | `POST` | `/agents/{param}/rollback` | `String agentId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `agents().update(...)` | `PUT` | `/agents/{param}` | `String agentId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `agents().update(...)` | `PUT` | `/agents/{param}` | `String agentId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `agents().update(...)` | `PUT` | `/agents/{param}` | `String agentId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `agents().update(...)` | `PUT` | `/agents/{param}` | `String agentId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `agents().runs().getByActionRunId(...)` | `GET` | `/action-runs/{param}` | `String actionRunId, QueryParams query, Class responseType` | `@Nullable T` | +| `agents().runs().getByActionRunId(...)` | `GET` | `/action-runs/{param}` | `String actionRunId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `agents().runs().getByActionRunId(...)` | `GET` | `/action-runs/{param}` | `String actionRunId, Class responseType` | `@Nullable T` | +| `agents().runs().getByActionRunId(...)` | `GET` | `/action-runs/{param}` | `String actionRunId, TypeReference responseType` | `@Nullable T` | +| `agents().runs().get(...)` | `GET` | `/agents/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `agents().runs().get(...)` | `GET` | `/agents/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `agents().runs().get(...)` | `GET` | `/agents/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `agents().runs().get(...)` | `GET` | `/agents/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `agents().runs().conversation(...)` | `GET` | `/agents/runs/{param}/conversation` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `agents().runs().conversation(...)` | `GET` | `/agents/runs/{param}/conversation` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `agents().runs().conversation(...)` | `GET` | `/agents/runs/{param}/conversation` | `String runId, Class responseType` | `@Nullable T` | +| `agents().runs().conversation(...)` | `GET` | `/agents/runs/{param}/conversation` | `String runId, TypeReference responseType` | `@Nullable T` | +| `agents().runs().list(...)` | `GET` | `/agents/{param}/runs` | `String agentId, QueryParams query, Class responseType` | `@Nullable T` | +| `agents().runs().list(...)` | `GET` | `/agents/{param}/runs` | `String agentId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `agents().runs().list(...)` | `GET` | `/agents/{param}/runs` | `String agentId, Class responseType` | `@Nullable T` | +| `agents().runs().list(...)` | `GET` | `/agents/{param}/runs` | `String agentId, TypeReference responseType` | `@Nullable T` | +| `agents().runs().create(...)` | `POST` | `/agents/{param}/runs` | `String agentId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `agents().runs().create(...)` | `POST` | `/agents/{param}/runs` | `String agentId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `agents().runs().create(...)` | `POST` | `/agents/{param}/runs` | `String agentId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `agents().runs().create(...)` | `POST` | `/agents/{param}/runs` | `String agentId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `agents().runs().stream(...)` | `STREAM` | `/agents/runs/{param}/stream` | `String runId, QueryParams query` | `Flow.Publisher` | +| `agents().runs().stream(...)` | `STREAM` | `/agents/runs/{param}/stream` | `String runId` | `Flow.Publisher` | +| `agents().runs().streamBlocking(...)` | `STREAM` | `/agents/runs/{param}/stream` | `String runId, QueryParams query` | `SseEventIterator` | +| `agents().runs().streamBlocking(...)` | `STREAM` | `/agents/runs/{param}/stream` | `String runId` | `SseEventIterator` | +| `agents().versions().list(...)` | `GET` | `/agents/{param}/versions` | `String agentId, QueryParams query, Class responseType` | `@Nullable T` | +| `agents().versions().list(...)` | `GET` | `/agents/{param}/versions` | `String agentId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `agents().versions().list(...)` | `GET` | `/agents/{param}/versions` | `String agentId, Class responseType` | `@Nullable T` | +| `agents().versions().list(...)` | `GET` | `/agents/{param}/versions` | `String agentId, TypeReference responseType` | `@Nullable T` | + +The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/ai.md b/docs/api/ai.md new file mode 100644 index 0000000..8213353 --- /dev/null +++ b/docs/api/ai.md @@ -0,0 +1,46 @@ +# Ai API + +Service accessor: `frontal.ai()` (`AiServiceClient`). + +Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. + +| Method | HTTP | Route | Parameters | Response | +| --- | --- | --- | --- | --- | +| `ai().health(...)` | `GET` | `/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ai().health(...)` | `GET` | `/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ai().health(...)` | `GET` | `/health` | `Class responseType` | `@Nullable T` | +| `ai().health(...)` | `GET` | `/health` | `TypeReference responseType` | `@Nullable T` | +| `ai().internal().embed(...)` | `POST` | `/internal/embeddings` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ai().internal().embed(...)` | `POST` | `/internal/embeddings` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ai().internal().embed(...)` | `POST` | `/internal/embeddings` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ai().internal().embed(...)` | `POST` | `/internal/embeddings` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ai().internal().predict(...)` | `POST` | `/internal/predictions` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ai().internal().predict(...)` | `POST` | `/internal/predictions` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ai().internal().predict(...)` | `POST` | `/internal/predictions` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ai().internal().predict(...)` | `POST` | `/internal/predictions` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ai().internal().rerank(...)` | `POST` | `/internal/rerank` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ai().internal().rerank(...)` | `POST` | `/internal/rerank` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ai().internal().rerank(...)` | `POST` | `/internal/rerank` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ai().internal().rerank(...)` | `POST` | `/internal/rerank` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ai().internal().predictForm(...)` | `POSTFORMDATA` | `/internal/predictions` | `QueryParams query, Map fields, Map files, Class responseType` | `@Nullable T` | +| `ai().internal().predictForm(...)` | `POSTFORMDATA` | `/internal/predictions` | `QueryParams query, Map fields, Map files, TypeReference responseType` | `@Nullable T` | +| `ai().internal().predictForm(...)` | `POSTFORMDATA` | `/internal/predictions` | `Map fields, Map files, Class responseType` | `@Nullable T` | +| `ai().internal().predictForm(...)` | `POSTFORMDATA` | `/internal/predictions` | `Map fields, Map files, TypeReference responseType` | `@Nullable T` | +| `ai().internal().predictRaw(...)` | `POSTRAW` | `/internal/predictions` | `QueryParams query, byte[] body, Class responseType` | `@Nullable T` | +| `ai().internal().predictRaw(...)` | `POSTRAW` | `/internal/predictions` | `QueryParams query, byte[] body, TypeReference responseType` | `@Nullable T` | +| `ai().internal().predictRaw(...)` | `POSTRAW` | `/internal/predictions` | `byte[] body, Class responseType` | `@Nullable T` | +| `ai().internal().predictRaw(...)` | `POSTRAW` | `/internal/predictions` | `byte[] body, TypeReference responseType` | `@Nullable T` | +| `ai().chat().completions().create(...)` | `POST` | `/ai/chat/completions` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ai().chat().completions().create(...)` | `POST` | `/ai/chat/completions` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ai().chat().completions().create(...)` | `POST` | `/ai/chat/completions` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ai().chat().completions().create(...)` | `POST` | `/ai/chat/completions` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ai().internal().models().list(...)` | `GET` | `/internal/models` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ai().internal().models().list(...)` | `GET` | `/internal/models` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ai().internal().models().list(...)` | `GET` | `/internal/models` | `Class responseType` | `@Nullable T` | +| `ai().internal().models().list(...)` | `GET` | `/internal/models` | `TypeReference responseType` | `@Nullable T` | +| `ai().internal().models().defaults(...)` | `GET` | `/internal/models/defaults` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ai().internal().models().defaults(...)` | `GET` | `/internal/models/defaults` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ai().internal().models().defaults(...)` | `GET` | `/internal/models/defaults` | `Class responseType` | `@Nullable T` | +| `ai().internal().models().defaults(...)` | `GET` | `/internal/models/defaults` | `TypeReference responseType` | `@Nullable T` | + +The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/audit.md b/docs/api/audit.md new file mode 100644 index 0000000..3a8584b --- /dev/null +++ b/docs/api/audit.md @@ -0,0 +1,26 @@ +# Audit API + +Service accessor: `frontal.audit()` (`AuditClient`). + +Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. + +| Method | HTTP | Route | Parameters | Response | +| --- | --- | --- | --- | --- | +| `audit().events().list(...)` | `GET` | `/audit/events` | `QueryParams query, Class responseType` | `@Nullable T` | +| `audit().events().list(...)` | `GET` | `/audit/events` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `audit().events().list(...)` | `GET` | `/audit/events` | `Class responseType` | `@Nullable T` | +| `audit().events().list(...)` | `GET` | `/audit/events` | `TypeReference responseType` | `@Nullable T` | +| `audit().events().get(...)` | `GET` | `/audit/events/{param}` | `String eventId, QueryParams query, Class responseType` | `@Nullable T` | +| `audit().events().get(...)` | `GET` | `/audit/events/{param}` | `String eventId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `audit().events().get(...)` | `GET` | `/audit/events/{param}` | `String eventId, Class responseType` | `@Nullable T` | +| `audit().events().get(...)` | `GET` | `/audit/events/{param}` | `String eventId, TypeReference responseType` | `@Nullable T` | +| `audit().events().create(...)` | `POST` | `/audit/events` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `audit().events().create(...)` | `POST` | `/audit/events` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `audit().events().create(...)` | `POST` | `/audit/events` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `audit().events().create(...)` | `POST` | `/audit/events` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `audit().events().batch(...)` | `POST` | `/audit/events/batch` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `audit().events().batch(...)` | `POST` | `/audit/events/batch` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `audit().events().batch(...)` | `POST` | `/audit/events/batch` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `audit().events().batch(...)` | `POST` | `/audit/events/batch` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | + +The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/auth.md b/docs/api/auth.md new file mode 100644 index 0000000..bf9e443 --- /dev/null +++ b/docs/api/auth.md @@ -0,0 +1,274 @@ +# Auth API + +Service accessor: `frontal.auth()` (`AuthClient`). + +Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. + +| Method | HTTP | Route | Parameters | Response | +| --- | --- | --- | --- | --- | +| `auth().getUser(...)` | `GET` | `/auth/user` | `QueryParams query, Class responseType` | `@Nullable T` | +| `auth().getUser(...)` | `GET` | `/auth/user` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().getUser(...)` | `GET` | `/auth/user` | `Class responseType` | `@Nullable T` | +| `auth().getUser(...)` | `GET` | `/auth/user` | `TypeReference responseType` | `@Nullable T` | +| `auth().createAuthorize(...)` | `POST` | `/auth/authorize` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createAuthorize(...)` | `POST` | `/auth/authorize` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().createAuthorize(...)` | `POST` | `/auth/authorize` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createAuthorize(...)` | `POST` | `/auth/authorize` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().createInvite(...)` | `POST` | `/auth/invite` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createInvite(...)` | `POST` | `/auth/invite` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().createInvite(...)` | `POST` | `/auth/invite` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createInvite(...)` | `POST` | `/auth/invite` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().login(...)` | `POST` | `/auth/login` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().login(...)` | `POST` | `/auth/login` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().login(...)` | `POST` | `/auth/login` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().login(...)` | `POST` | `/auth/login` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().logout(...)` | `POST` | `/auth/logout` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().logout(...)` | `POST` | `/auth/logout` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().logout(...)` | `POST` | `/auth/logout` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().logout(...)` | `POST` | `/auth/logout` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().createOtp(...)` | `POST` | `/auth/otp` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createOtp(...)` | `POST` | `/auth/otp` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().createOtp(...)` | `POST` | `/auth/otp` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createOtp(...)` | `POST` | `/auth/otp` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().createReauthenticate(...)` | `POST` | `/auth/reauthenticate` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createReauthenticate(...)` | `POST` | `/auth/reauthenticate` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().createReauthenticate(...)` | `POST` | `/auth/reauthenticate` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createReauthenticate(...)` | `POST` | `/auth/reauthenticate` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().createRecover(...)` | `POST` | `/auth/recover` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createRecover(...)` | `POST` | `/auth/recover` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().createRecover(...)` | `POST` | `/auth/recover` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createRecover(...)` | `POST` | `/auth/recover` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().createResend(...)` | `POST` | `/auth/resend` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createResend(...)` | `POST` | `/auth/resend` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().createResend(...)` | `POST` | `/auth/resend` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createResend(...)` | `POST` | `/auth/resend` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().createSignup(...)` | `POST` | `/auth/signup` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createSignup(...)` | `POST` | `/auth/signup` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().createSignup(...)` | `POST` | `/auth/signup` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createSignup(...)` | `POST` | `/auth/signup` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().createSso(...)` | `POST` | `/auth/sso` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createSso(...)` | `POST` | `/auth/sso` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().createSso(...)` | `POST` | `/auth/sso` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createSso(...)` | `POST` | `/auth/sso` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().createTokenGrantTypeIdToken(...)` | `POST` | `/auth/token?grant_type=id_token` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createTokenGrantTypeIdToken(...)` | `POST` | `/auth/token?grant_type=id_token` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().createTokenGrantTypeIdToken(...)` | `POST` | `/auth/token?grant_type=id_token` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createTokenGrantTypeIdToken(...)` | `POST` | `/auth/token?grant_type=id_token` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().createTokenGrantTypePassword(...)` | `POST` | `/auth/token?grant_type=password` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createTokenGrantTypePassword(...)` | `POST` | `/auth/token?grant_type=password` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().createTokenGrantTypePassword(...)` | `POST` | `/auth/token?grant_type=password` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createTokenGrantTypePassword(...)` | `POST` | `/auth/token?grant_type=password` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().createTokenGrantTypePkce(...)` | `POST` | `/auth/token?grant_type=pkce` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createTokenGrantTypePkce(...)` | `POST` | `/auth/token?grant_type=pkce` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().createTokenGrantTypePkce(...)` | `POST` | `/auth/token?grant_type=pkce` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createTokenGrantTypePkce(...)` | `POST` | `/auth/token?grant_type=pkce` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().createTokenGrantTypeRefreshToken(...)` | `POST` | `/auth/token?grant_type=refresh_token` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createTokenGrantTypeRefreshToken(...)` | `POST` | `/auth/token?grant_type=refresh_token` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().createTokenGrantTypeRefreshToken(...)` | `POST` | `/auth/token?grant_type=refresh_token` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().createTokenGrantTypeRefreshToken(...)` | `POST` | `/auth/token?grant_type=refresh_token` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().verify(...)` | `POST` | `/auth/verify` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().verify(...)` | `POST` | `/auth/verify` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().verify(...)` | `POST` | `/auth/verify` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().verify(...)` | `POST` | `/auth/verify` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().updateUser(...)` | `PUT` | `/auth/user` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().updateUser(...)` | `PUT` | `/auth/user` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().updateUser(...)` | `PUT` | `/auth/user` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().updateUser(...)` | `PUT` | `/auth/user` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().account().deleteProfile(...)` | `DELETE` | `/auth/account/profile` | `QueryParams query, Class responseType` | `@Nullable T` | +| `auth().account().deleteProfile(...)` | `DELETE` | `/auth/account/profile` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().account().deleteProfile(...)` | `DELETE` | `/auth/account/profile` | `Class responseType` | `@Nullable T` | +| `auth().account().deleteProfile(...)` | `DELETE` | `/auth/account/profile` | `TypeReference responseType` | `@Nullable T` | +| `auth().account().getAuditLog(...)` | `GET` | `/auth/account/audit-log` | `QueryParams query, Class responseType` | `@Nullable T` | +| `auth().account().getAuditLog(...)` | `GET` | `/auth/account/audit-log` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().account().getAuditLog(...)` | `GET` | `/auth/account/audit-log` | `Class responseType` | `@Nullable T` | +| `auth().account().getAuditLog(...)` | `GET` | `/auth/account/audit-log` | `TypeReference responseType` | `@Nullable T` | +| `auth().account().getMfa(...)` | `GET` | `/auth/account/mfa` | `QueryParams query, Class responseType` | `@Nullable T` | +| `auth().account().getMfa(...)` | `GET` | `/auth/account/mfa` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().account().getMfa(...)` | `GET` | `/auth/account/mfa` | `Class responseType` | `@Nullable T` | +| `auth().account().getMfa(...)` | `GET` | `/auth/account/mfa` | `TypeReference responseType` | `@Nullable T` | +| `auth().account().getProfile(...)` | `GET` | `/auth/account/profile` | `QueryParams query, Class responseType` | `@Nullable T` | +| `auth().account().getProfile(...)` | `GET` | `/auth/account/profile` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().account().getProfile(...)` | `GET` | `/auth/account/profile` | `Class responseType` | `@Nullable T` | +| `auth().account().getProfile(...)` | `GET` | `/auth/account/profile` | `TypeReference responseType` | `@Nullable T` | +| `auth().account().createMfa(...)` | `POST` | `/auth/account/mfa` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().account().createMfa(...)` | `POST` | `/auth/account/mfa` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().account().createMfa(...)` | `POST` | `/auth/account/mfa` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().account().createMfa(...)` | `POST` | `/auth/account/mfa` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().account().createPassword(...)` | `POST` | `/auth/account/password` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().account().createPassword(...)` | `POST` | `/auth/account/password` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().account().createPassword(...)` | `POST` | `/auth/account/password` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().account().createPassword(...)` | `POST` | `/auth/account/password` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().account().updateProfile(...)` | `PUT` | `/auth/account/profile` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().account().updateProfile(...)` | `PUT` | `/auth/account/profile` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().account().updateProfile(...)` | `PUT` | `/auth/account/profile` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().account().updateProfile(...)` | `PUT` | `/auth/account/profile` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().admin().createGenerateLink(...)` | `POST` | `/auth/admin/generate_link` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().admin().createGenerateLink(...)` | `POST` | `/auth/admin/generate_link` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().admin().createGenerateLink(...)` | `POST` | `/auth/admin/generate_link` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().admin().createGenerateLink(...)` | `POST` | `/auth/admin/generate_link` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().admin().logout(...)` | `POST` | `/auth/admin/logout` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().admin().logout(...)` | `POST` | `/auth/admin/logout` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().admin().logout(...)` | `POST` | `/auth/admin/logout` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().admin().logout(...)` | `POST` | `/auth/admin/logout` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().auth().getSession(...)` | `GET` | `/auth/auth/session` | `QueryParams query, Class responseType` | `@Nullable T` | +| `auth().auth().getSession(...)` | `GET` | `/auth/auth/session` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().auth().getSession(...)` | `GET` | `/auth/auth/session` | `Class responseType` | `@Nullable T` | +| `auth().auth().getSession(...)` | `GET` | `/auth/auth/session` | `TypeReference responseType` | `@Nullable T` | +| `auth().auth().createSession(...)` | `POST` | `/auth/auth/session` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().auth().createSession(...)` | `POST` | `/auth/auth/session` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().auth().createSession(...)` | `POST` | `/auth/auth/session` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().auth().createSession(...)` | `POST` | `/auth/auth/session` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().factors().delete(...)` | `DELETE` | `/auth/factors/{param}` | `String factorId, QueryParams query, Class responseType` | `@Nullable T` | +| `auth().factors().delete(...)` | `DELETE` | `/auth/factors/{param}` | `String factorId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().factors().delete(...)` | `DELETE` | `/auth/factors/{param}` | `String factorId, Class responseType` | `@Nullable T` | +| `auth().factors().delete(...)` | `DELETE` | `/auth/factors/{param}` | `String factorId, TypeReference responseType` | `@Nullable T` | +| `auth().factors().list(...)` | `GET` | `/auth/factors` | `QueryParams query, Class responseType` | `@Nullable T` | +| `auth().factors().list(...)` | `GET` | `/auth/factors` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().factors().list(...)` | `GET` | `/auth/factors` | `Class responseType` | `@Nullable T` | +| `auth().factors().list(...)` | `GET` | `/auth/factors` | `TypeReference responseType` | `@Nullable T` | +| `auth().factors().create(...)` | `POST` | `/auth/factors` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().factors().create(...)` | `POST` | `/auth/factors` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().factors().create(...)` | `POST` | `/auth/factors` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().factors().create(...)` | `POST` | `/auth/factors` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().factors().createChallenge(...)` | `POST` | `/auth/factors/{param}/challenge` | `String factorId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().factors().createChallenge(...)` | `POST` | `/auth/factors/{param}/challenge` | `String factorId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().factors().createChallenge(...)` | `POST` | `/auth/factors/{param}/challenge` | `String factorId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().factors().createChallenge(...)` | `POST` | `/auth/factors/{param}/challenge` | `String factorId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().factors().verify(...)` | `POST` | `/auth/factors/{param}/verify` | `String factorId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().factors().verify(...)` | `POST` | `/auth/factors/{param}/verify` | `String factorId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().factors().verify(...)` | `POST` | `/auth/factors/{param}/verify` | `String factorId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().factors().verify(...)` | `POST` | `/auth/factors/{param}/verify` | `String factorId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().mfa().status(...)` | `GET` | `/auth/mfa/status` | `QueryParams query, Class responseType` | `@Nullable T` | +| `auth().mfa().status(...)` | `GET` | `/auth/mfa/status` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().mfa().status(...)` | `GET` | `/auth/mfa/status` | `Class responseType` | `@Nullable T` | +| `auth().mfa().status(...)` | `GET` | `/auth/mfa/status` | `TypeReference responseType` | `@Nullable T` | +| `auth().mfa().disable(...)` | `POST` | `/auth/mfa/disable` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().mfa().disable(...)` | `POST` | `/auth/mfa/disable` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().mfa().disable(...)` | `POST` | `/auth/mfa/disable` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().mfa().disable(...)` | `POST` | `/auth/mfa/disable` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().mfa().enable(...)` | `POST` | `/auth/mfa/enable` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().mfa().enable(...)` | `POST` | `/auth/mfa/enable` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().mfa().enable(...)` | `POST` | `/auth/mfa/enable` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().mfa().enable(...)` | `POST` | `/auth/mfa/enable` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().mfa().setup(...)` | `POST` | `/auth/mfa/setup` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().mfa().setup(...)` | `POST` | `/auth/mfa/setup` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().mfa().setup(...)` | `POST` | `/auth/mfa/setup` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().mfa().setup(...)` | `POST` | `/auth/mfa/setup` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().mfa().verify(...)` | `POST` | `/auth/mfa/verify` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().mfa().verify(...)` | `POST` | `/auth/mfa/verify` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().mfa().verify(...)` | `POST` | `/auth/mfa/verify` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().mfa().verify(...)` | `POST` | `/auth/mfa/verify` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().account().mfa().delete(...)` | `DELETE` | `/auth/account/mfa/{param}` | `String mfaId, QueryParams query, Class responseType` | `@Nullable T` | +| `auth().account().mfa().delete(...)` | `DELETE` | `/auth/account/mfa/{param}` | `String mfaId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().account().mfa().delete(...)` | `DELETE` | `/auth/account/mfa/{param}` | `String mfaId, Class responseType` | `@Nullable T` | +| `auth().account().mfa().delete(...)` | `DELETE` | `/auth/account/mfa/{param}` | `String mfaId, TypeReference responseType` | `@Nullable T` | +| `auth().account().mfa().get(...)` | `GET` | `/auth/account/mfa/{param}` | `String mfaId, QueryParams query, Class responseType` | `@Nullable T` | +| `auth().account().mfa().get(...)` | `GET` | `/auth/account/mfa/{param}` | `String mfaId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().account().mfa().get(...)` | `GET` | `/auth/account/mfa/{param}` | `String mfaId, Class responseType` | `@Nullable T` | +| `auth().account().mfa().get(...)` | `GET` | `/auth/account/mfa/{param}` | `String mfaId, TypeReference responseType` | `@Nullable T` | +| `auth().account().mfa().createChallenge(...)` | `POST` | `/auth/account/mfa/{param}/challenge` | `String mfaId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().account().mfa().createChallenge(...)` | `POST` | `/auth/account/mfa/{param}/challenge` | `String mfaId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().account().mfa().createChallenge(...)` | `POST` | `/auth/account/mfa/{param}/challenge` | `String mfaId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().account().mfa().createChallenge(...)` | `POST` | `/auth/account/mfa/{param}/challenge` | `String mfaId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().account().mfa().verify(...)` | `POST` | `/auth/account/mfa/{param}/verify` | `String mfaId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().account().mfa().verify(...)` | `POST` | `/auth/account/mfa/{param}/verify` | `String mfaId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().account().mfa().verify(...)` | `POST` | `/auth/account/mfa/{param}/verify` | `String mfaId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().account().mfa().verify(...)` | `POST` | `/auth/account/mfa/{param}/verify` | `String mfaId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().account().sessions().delete(...)` | `DELETE` | `/auth/account/sessions/{param}` | `String sessionId, QueryParams query, Class responseType` | `@Nullable T` | +| `auth().account().sessions().delete(...)` | `DELETE` | `/auth/account/sessions/{param}` | `String sessionId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().account().sessions().delete(...)` | `DELETE` | `/auth/account/sessions/{param}` | `String sessionId, Class responseType` | `@Nullable T` | +| `auth().account().sessions().delete(...)` | `DELETE` | `/auth/account/sessions/{param}` | `String sessionId, TypeReference responseType` | `@Nullable T` | +| `auth().account().sessions().list(...)` | `GET` | `/auth/account/sessions` | `QueryParams query, Class responseType` | `@Nullable T` | +| `auth().account().sessions().list(...)` | `GET` | `/auth/account/sessions` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().account().sessions().list(...)` | `GET` | `/auth/account/sessions` | `Class responseType` | `@Nullable T` | +| `auth().account().sessions().list(...)` | `GET` | `/auth/account/sessions` | `TypeReference responseType` | `@Nullable T` | +| `auth().account().sessions().extend(...)` | `POST` | `/auth/account/sessions/{param}/extend` | `String sessionId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().account().sessions().extend(...)` | `POST` | `/auth/account/sessions/{param}/extend` | `String sessionId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().account().sessions().extend(...)` | `POST` | `/auth/account/sessions/{param}/extend` | `String sessionId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().account().sessions().extend(...)` | `POST` | `/auth/account/sessions/{param}/extend` | `String sessionId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().admin().users().delete(...)` | `DELETE` | `/auth/admin/users/{param}` | `String userId, QueryParams query, Class responseType` | `@Nullable T` | +| `auth().admin().users().delete(...)` | `DELETE` | `/auth/admin/users/{param}` | `String userId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().admin().users().delete(...)` | `DELETE` | `/auth/admin/users/{param}` | `String userId, Class responseType` | `@Nullable T` | +| `auth().admin().users().delete(...)` | `DELETE` | `/auth/admin/users/{param}` | `String userId, TypeReference responseType` | `@Nullable T` | +| `auth().admin().users().list(...)` | `GET` | `/auth/admin/users` | `QueryParams query, Class responseType` | `@Nullable T` | +| `auth().admin().users().list(...)` | `GET` | `/auth/admin/users` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().admin().users().list(...)` | `GET` | `/auth/admin/users` | `Class responseType` | `@Nullable T` | +| `auth().admin().users().list(...)` | `GET` | `/auth/admin/users` | `TypeReference responseType` | `@Nullable T` | +| `auth().admin().users().get(...)` | `GET` | `/auth/admin/users/{param}` | `String userId, QueryParams query, Class responseType` | `@Nullable T` | +| `auth().admin().users().get(...)` | `GET` | `/auth/admin/users/{param}` | `String userId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().admin().users().get(...)` | `GET` | `/auth/admin/users/{param}` | `String userId, Class responseType` | `@Nullable T` | +| `auth().admin().users().get(...)` | `GET` | `/auth/admin/users/{param}` | `String userId, TypeReference responseType` | `@Nullable T` | +| `auth().admin().users().create(...)` | `POST` | `/auth/admin/users` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().admin().users().create(...)` | `POST` | `/auth/admin/users` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().admin().users().create(...)` | `POST` | `/auth/admin/users` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().admin().users().create(...)` | `POST` | `/auth/admin/users` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().admin().users().update(...)` | `PUT` | `/auth/admin/users/{param}` | `String userId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().admin().users().update(...)` | `PUT` | `/auth/admin/users/{param}` | `String userId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().admin().users().update(...)` | `PUT` | `/auth/admin/users/{param}` | `String userId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().admin().users().update(...)` | `PUT` | `/auth/admin/users/{param}` | `String userId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().mfa().backupCodes().createRegenerate(...)` | `POST` | `/auth/mfa/backup-codes/regenerate` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().mfa().backupCodes().createRegenerate(...)` | `POST` | `/auth/mfa/backup-codes/regenerate` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().mfa().backupCodes().createRegenerate(...)` | `POST` | `/auth/mfa/backup-codes/regenerate` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().mfa().backupCodes().createRegenerate(...)` | `POST` | `/auth/mfa/backup-codes/regenerate` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().user().identities().delete(...)` | `DELETE` | `/auth/user/identities/{param}` | `String identityId, QueryParams query, Class responseType` | `@Nullable T` | +| `auth().user().identities().delete(...)` | `DELETE` | `/auth/user/identities/{param}` | `String identityId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().user().identities().delete(...)` | `DELETE` | `/auth/user/identities/{param}` | `String identityId, Class responseType` | `@Nullable T` | +| `auth().user().identities().delete(...)` | `DELETE` | `/auth/user/identities/{param}` | `String identityId, TypeReference responseType` | `@Nullable T` | +| `auth().user().identities().list(...)` | `GET` | `/auth/user/identities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `auth().user().identities().list(...)` | `GET` | `/auth/user/identities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().user().identities().list(...)` | `GET` | `/auth/user/identities` | `Class responseType` | `@Nullable T` | +| `auth().user().identities().list(...)` | `GET` | `/auth/user/identities` | `TypeReference responseType` | `@Nullable T` | +| `auth().user().identities().create(...)` | `POST` | `/auth/user/identities` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().user().identities().create(...)` | `POST` | `/auth/user/identities` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().user().identities().create(...)` | `POST` | `/auth/user/identities` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().user().identities().create(...)` | `POST` | `/auth/user/identities` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().account().security().apiKeys().delete(...)` | `DELETE` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, QueryParams query, Class responseType` | `@Nullable T` | +| `auth().account().security().apiKeys().delete(...)` | `DELETE` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().account().security().apiKeys().delete(...)` | `DELETE` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, Class responseType` | `@Nullable T` | +| `auth().account().security().apiKeys().delete(...)` | `DELETE` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, TypeReference responseType` | `@Nullable T` | +| `auth().account().security().apiKeys().list(...)` | `GET` | `/auth/account/security/api-keys` | `QueryParams query, Class responseType` | `@Nullable T` | +| `auth().account().security().apiKeys().list(...)` | `GET` | `/auth/account/security/api-keys` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().account().security().apiKeys().list(...)` | `GET` | `/auth/account/security/api-keys` | `Class responseType` | `@Nullable T` | +| `auth().account().security().apiKeys().list(...)` | `GET` | `/auth/account/security/api-keys` | `TypeReference responseType` | `@Nullable T` | +| `auth().account().security().apiKeys().get(...)` | `GET` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, QueryParams query, Class responseType` | `@Nullable T` | +| `auth().account().security().apiKeys().get(...)` | `GET` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().account().security().apiKeys().get(...)` | `GET` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, Class responseType` | `@Nullable T` | +| `auth().account().security().apiKeys().get(...)` | `GET` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, TypeReference responseType` | `@Nullable T` | +| `auth().account().security().apiKeys().create(...)` | `POST` | `/auth/account/security/api-keys` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().account().security().apiKeys().create(...)` | `POST` | `/auth/account/security/api-keys` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().account().security().apiKeys().create(...)` | `POST` | `/auth/account/security/api-keys` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().account().security().apiKeys().create(...)` | `POST` | `/auth/account/security/api-keys` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().account().security().apiKeys().update(...)` | `PUT` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().account().security().apiKeys().update(...)` | `PUT` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().account().security().apiKeys().update(...)` | `PUT` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().account().security().apiKeys().update(...)` | `PUT` | `/auth/account/security/api-keys/{param}` | `String apiKeyId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().account().security().devices().delete(...)` | `DELETE` | `/auth/account/security/devices/{param}` | `String deviceId, QueryParams query, Class responseType` | `@Nullable T` | +| `auth().account().security().devices().delete(...)` | `DELETE` | `/auth/account/security/devices/{param}` | `String deviceId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().account().security().devices().delete(...)` | `DELETE` | `/auth/account/security/devices/{param}` | `String deviceId, Class responseType` | `@Nullable T` | +| `auth().account().security().devices().delete(...)` | `DELETE` | `/auth/account/security/devices/{param}` | `String deviceId, TypeReference responseType` | `@Nullable T` | +| `auth().account().security().devices().list(...)` | `GET` | `/auth/account/security/devices` | `QueryParams query, Class responseType` | `@Nullable T` | +| `auth().account().security().devices().list(...)` | `GET` | `/auth/account/security/devices` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().account().security().devices().list(...)` | `GET` | `/auth/account/security/devices` | `Class responseType` | `@Nullable T` | +| `auth().account().security().devices().list(...)` | `GET` | `/auth/account/security/devices` | `TypeReference responseType` | `@Nullable T` | +| `auth().account().security().devices().get(...)` | `GET` | `/auth/account/security/devices/{param}` | `String deviceId, QueryParams query, Class responseType` | `@Nullable T` | +| `auth().account().security().devices().get(...)` | `GET` | `/auth/account/security/devices/{param}` | `String deviceId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().account().security().devices().get(...)` | `GET` | `/auth/account/security/devices/{param}` | `String deviceId, Class responseType` | `@Nullable T` | +| `auth().account().security().devices().get(...)` | `GET` | `/auth/account/security/devices/{param}` | `String deviceId, TypeReference responseType` | `@Nullable T` | +| `auth().account().security().devices().create(...)` | `POST` | `/auth/account/security/devices` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().account().security().devices().create(...)` | `POST` | `/auth/account/security/devices` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().account().security().devices().create(...)` | `POST` | `/auth/account/security/devices` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().account().security().devices().create(...)` | `POST` | `/auth/account/security/devices` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().account().security().devices().trust(...)` | `POST` | `/auth/account/security/devices/{param}/trust` | `String deviceId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().account().security().devices().trust(...)` | `POST` | `/auth/account/security/devices/{param}/trust` | `String deviceId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().account().security().devices().trust(...)` | `POST` | `/auth/account/security/devices/{param}/trust` | `String deviceId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `auth().account().security().devices().trust(...)` | `POST` | `/auth/account/security/devices/{param}/trust` | `String deviceId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `auth().admin().users().factors().delete(...)` | `DELETE` | `/auth/admin/users/{param}/factors/{param}` | `String userId, String factorId, QueryParams query, Class responseType` | `@Nullable T` | +| `auth().admin().users().factors().delete(...)` | `DELETE` | `/auth/admin/users/{param}/factors/{param}` | `String userId, String factorId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().admin().users().factors().delete(...)` | `DELETE` | `/auth/admin/users/{param}/factors/{param}` | `String userId, String factorId, Class responseType` | `@Nullable T` | +| `auth().admin().users().factors().delete(...)` | `DELETE` | `/auth/admin/users/{param}/factors/{param}` | `String userId, String factorId, TypeReference responseType` | `@Nullable T` | +| `auth().admin().users().factors().list(...)` | `GET` | `/auth/admin/users/{param}/factors` | `String userId, QueryParams query, Class responseType` | `@Nullable T` | +| `auth().admin().users().factors().list(...)` | `GET` | `/auth/admin/users/{param}/factors` | `String userId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `auth().admin().users().factors().list(...)` | `GET` | `/auth/admin/users/{param}/factors` | `String userId, Class responseType` | `@Nullable T` | +| `auth().admin().users().factors().list(...)` | `GET` | `/auth/admin/users/{param}/factors` | `String userId, TypeReference responseType` | `@Nullable T` | + +The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/billing.md b/docs/api/billing.md new file mode 100644 index 0000000..c9b8b06 --- /dev/null +++ b/docs/api/billing.md @@ -0,0 +1,102 @@ +# Billing API + +Service accessor: `frontal.billing()` (`BillingClient`). + +Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. + +| Method | HTTP | Route | Parameters | Response | +| --- | --- | --- | --- | --- | +| `billing().customers().usage(...)` | `GET` | `/billing/customers/{param}/usage` | `String customerId, QueryParams query, Class responseType` | `@Nullable T` | +| `billing().customers().usage(...)` | `GET` | `/billing/customers/{param}/usage` | `String customerId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `billing().customers().usage(...)` | `GET` | `/billing/customers/{param}/usage` | `String customerId, Class responseType` | `@Nullable T` | +| `billing().customers().usage(...)` | `GET` | `/billing/customers/{param}/usage` | `String customerId, TypeReference responseType` | `@Nullable T` | +| `billing().invoices().getPdf(...)` | `GETRAW` | `/billing/invoices/{param}/pdf` | `String invoiceId, QueryParams query, Class responseType` | `@Nullable T` | +| `billing().invoices().getPdf(...)` | `GETRAW` | `/billing/invoices/{param}/pdf` | `String invoiceId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `billing().invoices().getPdf(...)` | `GETRAW` | `/billing/invoices/{param}/pdf` | `String invoiceId, Class responseType` | `@Nullable T` | +| `billing().invoices().getPdf(...)` | `GETRAW` | `/billing/invoices/{param}/pdf` | `String invoiceId, TypeReference responseType` | `@Nullable T` | +| `billing().invoices().preview(...)` | `POST` | `/billing/invoices/preview` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `billing().invoices().preview(...)` | `POST` | `/billing/invoices/preview` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `billing().invoices().preview(...)` | `POST` | `/billing/invoices/preview` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `billing().invoices().preview(...)` | `POST` | `/billing/invoices/preview` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `billing().invoices().finalize(...)` | `POST` | `/billing/invoices/{param}/finalize` | `String invoiceId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `billing().invoices().finalize(...)` | `POST` | `/billing/invoices/{param}/finalize` | `String invoiceId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `billing().invoices().finalize(...)` | `POST` | `/billing/invoices/{param}/finalize` | `String invoiceId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `billing().invoices().finalize(...)` | `POST` | `/billing/invoices/{param}/finalize` | `String invoiceId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `billing().invoices().resourceVoid(...)` | `POST` | `/billing/invoices/{param}/void` | `String invoiceId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `billing().invoices().resourceVoid(...)` | `POST` | `/billing/invoices/{param}/void` | `String invoiceId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `billing().invoices().resourceVoid(...)` | `POST` | `/billing/invoices/{param}/void` | `String invoiceId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `billing().invoices().resourceVoid(...)` | `POST` | `/billing/invoices/{param}/void` | `String invoiceId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `billing().meters().disable(...)` | `POST` | `/billing/meters/{param}/disable` | `String meterId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `billing().meters().disable(...)` | `POST` | `/billing/meters/{param}/disable` | `String meterId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `billing().meters().disable(...)` | `POST` | `/billing/meters/{param}/disable` | `String meterId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `billing().meters().disable(...)` | `POST` | `/billing/meters/{param}/disable` | `String meterId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `billing().plans().clone(...)` | `POST` | `/billing/plans/{param}/clone` | `String planId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `billing().plans().clone(...)` | `POST` | `/billing/plans/{param}/clone` | `String planId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `billing().plans().clone(...)` | `POST` | `/billing/plans/{param}/clone` | `String planId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `billing().plans().clone(...)` | `POST` | `/billing/plans/{param}/clone` | `String planId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `billing().subscriptions().activate(...)` | `POST` | `/billing/subscriptions/{param}/activate` | `String subscriptionId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `billing().subscriptions().activate(...)` | `POST` | `/billing/subscriptions/{param}/activate` | `String subscriptionId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `billing().subscriptions().activate(...)` | `POST` | `/billing/subscriptions/{param}/activate` | `String subscriptionId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `billing().subscriptions().activate(...)` | `POST` | `/billing/subscriptions/{param}/activate` | `String subscriptionId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `billing().subscriptions().cancel(...)` | `POST` | `/billing/subscriptions/{param}/cancel` | `String subscriptionId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `billing().subscriptions().cancel(...)` | `POST` | `/billing/subscriptions/{param}/cancel` | `String subscriptionId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `billing().subscriptions().cancel(...)` | `POST` | `/billing/subscriptions/{param}/cancel` | `String subscriptionId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `billing().subscriptions().cancel(...)` | `POST` | `/billing/subscriptions/{param}/cancel` | `String subscriptionId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `billing().subscriptions().pause(...)` | `POST` | `/billing/subscriptions/{param}/pause` | `String subscriptionId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `billing().subscriptions().pause(...)` | `POST` | `/billing/subscriptions/{param}/pause` | `String subscriptionId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `billing().subscriptions().pause(...)` | `POST` | `/billing/subscriptions/{param}/pause` | `String subscriptionId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `billing().subscriptions().pause(...)` | `POST` | `/billing/subscriptions/{param}/pause` | `String subscriptionId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `billing().subscriptions().resume(...)` | `POST` | `/billing/subscriptions/{param}/resume` | `String subscriptionId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `billing().subscriptions().resume(...)` | `POST` | `/billing/subscriptions/{param}/resume` | `String subscriptionId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `billing().subscriptions().resume(...)` | `POST` | `/billing/subscriptions/{param}/resume` | `String subscriptionId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `billing().subscriptions().resume(...)` | `POST` | `/billing/subscriptions/{param}/resume` | `String subscriptionId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `billing().wallets().createTerminate(...)` | `POST` | `/billing/wallets/{param}/terminate` | `String walletId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `billing().wallets().createTerminate(...)` | `POST` | `/billing/wallets/{param}/terminate` | `String walletId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `billing().wallets().createTerminate(...)` | `POST` | `/billing/wallets/{param}/terminate` | `String walletId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `billing().wallets().createTerminate(...)` | `POST` | `/billing/wallets/{param}/terminate` | `String walletId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `billing().wallets().topUp(...)` | `POST` | `/billing/wallets/{param}/top-up` | `String walletId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `billing().wallets().topUp(...)` | `POST` | `/billing/wallets/{param}/top-up` | `String walletId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `billing().wallets().topUp(...)` | `POST` | `/billing/wallets/{param}/top-up` | `String walletId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `billing().wallets().topUp(...)` | `POST` | `/billing/wallets/{param}/top-up` | `String walletId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `billing().addons().entitlements().list(...)` | `GET` | `/billing/addons/{param}/entitlements` | `String addonId, QueryParams query, Class responseType` | `@Nullable T` | +| `billing().addons().entitlements().list(...)` | `GET` | `/billing/addons/{param}/entitlements` | `String addonId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `billing().addons().entitlements().list(...)` | `GET` | `/billing/addons/{param}/entitlements` | `String addonId, Class responseType` | `@Nullable T` | +| `billing().addons().entitlements().list(...)` | `GET` | `/billing/addons/{param}/entitlements` | `String addonId, TypeReference responseType` | `@Nullable T` | +| `billing().customers().entitlements().list(...)` | `GET` | `/billing/customers/{param}/entitlements` | `String customerId, QueryParams query, Class responseType` | `@Nullable T` | +| `billing().customers().entitlements().list(...)` | `GET` | `/billing/customers/{param}/entitlements` | `String customerId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `billing().customers().entitlements().list(...)` | `GET` | `/billing/customers/{param}/entitlements` | `String customerId, Class responseType` | `@Nullable T` | +| `billing().customers().entitlements().list(...)` | `GET` | `/billing/customers/{param}/entitlements` | `String customerId, TypeReference responseType` | `@Nullable T` | +| `billing().customers().invoices().summary(...)` | `GET` | `/billing/customers/{param}/invoices/summary` | `String customerId, QueryParams query, Class responseType` | `@Nullable T` | +| `billing().customers().invoices().summary(...)` | `GET` | `/billing/customers/{param}/invoices/summary` | `String customerId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `billing().customers().invoices().summary(...)` | `GET` | `/billing/customers/{param}/invoices/summary` | `String customerId, Class responseType` | `@Nullable T` | +| `billing().customers().invoices().summary(...)` | `GET` | `/billing/customers/{param}/invoices/summary` | `String customerId, TypeReference responseType` | `@Nullable T` | +| `billing().customers().portal().get(...)` | `GET` | `/billing/customers/portal/{param}` | `String portalId, QueryParams query, Class responseType` | `@Nullable T` | +| `billing().customers().portal().get(...)` | `GET` | `/billing/customers/portal/{param}` | `String portalId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `billing().customers().portal().get(...)` | `GET` | `/billing/customers/portal/{param}` | `String portalId, Class responseType` | `@Nullable T` | +| `billing().customers().portal().get(...)` | `GET` | `/billing/customers/portal/{param}` | `String portalId, TypeReference responseType` | `@Nullable T` | +| `billing().customers().wallets().list(...)` | `GET` | `/billing/customers/{param}/wallets` | `String customerId, QueryParams query, Class responseType` | `@Nullable T` | +| `billing().customers().wallets().list(...)` | `GET` | `/billing/customers/{param}/wallets` | `String customerId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `billing().customers().wallets().list(...)` | `GET` | `/billing/customers/{param}/wallets` | `String customerId, Class responseType` | `@Nullable T` | +| `billing().customers().wallets().list(...)` | `GET` | `/billing/customers/{param}/wallets` | `String customerId, TypeReference responseType` | `@Nullable T` | +| `billing().plans().entitlements().list(...)` | `GET` | `/billing/plans/{param}/entitlements` | `String planId, QueryParams query, Class responseType` | `@Nullable T` | +| `billing().plans().entitlements().list(...)` | `GET` | `/billing/plans/{param}/entitlements` | `String planId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `billing().plans().entitlements().list(...)` | `GET` | `/billing/plans/{param}/entitlements` | `String planId, Class responseType` | `@Nullable T` | +| `billing().plans().entitlements().list(...)` | `GET` | `/billing/plans/{param}/entitlements` | `String planId, TypeReference responseType` | `@Nullable T` | +| `billing().prices().lookup().get(...)` | `GET` | `/billing/prices/lookup/{param}` | `String lookupId, QueryParams query, Class responseType` | `@Nullable T` | +| `billing().prices().lookup().get(...)` | `GET` | `/billing/prices/lookup/{param}` | `String lookupId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `billing().prices().lookup().get(...)` | `GET` | `/billing/prices/lookup/{param}` | `String lookupId, Class responseType` | `@Nullable T` | +| `billing().prices().lookup().get(...)` | `GET` | `/billing/prices/lookup/{param}` | `String lookupId, TypeReference responseType` | `@Nullable T` | +| `billing().subscriptions().entitlements().list(...)` | `GET` | `/billing/subscriptions/{param}/entitlements` | `String subscriptionId, QueryParams query, Class responseType` | `@Nullable T` | +| `billing().subscriptions().entitlements().list(...)` | `GET` | `/billing/subscriptions/{param}/entitlements` | `String subscriptionId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `billing().subscriptions().entitlements().list(...)` | `GET` | `/billing/subscriptions/{param}/entitlements` | `String subscriptionId, Class responseType` | `@Nullable T` | +| `billing().subscriptions().entitlements().list(...)` | `GET` | `/billing/subscriptions/{param}/entitlements` | `String subscriptionId, TypeReference responseType` | `@Nullable T` | +| `billing().wallets().balance().getRealTime(...)` | `GET` | `/billing/wallets/{param}/balance/real-time` | `String walletId, QueryParams query, Class responseType` | `@Nullable T` | +| `billing().wallets().balance().getRealTime(...)` | `GET` | `/billing/wallets/{param}/balance/real-time` | `String walletId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `billing().wallets().balance().getRealTime(...)` | `GET` | `/billing/wallets/{param}/balance/real-time` | `String walletId, Class responseType` | `@Nullable T` | +| `billing().wallets().balance().getRealTime(...)` | `GET` | `/billing/wallets/{param}/balance/real-time` | `String walletId, TypeReference responseType` | `@Nullable T` | +| `billing().wallets().transactions().list(...)` | `GET` | `/billing/wallets/{param}/transactions` | `String walletId, QueryParams query, Class responseType` | `@Nullable T` | +| `billing().wallets().transactions().list(...)` | `GET` | `/billing/wallets/{param}/transactions` | `String walletId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `billing().wallets().transactions().list(...)` | `GET` | `/billing/wallets/{param}/transactions` | `String walletId, Class responseType` | `@Nullable T` | +| `billing().wallets().transactions().list(...)` | `GET` | `/billing/wallets/{param}/transactions` | `String walletId, TypeReference responseType` | `@Nullable T` | + +The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/blob.md b/docs/api/blob.md new file mode 100644 index 0000000..17251f0 --- /dev/null +++ b/docs/api/blob.md @@ -0,0 +1,42 @@ +# Blob API + +Service accessor: `frontal.blob()` (`BlobClient`). + +Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. + +| Method | HTTP | Route | Parameters | Response | +| --- | --- | --- | --- | --- | +| `blob().object().delete(...)` | `DELETE` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, QueryParams query, Class responseType` | `@Nullable T` | +| `blob().object().delete(...)` | `DELETE` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `blob().object().delete(...)` | `DELETE` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, Class responseType` | `@Nullable T` | +| `blob().object().delete(...)` | `DELETE` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, TypeReference responseType` | `@Nullable T` | +| `blob().object().get(...)` | `GET` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, QueryParams query, Class responseType` | `@Nullable T` | +| `blob().object().get(...)` | `GET` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `blob().object().get(...)` | `GET` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, Class responseType` | `@Nullable T` | +| `blob().object().get(...)` | `GET` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, TypeReference responseType` | `@Nullable T` | +| `blob().object().copy(...)` | `POST` | `/blob/object/copy` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `blob().object().copy(...)` | `POST` | `/blob/object/copy` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `blob().object().copy(...)` | `POST` | `/blob/object/copy` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `blob().object().copy(...)` | `POST` | `/blob/object/copy` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `blob().object().move(...)` | `POST` | `/blob/object/move` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `blob().object().move(...)` | `POST` | `/blob/object/move` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `blob().object().move(...)` | `POST` | `/blob/object/move` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `blob().object().move(...)` | `POST` | `/blob/object/move` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `blob().object().get2(...)` | `POSTFORMDATA` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, QueryParams query, Map fields, Map files, Class responseType` | `@Nullable T` | +| `blob().object().get2(...)` | `POSTFORMDATA` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, QueryParams query, Map fields, Map files, TypeReference responseType` | `@Nullable T` | +| `blob().object().get2(...)` | `POSTFORMDATA` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, Map fields, Map files, Class responseType` | `@Nullable T` | +| `blob().object().get2(...)` | `POSTFORMDATA` | `/blob/object/{param}/{param}` | `String objectId, String objectId2, Map fields, Map files, TypeReference responseType` | `@Nullable T` | +| `blob().object().info().get(...)` | `GET` | `/blob/object/info/{param}/{param}` | `String infoId, String infoId2, QueryParams query, Class responseType` | `@Nullable T` | +| `blob().object().info().get(...)` | `GET` | `/blob/object/info/{param}/{param}` | `String infoId, String infoId2, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `blob().object().info().get(...)` | `GET` | `/blob/object/info/{param}/{param}` | `String infoId, String infoId2, Class responseType` | `@Nullable T` | +| `blob().object().info().get(...)` | `GET` | `/blob/object/info/{param}/{param}` | `String infoId, String infoId2, TypeReference responseType` | `@Nullable T` | +| `blob().object().list().get(...)` | `POST` | `/blob/object/list/{param}` | `String listId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `blob().object().list().get(...)` | `POST` | `/blob/object/list/{param}` | `String listId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `blob().object().list().get(...)` | `POST` | `/blob/object/list/{param}` | `String listId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `blob().object().list().get(...)` | `POST` | `/blob/object/list/{param}` | `String listId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `blob().object().sign().get(...)` | `POST` | `/blob/object/sign/{param}/{param}` | `String signId, String signId2, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `blob().object().sign().get(...)` | `POST` | `/blob/object/sign/{param}/{param}` | `String signId, String signId2, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `blob().object().sign().get(...)` | `POST` | `/blob/object/sign/{param}/{param}` | `String signId, String signId2, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `blob().object().sign().get(...)` | `POST` | `/blob/object/sign/{param}/{param}` | `String signId, String signId2, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | + +The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/connection-tests.md b/docs/api/connection-tests.md new file mode 100644 index 0000000..f5fd7a1 --- /dev/null +++ b/docs/api/connection-tests.md @@ -0,0 +1,14 @@ +# ConnectionTests API + +Service accessor: `frontal.connectionTests()` (`ConnectionTestsClient`). + +Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. + +| Method | HTTP | Route | Parameters | Response | +| --- | --- | --- | --- | --- | +| `connectionTests().get(...)` | `GET` | `/connection-tests/{param}` | `String connectionTestId, QueryParams query, Class responseType` | `@Nullable T` | +| `connectionTests().get(...)` | `GET` | `/connection-tests/{param}` | `String connectionTestId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `connectionTests().get(...)` | `GET` | `/connection-tests/{param}` | `String connectionTestId, Class responseType` | `@Nullable T` | +| `connectionTests().get(...)` | `GET` | `/connection-tests/{param}` | `String connectionTestId, TypeReference responseType` | `@Nullable T` | + +The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/connectors.md b/docs/api/connectors.md new file mode 100644 index 0000000..d640857 --- /dev/null +++ b/docs/api/connectors.md @@ -0,0 +1,58 @@ +# Connectors API + +Service accessor: `frontal.connectors()` (`ConnectorsClient`). + +Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. + +| Method | HTTP | Route | Parameters | Response | +| --- | --- | --- | --- | --- | +| `connectors().getCatalog(...)` | `GET` | `/connectors/catalog` | `QueryParams query, Class responseType` | `@Nullable T` | +| `connectors().getCatalog(...)` | `GET` | `/connectors/catalog` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `connectors().getCatalog(...)` | `GET` | `/connectors/catalog` | `Class responseType` | `@Nullable T` | +| `connectors().getCatalog(...)` | `GET` | `/connectors/catalog` | `TypeReference responseType` | `@Nullable T` | +| `connectors().catalog().get(...)` | `GET` | `/connectors/catalog/{param}` | `String catalogId, QueryParams query, Class responseType` | `@Nullable T` | +| `connectors().catalog().get(...)` | `GET` | `/connectors/catalog/{param}` | `String catalogId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `connectors().catalog().get(...)` | `GET` | `/connectors/catalog/{param}` | `String catalogId, Class responseType` | `@Nullable T` | +| `connectors().catalog().get(...)` | `GET` | `/connectors/catalog/{param}` | `String catalogId, TypeReference responseType` | `@Nullable T` | +| `connectors().connectionTests().get(...)` | `GET` | `/connectors/connection-tests/{param}` | `String connectionTestId, QueryParams query, Class responseType` | `@Nullable T` | +| `connectors().connectionTests().get(...)` | `GET` | `/connectors/connection-tests/{param}` | `String connectionTestId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `connectors().connectionTests().get(...)` | `GET` | `/connectors/connection-tests/{param}` | `String connectionTestId, Class responseType` | `@Nullable T` | +| `connectors().connectionTests().get(...)` | `GET` | `/connectors/connection-tests/{param}` | `String connectionTestId, TypeReference responseType` | `@Nullable T` | +| `connectors().diagnostics().list(...)` | `GET` | `/diagnostics` | `QueryParams query, Class responseType` | `@Nullable T` | +| `connectors().diagnostics().list(...)` | `GET` | `/diagnostics` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `connectors().diagnostics().list(...)` | `GET` | `/diagnostics` | `Class responseType` | `@Nullable T` | +| `connectors().diagnostics().list(...)` | `GET` | `/diagnostics` | `TypeReference responseType` | `@Nullable T` | +| `connectors().installations().delete(...)` | `DELETE` | `/connectors/installations/{param}` | `String installationId, QueryParams query, Class responseType` | `@Nullable T` | +| `connectors().installations().delete(...)` | `DELETE` | `/connectors/installations/{param}` | `String installationId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `connectors().installations().delete(...)` | `DELETE` | `/connectors/installations/{param}` | `String installationId, Class responseType` | `@Nullable T` | +| `connectors().installations().delete(...)` | `DELETE` | `/connectors/installations/{param}` | `String installationId, TypeReference responseType` | `@Nullable T` | +| `connectors().installations().list(...)` | `GET` | `/connectors/installations` | `QueryParams query, Class responseType` | `@Nullable T` | +| `connectors().installations().list(...)` | `GET` | `/connectors/installations` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `connectors().installations().list(...)` | `GET` | `/connectors/installations` | `Class responseType` | `@Nullable T` | +| `connectors().installations().list(...)` | `GET` | `/connectors/installations` | `TypeReference responseType` | `@Nullable T` | +| `connectors().installations().get(...)` | `GET` | `/connectors/installations/{param}` | `String installationId, QueryParams query, Class responseType` | `@Nullable T` | +| `connectors().installations().get(...)` | `GET` | `/connectors/installations/{param}` | `String installationId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `connectors().installations().get(...)` | `GET` | `/connectors/installations/{param}` | `String installationId, Class responseType` | `@Nullable T` | +| `connectors().installations().get(...)` | `GET` | `/connectors/installations/{param}` | `String installationId, TypeReference responseType` | `@Nullable T` | +| `connectors().installations().update(...)` | `PATCH` | `/connectors/installations/{param}` | `String installationId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `connectors().installations().update(...)` | `PATCH` | `/connectors/installations/{param}` | `String installationId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `connectors().installations().update(...)` | `PATCH` | `/connectors/installations/{param}` | `String installationId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `connectors().installations().update(...)` | `PATCH` | `/connectors/installations/{param}` | `String installationId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `connectors().installations().create(...)` | `POST` | `/connectors/installations` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `connectors().installations().create(...)` | `POST` | `/connectors/installations` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `connectors().installations().create(...)` | `POST` | `/connectors/installations` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `connectors().installations().create(...)` | `POST` | `/connectors/installations` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `connectors().installations().pause(...)` | `POST` | `/connectors/installations/{param}/pause` | `String installationId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `connectors().installations().pause(...)` | `POST` | `/connectors/installations/{param}/pause` | `String installationId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `connectors().installations().pause(...)` | `POST` | `/connectors/installations/{param}/pause` | `String installationId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `connectors().installations().pause(...)` | `POST` | `/connectors/installations/{param}/pause` | `String installationId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `connectors().installations().resume(...)` | `POST` | `/connectors/installations/{param}/resume` | `String installationId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `connectors().installations().resume(...)` | `POST` | `/connectors/installations/{param}/resume` | `String installationId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `connectors().installations().resume(...)` | `POST` | `/connectors/installations/{param}/resume` | `String installationId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `connectors().installations().resume(...)` | `POST` | `/connectors/installations/{param}/resume` | `String installationId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `connectors().syncRuns().replay(...)` | `POST` | `/connectors/sync-runs/{param}/replay` | `String syncRunId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `connectors().syncRuns().replay(...)` | `POST` | `/connectors/sync-runs/{param}/replay` | `String syncRunId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `connectors().syncRuns().replay(...)` | `POST` | `/connectors/sync-runs/{param}/replay` | `String syncRunId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `connectors().syncRuns().replay(...)` | `POST` | `/connectors/sync-runs/{param}/replay` | `String syncRunId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | + +The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/data.md b/docs/api/data.md new file mode 100644 index 0000000..c3a2e49 --- /dev/null +++ b/docs/api/data.md @@ -0,0 +1,614 @@ +# Data API + +Service accessor: `frontal.data()` (`DataClient`). + +Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. + +| Method | HTTP | Route | Parameters | Response | +| --- | --- | --- | --- | --- | +| `data().aggregations().health(...)` | `GET` | `/data/aggregations/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().aggregations().health(...)` | `GET` | `/data/aggregations/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().aggregations().health(...)` | `GET` | `/data/aggregations/health` | `Class responseType` | `@Nullable T` | +| `data().aggregations().health(...)` | `GET` | `/data/aggregations/health` | `TypeReference responseType` | `@Nullable T` | +| `data().aggregations().getInfo(...)` | `GET` | `/data/aggregations/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().aggregations().getInfo(...)` | `GET` | `/data/aggregations/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().aggregations().getInfo(...)` | `GET` | `/data/aggregations/info` | `Class responseType` | `@Nullable T` | +| `data().aggregations().getInfo(...)` | `GET` | `/data/aggregations/info` | `TypeReference responseType` | `@Nullable T` | +| `data().archival().health(...)` | `GET` | `/data/archival/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().archival().health(...)` | `GET` | `/data/archival/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().archival().health(...)` | `GET` | `/data/archival/health` | `Class responseType` | `@Nullable T` | +| `data().archival().health(...)` | `GET` | `/data/archival/health` | `TypeReference responseType` | `@Nullable T` | +| `data().archival().getInfo(...)` | `GET` | `/data/archival/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().archival().getInfo(...)` | `GET` | `/data/archival/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().archival().getInfo(...)` | `GET` | `/data/archival/info` | `Class responseType` | `@Nullable T` | +| `data().archival().getInfo(...)` | `GET` | `/data/archival/info` | `TypeReference responseType` | `@Nullable T` | +| `data().catalog().health(...)` | `GET` | `/data/catalog/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().catalog().health(...)` | `GET` | `/data/catalog/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().catalog().health(...)` | `GET` | `/data/catalog/health` | `Class responseType` | `@Nullable T` | +| `data().catalog().health(...)` | `GET` | `/data/catalog/health` | `TypeReference responseType` | `@Nullable T` | +| `data().catalog().getInfo(...)` | `GET` | `/data/catalog/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().catalog().getInfo(...)` | `GET` | `/data/catalog/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().catalog().getInfo(...)` | `GET` | `/data/catalog/info` | `Class responseType` | `@Nullable T` | +| `data().catalog().getInfo(...)` | `GET` | `/data/catalog/info` | `TypeReference responseType` | `@Nullable T` | +| `data().enrichment().health(...)` | `GET` | `/data/enrichment/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().enrichment().health(...)` | `GET` | `/data/enrichment/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().enrichment().health(...)` | `GET` | `/data/enrichment/health` | `Class responseType` | `@Nullable T` | +| `data().enrichment().health(...)` | `GET` | `/data/enrichment/health` | `TypeReference responseType` | `@Nullable T` | +| `data().enrichment().getInfo(...)` | `GET` | `/data/enrichment/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().enrichment().getInfo(...)` | `GET` | `/data/enrichment/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().enrichment().getInfo(...)` | `GET` | `/data/enrichment/info` | `Class responseType` | `@Nullable T` | +| `data().enrichment().getInfo(...)` | `GET` | `/data/enrichment/info` | `TypeReference responseType` | `@Nullable T` | +| `data().exports().health(...)` | `GET` | `/data/exports/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().exports().health(...)` | `GET` | `/data/exports/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().exports().health(...)` | `GET` | `/data/exports/health` | `Class responseType` | `@Nullable T` | +| `data().exports().health(...)` | `GET` | `/data/exports/health` | `TypeReference responseType` | `@Nullable T` | +| `data().exports().getInfo(...)` | `GET` | `/data/exports/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().exports().getInfo(...)` | `GET` | `/data/exports/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().exports().getInfo(...)` | `GET` | `/data/exports/info` | `Class responseType` | `@Nullable T` | +| `data().exports().getInfo(...)` | `GET` | `/data/exports/info` | `TypeReference responseType` | `@Nullable T` | +| `data().ingest().health(...)` | `GET` | `/data/ingest/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().ingest().health(...)` | `GET` | `/data/ingest/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().ingest().health(...)` | `GET` | `/data/ingest/health` | `Class responseType` | `@Nullable T` | +| `data().ingest().health(...)` | `GET` | `/data/ingest/health` | `TypeReference responseType` | `@Nullable T` | +| `data().ingest().getInfo(...)` | `GET` | `/data/ingest/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().ingest().getInfo(...)` | `GET` | `/data/ingest/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().ingest().getInfo(...)` | `GET` | `/data/ingest/info` | `Class responseType` | `@Nullable T` | +| `data().ingest().getInfo(...)` | `GET` | `/data/ingest/info` | `TypeReference responseType` | `@Nullable T` | +| `data().normalization().health(...)` | `GET` | `/data/normalization/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().normalization().health(...)` | `GET` | `/data/normalization/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().normalization().health(...)` | `GET` | `/data/normalization/health` | `Class responseType` | `@Nullable T` | +| `data().normalization().health(...)` | `GET` | `/data/normalization/health` | `TypeReference responseType` | `@Nullable T` | +| `data().normalization().getInfo(...)` | `GET` | `/data/normalization/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().normalization().getInfo(...)` | `GET` | `/data/normalization/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().normalization().getInfo(...)` | `GET` | `/data/normalization/info` | `Class responseType` | `@Nullable T` | +| `data().normalization().getInfo(...)` | `GET` | `/data/normalization/info` | `TypeReference responseType` | `@Nullable T` | +| `data().pipelines().health(...)` | `GET` | `/data/pipelines/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().pipelines().health(...)` | `GET` | `/data/pipelines/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().pipelines().health(...)` | `GET` | `/data/pipelines/health` | `Class responseType` | `@Nullable T` | +| `data().pipelines().health(...)` | `GET` | `/data/pipelines/health` | `TypeReference responseType` | `@Nullable T` | +| `data().pipelines().getInfo(...)` | `GET` | `/data/pipelines/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().pipelines().getInfo(...)` | `GET` | `/data/pipelines/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().pipelines().getInfo(...)` | `GET` | `/data/pipelines/info` | `Class responseType` | `@Nullable T` | +| `data().pipelines().getInfo(...)` | `GET` | `/data/pipelines/info` | `TypeReference responseType` | `@Nullable T` | +| `data().quality().health(...)` | `GET` | `/data/quality/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().quality().health(...)` | `GET` | `/data/quality/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().quality().health(...)` | `GET` | `/data/quality/health` | `Class responseType` | `@Nullable T` | +| `data().quality().health(...)` | `GET` | `/data/quality/health` | `TypeReference responseType` | `@Nullable T` | +| `data().quality().getInfo(...)` | `GET` | `/data/quality/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().quality().getInfo(...)` | `GET` | `/data/quality/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().quality().getInfo(...)` | `GET` | `/data/quality/info` | `Class responseType` | `@Nullable T` | +| `data().quality().getInfo(...)` | `GET` | `/data/quality/info` | `TypeReference responseType` | `@Nullable T` | +| `data().query().health(...)` | `GET` | `/data/query/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().query().health(...)` | `GET` | `/data/query/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().query().health(...)` | `GET` | `/data/query/health` | `Class responseType` | `@Nullable T` | +| `data().query().health(...)` | `GET` | `/data/query/health` | `TypeReference responseType` | `@Nullable T` | +| `data().query().getInfo(...)` | `GET` | `/data/query/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().query().getInfo(...)` | `GET` | `/data/query/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().query().getInfo(...)` | `GET` | `/data/query/info` | `Class responseType` | `@Nullable T` | +| `data().query().getInfo(...)` | `GET` | `/data/query/info` | `TypeReference responseType` | `@Nullable T` | +| `data().schemas().health(...)` | `GET` | `/data/schemas/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().schemas().health(...)` | `GET` | `/data/schemas/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().schemas().health(...)` | `GET` | `/data/schemas/health` | `Class responseType` | `@Nullable T` | +| `data().schemas().health(...)` | `GET` | `/data/schemas/health` | `TypeReference responseType` | `@Nullable T` | +| `data().schemas().getInfo(...)` | `GET` | `/data/schemas/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().schemas().getInfo(...)` | `GET` | `/data/schemas/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().schemas().getInfo(...)` | `GET` | `/data/schemas/info` | `Class responseType` | `@Nullable T` | +| `data().schemas().getInfo(...)` | `GET` | `/data/schemas/info` | `TypeReference responseType` | `@Nullable T` | +| `data().serving().health(...)` | `GET` | `/data/serving/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().serving().health(...)` | `GET` | `/data/serving/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().serving().health(...)` | `GET` | `/data/serving/health` | `Class responseType` | `@Nullable T` | +| `data().serving().health(...)` | `GET` | `/data/serving/health` | `TypeReference responseType` | `@Nullable T` | +| `data().serving().getInfo(...)` | `GET` | `/data/serving/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().serving().getInfo(...)` | `GET` | `/data/serving/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().serving().getInfo(...)` | `GET` | `/data/serving/info` | `Class responseType` | `@Nullable T` | +| `data().serving().getInfo(...)` | `GET` | `/data/serving/info` | `TypeReference responseType` | `@Nullable T` | +| `data().streams().health(...)` | `GET` | `/data/streams/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().streams().health(...)` | `GET` | `/data/streams/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().streams().health(...)` | `GET` | `/data/streams/health` | `Class responseType` | `@Nullable T` | +| `data().streams().health(...)` | `GET` | `/data/streams/health` | `TypeReference responseType` | `@Nullable T` | +| `data().streams().getInfo(...)` | `GET` | `/data/streams/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().streams().getInfo(...)` | `GET` | `/data/streams/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().streams().getInfo(...)` | `GET` | `/data/streams/info` | `Class responseType` | `@Nullable T` | +| `data().streams().getInfo(...)` | `GET` | `/data/streams/info` | `TypeReference responseType` | `@Nullable T` | +| `data().sync().health(...)` | `GET` | `/data/sync/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().sync().health(...)` | `GET` | `/data/sync/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().sync().health(...)` | `GET` | `/data/sync/health` | `Class responseType` | `@Nullable T` | +| `data().sync().health(...)` | `GET` | `/data/sync/health` | `TypeReference responseType` | `@Nullable T` | +| `data().sync().getInfo(...)` | `GET` | `/data/sync/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().sync().getInfo(...)` | `GET` | `/data/sync/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().sync().getInfo(...)` | `GET` | `/data/sync/info` | `Class responseType` | `@Nullable T` | +| `data().sync().getInfo(...)` | `GET` | `/data/sync/info` | `TypeReference responseType` | `@Nullable T` | +| `data().transformations().health(...)` | `GET` | `/data/transformations/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().transformations().health(...)` | `GET` | `/data/transformations/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().transformations().health(...)` | `GET` | `/data/transformations/health` | `Class responseType` | `@Nullable T` | +| `data().transformations().health(...)` | `GET` | `/data/transformations/health` | `TypeReference responseType` | `@Nullable T` | +| `data().transformations().getInfo(...)` | `GET` | `/data/transformations/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().transformations().getInfo(...)` | `GET` | `/data/transformations/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().transformations().getInfo(...)` | `GET` | `/data/transformations/info` | `Class responseType` | `@Nullable T` | +| `data().transformations().getInfo(...)` | `GET` | `/data/transformations/info` | `TypeReference responseType` | `@Nullable T` | +| `data().aggregations().aggregations().list(...)` | `GET` | `/data/aggregations/aggregations` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().aggregations().aggregations().list(...)` | `GET` | `/data/aggregations/aggregations` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().aggregations().aggregations().list(...)` | `GET` | `/data/aggregations/aggregations` | `Class responseType` | `@Nullable T` | +| `data().aggregations().aggregations().list(...)` | `GET` | `/data/aggregations/aggregations` | `TypeReference responseType` | `@Nullable T` | +| `data().aggregations().aggregations().get(...)` | `GET` | `/data/aggregations/aggregations/{param}` | `String aggregationId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().aggregations().aggregations().get(...)` | `GET` | `/data/aggregations/aggregations/{param}` | `String aggregationId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().aggregations().aggregations().get(...)` | `GET` | `/data/aggregations/aggregations/{param}` | `String aggregationId, Class responseType` | `@Nullable T` | +| `data().aggregations().aggregations().get(...)` | `GET` | `/data/aggregations/aggregations/{param}` | `String aggregationId, TypeReference responseType` | `@Nullable T` | +| `data().aggregations().aggregations().create(...)` | `POST` | `/data/aggregations/aggregations` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().aggregations().aggregations().create(...)` | `POST` | `/data/aggregations/aggregations` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().aggregations().aggregations().create(...)` | `POST` | `/data/aggregations/aggregations` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().aggregations().aggregations().create(...)` | `POST` | `/data/aggregations/aggregations` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().aggregations().capabilities().list(...)` | `GET` | `/data/aggregations/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().aggregations().capabilities().list(...)` | `GET` | `/data/aggregations/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().aggregations().capabilities().list(...)` | `GET` | `/data/aggregations/capabilities` | `Class responseType` | `@Nullable T` | +| `data().aggregations().capabilities().list(...)` | `GET` | `/data/aggregations/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `data().aggregations().runs().list(...)` | `GET` | `/data/aggregations/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().aggregations().runs().list(...)` | `GET` | `/data/aggregations/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().aggregations().runs().list(...)` | `GET` | `/data/aggregations/runs` | `Class responseType` | `@Nullable T` | +| `data().aggregations().runs().list(...)` | `GET` | `/data/aggregations/runs` | `TypeReference responseType` | `@Nullable T` | +| `data().aggregations().runs().get(...)` | `GET` | `/data/aggregations/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().aggregations().runs().get(...)` | `GET` | `/data/aggregations/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().aggregations().runs().get(...)` | `GET` | `/data/aggregations/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `data().aggregations().runs().get(...)` | `GET` | `/data/aggregations/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `data().aggregations().runs().create(...)` | `POST` | `/data/aggregations/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().aggregations().runs().create(...)` | `POST` | `/data/aggregations/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().aggregations().runs().create(...)` | `POST` | `/data/aggregations/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().aggregations().runs().create(...)` | `POST` | `/data/aggregations/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().archival().capabilities().list(...)` | `GET` | `/data/archival/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().archival().capabilities().list(...)` | `GET` | `/data/archival/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().archival().capabilities().list(...)` | `GET` | `/data/archival/capabilities` | `Class responseType` | `@Nullable T` | +| `data().archival().capabilities().list(...)` | `GET` | `/data/archival/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `data().archival().runs().list(...)` | `GET` | `/data/archival/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().archival().runs().list(...)` | `GET` | `/data/archival/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().archival().runs().list(...)` | `GET` | `/data/archival/runs` | `Class responseType` | `@Nullable T` | +| `data().archival().runs().list(...)` | `GET` | `/data/archival/runs` | `TypeReference responseType` | `@Nullable T` | +| `data().archival().runs().get(...)` | `GET` | `/data/archival/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().archival().runs().get(...)` | `GET` | `/data/archival/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().archival().runs().get(...)` | `GET` | `/data/archival/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `data().archival().runs().get(...)` | `GET` | `/data/archival/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `data().archival().runs().create(...)` | `POST` | `/data/archival/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().archival().runs().create(...)` | `POST` | `/data/archival/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().archival().runs().create(...)` | `POST` | `/data/archival/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().archival().runs().create(...)` | `POST` | `/data/archival/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().catalog().capabilities().list(...)` | `GET` | `/data/catalog/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().catalog().capabilities().list(...)` | `GET` | `/data/catalog/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().catalog().capabilities().list(...)` | `GET` | `/data/catalog/capabilities` | `Class responseType` | `@Nullable T` | +| `data().catalog().capabilities().list(...)` | `GET` | `/data/catalog/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `data().catalog().runs().list(...)` | `GET` | `/data/catalog/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().catalog().runs().list(...)` | `GET` | `/data/catalog/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().catalog().runs().list(...)` | `GET` | `/data/catalog/runs` | `Class responseType` | `@Nullable T` | +| `data().catalog().runs().list(...)` | `GET` | `/data/catalog/runs` | `TypeReference responseType` | `@Nullable T` | +| `data().catalog().runs().get(...)` | `GET` | `/data/catalog/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().catalog().runs().get(...)` | `GET` | `/data/catalog/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().catalog().runs().get(...)` | `GET` | `/data/catalog/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `data().catalog().runs().get(...)` | `GET` | `/data/catalog/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `data().catalog().runs().create(...)` | `POST` | `/data/catalog/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().catalog().runs().create(...)` | `POST` | `/data/catalog/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().catalog().runs().create(...)` | `POST` | `/data/catalog/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().catalog().runs().create(...)` | `POST` | `/data/catalog/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().enrichment().capabilities().list(...)` | `GET` | `/data/enrichment/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().enrichment().capabilities().list(...)` | `GET` | `/data/enrichment/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().enrichment().capabilities().list(...)` | `GET` | `/data/enrichment/capabilities` | `Class responseType` | `@Nullable T` | +| `data().enrichment().capabilities().list(...)` | `GET` | `/data/enrichment/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `data().enrichment().runs().list(...)` | `GET` | `/data/enrichment/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().enrichment().runs().list(...)` | `GET` | `/data/enrichment/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().enrichment().runs().list(...)` | `GET` | `/data/enrichment/runs` | `Class responseType` | `@Nullable T` | +| `data().enrichment().runs().list(...)` | `GET` | `/data/enrichment/runs` | `TypeReference responseType` | `@Nullable T` | +| `data().enrichment().runs().get(...)` | `GET` | `/data/enrichment/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().enrichment().runs().get(...)` | `GET` | `/data/enrichment/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().enrichment().runs().get(...)` | `GET` | `/data/enrichment/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `data().enrichment().runs().get(...)` | `GET` | `/data/enrichment/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `data().enrichment().runs().create(...)` | `POST` | `/data/enrichment/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().enrichment().runs().create(...)` | `POST` | `/data/enrichment/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().enrichment().runs().create(...)` | `POST` | `/data/enrichment/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().enrichment().runs().create(...)` | `POST` | `/data/enrichment/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().exports().capabilities().list(...)` | `GET` | `/data/exports/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().exports().capabilities().list(...)` | `GET` | `/data/exports/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().exports().capabilities().list(...)` | `GET` | `/data/exports/capabilities` | `Class responseType` | `@Nullable T` | +| `data().exports().capabilities().list(...)` | `GET` | `/data/exports/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `data().exports().exports().list(...)` | `GET` | `/data/exports/exports` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().exports().exports().list(...)` | `GET` | `/data/exports/exports` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().exports().exports().list(...)` | `GET` | `/data/exports/exports` | `Class responseType` | `@Nullable T` | +| `data().exports().exports().list(...)` | `GET` | `/data/exports/exports` | `TypeReference responseType` | `@Nullable T` | +| `data().exports().exports().get(...)` | `GET` | `/data/exports/exports/{param}` | `String exportId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().exports().exports().get(...)` | `GET` | `/data/exports/exports/{param}` | `String exportId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().exports().exports().get(...)` | `GET` | `/data/exports/exports/{param}` | `String exportId, Class responseType` | `@Nullable T` | +| `data().exports().exports().get(...)` | `GET` | `/data/exports/exports/{param}` | `String exportId, TypeReference responseType` | `@Nullable T` | +| `data().exports().exports().create(...)` | `POST` | `/data/exports/exports` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().exports().exports().create(...)` | `POST` | `/data/exports/exports` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().exports().exports().create(...)` | `POST` | `/data/exports/exports` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().exports().exports().create(...)` | `POST` | `/data/exports/exports` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().exports().runs().list(...)` | `GET` | `/data/exports/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().exports().runs().list(...)` | `GET` | `/data/exports/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().exports().runs().list(...)` | `GET` | `/data/exports/runs` | `Class responseType` | `@Nullable T` | +| `data().exports().runs().list(...)` | `GET` | `/data/exports/runs` | `TypeReference responseType` | `@Nullable T` | +| `data().exports().runs().get(...)` | `GET` | `/data/exports/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().exports().runs().get(...)` | `GET` | `/data/exports/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().exports().runs().get(...)` | `GET` | `/data/exports/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `data().exports().runs().get(...)` | `GET` | `/data/exports/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `data().exports().runs().create(...)` | `POST` | `/data/exports/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().exports().runs().create(...)` | `POST` | `/data/exports/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().exports().runs().create(...)` | `POST` | `/data/exports/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().exports().runs().create(...)` | `POST` | `/data/exports/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().ingest().capabilities().list(...)` | `GET` | `/data/ingest/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().ingest().capabilities().list(...)` | `GET` | `/data/ingest/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().ingest().capabilities().list(...)` | `GET` | `/data/ingest/capabilities` | `Class responseType` | `@Nullable T` | +| `data().ingest().capabilities().list(...)` | `GET` | `/data/ingest/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `data().ingest().datasets().list(...)` | `GET` | `/data/ingest/datasets` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().ingest().datasets().list(...)` | `GET` | `/data/ingest/datasets` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().ingest().datasets().list(...)` | `GET` | `/data/ingest/datasets` | `Class responseType` | `@Nullable T` | +| `data().ingest().datasets().list(...)` | `GET` | `/data/ingest/datasets` | `TypeReference responseType` | `@Nullable T` | +| `data().ingest().datasets().get(...)` | `GET` | `/data/ingest/datasets/{param}` | `String datasetId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().ingest().datasets().get(...)` | `GET` | `/data/ingest/datasets/{param}` | `String datasetId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().ingest().datasets().get(...)` | `GET` | `/data/ingest/datasets/{param}` | `String datasetId, Class responseType` | `@Nullable T` | +| `data().ingest().datasets().get(...)` | `GET` | `/data/ingest/datasets/{param}` | `String datasetId, TypeReference responseType` | `@Nullable T` | +| `data().ingest().datasets().ingest(...)` | `POST` | `/data/ingest/datasets/ingest` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().ingest().datasets().ingest(...)` | `POST` | `/data/ingest/datasets/ingest` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().ingest().datasets().ingest(...)` | `POST` | `/data/ingest/datasets/ingest` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().ingest().datasets().ingest(...)` | `POST` | `/data/ingest/datasets/ingest` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().ingest().runs().list(...)` | `GET` | `/data/ingest/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().ingest().runs().list(...)` | `GET` | `/data/ingest/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().ingest().runs().list(...)` | `GET` | `/data/ingest/runs` | `Class responseType` | `@Nullable T` | +| `data().ingest().runs().list(...)` | `GET` | `/data/ingest/runs` | `TypeReference responseType` | `@Nullable T` | +| `data().ingest().runs().get(...)` | `GET` | `/data/ingest/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().ingest().runs().get(...)` | `GET` | `/data/ingest/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().ingest().runs().get(...)` | `GET` | `/data/ingest/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `data().ingest().runs().get(...)` | `GET` | `/data/ingest/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `data().ingest().runs().create(...)` | `POST` | `/data/ingest/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().ingest().runs().create(...)` | `POST` | `/data/ingest/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().ingest().runs().create(...)` | `POST` | `/data/ingest/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().ingest().runs().create(...)` | `POST` | `/data/ingest/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().ingest().schemas().list(...)` | `GET` | `/data/ingest/schemas` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().ingest().schemas().list(...)` | `GET` | `/data/ingest/schemas` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().ingest().schemas().list(...)` | `GET` | `/data/ingest/schemas` | `Class responseType` | `@Nullable T` | +| `data().ingest().schemas().list(...)` | `GET` | `/data/ingest/schemas` | `TypeReference responseType` | `@Nullable T` | +| `data().ingest().schemas().get(...)` | `GET` | `/data/ingest/schemas/{param}` | `String schemaRef, QueryParams query, Class responseType` | `@Nullable T` | +| `data().ingest().schemas().get(...)` | `GET` | `/data/ingest/schemas/{param}` | `String schemaRef, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().ingest().schemas().get(...)` | `GET` | `/data/ingest/schemas/{param}` | `String schemaRef, Class responseType` | `@Nullable T` | +| `data().ingest().schemas().get(...)` | `GET` | `/data/ingest/schemas/{param}` | `String schemaRef, TypeReference responseType` | `@Nullable T` | +| `data().normalization().capabilities().list(...)` | `GET` | `/data/normalization/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().normalization().capabilities().list(...)` | `GET` | `/data/normalization/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().normalization().capabilities().list(...)` | `GET` | `/data/normalization/capabilities` | `Class responseType` | `@Nullable T` | +| `data().normalization().capabilities().list(...)` | `GET` | `/data/normalization/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `data().normalization().runs().list(...)` | `GET` | `/data/normalization/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().normalization().runs().list(...)` | `GET` | `/data/normalization/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().normalization().runs().list(...)` | `GET` | `/data/normalization/runs` | `Class responseType` | `@Nullable T` | +| `data().normalization().runs().list(...)` | `GET` | `/data/normalization/runs` | `TypeReference responseType` | `@Nullable T` | +| `data().normalization().runs().get(...)` | `GET` | `/data/normalization/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().normalization().runs().get(...)` | `GET` | `/data/normalization/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().normalization().runs().get(...)` | `GET` | `/data/normalization/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `data().normalization().runs().get(...)` | `GET` | `/data/normalization/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `data().normalization().runs().create(...)` | `POST` | `/data/normalization/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().normalization().runs().create(...)` | `POST` | `/data/normalization/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().normalization().runs().create(...)` | `POST` | `/data/normalization/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().normalization().runs().create(...)` | `POST` | `/data/normalization/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().pipelines().capabilities().list(...)` | `GET` | `/data/pipelines/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().pipelines().capabilities().list(...)` | `GET` | `/data/pipelines/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().pipelines().capabilities().list(...)` | `GET` | `/data/pipelines/capabilities` | `Class responseType` | `@Nullable T` | +| `data().pipelines().capabilities().list(...)` | `GET` | `/data/pipelines/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `data().pipelines().pipelineRuns().list(...)` | `GET` | `/data/pipelines/pipeline-runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().pipelines().pipelineRuns().list(...)` | `GET` | `/data/pipelines/pipeline-runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().pipelines().pipelineRuns().list(...)` | `GET` | `/data/pipelines/pipeline-runs` | `Class responseType` | `@Nullable T` | +| `data().pipelines().pipelineRuns().list(...)` | `GET` | `/data/pipelines/pipeline-runs` | `TypeReference responseType` | `@Nullable T` | +| `data().pipelines().pipelineRuns().get(...)` | `GET` | `/data/pipelines/pipeline-runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().pipelines().pipelineRuns().get(...)` | `GET` | `/data/pipelines/pipeline-runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().pipelines().pipelineRuns().get(...)` | `GET` | `/data/pipelines/pipeline-runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `data().pipelines().pipelineRuns().get(...)` | `GET` | `/data/pipelines/pipeline-runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `data().pipelines().pipelines().list(...)` | `GET` | `/data/pipelines/pipelines` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().pipelines().pipelines().list(...)` | `GET` | `/data/pipelines/pipelines` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().pipelines().pipelines().list(...)` | `GET` | `/data/pipelines/pipelines` | `Class responseType` | `@Nullable T` | +| `data().pipelines().pipelines().list(...)` | `GET` | `/data/pipelines/pipelines` | `TypeReference responseType` | `@Nullable T` | +| `data().pipelines().pipelines().get(...)` | `GET` | `/data/pipelines/pipelines/{param}` | `String definitionId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().pipelines().pipelines().get(...)` | `GET` | `/data/pipelines/pipelines/{param}` | `String definitionId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().pipelines().pipelines().get(...)` | `GET` | `/data/pipelines/pipelines/{param}` | `String definitionId, Class responseType` | `@Nullable T` | +| `data().pipelines().pipelines().get(...)` | `GET` | `/data/pipelines/pipelines/{param}` | `String definitionId, TypeReference responseType` | `@Nullable T` | +| `data().pipelines().pipelines().create(...)` | `POST` | `/data/pipelines/pipelines` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().pipelines().pipelines().create(...)` | `POST` | `/data/pipelines/pipelines` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().pipelines().pipelines().create(...)` | `POST` | `/data/pipelines/pipelines` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().pipelines().pipelines().create(...)` | `POST` | `/data/pipelines/pipelines` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().pipelines().runs().list(...)` | `GET` | `/data/pipelines/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().pipelines().runs().list(...)` | `GET` | `/data/pipelines/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().pipelines().runs().list(...)` | `GET` | `/data/pipelines/runs` | `Class responseType` | `@Nullable T` | +| `data().pipelines().runs().list(...)` | `GET` | `/data/pipelines/runs` | `TypeReference responseType` | `@Nullable T` | +| `data().pipelines().runs().get(...)` | `GET` | `/data/pipelines/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().pipelines().runs().get(...)` | `GET` | `/data/pipelines/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().pipelines().runs().get(...)` | `GET` | `/data/pipelines/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `data().pipelines().runs().get(...)` | `GET` | `/data/pipelines/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `data().pipelines().runs().create(...)` | `POST` | `/data/pipelines/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().pipelines().runs().create(...)` | `POST` | `/data/pipelines/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().pipelines().runs().create(...)` | `POST` | `/data/pipelines/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().pipelines().runs().create(...)` | `POST` | `/data/pipelines/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().quality().capabilities().list(...)` | `GET` | `/data/quality/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().quality().capabilities().list(...)` | `GET` | `/data/quality/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().quality().capabilities().list(...)` | `GET` | `/data/quality/capabilities` | `Class responseType` | `@Nullable T` | +| `data().quality().capabilities().list(...)` | `GET` | `/data/quality/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `data().quality().runs().list(...)` | `GET` | `/data/quality/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().quality().runs().list(...)` | `GET` | `/data/quality/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().quality().runs().list(...)` | `GET` | `/data/quality/runs` | `Class responseType` | `@Nullable T` | +| `data().quality().runs().list(...)` | `GET` | `/data/quality/runs` | `TypeReference responseType` | `@Nullable T` | +| `data().quality().runs().get(...)` | `GET` | `/data/quality/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().quality().runs().get(...)` | `GET` | `/data/quality/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().quality().runs().get(...)` | `GET` | `/data/quality/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `data().quality().runs().get(...)` | `GET` | `/data/quality/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `data().quality().runs().create(...)` | `POST` | `/data/quality/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().quality().runs().create(...)` | `POST` | `/data/quality/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().quality().runs().create(...)` | `POST` | `/data/quality/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().quality().runs().create(...)` | `POST` | `/data/quality/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().query().capabilities().list(...)` | `GET` | `/data/query/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().query().capabilities().list(...)` | `GET` | `/data/query/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().query().capabilities().list(...)` | `GET` | `/data/query/capabilities` | `Class responseType` | `@Nullable T` | +| `data().query().capabilities().list(...)` | `GET` | `/data/query/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `data().query().query().federated(...)` | `POST` | `/data/query/query/federated` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().query().query().federated(...)` | `POST` | `/data/query/query/federated` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().query().query().federated(...)` | `POST` | `/data/query/query/federated` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().query().query().federated(...)` | `POST` | `/data/query/query/federated` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().query().runs().list(...)` | `GET` | `/data/query/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().query().runs().list(...)` | `GET` | `/data/query/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().query().runs().list(...)` | `GET` | `/data/query/runs` | `Class responseType` | `@Nullable T` | +| `data().query().runs().list(...)` | `GET` | `/data/query/runs` | `TypeReference responseType` | `@Nullable T` | +| `data().query().runs().get(...)` | `GET` | `/data/query/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().query().runs().get(...)` | `GET` | `/data/query/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().query().runs().get(...)` | `GET` | `/data/query/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `data().query().runs().get(...)` | `GET` | `/data/query/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `data().query().runs().create(...)` | `POST` | `/data/query/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().query().runs().create(...)` | `POST` | `/data/query/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().query().runs().create(...)` | `POST` | `/data/query/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().query().runs().create(...)` | `POST` | `/data/query/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().schemas().capabilities().list(...)` | `GET` | `/data/schemas/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().schemas().capabilities().list(...)` | `GET` | `/data/schemas/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().schemas().capabilities().list(...)` | `GET` | `/data/schemas/capabilities` | `Class responseType` | `@Nullable T` | +| `data().schemas().capabilities().list(...)` | `GET` | `/data/schemas/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `data().schemas().runs().list(...)` | `GET` | `/data/schemas/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().schemas().runs().list(...)` | `GET` | `/data/schemas/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().schemas().runs().list(...)` | `GET` | `/data/schemas/runs` | `Class responseType` | `@Nullable T` | +| `data().schemas().runs().list(...)` | `GET` | `/data/schemas/runs` | `TypeReference responseType` | `@Nullable T` | +| `data().schemas().runs().get(...)` | `GET` | `/data/schemas/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().schemas().runs().get(...)` | `GET` | `/data/schemas/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().schemas().runs().get(...)` | `GET` | `/data/schemas/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `data().schemas().runs().get(...)` | `GET` | `/data/schemas/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `data().schemas().runs().create(...)` | `POST` | `/data/schemas/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().schemas().runs().create(...)` | `POST` | `/data/schemas/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().schemas().runs().create(...)` | `POST` | `/data/schemas/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().schemas().runs().create(...)` | `POST` | `/data/schemas/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().schemas().schemas().list(...)` | `GET` | `/data/schemas/schemas` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().schemas().schemas().list(...)` | `GET` | `/data/schemas/schemas` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().schemas().schemas().list(...)` | `GET` | `/data/schemas/schemas` | `Class responseType` | `@Nullable T` | +| `data().schemas().schemas().list(...)` | `GET` | `/data/schemas/schemas` | `TypeReference responseType` | `@Nullable T` | +| `data().schemas().schemas().get(...)` | `GET` | `/data/schemas/schemas/{param}` | `String schemaRef, QueryParams query, Class responseType` | `@Nullable T` | +| `data().schemas().schemas().get(...)` | `GET` | `/data/schemas/schemas/{param}` | `String schemaRef, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().schemas().schemas().get(...)` | `GET` | `/data/schemas/schemas/{param}` | `String schemaRef, Class responseType` | `@Nullable T` | +| `data().schemas().schemas().get(...)` | `GET` | `/data/schemas/schemas/{param}` | `String schemaRef, TypeReference responseType` | `@Nullable T` | +| `data().schemas().schemas().create(...)` | `POST` | `/data/schemas/schemas` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().schemas().schemas().create(...)` | `POST` | `/data/schemas/schemas` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().schemas().schemas().create(...)` | `POST` | `/data/schemas/schemas` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().schemas().schemas().create(...)` | `POST` | `/data/schemas/schemas` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().schemas().schemas().resolve(...)` | `POST` | `/data/schemas/schemas/resolve` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().schemas().schemas().resolve(...)` | `POST` | `/data/schemas/schemas/resolve` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().schemas().schemas().resolve(...)` | `POST` | `/data/schemas/schemas/resolve` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().schemas().schemas().resolve(...)` | `POST` | `/data/schemas/schemas/resolve` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().serving().capabilities().list(...)` | `GET` | `/data/serving/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().serving().capabilities().list(...)` | `GET` | `/data/serving/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().serving().capabilities().list(...)` | `GET` | `/data/serving/capabilities` | `Class responseType` | `@Nullable T` | +| `data().serving().capabilities().list(...)` | `GET` | `/data/serving/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `data().serving().runs().list(...)` | `GET` | `/data/serving/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().serving().runs().list(...)` | `GET` | `/data/serving/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().serving().runs().list(...)` | `GET` | `/data/serving/runs` | `Class responseType` | `@Nullable T` | +| `data().serving().runs().list(...)` | `GET` | `/data/serving/runs` | `TypeReference responseType` | `@Nullable T` | +| `data().serving().runs().get(...)` | `GET` | `/data/serving/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().serving().runs().get(...)` | `GET` | `/data/serving/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().serving().runs().get(...)` | `GET` | `/data/serving/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `data().serving().runs().get(...)` | `GET` | `/data/serving/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `data().serving().runs().create(...)` | `POST` | `/data/serving/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().serving().runs().create(...)` | `POST` | `/data/serving/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().serving().runs().create(...)` | `POST` | `/data/serving/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().serving().runs().create(...)` | `POST` | `/data/serving/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().streams().capabilities().list(...)` | `GET` | `/data/streams/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().streams().capabilities().list(...)` | `GET` | `/data/streams/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().streams().capabilities().list(...)` | `GET` | `/data/streams/capabilities` | `Class responseType` | `@Nullable T` | +| `data().streams().capabilities().list(...)` | `GET` | `/data/streams/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `data().streams().runs().list(...)` | `GET` | `/data/streams/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().streams().runs().list(...)` | `GET` | `/data/streams/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().streams().runs().list(...)` | `GET` | `/data/streams/runs` | `Class responseType` | `@Nullable T` | +| `data().streams().runs().list(...)` | `GET` | `/data/streams/runs` | `TypeReference responseType` | `@Nullable T` | +| `data().streams().runs().get(...)` | `GET` | `/data/streams/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().streams().runs().get(...)` | `GET` | `/data/streams/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().streams().runs().get(...)` | `GET` | `/data/streams/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `data().streams().runs().get(...)` | `GET` | `/data/streams/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `data().streams().runs().create(...)` | `POST` | `/data/streams/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().streams().runs().create(...)` | `POST` | `/data/streams/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().streams().runs().create(...)` | `POST` | `/data/streams/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().streams().runs().create(...)` | `POST` | `/data/streams/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().streams().streams().list(...)` | `GET` | `/data/streams/streams` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().streams().streams().list(...)` | `GET` | `/data/streams/streams` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().streams().streams().list(...)` | `GET` | `/data/streams/streams` | `Class responseType` | `@Nullable T` | +| `data().streams().streams().list(...)` | `GET` | `/data/streams/streams` | `TypeReference responseType` | `@Nullable T` | +| `data().streams().streams().get(...)` | `GET` | `/data/streams/streams/{param}` | `String streamId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().streams().streams().get(...)` | `GET` | `/data/streams/streams/{param}` | `String streamId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().streams().streams().get(...)` | `GET` | `/data/streams/streams/{param}` | `String streamId, Class responseType` | `@Nullable T` | +| `data().streams().streams().get(...)` | `GET` | `/data/streams/streams/{param}` | `String streamId, TypeReference responseType` | `@Nullable T` | +| `data().streams().streams().create(...)` | `POST` | `/data/streams/streams` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().streams().streams().create(...)` | `POST` | `/data/streams/streams` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().streams().streams().create(...)` | `POST` | `/data/streams/streams` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().streams().streams().create(...)` | `POST` | `/data/streams/streams` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().sync().capabilities().list(...)` | `GET` | `/data/sync/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().sync().capabilities().list(...)` | `GET` | `/data/sync/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().sync().capabilities().list(...)` | `GET` | `/data/sync/capabilities` | `Class responseType` | `@Nullable T` | +| `data().sync().capabilities().list(...)` | `GET` | `/data/sync/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `data().sync().runs().list(...)` | `GET` | `/data/sync/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().sync().runs().list(...)` | `GET` | `/data/sync/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().sync().runs().list(...)` | `GET` | `/data/sync/runs` | `Class responseType` | `@Nullable T` | +| `data().sync().runs().list(...)` | `GET` | `/data/sync/runs` | `TypeReference responseType` | `@Nullable T` | +| `data().sync().runs().get(...)` | `GET` | `/data/sync/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().sync().runs().get(...)` | `GET` | `/data/sync/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().sync().runs().get(...)` | `GET` | `/data/sync/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `data().sync().runs().get(...)` | `GET` | `/data/sync/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `data().sync().runs().create(...)` | `POST` | `/data/sync/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().sync().runs().create(...)` | `POST` | `/data/sync/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().sync().runs().create(...)` | `POST` | `/data/sync/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().sync().runs().create(...)` | `POST` | `/data/sync/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().transformations().capabilities().list(...)` | `GET` | `/data/transformations/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().transformations().capabilities().list(...)` | `GET` | `/data/transformations/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().transformations().capabilities().list(...)` | `GET` | `/data/transformations/capabilities` | `Class responseType` | `@Nullable T` | +| `data().transformations().capabilities().list(...)` | `GET` | `/data/transformations/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `data().transformations().runs().list(...)` | `GET` | `/data/transformations/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().transformations().runs().list(...)` | `GET` | `/data/transformations/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().transformations().runs().list(...)` | `GET` | `/data/transformations/runs` | `Class responseType` | `@Nullable T` | +| `data().transformations().runs().list(...)` | `GET` | `/data/transformations/runs` | `TypeReference responseType` | `@Nullable T` | +| `data().transformations().runs().get(...)` | `GET` | `/data/transformations/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().transformations().runs().get(...)` | `GET` | `/data/transformations/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().transformations().runs().get(...)` | `GET` | `/data/transformations/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `data().transformations().runs().get(...)` | `GET` | `/data/transformations/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `data().transformations().runs().create(...)` | `POST` | `/data/transformations/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().transformations().runs().create(...)` | `POST` | `/data/transformations/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().transformations().runs().create(...)` | `POST` | `/data/transformations/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().transformations().runs().create(...)` | `POST` | `/data/transformations/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().transformations().transformations().list(...)` | `GET` | `/data/transformations/transformations` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().transformations().transformations().list(...)` | `GET` | `/data/transformations/transformations` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().transformations().transformations().list(...)` | `GET` | `/data/transformations/transformations` | `Class responseType` | `@Nullable T` | +| `data().transformations().transformations().list(...)` | `GET` | `/data/transformations/transformations` | `TypeReference responseType` | `@Nullable T` | +| `data().transformations().transformations().get(...)` | `GET` | `/data/transformations/transformations/{param}` | `String transformationId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().transformations().transformations().get(...)` | `GET` | `/data/transformations/transformations/{param}` | `String transformationId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().transformations().transformations().get(...)` | `GET` | `/data/transformations/transformations/{param}` | `String transformationId, Class responseType` | `@Nullable T` | +| `data().transformations().transformations().get(...)` | `GET` | `/data/transformations/transformations/{param}` | `String transformationId, TypeReference responseType` | `@Nullable T` | +| `data().transformations().transformations().create(...)` | `POST` | `/data/transformations/transformations` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().transformations().transformations().create(...)` | `POST` | `/data/transformations/transformations` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().transformations().transformations().create(...)` | `POST` | `/data/transformations/transformations` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().transformations().transformations().create(...)` | `POST` | `/data/transformations/transformations` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().aggregations().aggregations().executions().create(...)` | `POST` | `/data/aggregations/aggregations/{param}/executions` | `String aggregationId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().aggregations().aggregations().executions().create(...)` | `POST` | `/data/aggregations/aggregations/{param}/executions` | `String aggregationId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().aggregations().aggregations().executions().create(...)` | `POST` | `/data/aggregations/aggregations/{param}/executions` | `String aggregationId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().aggregations().aggregations().executions().create(...)` | `POST` | `/data/aggregations/aggregations/{param}/executions` | `String aggregationId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().archival().archival().policies().list(...)` | `GET` | `/data/archival/archival/policies` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().archival().archival().policies().list(...)` | `GET` | `/data/archival/archival/policies` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().archival().archival().policies().list(...)` | `GET` | `/data/archival/archival/policies` | `Class responseType` | `@Nullable T` | +| `data().archival().archival().policies().list(...)` | `GET` | `/data/archival/archival/policies` | `TypeReference responseType` | `@Nullable T` | +| `data().archival().archival().policies().get(...)` | `GET` | `/data/archival/archival/policies/{param}` | `String policyId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().archival().archival().policies().get(...)` | `GET` | `/data/archival/archival/policies/{param}` | `String policyId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().archival().archival().policies().get(...)` | `GET` | `/data/archival/archival/policies/{param}` | `String policyId, Class responseType` | `@Nullable T` | +| `data().archival().archival().policies().get(...)` | `GET` | `/data/archival/archival/policies/{param}` | `String policyId, TypeReference responseType` | `@Nullable T` | +| `data().archival().archival().policies().create(...)` | `POST` | `/data/archival/archival/policies` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().archival().archival().policies().create(...)` | `POST` | `/data/archival/archival/policies` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().archival().archival().policies().create(...)` | `POST` | `/data/archival/archival/policies` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().archival().archival().policies().create(...)` | `POST` | `/data/archival/archival/policies` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().catalog().catalog().datasets().list(...)` | `GET` | `/data/catalog/catalog/datasets` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().catalog().catalog().datasets().list(...)` | `GET` | `/data/catalog/catalog/datasets` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().catalog().catalog().datasets().list(...)` | `GET` | `/data/catalog/catalog/datasets` | `Class responseType` | `@Nullable T` | +| `data().catalog().catalog().datasets().list(...)` | `GET` | `/data/catalog/catalog/datasets` | `TypeReference responseType` | `@Nullable T` | +| `data().catalog().catalog().datasets().get(...)` | `GET` | `/data/catalog/catalog/datasets/{param}` | `String datasetId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().catalog().catalog().datasets().get(...)` | `GET` | `/data/catalog/catalog/datasets/{param}` | `String datasetId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().catalog().catalog().datasets().get(...)` | `GET` | `/data/catalog/catalog/datasets/{param}` | `String datasetId, Class responseType` | `@Nullable T` | +| `data().catalog().catalog().datasets().get(...)` | `GET` | `/data/catalog/catalog/datasets/{param}` | `String datasetId, TypeReference responseType` | `@Nullable T` | +| `data().catalog().catalog().sources().list(...)` | `GET` | `/data/catalog/catalog/sources` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().catalog().catalog().sources().list(...)` | `GET` | `/data/catalog/catalog/sources` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().catalog().catalog().sources().list(...)` | `GET` | `/data/catalog/catalog/sources` | `Class responseType` | `@Nullable T` | +| `data().catalog().catalog().sources().list(...)` | `GET` | `/data/catalog/catalog/sources` | `TypeReference responseType` | `@Nullable T` | +| `data().catalog().catalog().sources().get(...)` | `GET` | `/data/catalog/catalog/sources/{param}` | `String sourceId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().catalog().catalog().sources().get(...)` | `GET` | `/data/catalog/catalog/sources/{param}` | `String sourceId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().catalog().catalog().sources().get(...)` | `GET` | `/data/catalog/catalog/sources/{param}` | `String sourceId, Class responseType` | `@Nullable T` | +| `data().catalog().catalog().sources().get(...)` | `GET` | `/data/catalog/catalog/sources/{param}` | `String sourceId, TypeReference responseType` | `@Nullable T` | +| `data().enrichment().enrichment().profiles().list(...)` | `GET` | `/data/enrichment/enrichment/profiles` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().enrichment().enrichment().profiles().list(...)` | `GET` | `/data/enrichment/enrichment/profiles` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().enrichment().enrichment().profiles().list(...)` | `GET` | `/data/enrichment/enrichment/profiles` | `Class responseType` | `@Nullable T` | +| `data().enrichment().enrichment().profiles().list(...)` | `GET` | `/data/enrichment/enrichment/profiles` | `TypeReference responseType` | `@Nullable T` | +| `data().enrichment().enrichment().profiles().get(...)` | `GET` | `/data/enrichment/enrichment/profiles/{param}` | `String profileId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().enrichment().enrichment().profiles().get(...)` | `GET` | `/data/enrichment/enrichment/profiles/{param}` | `String profileId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().enrichment().enrichment().profiles().get(...)` | `GET` | `/data/enrichment/enrichment/profiles/{param}` | `String profileId, Class responseType` | `@Nullable T` | +| `data().enrichment().enrichment().profiles().get(...)` | `GET` | `/data/enrichment/enrichment/profiles/{param}` | `String profileId, TypeReference responseType` | `@Nullable T` | +| `data().enrichment().enrichment().profiles().create(...)` | `POST` | `/data/enrichment/enrichment/profiles` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().enrichment().enrichment().profiles().create(...)` | `POST` | `/data/enrichment/enrichment/profiles` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().enrichment().enrichment().profiles().create(...)` | `POST` | `/data/enrichment/enrichment/profiles` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().enrichment().enrichment().profiles().create(...)` | `POST` | `/data/enrichment/enrichment/profiles` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().exports().exports().executions().create(...)` | `POST` | `/data/exports/exports/{param}/executions` | `String exportId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().exports().exports().executions().create(...)` | `POST` | `/data/exports/exports/{param}/executions` | `String exportId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().exports().exports().executions().create(...)` | `POST` | `/data/exports/exports/{param}/executions` | `String exportId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().exports().exports().executions().create(...)` | `POST` | `/data/exports/exports/{param}/executions` | `String exportId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().ingest().datasets().artifacts().getContent(...)` | `GET` | `/data/ingest/datasets/{param}/artifacts/{param}/content` | `String datasetId, String manifestId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().ingest().datasets().artifacts().getContent(...)` | `GET` | `/data/ingest/datasets/{param}/artifacts/{param}/content` | `String datasetId, String manifestId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().ingest().datasets().artifacts().getContent(...)` | `GET` | `/data/ingest/datasets/{param}/artifacts/{param}/content` | `String datasetId, String manifestId, Class responseType` | `@Nullable T` | +| `data().ingest().datasets().artifacts().getContent(...)` | `GET` | `/data/ingest/datasets/{param}/artifacts/{param}/content` | `String datasetId, String manifestId, TypeReference responseType` | `@Nullable T` | +| `data().normalization().normalization().profiles().list(...)` | `GET` | `/data/normalization/normalization/profiles` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().normalization().normalization().profiles().list(...)` | `GET` | `/data/normalization/normalization/profiles` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().normalization().normalization().profiles().list(...)` | `GET` | `/data/normalization/normalization/profiles` | `Class responseType` | `@Nullable T` | +| `data().normalization().normalization().profiles().list(...)` | `GET` | `/data/normalization/normalization/profiles` | `TypeReference responseType` | `@Nullable T` | +| `data().normalization().normalization().profiles().get(...)` | `GET` | `/data/normalization/normalization/profiles/{param}` | `String profileId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().normalization().normalization().profiles().get(...)` | `GET` | `/data/normalization/normalization/profiles/{param}` | `String profileId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().normalization().normalization().profiles().get(...)` | `GET` | `/data/normalization/normalization/profiles/{param}` | `String profileId, Class responseType` | `@Nullable T` | +| `data().normalization().normalization().profiles().get(...)` | `GET` | `/data/normalization/normalization/profiles/{param}` | `String profileId, TypeReference responseType` | `@Nullable T` | +| `data().normalization().normalization().profiles().create(...)` | `POST` | `/data/normalization/normalization/profiles` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().normalization().normalization().profiles().create(...)` | `POST` | `/data/normalization/normalization/profiles` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().normalization().normalization().profiles().create(...)` | `POST` | `/data/normalization/normalization/profiles` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().normalization().normalization().profiles().create(...)` | `POST` | `/data/normalization/normalization/profiles` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().quality().quality().rulesets().list(...)` | `GET` | `/data/quality/quality/rulesets` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().quality().quality().rulesets().list(...)` | `GET` | `/data/quality/quality/rulesets` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().quality().quality().rulesets().list(...)` | `GET` | `/data/quality/quality/rulesets` | `Class responseType` | `@Nullable T` | +| `data().quality().quality().rulesets().list(...)` | `GET` | `/data/quality/quality/rulesets` | `TypeReference responseType` | `@Nullable T` | +| `data().quality().quality().rulesets().get(...)` | `GET` | `/data/quality/quality/rulesets/{param}` | `String rulesetId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().quality().quality().rulesets().get(...)` | `GET` | `/data/quality/quality/rulesets/{param}` | `String rulesetId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().quality().quality().rulesets().get(...)` | `GET` | `/data/quality/quality/rulesets/{param}` | `String rulesetId, Class responseType` | `@Nullable T` | +| `data().quality().quality().rulesets().get(...)` | `GET` | `/data/quality/quality/rulesets/{param}` | `String rulesetId, TypeReference responseType` | `@Nullable T` | +| `data().quality().quality().rulesets().create(...)` | `POST` | `/data/quality/quality/rulesets` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().quality().quality().rulesets().create(...)` | `POST` | `/data/quality/quality/rulesets` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().quality().quality().rulesets().create(...)` | `POST` | `/data/quality/quality/rulesets` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().quality().quality().rulesets().create(...)` | `POST` | `/data/quality/quality/rulesets` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().serving().serving().products().list(...)` | `GET` | `/data/serving/serving/products` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().serving().serving().products().list(...)` | `GET` | `/data/serving/serving/products` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().serving().serving().products().list(...)` | `GET` | `/data/serving/serving/products` | `Class responseType` | `@Nullable T` | +| `data().serving().serving().products().list(...)` | `GET` | `/data/serving/serving/products` | `TypeReference responseType` | `@Nullable T` | +| `data().serving().serving().products().get(...)` | `GET` | `/data/serving/serving/products/{param}` | `String productId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().serving().serving().products().get(...)` | `GET` | `/data/serving/serving/products/{param}` | `String productId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().serving().serving().products().get(...)` | `GET` | `/data/serving/serving/products/{param}` | `String productId, Class responseType` | `@Nullable T` | +| `data().serving().serving().products().get(...)` | `GET` | `/data/serving/serving/products/{param}` | `String productId, TypeReference responseType` | `@Nullable T` | +| `data().serving().serving().products().create(...)` | `POST` | `/data/serving/serving/products` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().serving().serving().products().create(...)` | `POST` | `/data/serving/serving/products` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().serving().serving().products().create(...)` | `POST` | `/data/serving/serving/products` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().serving().serving().products().create(...)` | `POST` | `/data/serving/serving/products` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().streams().streams().deliveries().create(...)` | `POST` | `/data/streams/streams/{param}/deliveries` | `String streamId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().streams().streams().deliveries().create(...)` | `POST` | `/data/streams/streams/{param}/deliveries` | `String streamId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().streams().streams().deliveries().create(...)` | `POST` | `/data/streams/streams/{param}/deliveries` | `String streamId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().streams().streams().deliveries().create(...)` | `POST` | `/data/streams/streams/{param}/deliveries` | `String streamId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().sync().sync().jobs().list(...)` | `GET` | `/data/sync/sync/jobs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `data().sync().sync().jobs().list(...)` | `GET` | `/data/sync/sync/jobs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().sync().sync().jobs().list(...)` | `GET` | `/data/sync/sync/jobs` | `Class responseType` | `@Nullable T` | +| `data().sync().sync().jobs().list(...)` | `GET` | `/data/sync/sync/jobs` | `TypeReference responseType` | `@Nullable T` | +| `data().sync().sync().jobs().get(...)` | `GET` | `/data/sync/sync/jobs/{param}` | `String jobId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().sync().sync().jobs().get(...)` | `GET` | `/data/sync/sync/jobs/{param}` | `String jobId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().sync().sync().jobs().get(...)` | `GET` | `/data/sync/sync/jobs/{param}` | `String jobId, Class responseType` | `@Nullable T` | +| `data().sync().sync().jobs().get(...)` | `GET` | `/data/sync/sync/jobs/{param}` | `String jobId, TypeReference responseType` | `@Nullable T` | +| `data().sync().sync().jobs().create(...)` | `POST` | `/data/sync/sync/jobs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().sync().sync().jobs().create(...)` | `POST` | `/data/sync/sync/jobs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().sync().sync().jobs().create(...)` | `POST` | `/data/sync/sync/jobs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().sync().sync().jobs().create(...)` | `POST` | `/data/sync/sync/jobs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().transformations().transformations().executions().create(...)` | `POST` | `/data/transformations/transformations/{param}/executions` | `String transformationId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().transformations().transformations().executions().create(...)` | `POST` | `/data/transformations/transformations/{param}/executions` | `String transformationId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().transformations().transformations().executions().create(...)` | `POST` | `/data/transformations/transformations/{param}/executions` | `String transformationId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().transformations().transformations().executions().create(...)` | `POST` | `/data/transformations/transformations/{param}/executions` | `String transformationId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().archival().archival().policies().executions().create(...)` | `POST` | `/data/archival/archival/policies/{param}/executions` | `String policyId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().archival().archival().policies().executions().create(...)` | `POST` | `/data/archival/archival/policies/{param}/executions` | `String policyId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().archival().archival().policies().executions().create(...)` | `POST` | `/data/archival/archival/policies/{param}/executions` | `String policyId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().archival().archival().policies().executions().create(...)` | `POST` | `/data/archival/archival/policies/{param}/executions` | `String policyId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().catalog().catalog().datasets().artifacts().getContent(...)` | `GET` | `/data/catalog/catalog/datasets/{param}/artifacts/{param}/content` | `String datasetId, String manifestId, QueryParams query, Class responseType` | `@Nullable T` | +| `data().catalog().catalog().datasets().artifacts().getContent(...)` | `GET` | `/data/catalog/catalog/datasets/{param}/artifacts/{param}/content` | `String datasetId, String manifestId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `data().catalog().catalog().datasets().artifacts().getContent(...)` | `GET` | `/data/catalog/catalog/datasets/{param}/artifacts/{param}/content` | `String datasetId, String manifestId, Class responseType` | `@Nullable T` | +| `data().catalog().catalog().datasets().artifacts().getContent(...)` | `GET` | `/data/catalog/catalog/datasets/{param}/artifacts/{param}/content` | `String datasetId, String manifestId, TypeReference responseType` | `@Nullable T` | +| `data().enrichment().enrichment().profiles().executions().create(...)` | `POST` | `/data/enrichment/enrichment/profiles/{param}/executions` | `String profileId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().enrichment().enrichment().profiles().executions().create(...)` | `POST` | `/data/enrichment/enrichment/profiles/{param}/executions` | `String profileId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().enrichment().enrichment().profiles().executions().create(...)` | `POST` | `/data/enrichment/enrichment/profiles/{param}/executions` | `String profileId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().enrichment().enrichment().profiles().executions().create(...)` | `POST` | `/data/enrichment/enrichment/profiles/{param}/executions` | `String profileId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().normalization().normalization().profiles().executions().create(...)` | `POST` | `/data/normalization/normalization/profiles/{param}/executions` | `String profileId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().normalization().normalization().profiles().executions().create(...)` | `POST` | `/data/normalization/normalization/profiles/{param}/executions` | `String profileId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().normalization().normalization().profiles().executions().create(...)` | `POST` | `/data/normalization/normalization/profiles/{param}/executions` | `String profileId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().normalization().normalization().profiles().executions().create(...)` | `POST` | `/data/normalization/normalization/profiles/{param}/executions` | `String profileId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().quality().quality().rulesets().evaluations().create(...)` | `POST` | `/data/quality/quality/rulesets/{param}/evaluations` | `String rulesetId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().quality().quality().rulesets().evaluations().create(...)` | `POST` | `/data/quality/quality/rulesets/{param}/evaluations` | `String rulesetId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().quality().quality().rulesets().evaluations().create(...)` | `POST` | `/data/quality/quality/rulesets/{param}/evaluations` | `String rulesetId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().quality().quality().rulesets().evaluations().create(...)` | `POST` | `/data/quality/quality/rulesets/{param}/evaluations` | `String rulesetId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().serving().serving().products().refreshes().create(...)` | `POST` | `/data/serving/serving/products/{param}/refreshes` | `String productId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().serving().serving().products().refreshes().create(...)` | `POST` | `/data/serving/serving/products/{param}/refreshes` | `String productId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().serving().serving().products().refreshes().create(...)` | `POST` | `/data/serving/serving/products/{param}/refreshes` | `String productId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().serving().serving().products().refreshes().create(...)` | `POST` | `/data/serving/serving/products/{param}/refreshes` | `String productId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().sync().sync().jobs().executions().create(...)` | `POST` | `/data/sync/sync/jobs/{param}/executions` | `String jobId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().sync().sync().jobs().executions().create(...)` | `POST` | `/data/sync/sync/jobs/{param}/executions` | `String jobId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `data().sync().sync().jobs().executions().create(...)` | `POST` | `/data/sync/sync/jobs/{param}/executions` | `String jobId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `data().sync().sync().jobs().executions().create(...)` | `POST` | `/data/sync/sync/jobs/{param}/executions` | `String jobId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | + +The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/events.md b/docs/api/events.md new file mode 100644 index 0000000..70a8aa0 --- /dev/null +++ b/docs/api/events.md @@ -0,0 +1,78 @@ +# Events API + +Service accessor: `frontal.events()` (`EventsClient`). + +Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. + +| Method | HTTP | Route | Parameters | Response | +| --- | --- | --- | --- | --- | +| `events().list(...)` | `GET` | `/events` | `QueryParams query, Class responseType` | `@Nullable T` | +| `events().list(...)` | `GET` | `/events` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `events().list(...)` | `GET` | `/events` | `Class responseType` | `@Nullable T` | +| `events().list(...)` | `GET` | `/events` | `TypeReference responseType` | `@Nullable T` | +| `events().getMonitoring(...)` | `GET` | `/events/monitoring` | `QueryParams query, Class responseType` | `@Nullable T` | +| `events().getMonitoring(...)` | `GET` | `/events/monitoring` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `events().getMonitoring(...)` | `GET` | `/events/monitoring` | `Class responseType` | `@Nullable T` | +| `events().getMonitoring(...)` | `GET` | `/events/monitoring` | `TypeReference responseType` | `@Nullable T` | +| `events().get(...)` | `GET` | `/events/{param}` | `String id, QueryParams query, Class responseType` | `@Nullable T` | +| `events().get(...)` | `GET` | `/events/{param}` | `String id, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `events().get(...)` | `GET` | `/events/{param}` | `String id, Class responseType` | `@Nullable T` | +| `events().get(...)` | `GET` | `/events/{param}` | `String id, TypeReference responseType` | `@Nullable T` | +| `events().create(...)` | `POST` | `/events` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().create(...)` | `POST` | `/events` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().create(...)` | `POST` | `/events` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().create(...)` | `POST` | `/events` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().analytics(...)` | `POST` | `/events/analytics` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().analytics(...)` | `POST` | `/events/analytics` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().analytics(...)` | `POST` | `/events/analytics` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().analytics(...)` | `POST` | `/events/analytics` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().createAnalyticsV2(...)` | `POST` | `/events/analytics-v2` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().createAnalyticsV2(...)` | `POST` | `/events/analytics-v2` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().createAnalyticsV2(...)` | `POST` | `/events/analytics-v2` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().createAnalyticsV2(...)` | `POST` | `/events/analytics-v2` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().bulk(...)` | `POST` | `/events/bulk` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().bulk(...)` | `POST` | `/events/bulk` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().bulk(...)` | `POST` | `/events/bulk` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().bulk(...)` | `POST` | `/events/bulk` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().createHuggingfaceBilling(...)` | `POST` | `/events/huggingface-billing` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().createHuggingfaceBilling(...)` | `POST` | `/events/huggingface-billing` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().createHuggingfaceBilling(...)` | `POST` | `/events/huggingface-billing` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().createHuggingfaceBilling(...)` | `POST` | `/events/huggingface-billing` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().query(...)` | `POST` | `/events/query` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().query(...)` | `POST` | `/events/query` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().query(...)` | `POST` | `/events/query` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().query(...)` | `POST` | `/events/query` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().reprocess(...)` | `POST` | `/events/reprocess` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().reprocess(...)` | `POST` | `/events/reprocess` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().reprocess(...)` | `POST` | `/events/reprocess` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().reprocess(...)` | `POST` | `/events/reprocess` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().usage(...)` | `POST` | `/events/usage` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().usage(...)` | `POST` | `/events/usage` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().usage(...)` | `POST` | `/events/usage` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().usage(...)` | `POST` | `/events/usage` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().benchmark().createV1(...)` | `POST` | `/events/benchmark/v1` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().benchmark().createV1(...)` | `POST` | `/events/benchmark/v1` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().benchmark().createV1(...)` | `POST` | `/events/benchmark/v1` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().benchmark().createV1(...)` | `POST` | `/events/benchmark/v1` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().benchmark().createV2(...)` | `POST` | `/events/benchmark/v2` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().benchmark().createV2(...)` | `POST` | `/events/benchmark/v2` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().benchmark().createV2(...)` | `POST` | `/events/benchmark/v2` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().benchmark().createV2(...)` | `POST` | `/events/benchmark/v2` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().reprocess().createInternal(...)` | `POST` | `/events/reprocess/internal` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().reprocess().createInternal(...)` | `POST` | `/events/reprocess/internal` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().reprocess().createInternal(...)` | `POST` | `/events/reprocess/internal` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().reprocess().createInternal(...)` | `POST` | `/events/reprocess/internal` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().usage().createMeter(...)` | `POST` | `/events/usage/meter` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().usage().createMeter(...)` | `POST` | `/events/usage/meter` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().usage().createMeter(...)` | `POST` | `/events/usage/meter` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().usage().createMeter(...)` | `POST` | `/events/usage/meter` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().raw().reprocess().createAll(...)` | `POST` | `/events/raw/reprocess/all` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().raw().reprocess().createAll(...)` | `POST` | `/events/raw/reprocess/all` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().raw().reprocess().createAll(...)` | `POST` | `/events/raw/reprocess/all` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().raw().reprocess().createAll(...)` | `POST` | `/events/raw/reprocess/all` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().raw().reprocess().createPending(...)` | `POST` | `/events/raw/reprocess/pending` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().raw().reprocess().createPending(...)` | `POST` | `/events/raw/reprocess/pending` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `events().raw().reprocess().createPending(...)` | `POST` | `/events/raw/reprocess/pending` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `events().raw().reprocess().createPending(...)` | `POST` | `/events/raw/reprocess/pending` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | + +The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/governance.md b/docs/api/governance.md new file mode 100644 index 0000000..c312085 --- /dev/null +++ b/docs/api/governance.md @@ -0,0 +1,106 @@ +# Governance API + +Service accessor: `frontal.governance()` (`GovernanceClient`). + +Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. + +| Method | HTTP | Route | Parameters | Response | +| --- | --- | --- | --- | --- | +| `governance().access().check(...)` | `POST` | `/access/check` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `governance().access().check(...)` | `POST` | `/access/check` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `governance().access().check(...)` | `POST` | `/access/check` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `governance().access().check(...)` | `POST` | `/access/check` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `governance().compliance().getScore(...)` | `GET` | `/compliance/score` | `QueryParams query, Class responseType` | `@Nullable T` | +| `governance().compliance().getScore(...)` | `GET` | `/compliance/score` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `governance().compliance().getScore(...)` | `GET` | `/compliance/score` | `Class responseType` | `@Nullable T` | +| `governance().compliance().getScore(...)` | `GET` | `/compliance/score` | `TypeReference responseType` | `@Nullable T` | +| `governance().permissions().list(...)` | `GET` | `/permissions` | `QueryParams query, Class responseType` | `@Nullable T` | +| `governance().permissions().list(...)` | `GET` | `/permissions` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `governance().permissions().list(...)` | `GET` | `/permissions` | `Class responseType` | `@Nullable T` | +| `governance().permissions().list(...)` | `GET` | `/permissions` | `TypeReference responseType` | `@Nullable T` | +| `governance().permissions().get(...)` | `GET` | `/permissions/{param}` | `String permissionId, QueryParams query, Class responseType` | `@Nullable T` | +| `governance().permissions().get(...)` | `GET` | `/permissions/{param}` | `String permissionId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `governance().permissions().get(...)` | `GET` | `/permissions/{param}` | `String permissionId, Class responseType` | `@Nullable T` | +| `governance().permissions().get(...)` | `GET` | `/permissions/{param}` | `String permissionId, TypeReference responseType` | `@Nullable T` | +| `governance().permissions().create(...)` | `POST` | `/permissions` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `governance().permissions().create(...)` | `POST` | `/permissions` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `governance().permissions().create(...)` | `POST` | `/permissions` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `governance().permissions().create(...)` | `POST` | `/permissions` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `governance().policies().delete(...)` | `DELETE` | `/policies/{param}` | `String policyId, QueryParams query, Class responseType` | `@Nullable T` | +| `governance().policies().delete(...)` | `DELETE` | `/policies/{param}` | `String policyId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `governance().policies().delete(...)` | `DELETE` | `/policies/{param}` | `String policyId, Class responseType` | `@Nullable T` | +| `governance().policies().delete(...)` | `DELETE` | `/policies/{param}` | `String policyId, TypeReference responseType` | `@Nullable T` | +| `governance().policies().list(...)` | `GET` | `/policies` | `QueryParams query, Class responseType` | `@Nullable T` | +| `governance().policies().list(...)` | `GET` | `/policies` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `governance().policies().list(...)` | `GET` | `/policies` | `Class responseType` | `@Nullable T` | +| `governance().policies().list(...)` | `GET` | `/policies` | `TypeReference responseType` | `@Nullable T` | +| `governance().policies().get(...)` | `GET` | `/policies/{param}` | `String policyId, QueryParams query, Class responseType` | `@Nullable T` | +| `governance().policies().get(...)` | `GET` | `/policies/{param}` | `String policyId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `governance().policies().get(...)` | `GET` | `/policies/{param}` | `String policyId, Class responseType` | `@Nullable T` | +| `governance().policies().get(...)` | `GET` | `/policies/{param}` | `String policyId, TypeReference responseType` | `@Nullable T` | +| `governance().policies().create(...)` | `POST` | `/policies` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `governance().policies().create(...)` | `POST` | `/policies` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `governance().policies().create(...)` | `POST` | `/policies` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `governance().policies().create(...)` | `POST` | `/policies` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `governance().policies().createFromTemplate(...)` | `POST` | `/policies/from-template` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `governance().policies().createFromTemplate(...)` | `POST` | `/policies/from-template` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `governance().policies().createFromTemplate(...)` | `POST` | `/policies/from-template` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `governance().policies().createFromTemplate(...)` | `POST` | `/policies/from-template` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `governance().policies().validate(...)` | `POST` | `/policies/validate` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `governance().policies().validate(...)` | `POST` | `/policies/validate` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `governance().policies().validate(...)` | `POST` | `/policies/validate` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `governance().policies().validate(...)` | `POST` | `/policies/validate` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `governance().policies().update(...)` | `PUT` | `/policies/{param}` | `String policyId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `governance().policies().update(...)` | `PUT` | `/policies/{param}` | `String policyId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `governance().policies().update(...)` | `PUT` | `/policies/{param}` | `String policyId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `governance().policies().update(...)` | `PUT` | `/policies/{param}` | `String policyId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `governance().roles().delete(...)` | `DELETE` | `/roles/{param}` | `String roleId, QueryParams query, Class responseType` | `@Nullable T` | +| `governance().roles().delete(...)` | `DELETE` | `/roles/{param}` | `String roleId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `governance().roles().delete(...)` | `DELETE` | `/roles/{param}` | `String roleId, Class responseType` | `@Nullable T` | +| `governance().roles().delete(...)` | `DELETE` | `/roles/{param}` | `String roleId, TypeReference responseType` | `@Nullable T` | +| `governance().roles().list(...)` | `GET` | `/roles` | `QueryParams query, Class responseType` | `@Nullable T` | +| `governance().roles().list(...)` | `GET` | `/roles` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `governance().roles().list(...)` | `GET` | `/roles` | `Class responseType` | `@Nullable T` | +| `governance().roles().list(...)` | `GET` | `/roles` | `TypeReference responseType` | `@Nullable T` | +| `governance().roles().get(...)` | `GET` | `/roles/{param}` | `String roleId, QueryParams query, Class responseType` | `@Nullable T` | +| `governance().roles().get(...)` | `GET` | `/roles/{param}` | `String roleId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `governance().roles().get(...)` | `GET` | `/roles/{param}` | `String roleId, Class responseType` | `@Nullable T` | +| `governance().roles().get(...)` | `GET` | `/roles/{param}` | `String roleId, TypeReference responseType` | `@Nullable T` | +| `governance().roles().create(...)` | `POST` | `/roles` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `governance().roles().create(...)` | `POST` | `/roles` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `governance().roles().create(...)` | `POST` | `/roles` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `governance().roles().create(...)` | `POST` | `/roles` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `governance().compliance().assessments().list(...)` | `GET` | `/compliance/assessments` | `QueryParams query, Class responseType` | `@Nullable T` | +| `governance().compliance().assessments().list(...)` | `GET` | `/compliance/assessments` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `governance().compliance().assessments().list(...)` | `GET` | `/compliance/assessments` | `Class responseType` | `@Nullable T` | +| `governance().compliance().assessments().list(...)` | `GET` | `/compliance/assessments` | `TypeReference responseType` | `@Nullable T` | +| `governance().compliance().assessments().get(...)` | `GET` | `/compliance/assessments/{param}` | `String assessmentId, QueryParams query, Class responseType` | `@Nullable T` | +| `governance().compliance().assessments().get(...)` | `GET` | `/compliance/assessments/{param}` | `String assessmentId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `governance().compliance().assessments().get(...)` | `GET` | `/compliance/assessments/{param}` | `String assessmentId, Class responseType` | `@Nullable T` | +| `governance().compliance().assessments().get(...)` | `GET` | `/compliance/assessments/{param}` | `String assessmentId, TypeReference responseType` | `@Nullable T` | +| `governance().compliance().assessments().create(...)` | `POST` | `/compliance/assessments` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `governance().compliance().assessments().create(...)` | `POST` | `/compliance/assessments` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `governance().compliance().assessments().create(...)` | `POST` | `/compliance/assessments` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `governance().compliance().assessments().create(...)` | `POST` | `/compliance/assessments` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `governance().compliance().frameworks().list(...)` | `GET` | `/compliance/frameworks` | `QueryParams query, Class responseType` | `@Nullable T` | +| `governance().compliance().frameworks().list(...)` | `GET` | `/compliance/frameworks` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `governance().compliance().frameworks().list(...)` | `GET` | `/compliance/frameworks` | `Class responseType` | `@Nullable T` | +| `governance().compliance().frameworks().list(...)` | `GET` | `/compliance/frameworks` | `TypeReference responseType` | `@Nullable T` | +| `governance().compliance().violations().list(...)` | `GET` | `/compliance/violations` | `QueryParams query, Class responseType` | `@Nullable T` | +| `governance().compliance().violations().list(...)` | `GET` | `/compliance/violations` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `governance().compliance().violations().list(...)` | `GET` | `/compliance/violations` | `Class responseType` | `@Nullable T` | +| `governance().compliance().violations().list(...)` | `GET` | `/compliance/violations` | `TypeReference responseType` | `@Nullable T` | +| `governance().compliance().violations().resolve(...)` | `POST` | `/compliance/violations/{param}/resolve` | `String violationId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `governance().compliance().violations().resolve(...)` | `POST` | `/compliance/violations/{param}/resolve` | `String violationId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `governance().compliance().violations().resolve(...)` | `POST` | `/compliance/violations/{param}/resolve` | `String violationId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `governance().compliance().violations().resolve(...)` | `POST` | `/compliance/violations/{param}/resolve` | `String violationId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `governance().policies().templates().list(...)` | `GET` | `/policies/templates` | `QueryParams query, Class responseType` | `@Nullable T` | +| `governance().policies().templates().list(...)` | `GET` | `/policies/templates` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `governance().policies().templates().list(...)` | `GET` | `/policies/templates` | `Class responseType` | `@Nullable T` | +| `governance().policies().templates().list(...)` | `GET` | `/policies/templates` | `TypeReference responseType` | `@Nullable T` | +| `governance().policies().versions().list(...)` | `GET` | `/policies/{param}/versions` | `String policyId, QueryParams query, Class responseType` | `@Nullable T` | +| `governance().policies().versions().list(...)` | `GET` | `/policies/{param}/versions` | `String policyId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `governance().policies().versions().list(...)` | `GET` | `/policies/{param}/versions` | `String policyId, Class responseType` | `@Nullable T` | +| `governance().policies().versions().list(...)` | `GET` | `/policies/{param}/versions` | `String policyId, TypeReference responseType` | `@Nullable T` | + +The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/invocations.md b/docs/api/invocations.md new file mode 100644 index 0000000..05b04b0 --- /dev/null +++ b/docs/api/invocations.md @@ -0,0 +1,14 @@ +# Invocations API + +Service accessor: `frontal.invocations()` (`InvocationsClient`). + +Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. + +| Method | HTTP | Route | Parameters | Response | +| --- | --- | --- | --- | --- | +| `invocations().create(...)` | `POST` | `/invocations` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `invocations().create(...)` | `POST` | `/invocations` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `invocations().create(...)` | `POST` | `/invocations` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `invocations().create(...)` | `POST` | `/invocations` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | + +The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/lineage.md b/docs/api/lineage.md new file mode 100644 index 0000000..b1a38e2 --- /dev/null +++ b/docs/api/lineage.md @@ -0,0 +1,38 @@ +# Lineage API + +Service accessor: `frontal.lineage()` (`LineageClient`). + +Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. + +| Method | HTTP | Route | Parameters | Response | +| --- | --- | --- | --- | --- | +| `lineage().getGraph(...)` | `GET` | `/lineage/graph` | `QueryParams query, Class responseType` | `@Nullable T` | +| `lineage().getGraph(...)` | `GET` | `/lineage/graph` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `lineage().getGraph(...)` | `GET` | `/lineage/graph` | `Class responseType` | `@Nullable T` | +| `lineage().getGraph(...)` | `GET` | `/lineage/graph` | `TypeReference responseType` | `@Nullable T` | +| `lineage().createImpact(...)` | `POST` | `/lineage/impact` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `lineage().createImpact(...)` | `POST` | `/lineage/impact` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `lineage().createImpact(...)` | `POST` | `/lineage/impact` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `lineage().createImpact(...)` | `POST` | `/lineage/impact` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `lineage().edges().list(...)` | `GET` | `/lineage/edges` | `QueryParams query, Class responseType` | `@Nullable T` | +| `lineage().edges().list(...)` | `GET` | `/lineage/edges` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `lineage().edges().list(...)` | `GET` | `/lineage/edges` | `Class responseType` | `@Nullable T` | +| `lineage().edges().list(...)` | `GET` | `/lineage/edges` | `TypeReference responseType` | `@Nullable T` | +| `lineage().edges().get(...)` | `GET` | `/lineage/edges/{param}` | `String edgeId, QueryParams query, Class responseType` | `@Nullable T` | +| `lineage().edges().get(...)` | `GET` | `/lineage/edges/{param}` | `String edgeId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `lineage().edges().get(...)` | `GET` | `/lineage/edges/{param}` | `String edgeId, Class responseType` | `@Nullable T` | +| `lineage().edges().get(...)` | `GET` | `/lineage/edges/{param}` | `String edgeId, TypeReference responseType` | `@Nullable T` | +| `lineage().nodes().list(...)` | `GET` | `/lineage/nodes` | `QueryParams query, Class responseType` | `@Nullable T` | +| `lineage().nodes().list(...)` | `GET` | `/lineage/nodes` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `lineage().nodes().list(...)` | `GET` | `/lineage/nodes` | `Class responseType` | `@Nullable T` | +| `lineage().nodes().list(...)` | `GET` | `/lineage/nodes` | `TypeReference responseType` | `@Nullable T` | +| `lineage().nodes().get(...)` | `GET` | `/lineage/nodes/{param}` | `String nodeId, QueryParams query, Class responseType` | `@Nullable T` | +| `lineage().nodes().get(...)` | `GET` | `/lineage/nodes/{param}` | `String nodeId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `lineage().nodes().get(...)` | `GET` | `/lineage/nodes/{param}` | `String nodeId, Class responseType` | `@Nullable T` | +| `lineage().nodes().get(...)` | `GET` | `/lineage/nodes/{param}` | `String nodeId, TypeReference responseType` | `@Nullable T` | +| `lineage().nodes().getTrace(...)` | `GET` | `/lineage/nodes/{param}/trace` | `String nodeId, QueryParams query, Class responseType` | `@Nullable T` | +| `lineage().nodes().getTrace(...)` | `GET` | `/lineage/nodes/{param}/trace` | `String nodeId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `lineage().nodes().getTrace(...)` | `GET` | `/lineage/nodes/{param}/trace` | `String nodeId, Class responseType` | `@Nullable T` | +| `lineage().nodes().getTrace(...)` | `GET` | `/lineage/nodes/{param}/trace` | `String nodeId, TypeReference responseType` | `@Nullable T` | + +The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/observability.md b/docs/api/observability.md new file mode 100644 index 0000000..f897601 --- /dev/null +++ b/docs/api/observability.md @@ -0,0 +1,134 @@ +# Observability API + +Service accessor: `frontal.observability()` (`ObservabilityClient`). + +Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. + +| Method | HTTP | Route | Parameters | Response | +| --- | --- | --- | --- | --- | +| `observability().alerts().delete(...)` | `DELETE` | `/observability/alerts/{param}` | `String alertId, QueryParams query, Class responseType` | `@Nullable T` | +| `observability().alerts().delete(...)` | `DELETE` | `/observability/alerts/{param}` | `String alertId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `observability().alerts().delete(...)` | `DELETE` | `/observability/alerts/{param}` | `String alertId, Class responseType` | `@Nullable T` | +| `observability().alerts().delete(...)` | `DELETE` | `/observability/alerts/{param}` | `String alertId, TypeReference responseType` | `@Nullable T` | +| `observability().alerts().list(...)` | `GET` | `/observability/alerts` | `QueryParams query, Class responseType` | `@Nullable T` | +| `observability().alerts().list(...)` | `GET` | `/observability/alerts` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `observability().alerts().list(...)` | `GET` | `/observability/alerts` | `Class responseType` | `@Nullable T` | +| `observability().alerts().list(...)` | `GET` | `/observability/alerts` | `TypeReference responseType` | `@Nullable T` | +| `observability().alerts().create(...)` | `POST` | `/observability/alerts` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().alerts().create(...)` | `POST` | `/observability/alerts` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().alerts().create(...)` | `POST` | `/observability/alerts` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().alerts().create(...)` | `POST` | `/observability/alerts` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().alerts().disable(...)` | `POST` | `/observability/alerts/{param}/disable` | `String alertId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().alerts().disable(...)` | `POST` | `/observability/alerts/{param}/disable` | `String alertId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().alerts().disable(...)` | `POST` | `/observability/alerts/{param}/disable` | `String alertId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().alerts().disable(...)` | `POST` | `/observability/alerts/{param}/disable` | `String alertId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().alerts().enable(...)` | `POST` | `/observability/alerts/{param}/enable` | `String alertId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().alerts().enable(...)` | `POST` | `/observability/alerts/{param}/enable` | `String alertId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().alerts().enable(...)` | `POST` | `/observability/alerts/{param}/enable` | `String alertId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().alerts().enable(...)` | `POST` | `/observability/alerts/{param}/enable` | `String alertId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().alerts().update(...)` | `PUT` | `/observability/alerts/{param}` | `String alertId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().alerts().update(...)` | `PUT` | `/observability/alerts/{param}` | `String alertId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().alerts().update(...)` | `PUT` | `/observability/alerts/{param}` | `String alertId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().alerts().update(...)` | `PUT` | `/observability/alerts/{param}` | `String alertId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().dashboards().delete(...)` | `DELETE` | `/observability/dashboards/{param}` | `String dashboardId, QueryParams query, Class responseType` | `@Nullable T` | +| `observability().dashboards().delete(...)` | `DELETE` | `/observability/dashboards/{param}` | `String dashboardId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `observability().dashboards().delete(...)` | `DELETE` | `/observability/dashboards/{param}` | `String dashboardId, Class responseType` | `@Nullable T` | +| `observability().dashboards().delete(...)` | `DELETE` | `/observability/dashboards/{param}` | `String dashboardId, TypeReference responseType` | `@Nullable T` | +| `observability().dashboards().list(...)` | `GET` | `/observability/dashboards` | `QueryParams query, Class responseType` | `@Nullable T` | +| `observability().dashboards().list(...)` | `GET` | `/observability/dashboards` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `observability().dashboards().list(...)` | `GET` | `/observability/dashboards` | `Class responseType` | `@Nullable T` | +| `observability().dashboards().list(...)` | `GET` | `/observability/dashboards` | `TypeReference responseType` | `@Nullable T` | +| `observability().dashboards().get(...)` | `GET` | `/observability/dashboards/{param}` | `String dashboardId, QueryParams query, Class responseType` | `@Nullable T` | +| `observability().dashboards().get(...)` | `GET` | `/observability/dashboards/{param}` | `String dashboardId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `observability().dashboards().get(...)` | `GET` | `/observability/dashboards/{param}` | `String dashboardId, Class responseType` | `@Nullable T` | +| `observability().dashboards().get(...)` | `GET` | `/observability/dashboards/{param}` | `String dashboardId, TypeReference responseType` | `@Nullable T` | +| `observability().dashboards().create(...)` | `POST` | `/observability/dashboards` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().dashboards().create(...)` | `POST` | `/observability/dashboards` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().dashboards().create(...)` | `POST` | `/observability/dashboards` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().dashboards().create(...)` | `POST` | `/observability/dashboards` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().dashboards().share(...)` | `POST` | `/observability/dashboards/{param}/share` | `String dashboardId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().dashboards().share(...)` | `POST` | `/observability/dashboards/{param}/share` | `String dashboardId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().dashboards().share(...)` | `POST` | `/observability/dashboards/{param}/share` | `String dashboardId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().dashboards().share(...)` | `POST` | `/observability/dashboards/{param}/share` | `String dashboardId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().dashboards().update(...)` | `PUT` | `/observability/dashboards/{param}` | `String dashboardId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().dashboards().update(...)` | `PUT` | `/observability/dashboards/{param}` | `String dashboardId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().dashboards().update(...)` | `PUT` | `/observability/dashboards/{param}` | `String dashboardId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().dashboards().update(...)` | `PUT` | `/observability/dashboards/{param}` | `String dashboardId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().events().create(...)` | `POST` | `/observability/events` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().events().create(...)` | `POST` | `/observability/events` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().events().create(...)` | `POST` | `/observability/events` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().events().create(...)` | `POST` | `/observability/events` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().events().batch(...)` | `POST` | `/observability/events/batch` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().events().batch(...)` | `POST` | `/observability/events/batch` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().events().batch(...)` | `POST` | `/observability/events/batch` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().events().batch(...)` | `POST` | `/observability/events/batch` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().logs().ingest(...)` | `POST` | `/observability/logs/ingest` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().logs().ingest(...)` | `POST` | `/observability/logs/ingest` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().logs().ingest(...)` | `POST` | `/observability/logs/ingest` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().logs().ingest(...)` | `POST` | `/observability/logs/ingest` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().logs().query(...)` | `POST` | `/observability/logs/query` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().logs().query(...)` | `POST` | `/observability/logs/query` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().logs().query(...)` | `POST` | `/observability/logs/query` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().logs().query(...)` | `POST` | `/observability/logs/query` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().logs().stream(...)` | `STREAM` | `/observability/logs/stream` | `QueryParams query` | `Flow.Publisher` | +| `observability().logs().stream(...)` | `STREAM` | `/observability/logs/stream` | `` | `Flow.Publisher` | +| `observability().logs().streamBlocking(...)` | `STREAM` | `/observability/logs/stream` | `QueryParams query` | `SseEventIterator` | +| `observability().logs().streamBlocking(...)` | `STREAM` | `/observability/logs/stream` | `` | `SseEventIterator` | +| `observability().metrics().list(...)` | `GET` | `/observability/metrics` | `QueryParams query, Class responseType` | `@Nullable T` | +| `observability().metrics().list(...)` | `GET` | `/observability/metrics` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `observability().metrics().list(...)` | `GET` | `/observability/metrics` | `Class responseType` | `@Nullable T` | +| `observability().metrics().list(...)` | `GET` | `/observability/metrics` | `TypeReference responseType` | `@Nullable T` | +| `observability().metrics().getList(...)` | `GET` | `/observability/metrics/list` | `QueryParams query, Class responseType` | `@Nullable T` | +| `observability().metrics().getList(...)` | `GET` | `/observability/metrics/list` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `observability().metrics().getList(...)` | `GET` | `/observability/metrics/list` | `Class responseType` | `@Nullable T` | +| `observability().metrics().getList(...)` | `GET` | `/observability/metrics/list` | `TypeReference responseType` | `@Nullable T` | +| `observability().metrics().ingest(...)` | `POST` | `/observability/metrics/ingest` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().metrics().ingest(...)` | `POST` | `/observability/metrics/ingest` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().metrics().ingest(...)` | `POST` | `/observability/metrics/ingest` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().metrics().ingest(...)` | `POST` | `/observability/metrics/ingest` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().traces().list(...)` | `GET` | `/observability/traces` | `QueryParams query, Class responseType` | `@Nullable T` | +| `observability().traces().list(...)` | `GET` | `/observability/traces` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `observability().traces().list(...)` | `GET` | `/observability/traces` | `Class responseType` | `@Nullable T` | +| `observability().traces().list(...)` | `GET` | `/observability/traces` | `TypeReference responseType` | `@Nullable T` | +| `observability().traces().get(...)` | `GET` | `/observability/traces/{param}` | `String traceId, QueryParams query, Class responseType` | `@Nullable T` | +| `observability().traces().get(...)` | `GET` | `/observability/traces/{param}` | `String traceId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `observability().traces().get(...)` | `GET` | `/observability/traces/{param}` | `String traceId, Class responseType` | `@Nullable T` | +| `observability().traces().get(...)` | `GET` | `/observability/traces/{param}` | `String traceId, TypeReference responseType` | `@Nullable T` | +| `observability().traces().query(...)` | `POST` | `/observability/traces/query` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().traces().query(...)` | `POST` | `/observability/traces/query` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().traces().query(...)` | `POST` | `/observability/traces/query` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().traces().query(...)` | `POST` | `/observability/traces/query` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().alerts().incidents().list(...)` | `GET` | `/observability/alerts/incidents` | `QueryParams query, Class responseType` | `@Nullable T` | +| `observability().alerts().incidents().list(...)` | `GET` | `/observability/alerts/incidents` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `observability().alerts().incidents().list(...)` | `GET` | `/observability/alerts/incidents` | `Class responseType` | `@Nullable T` | +| `observability().alerts().incidents().list(...)` | `GET` | `/observability/alerts/incidents` | `TypeReference responseType` | `@Nullable T` | +| `observability().alerts().rules().delete(...)` | `DELETE` | `/observability/alerts/rules/{param}` | `String ruleId, QueryParams query, Class responseType` | `@Nullable T` | +| `observability().alerts().rules().delete(...)` | `DELETE` | `/observability/alerts/rules/{param}` | `String ruleId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `observability().alerts().rules().delete(...)` | `DELETE` | `/observability/alerts/rules/{param}` | `String ruleId, Class responseType` | `@Nullable T` | +| `observability().alerts().rules().delete(...)` | `DELETE` | `/observability/alerts/rules/{param}` | `String ruleId, TypeReference responseType` | `@Nullable T` | +| `observability().alerts().rules().list(...)` | `GET` | `/observability/alerts/rules` | `QueryParams query, Class responseType` | `@Nullable T` | +| `observability().alerts().rules().list(...)` | `GET` | `/observability/alerts/rules` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `observability().alerts().rules().list(...)` | `GET` | `/observability/alerts/rules` | `Class responseType` | `@Nullable T` | +| `observability().alerts().rules().list(...)` | `GET` | `/observability/alerts/rules` | `TypeReference responseType` | `@Nullable T` | +| `observability().alerts().rules().get(...)` | `GET` | `/observability/alerts/rules/{param}` | `String ruleId, QueryParams query, Class responseType` | `@Nullable T` | +| `observability().alerts().rules().get(...)` | `GET` | `/observability/alerts/rules/{param}` | `String ruleId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `observability().alerts().rules().get(...)` | `GET` | `/observability/alerts/rules/{param}` | `String ruleId, Class responseType` | `@Nullable T` | +| `observability().alerts().rules().get(...)` | `GET` | `/observability/alerts/rules/{param}` | `String ruleId, TypeReference responseType` | `@Nullable T` | +| `observability().alerts().rules().create(...)` | `POST` | `/observability/alerts/rules` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().alerts().rules().create(...)` | `POST` | `/observability/alerts/rules` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().alerts().rules().create(...)` | `POST` | `/observability/alerts/rules` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().alerts().rules().create(...)` | `POST` | `/observability/alerts/rules` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().alerts().rules().toggle(...)` | `POST` | `/observability/alerts/rules/{param}/toggle` | `String ruleId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().alerts().rules().toggle(...)` | `POST` | `/observability/alerts/rules/{param}/toggle` | `String ruleId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().alerts().rules().toggle(...)` | `POST` | `/observability/alerts/rules/{param}/toggle` | `String ruleId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().alerts().rules().toggle(...)` | `POST` | `/observability/alerts/rules/{param}/toggle` | `String ruleId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().alerts().rules().update(...)` | `PUT` | `/observability/alerts/rules/{param}` | `String ruleId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().alerts().rules().update(...)` | `PUT` | `/observability/alerts/rules/{param}` | `String ruleId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().alerts().rules().update(...)` | `PUT` | `/observability/alerts/rules/{param}` | `String ruleId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `observability().alerts().rules().update(...)` | `PUT` | `/observability/alerts/rules/{param}` | `String ruleId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `observability().events().stats().list(...)` | `GET` | `/observability/events/stats` | `QueryParams query, Class responseType` | `@Nullable T` | +| `observability().events().stats().list(...)` | `GET` | `/observability/events/stats` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `observability().events().stats().list(...)` | `GET` | `/observability/events/stats` | `Class responseType` | `@Nullable T` | +| `observability().events().stats().list(...)` | `GET` | `/observability/events/stats` | `TypeReference responseType` | `@Nullable T` | + +The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/ontology.md b/docs/api/ontology.md new file mode 100644 index 0000000..c431f90 --- /dev/null +++ b/docs/api/ontology.md @@ -0,0 +1,694 @@ +# Ontology API + +Service accessor: `frontal.ontology()` (`OntologyClient`). + +Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. + +| Method | HTTP | Route | Parameters | Response | +| --- | --- | --- | --- | --- | +| `ontology().engine().health(...)` | `GET` | `/ontology/engine/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().engine().health(...)` | `GET` | `/ontology/engine/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().engine().health(...)` | `GET` | `/ontology/engine/health` | `Class responseType` | `@Nullable T` | +| `ontology().engine().health(...)` | `GET` | `/ontology/engine/health` | `TypeReference responseType` | `@Nullable T` | +| `ontology().engine().getInfo(...)` | `GET` | `/ontology/engine/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().engine().getInfo(...)` | `GET` | `/ontology/engine/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().engine().getInfo(...)` | `GET` | `/ontology/engine/info` | `Class responseType` | `@Nullable T` | +| `ontology().engine().getInfo(...)` | `GET` | `/ontology/engine/info` | `TypeReference responseType` | `@Nullable T` | +| `ontology().events().health(...)` | `GET` | `/ontology/events/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().events().health(...)` | `GET` | `/ontology/events/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().events().health(...)` | `GET` | `/ontology/events/health` | `Class responseType` | `@Nullable T` | +| `ontology().events().health(...)` | `GET` | `/ontology/events/health` | `TypeReference responseType` | `@Nullable T` | +| `ontology().events().getInfo(...)` | `GET` | `/ontology/events/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().events().getInfo(...)` | `GET` | `/ontology/events/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().events().getInfo(...)` | `GET` | `/ontology/events/info` | `Class responseType` | `@Nullable T` | +| `ontology().events().getInfo(...)` | `GET` | `/ontology/events/info` | `TypeReference responseType` | `@Nullable T` | +| `ontology().extract().health(...)` | `GET` | `/ontology/extract/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().extract().health(...)` | `GET` | `/ontology/extract/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().extract().health(...)` | `GET` | `/ontology/extract/health` | `Class responseType` | `@Nullable T` | +| `ontology().extract().health(...)` | `GET` | `/ontology/extract/health` | `TypeReference responseType` | `@Nullable T` | +| `ontology().extract().getInfo(...)` | `GET` | `/ontology/extract/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().extract().getInfo(...)` | `GET` | `/ontology/extract/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().extract().getInfo(...)` | `GET` | `/ontology/extract/info` | `Class responseType` | `@Nullable T` | +| `ontology().extract().getInfo(...)` | `GET` | `/ontology/extract/info` | `TypeReference responseType` | `@Nullable T` | +| `ontology().graph().health(...)` | `GET` | `/ontology/graph/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().graph().health(...)` | `GET` | `/ontology/graph/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().health(...)` | `GET` | `/ontology/graph/health` | `Class responseType` | `@Nullable T` | +| `ontology().graph().health(...)` | `GET` | `/ontology/graph/health` | `TypeReference responseType` | `@Nullable T` | +| `ontology().graph().getInfo(...)` | `GET` | `/ontology/graph/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().graph().getInfo(...)` | `GET` | `/ontology/graph/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().getInfo(...)` | `GET` | `/ontology/graph/info` | `Class responseType` | `@Nullable T` | +| `ontology().graph().getInfo(...)` | `GET` | `/ontology/graph/info` | `TypeReference responseType` | `@Nullable T` | +| `ontology().objects().health(...)` | `GET` | `/ontology/objects/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().objects().health(...)` | `GET` | `/ontology/objects/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().objects().health(...)` | `GET` | `/ontology/objects/health` | `Class responseType` | `@Nullable T` | +| `ontology().objects().health(...)` | `GET` | `/ontology/objects/health` | `TypeReference responseType` | `@Nullable T` | +| `ontology().objects().getInfo(...)` | `GET` | `/ontology/objects/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().objects().getInfo(...)` | `GET` | `/ontology/objects/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().objects().getInfo(...)` | `GET` | `/ontology/objects/info` | `Class responseType` | `@Nullable T` | +| `ontology().objects().getInfo(...)` | `GET` | `/ontology/objects/info` | `TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().health(...)` | `GET` | `/ontology/reasoning/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().reasoning().health(...)` | `GET` | `/ontology/reasoning/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().health(...)` | `GET` | `/ontology/reasoning/health` | `Class responseType` | `@Nullable T` | +| `ontology().reasoning().health(...)` | `GET` | `/ontology/reasoning/health` | `TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().getInfo(...)` | `GET` | `/ontology/reasoning/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().reasoning().getInfo(...)` | `GET` | `/ontology/reasoning/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().getInfo(...)` | `GET` | `/ontology/reasoning/info` | `Class responseType` | `@Nullable T` | +| `ontology().reasoning().getInfo(...)` | `GET` | `/ontology/reasoning/info` | `TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().createExplain(...)` | `POST` | `/ontology/reasoning/explain` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().reasoning().createExplain(...)` | `POST` | `/ontology/reasoning/explain` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().createExplain(...)` | `POST` | `/ontology/reasoning/explain` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().reasoning().createExplain(...)` | `POST` | `/ontology/reasoning/explain` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().health(...)` | `GET` | `/ontology/relationships/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().relationships().health(...)` | `GET` | `/ontology/relationships/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().health(...)` | `GET` | `/ontology/relationships/health` | `Class responseType` | `@Nullable T` | +| `ontology().relationships().health(...)` | `GET` | `/ontology/relationships/health` | `TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().getInfo(...)` | `GET` | `/ontology/relationships/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().relationships().getInfo(...)` | `GET` | `/ontology/relationships/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().getInfo(...)` | `GET` | `/ontology/relationships/info` | `Class responseType` | `@Nullable T` | +| `ontology().relationships().getInfo(...)` | `GET` | `/ontology/relationships/info` | `TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().health(...)` | `GET` | `/ontology/rollouts/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().rollouts().health(...)` | `GET` | `/ontology/rollouts/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().health(...)` | `GET` | `/ontology/rollouts/health` | `Class responseType` | `@Nullable T` | +| `ontology().rollouts().health(...)` | `GET` | `/ontology/rollouts/health` | `TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().getInfo(...)` | `GET` | `/ontology/rollouts/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().rollouts().getInfo(...)` | `GET` | `/ontology/rollouts/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().getInfo(...)` | `GET` | `/ontology/rollouts/info` | `Class responseType` | `@Nullable T` | +| `ontology().rollouts().getInfo(...)` | `GET` | `/ontology/rollouts/info` | `TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().health(...)` | `GET` | `/ontology/rollups/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().rollups().health(...)` | `GET` | `/ontology/rollups/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().health(...)` | `GET` | `/ontology/rollups/health` | `Class responseType` | `@Nullable T` | +| `ontology().rollups().health(...)` | `GET` | `/ontology/rollups/health` | `TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().getInfo(...)` | `GET` | `/ontology/rollups/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().rollups().getInfo(...)` | `GET` | `/ontology/rollups/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().getInfo(...)` | `GET` | `/ontology/rollups/info` | `Class responseType` | `@Nullable T` | +| `ontology().rollups().getInfo(...)` | `GET` | `/ontology/rollups/info` | `TypeReference responseType` | `@Nullable T` | +| `ontology().schemas().health(...)` | `GET` | `/ontology/schemas/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().schemas().health(...)` | `GET` | `/ontology/schemas/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().schemas().health(...)` | `GET` | `/ontology/schemas/health` | `Class responseType` | `@Nullable T` | +| `ontology().schemas().health(...)` | `GET` | `/ontology/schemas/health` | `TypeReference responseType` | `@Nullable T` | +| `ontology().schemas().getInfo(...)` | `GET` | `/ontology/schemas/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().schemas().getInfo(...)` | `GET` | `/ontology/schemas/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().schemas().getInfo(...)` | `GET` | `/ontology/schemas/info` | `Class responseType` | `@Nullable T` | +| `ontology().schemas().getInfo(...)` | `GET` | `/ontology/schemas/info` | `TypeReference responseType` | `@Nullable T` | +| `ontology().transformations().health(...)` | `GET` | `/ontology/transformations/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().transformations().health(...)` | `GET` | `/ontology/transformations/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().transformations().health(...)` | `GET` | `/ontology/transformations/health` | `Class responseType` | `@Nullable T` | +| `ontology().transformations().health(...)` | `GET` | `/ontology/transformations/health` | `TypeReference responseType` | `@Nullable T` | +| `ontology().transformations().getInfo(...)` | `GET` | `/ontology/transformations/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().transformations().getInfo(...)` | `GET` | `/ontology/transformations/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().transformations().getInfo(...)` | `GET` | `/ontology/transformations/info` | `Class responseType` | `@Nullable T` | +| `ontology().transformations().getInfo(...)` | `GET` | `/ontology/transformations/info` | `TypeReference responseType` | `@Nullable T` | +| `ontology().validation().health(...)` | `GET` | `/ontology/validation/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().validation().health(...)` | `GET` | `/ontology/validation/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().validation().health(...)` | `GET` | `/ontology/validation/health` | `Class responseType` | `@Nullable T` | +| `ontology().validation().health(...)` | `GET` | `/ontology/validation/health` | `TypeReference responseType` | `@Nullable T` | +| `ontology().validation().getInfo(...)` | `GET` | `/ontology/validation/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().validation().getInfo(...)` | `GET` | `/ontology/validation/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().validation().getInfo(...)` | `GET` | `/ontology/validation/info` | `Class responseType` | `@Nullable T` | +| `ontology().validation().getInfo(...)` | `GET` | `/ontology/validation/info` | `TypeReference responseType` | `@Nullable T` | +| `ontology().versions().health(...)` | `GET` | `/ontology/versions/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().versions().health(...)` | `GET` | `/ontology/versions/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().versions().health(...)` | `GET` | `/ontology/versions/health` | `Class responseType` | `@Nullable T` | +| `ontology().versions().health(...)` | `GET` | `/ontology/versions/health` | `TypeReference responseType` | `@Nullable T` | +| `ontology().versions().getInfo(...)` | `GET` | `/ontology/versions/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().versions().getInfo(...)` | `GET` | `/ontology/versions/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().versions().getInfo(...)` | `GET` | `/ontology/versions/info` | `Class responseType` | `@Nullable T` | +| `ontology().versions().getInfo(...)` | `GET` | `/ontology/versions/info` | `TypeReference responseType` | `@Nullable T` | +| `ontology().engine().capabilities().list(...)` | `GET` | `/ontology/engine/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().engine().capabilities().list(...)` | `GET` | `/ontology/engine/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().engine().capabilities().list(...)` | `GET` | `/ontology/engine/capabilities` | `Class responseType` | `@Nullable T` | +| `ontology().engine().capabilities().list(...)` | `GET` | `/ontology/engine/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `ontology().engine().ontologies().export(...)` | `POST` | `/ontology/engine/ontologies/export` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().engine().ontologies().export(...)` | `POST` | `/ontology/engine/ontologies/export` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().engine().ontologies().export(...)` | `POST` | `/ontology/engine/ontologies/export` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().engine().ontologies().export(...)` | `POST` | `/ontology/engine/ontologies/export` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().engine().ontologies().createExportShacl(...)` | `POST` | `/ontology/engine/ontologies/export-shacl` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().engine().ontologies().createExportShacl(...)` | `POST` | `/ontology/engine/ontologies/export-shacl` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().engine().ontologies().createExportShacl(...)` | `POST` | `/ontology/engine/ontologies/export-shacl` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().engine().ontologies().createExportShacl(...)` | `POST` | `/ontology/engine/ontologies/export-shacl` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().engine().ontologies().generate(...)` | `POST` | `/ontology/engine/ontologies/generate` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().engine().ontologies().generate(...)` | `POST` | `/ontology/engine/ontologies/generate` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().engine().ontologies().generate(...)` | `POST` | `/ontology/engine/ontologies/generate` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().engine().ontologies().generate(...)` | `POST` | `/ontology/engine/ontologies/generate` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().engine().ontologies().validate(...)` | `POST` | `/ontology/engine/ontologies/validate` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().engine().ontologies().validate(...)` | `POST` | `/ontology/engine/ontologies/validate` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().engine().ontologies().validate(...)` | `POST` | `/ontology/engine/ontologies/validate` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().engine().ontologies().validate(...)` | `POST` | `/ontology/engine/ontologies/validate` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().engine().runs().list(...)` | `GET` | `/ontology/engine/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().engine().runs().list(...)` | `GET` | `/ontology/engine/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().engine().runs().list(...)` | `GET` | `/ontology/engine/runs` | `Class responseType` | `@Nullable T` | +| `ontology().engine().runs().list(...)` | `GET` | `/ontology/engine/runs` | `TypeReference responseType` | `@Nullable T` | +| `ontology().engine().runs().get(...)` | `GET` | `/ontology/engine/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().engine().runs().get(...)` | `GET` | `/ontology/engine/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().engine().runs().get(...)` | `GET` | `/ontology/engine/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `ontology().engine().runs().get(...)` | `GET` | `/ontology/engine/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `ontology().engine().runs().create(...)` | `POST` | `/ontology/engine/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().engine().runs().create(...)` | `POST` | `/ontology/engine/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().engine().runs().create(...)` | `POST` | `/ontology/engine/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().engine().runs().create(...)` | `POST` | `/ontology/engine/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().events().capabilities().list(...)` | `GET` | `/ontology/events/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().events().capabilities().list(...)` | `GET` | `/ontology/events/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().events().capabilities().list(...)` | `GET` | `/ontology/events/capabilities` | `Class responseType` | `@Nullable T` | +| `ontology().events().capabilities().list(...)` | `GET` | `/ontology/events/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `ontology().events().events().list(...)` | `GET` | `/ontology/events/events` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().events().events().list(...)` | `GET` | `/ontology/events/events` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().events().events().list(...)` | `GET` | `/ontology/events/events` | `Class responseType` | `@Nullable T` | +| `ontology().events().events().list(...)` | `GET` | `/ontology/events/events` | `TypeReference responseType` | `@Nullable T` | +| `ontology().events().events().get(...)` | `GET` | `/ontology/events/events/{param}` | `String eventId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().events().events().get(...)` | `GET` | `/ontology/events/events/{param}` | `String eventId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().events().events().get(...)` | `GET` | `/ontology/events/events/{param}` | `String eventId, Class responseType` | `@Nullable T` | +| `ontology().events().events().get(...)` | `GET` | `/ontology/events/events/{param}` | `String eventId, TypeReference responseType` | `@Nullable T` | +| `ontology().events().events().create(...)` | `POST` | `/ontology/events/events` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().events().events().create(...)` | `POST` | `/ontology/events/events` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().events().events().create(...)` | `POST` | `/ontology/events/events` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().events().events().create(...)` | `POST` | `/ontology/events/events` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().events().runs().list(...)` | `GET` | `/ontology/events/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().events().runs().list(...)` | `GET` | `/ontology/events/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().events().runs().list(...)` | `GET` | `/ontology/events/runs` | `Class responseType` | `@Nullable T` | +| `ontology().events().runs().list(...)` | `GET` | `/ontology/events/runs` | `TypeReference responseType` | `@Nullable T` | +| `ontology().events().runs().get(...)` | `GET` | `/ontology/events/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().events().runs().get(...)` | `GET` | `/ontology/events/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().events().runs().get(...)` | `GET` | `/ontology/events/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `ontology().events().runs().get(...)` | `GET` | `/ontology/events/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `ontology().events().runs().create(...)` | `POST` | `/ontology/events/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().events().runs().create(...)` | `POST` | `/ontology/events/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().events().runs().create(...)` | `POST` | `/ontology/events/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().events().runs().create(...)` | `POST` | `/ontology/events/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().extract().capabilities().list(...)` | `GET` | `/ontology/extract/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().extract().capabilities().list(...)` | `GET` | `/ontology/extract/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().extract().capabilities().list(...)` | `GET` | `/ontology/extract/capabilities` | `Class responseType` | `@Nullable T` | +| `ontology().extract().capabilities().list(...)` | `GET` | `/ontology/extract/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `ontology().extract().extract().analyze(...)` | `POST` | `/ontology/extract/extract/analyze` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().extract().extract().analyze(...)` | `POST` | `/ontology/extract/extract/analyze` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().extract().extract().analyze(...)` | `POST` | `/ontology/extract/extract/analyze` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().extract().extract().analyze(...)` | `POST` | `/ontology/extract/extract/analyze` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().extract().extract().createArchitecture(...)` | `POST` | `/ontology/extract/extract/architecture` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().extract().extract().createArchitecture(...)` | `POST` | `/ontology/extract/extract/architecture` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().extract().extract().createArchitecture(...)` | `POST` | `/ontology/extract/extract/architecture` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().extract().extract().createArchitecture(...)` | `POST` | `/ontology/extract/extract/architecture` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().extract().runs().list(...)` | `GET` | `/ontology/extract/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().extract().runs().list(...)` | `GET` | `/ontology/extract/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().extract().runs().list(...)` | `GET` | `/ontology/extract/runs` | `Class responseType` | `@Nullable T` | +| `ontology().extract().runs().list(...)` | `GET` | `/ontology/extract/runs` | `TypeReference responseType` | `@Nullable T` | +| `ontology().extract().runs().get(...)` | `GET` | `/ontology/extract/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().extract().runs().get(...)` | `GET` | `/ontology/extract/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().extract().runs().get(...)` | `GET` | `/ontology/extract/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `ontology().extract().runs().get(...)` | `GET` | `/ontology/extract/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `ontology().extract().runs().create(...)` | `POST` | `/ontology/extract/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().extract().runs().create(...)` | `POST` | `/ontology/extract/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().extract().runs().create(...)` | `POST` | `/ontology/extract/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().extract().runs().create(...)` | `POST` | `/ontology/extract/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().capabilities().list(...)` | `GET` | `/ontology/graph/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().graph().capabilities().list(...)` | `GET` | `/ontology/graph/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().capabilities().list(...)` | `GET` | `/ontology/graph/capabilities` | `Class responseType` | `@Nullable T` | +| `ontology().graph().capabilities().list(...)` | `GET` | `/ontology/graph/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `ontology().graph().entities().get(...)` | `GET` | `/ontology/graph/entities/{param}` | `String entityId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().graph().entities().get(...)` | `GET` | `/ontology/graph/entities/{param}` | `String entityId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().entities().get(...)` | `GET` | `/ontology/graph/entities/{param}` | `String entityId, Class responseType` | `@Nullable T` | +| `ontology().graph().entities().get(...)` | `GET` | `/ontology/graph/entities/{param}` | `String entityId, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().entities().getProvenance(...)` | `GET` | `/ontology/graph/entities/{param}/provenance` | `String entityId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().graph().entities().getProvenance(...)` | `GET` | `/ontology/graph/entities/{param}/provenance` | `String entityId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().entities().getProvenance(...)` | `GET` | `/ontology/graph/entities/{param}/provenance` | `String entityId, Class responseType` | `@Nullable T` | +| `ontology().graph().entities().getProvenance(...)` | `GET` | `/ontology/graph/entities/{param}/provenance` | `String entityId, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().entities().update(...)` | `PUT` | `/ontology/graph/entities/{param}` | `String entityId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().graph().entities().update(...)` | `PUT` | `/ontology/graph/entities/{param}` | `String entityId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().entities().update(...)` | `PUT` | `/ontology/graph/entities/{param}` | `String entityId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().graph().entities().update(...)` | `PUT` | `/ontology/graph/entities/{param}` | `String entityId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().graph().analyze(...)` | `POST` | `/ontology/graph/graph/analyze` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().graph().graph().analyze(...)` | `POST` | `/ontology/graph/graph/analyze` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().graph().analyze(...)` | `POST` | `/ontology/graph/graph/analyze` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().graph().graph().analyze(...)` | `POST` | `/ontology/graph/graph/analyze` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().graph().createBuild(...)` | `POST` | `/ontology/graph/graph/build` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().graph().graph().createBuild(...)` | `POST` | `/ontology/graph/graph/build` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().graph().createBuild(...)` | `POST` | `/ontology/graph/graph/build` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().graph().graph().createBuild(...)` | `POST` | `/ontology/graph/graph/build` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().graph().createBulkRead(...)` | `POST` | `/ontology/graph/graph/bulk-read` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().graph().graph().createBulkRead(...)` | `POST` | `/ontology/graph/graph/bulk-read` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().graph().createBulkRead(...)` | `POST` | `/ontology/graph/graph/bulk-read` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().graph().graph().createBulkRead(...)` | `POST` | `/ontology/graph/graph/bulk-read` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().graph().createNeighborhood(...)` | `POST` | `/ontology/graph/graph/neighborhood` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().graph().graph().createNeighborhood(...)` | `POST` | `/ontology/graph/graph/neighborhood` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().graph().createNeighborhood(...)` | `POST` | `/ontology/graph/graph/neighborhood` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().graph().graph().createNeighborhood(...)` | `POST` | `/ontology/graph/graph/neighborhood` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().graph().createPath(...)` | `POST` | `/ontology/graph/graph/path` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().graph().graph().createPath(...)` | `POST` | `/ontology/graph/graph/path` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().graph().createPath(...)` | `POST` | `/ontology/graph/graph/path` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().graph().graph().createPath(...)` | `POST` | `/ontology/graph/graph/path` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().graph().query(...)` | `POST` | `/ontology/graph/graph/query` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().graph().graph().query(...)` | `POST` | `/ontology/graph/graph/query` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().graph().query(...)` | `POST` | `/ontology/graph/graph/query` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().graph().graph().query(...)` | `POST` | `/ontology/graph/graph/query` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().relationships().get(...)` | `GET` | `/ontology/graph/relationships/{param}` | `String relationshipId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().graph().relationships().get(...)` | `GET` | `/ontology/graph/relationships/{param}` | `String relationshipId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().relationships().get(...)` | `GET` | `/ontology/graph/relationships/{param}` | `String relationshipId, Class responseType` | `@Nullable T` | +| `ontology().graph().relationships().get(...)` | `GET` | `/ontology/graph/relationships/{param}` | `String relationshipId, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().relationships().update(...)` | `PUT` | `/ontology/graph/relationships/{param}` | `String relationshipId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().graph().relationships().update(...)` | `PUT` | `/ontology/graph/relationships/{param}` | `String relationshipId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().relationships().update(...)` | `PUT` | `/ontology/graph/relationships/{param}` | `String relationshipId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().graph().relationships().update(...)` | `PUT` | `/ontology/graph/relationships/{param}` | `String relationshipId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().runs().list(...)` | `GET` | `/ontology/graph/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().graph().runs().list(...)` | `GET` | `/ontology/graph/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().runs().list(...)` | `GET` | `/ontology/graph/runs` | `Class responseType` | `@Nullable T` | +| `ontology().graph().runs().list(...)` | `GET` | `/ontology/graph/runs` | `TypeReference responseType` | `@Nullable T` | +| `ontology().graph().runs().get(...)` | `GET` | `/ontology/graph/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().graph().runs().get(...)` | `GET` | `/ontology/graph/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().runs().get(...)` | `GET` | `/ontology/graph/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `ontology().graph().runs().get(...)` | `GET` | `/ontology/graph/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().runs().create(...)` | `POST` | `/ontology/graph/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().graph().runs().create(...)` | `POST` | `/ontology/graph/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().graph().runs().create(...)` | `POST` | `/ontology/graph/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().graph().runs().create(...)` | `POST` | `/ontology/graph/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().objects().capabilities().list(...)` | `GET` | `/ontology/objects/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().objects().capabilities().list(...)` | `GET` | `/ontology/objects/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().objects().capabilities().list(...)` | `GET` | `/ontology/objects/capabilities` | `Class responseType` | `@Nullable T` | +| `ontology().objects().capabilities().list(...)` | `GET` | `/ontology/objects/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `ontology().objects().objectTypes().delete(...)` | `DELETE` | `/ontology/objects/object-types/{param}` | `String objectTypeId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().objects().objectTypes().delete(...)` | `DELETE` | `/ontology/objects/object-types/{param}` | `String objectTypeId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().objects().objectTypes().delete(...)` | `DELETE` | `/ontology/objects/object-types/{param}` | `String objectTypeId, Class responseType` | `@Nullable T` | +| `ontology().objects().objectTypes().delete(...)` | `DELETE` | `/ontology/objects/object-types/{param}` | `String objectTypeId, TypeReference responseType` | `@Nullable T` | +| `ontology().objects().objectTypes().list(...)` | `GET` | `/ontology/objects/object-types` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().objects().objectTypes().list(...)` | `GET` | `/ontology/objects/object-types` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().objects().objectTypes().list(...)` | `GET` | `/ontology/objects/object-types` | `Class responseType` | `@Nullable T` | +| `ontology().objects().objectTypes().list(...)` | `GET` | `/ontology/objects/object-types` | `TypeReference responseType` | `@Nullable T` | +| `ontology().objects().objectTypes().get(...)` | `GET` | `/ontology/objects/object-types/{param}` | `String objectTypeId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().objects().objectTypes().get(...)` | `GET` | `/ontology/objects/object-types/{param}` | `String objectTypeId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().objects().objectTypes().get(...)` | `GET` | `/ontology/objects/object-types/{param}` | `String objectTypeId, Class responseType` | `@Nullable T` | +| `ontology().objects().objectTypes().get(...)` | `GET` | `/ontology/objects/object-types/{param}` | `String objectTypeId, TypeReference responseType` | `@Nullable T` | +| `ontology().objects().objectTypes().update(...)` | `PUT` | `/ontology/objects/object-types/{param}` | `String objectTypeId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().objects().objectTypes().update(...)` | `PUT` | `/ontology/objects/object-types/{param}` | `String objectTypeId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().objects().objectTypes().update(...)` | `PUT` | `/ontology/objects/object-types/{param}` | `String objectTypeId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().objects().objectTypes().update(...)` | `PUT` | `/ontology/objects/object-types/{param}` | `String objectTypeId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().objects().objects().delete(...)` | `DELETE` | `/ontology/objects/objects/{param}` | `String objectId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().objects().objects().delete(...)` | `DELETE` | `/ontology/objects/objects/{param}` | `String objectId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().objects().objects().delete(...)` | `DELETE` | `/ontology/objects/objects/{param}` | `String objectId, Class responseType` | `@Nullable T` | +| `ontology().objects().objects().delete(...)` | `DELETE` | `/ontology/objects/objects/{param}` | `String objectId, TypeReference responseType` | `@Nullable T` | +| `ontology().objects().objects().list(...)` | `GET` | `/ontology/objects/objects` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().objects().objects().list(...)` | `GET` | `/ontology/objects/objects` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().objects().objects().list(...)` | `GET` | `/ontology/objects/objects` | `Class responseType` | `@Nullable T` | +| `ontology().objects().objects().list(...)` | `GET` | `/ontology/objects/objects` | `TypeReference responseType` | `@Nullable T` | +| `ontology().objects().objects().get(...)` | `GET` | `/ontology/objects/objects/{param}` | `String objectId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().objects().objects().get(...)` | `GET` | `/ontology/objects/objects/{param}` | `String objectId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().objects().objects().get(...)` | `GET` | `/ontology/objects/objects/{param}` | `String objectId, Class responseType` | `@Nullable T` | +| `ontology().objects().objects().get(...)` | `GET` | `/ontology/objects/objects/{param}` | `String objectId, TypeReference responseType` | `@Nullable T` | +| `ontology().objects().objects().update(...)` | `PUT` | `/ontology/objects/objects/{param}` | `String objectId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().objects().objects().update(...)` | `PUT` | `/ontology/objects/objects/{param}` | `String objectId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().objects().objects().update(...)` | `PUT` | `/ontology/objects/objects/{param}` | `String objectId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().objects().objects().update(...)` | `PUT` | `/ontology/objects/objects/{param}` | `String objectId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().objects().runs().list(...)` | `GET` | `/ontology/objects/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().objects().runs().list(...)` | `GET` | `/ontology/objects/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().objects().runs().list(...)` | `GET` | `/ontology/objects/runs` | `Class responseType` | `@Nullable T` | +| `ontology().objects().runs().list(...)` | `GET` | `/ontology/objects/runs` | `TypeReference responseType` | `@Nullable T` | +| `ontology().objects().runs().get(...)` | `GET` | `/ontology/objects/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().objects().runs().get(...)` | `GET` | `/ontology/objects/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().objects().runs().get(...)` | `GET` | `/ontology/objects/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `ontology().objects().runs().get(...)` | `GET` | `/ontology/objects/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `ontology().objects().runs().create(...)` | `POST` | `/ontology/objects/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().objects().runs().create(...)` | `POST` | `/ontology/objects/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().objects().runs().create(...)` | `POST` | `/ontology/objects/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().objects().runs().create(...)` | `POST` | `/ontology/objects/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().capabilities().list(...)` | `GET` | `/ontology/reasoning/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().reasoning().capabilities().list(...)` | `GET` | `/ontology/reasoning/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().capabilities().list(...)` | `GET` | `/ontology/reasoning/capabilities` | `Class responseType` | `@Nullable T` | +| `ontology().reasoning().capabilities().list(...)` | `GET` | `/ontology/reasoning/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().facts().create(...)` | `POST` | `/ontology/reasoning/facts` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().reasoning().facts().create(...)` | `POST` | `/ontology/reasoning/facts` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().facts().create(...)` | `POST` | `/ontology/reasoning/facts` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().reasoning().facts().create(...)` | `POST` | `/ontology/reasoning/facts` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().facts().createLoadGraph(...)` | `POST` | `/ontology/reasoning/facts/load-graph` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().reasoning().facts().createLoadGraph(...)` | `POST` | `/ontology/reasoning/facts/load-graph` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().facts().createLoadGraph(...)` | `POST` | `/ontology/reasoning/facts/load-graph` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().reasoning().facts().createLoadGraph(...)` | `POST` | `/ontology/reasoning/facts/load-graph` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().reason().createBackward(...)` | `POST` | `/ontology/reasoning/reason/backward` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().reasoning().reason().createBackward(...)` | `POST` | `/ontology/reasoning/reason/backward` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().reason().createBackward(...)` | `POST` | `/ontology/reasoning/reason/backward` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().reasoning().reason().createBackward(...)` | `POST` | `/ontology/reasoning/reason/backward` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().reason().createForward(...)` | `POST` | `/ontology/reasoning/reason/forward` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().reasoning().reason().createForward(...)` | `POST` | `/ontology/reasoning/reason/forward` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().reason().createForward(...)` | `POST` | `/ontology/reasoning/reason/forward` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().reasoning().reason().createForward(...)` | `POST` | `/ontology/reasoning/reason/forward` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().rules().delete(...)` | `DELETE` | `/ontology/reasoning/rules/{param}` | `String ruleId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().reasoning().rules().delete(...)` | `DELETE` | `/ontology/reasoning/rules/{param}` | `String ruleId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().rules().delete(...)` | `DELETE` | `/ontology/reasoning/rules/{param}` | `String ruleId, Class responseType` | `@Nullable T` | +| `ontology().reasoning().rules().delete(...)` | `DELETE` | `/ontology/reasoning/rules/{param}` | `String ruleId, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().rules().list(...)` | `GET` | `/ontology/reasoning/rules` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().reasoning().rules().list(...)` | `GET` | `/ontology/reasoning/rules` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().rules().list(...)` | `GET` | `/ontology/reasoning/rules` | `Class responseType` | `@Nullable T` | +| `ontology().reasoning().rules().list(...)` | `GET` | `/ontology/reasoning/rules` | `TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().rules().create(...)` | `POST` | `/ontology/reasoning/rules` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().reasoning().rules().create(...)` | `POST` | `/ontology/reasoning/rules` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().rules().create(...)` | `POST` | `/ontology/reasoning/rules` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().reasoning().rules().create(...)` | `POST` | `/ontology/reasoning/rules` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().rules().update(...)` | `PUT` | `/ontology/reasoning/rules/{param}` | `String ruleId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().reasoning().rules().update(...)` | `PUT` | `/ontology/reasoning/rules/{param}` | `String ruleId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().rules().update(...)` | `PUT` | `/ontology/reasoning/rules/{param}` | `String ruleId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().reasoning().rules().update(...)` | `PUT` | `/ontology/reasoning/rules/{param}` | `String ruleId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().runs().list(...)` | `GET` | `/ontology/reasoning/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().reasoning().runs().list(...)` | `GET` | `/ontology/reasoning/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().runs().list(...)` | `GET` | `/ontology/reasoning/runs` | `Class responseType` | `@Nullable T` | +| `ontology().reasoning().runs().list(...)` | `GET` | `/ontology/reasoning/runs` | `TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().runs().get(...)` | `GET` | `/ontology/reasoning/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().reasoning().runs().get(...)` | `GET` | `/ontology/reasoning/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().runs().get(...)` | `GET` | `/ontology/reasoning/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `ontology().reasoning().runs().get(...)` | `GET` | `/ontology/reasoning/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().runs().create(...)` | `POST` | `/ontology/reasoning/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().reasoning().runs().create(...)` | `POST` | `/ontology/reasoning/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().reasoning().runs().create(...)` | `POST` | `/ontology/reasoning/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().reasoning().runs().create(...)` | `POST` | `/ontology/reasoning/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().capabilities().list(...)` | `GET` | `/ontology/relationships/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().relationships().capabilities().list(...)` | `GET` | `/ontology/relationships/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().capabilities().list(...)` | `GET` | `/ontology/relationships/capabilities` | `Class responseType` | `@Nullable T` | +| `ontology().relationships().capabilities().list(...)` | `GET` | `/ontology/relationships/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().relationshipTypes().delete(...)` | `DELETE` | `/ontology/relationships/relationship-types/{param}` | `String relationshipTypeId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().relationships().relationshipTypes().delete(...)` | `DELETE` | `/ontology/relationships/relationship-types/{param}` | `String relationshipTypeId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().relationshipTypes().delete(...)` | `DELETE` | `/ontology/relationships/relationship-types/{param}` | `String relationshipTypeId, Class responseType` | `@Nullable T` | +| `ontology().relationships().relationshipTypes().delete(...)` | `DELETE` | `/ontology/relationships/relationship-types/{param}` | `String relationshipTypeId, TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().relationshipTypes().list(...)` | `GET` | `/ontology/relationships/relationship-types` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().relationships().relationshipTypes().list(...)` | `GET` | `/ontology/relationships/relationship-types` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().relationshipTypes().list(...)` | `GET` | `/ontology/relationships/relationship-types` | `Class responseType` | `@Nullable T` | +| `ontology().relationships().relationshipTypes().list(...)` | `GET` | `/ontology/relationships/relationship-types` | `TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().relationships().delete(...)` | `DELETE` | `/ontology/relationships/relationships/{param}` | `String relationshipId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().relationships().relationships().delete(...)` | `DELETE` | `/ontology/relationships/relationships/{param}` | `String relationshipId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().relationships().delete(...)` | `DELETE` | `/ontology/relationships/relationships/{param}` | `String relationshipId, Class responseType` | `@Nullable T` | +| `ontology().relationships().relationships().delete(...)` | `DELETE` | `/ontology/relationships/relationships/{param}` | `String relationshipId, TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().relationships().list(...)` | `GET` | `/ontology/relationships/relationships` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().relationships().relationships().list(...)` | `GET` | `/ontology/relationships/relationships` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().relationships().list(...)` | `GET` | `/ontology/relationships/relationships` | `Class responseType` | `@Nullable T` | +| `ontology().relationships().relationships().list(...)` | `GET` | `/ontology/relationships/relationships` | `TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().relationships().get(...)` | `GET` | `/ontology/relationships/relationships/{param}` | `String relationshipId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().relationships().relationships().get(...)` | `GET` | `/ontology/relationships/relationships/{param}` | `String relationshipId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().relationships().get(...)` | `GET` | `/ontology/relationships/relationships/{param}` | `String relationshipId, Class responseType` | `@Nullable T` | +| `ontology().relationships().relationships().get(...)` | `GET` | `/ontology/relationships/relationships/{param}` | `String relationshipId, TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().relationships().update(...)` | `PUT` | `/ontology/relationships/relationships/{param}` | `String relationshipId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().relationships().relationships().update(...)` | `PUT` | `/ontology/relationships/relationships/{param}` | `String relationshipId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().relationships().update(...)` | `PUT` | `/ontology/relationships/relationships/{param}` | `String relationshipId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().relationships().relationships().update(...)` | `PUT` | `/ontology/relationships/relationships/{param}` | `String relationshipId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().runs().list(...)` | `GET` | `/ontology/relationships/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().relationships().runs().list(...)` | `GET` | `/ontology/relationships/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().runs().list(...)` | `GET` | `/ontology/relationships/runs` | `Class responseType` | `@Nullable T` | +| `ontology().relationships().runs().list(...)` | `GET` | `/ontology/relationships/runs` | `TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().runs().get(...)` | `GET` | `/ontology/relationships/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().relationships().runs().get(...)` | `GET` | `/ontology/relationships/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().runs().get(...)` | `GET` | `/ontology/relationships/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `ontology().relationships().runs().get(...)` | `GET` | `/ontology/relationships/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().runs().create(...)` | `POST` | `/ontology/relationships/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().relationships().runs().create(...)` | `POST` | `/ontology/relationships/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().relationships().runs().create(...)` | `POST` | `/ontology/relationships/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().relationships().runs().create(...)` | `POST` | `/ontology/relationships/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().capabilities().list(...)` | `GET` | `/ontology/rollouts/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().rollouts().capabilities().list(...)` | `GET` | `/ontology/rollouts/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().capabilities().list(...)` | `GET` | `/ontology/rollouts/capabilities` | `Class responseType` | `@Nullable T` | +| `ontology().rollouts().capabilities().list(...)` | `GET` | `/ontology/rollouts/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().delete(...)` | `DELETE` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().delete(...)` | `DELETE` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().delete(...)` | `DELETE` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, Class responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().delete(...)` | `DELETE` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().list(...)` | `GET` | `/ontology/rollouts/rollouts` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().list(...)` | `GET` | `/ontology/rollouts/rollouts` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().list(...)` | `GET` | `/ontology/rollouts/rollouts` | `Class responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().list(...)` | `GET` | `/ontology/rollouts/rollouts` | `TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().get(...)` | `GET` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().get(...)` | `GET` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().get(...)` | `GET` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, Class responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().get(...)` | `GET` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().status(...)` | `GET` | `/ontology/rollouts/rollouts/{param}/status` | `String rolloutId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().status(...)` | `GET` | `/ontology/rollouts/rollouts/{param}/status` | `String rolloutId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().status(...)` | `GET` | `/ontology/rollouts/rollouts/{param}/status` | `String rolloutId, Class responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().status(...)` | `GET` | `/ontology/rollouts/rollouts/{param}/status` | `String rolloutId, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().create(...)` | `POST` | `/ontology/rollouts/rollouts` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().create(...)` | `POST` | `/ontology/rollouts/rollouts` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().create(...)` | `POST` | `/ontology/rollouts/rollouts` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().create(...)` | `POST` | `/ontology/rollouts/rollouts` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().pause(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/pause` | `String rolloutId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().pause(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/pause` | `String rolloutId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().pause(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/pause` | `String rolloutId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().pause(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/pause` | `String rolloutId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().resume(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/resume` | `String rolloutId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().resume(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/resume` | `String rolloutId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().resume(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/resume` | `String rolloutId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().resume(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/resume` | `String rolloutId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().rollback(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/rollback` | `String rolloutId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().rollback(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/rollback` | `String rolloutId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().rollback(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/rollback` | `String rolloutId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().rollback(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/rollback` | `String rolloutId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().createStart(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/start` | `String rolloutId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().createStart(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/start` | `String rolloutId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().createStart(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/start` | `String rolloutId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().createStart(...)` | `POST` | `/ontology/rollouts/rollouts/{param}/start` | `String rolloutId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().update(...)` | `PUT` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().update(...)` | `PUT` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().update(...)` | `PUT` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollouts().rollouts().update(...)` | `PUT` | `/ontology/rollouts/rollouts/{param}` | `String rolloutId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().runs().list(...)` | `GET` | `/ontology/rollouts/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().rollouts().runs().list(...)` | `GET` | `/ontology/rollouts/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().runs().list(...)` | `GET` | `/ontology/rollouts/runs` | `Class responseType` | `@Nullable T` | +| `ontology().rollouts().runs().list(...)` | `GET` | `/ontology/rollouts/runs` | `TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().runs().get(...)` | `GET` | `/ontology/rollouts/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().rollouts().runs().get(...)` | `GET` | `/ontology/rollouts/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().runs().get(...)` | `GET` | `/ontology/rollouts/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `ontology().rollouts().runs().get(...)` | `GET` | `/ontology/rollouts/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().runs().create(...)` | `POST` | `/ontology/rollouts/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollouts().runs().create(...)` | `POST` | `/ontology/rollouts/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollouts().runs().create(...)` | `POST` | `/ontology/rollouts/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollouts().runs().create(...)` | `POST` | `/ontology/rollouts/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().capabilities().list(...)` | `GET` | `/ontology/rollups/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().rollups().capabilities().list(...)` | `GET` | `/ontology/rollups/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().capabilities().list(...)` | `GET` | `/ontology/rollups/capabilities` | `Class responseType` | `@Nullable T` | +| `ontology().rollups().capabilities().list(...)` | `GET` | `/ontology/rollups/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().rollupResults().get(...)` | `GET` | `/ontology/rollups/rollup-results/{param}` | `String executionId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().rollups().rollupResults().get(...)` | `GET` | `/ontology/rollups/rollup-results/{param}` | `String executionId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().rollupResults().get(...)` | `GET` | `/ontology/rollups/rollup-results/{param}` | `String executionId, Class responseType` | `@Nullable T` | +| `ontology().rollups().rollupResults().get(...)` | `GET` | `/ontology/rollups/rollup-results/{param}` | `String executionId, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().rollups().delete(...)` | `DELETE` | `/ontology/rollups/rollups/{param}` | `String rollupId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().rollups().rollups().delete(...)` | `DELETE` | `/ontology/rollups/rollups/{param}` | `String rollupId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().rollups().delete(...)` | `DELETE` | `/ontology/rollups/rollups/{param}` | `String rollupId, Class responseType` | `@Nullable T` | +| `ontology().rollups().rollups().delete(...)` | `DELETE` | `/ontology/rollups/rollups/{param}` | `String rollupId, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().rollups().list(...)` | `GET` | `/ontology/rollups/rollups` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().rollups().rollups().list(...)` | `GET` | `/ontology/rollups/rollups` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().rollups().list(...)` | `GET` | `/ontology/rollups/rollups` | `Class responseType` | `@Nullable T` | +| `ontology().rollups().rollups().list(...)` | `GET` | `/ontology/rollups/rollups` | `TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().rollups().get(...)` | `GET` | `/ontology/rollups/rollups/{param}` | `String rollupId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().rollups().rollups().get(...)` | `GET` | `/ontology/rollups/rollups/{param}` | `String rollupId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().rollups().get(...)` | `GET` | `/ontology/rollups/rollups/{param}` | `String rollupId, Class responseType` | `@Nullable T` | +| `ontology().rollups().rollups().get(...)` | `GET` | `/ontology/rollups/rollups/{param}` | `String rollupId, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().rollups().getResult(...)` | `GET` | `/ontology/rollups/rollups/{param}/result` | `String rollupId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().rollups().rollups().getResult(...)` | `GET` | `/ontology/rollups/rollups/{param}/result` | `String rollupId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().rollups().getResult(...)` | `GET` | `/ontology/rollups/rollups/{param}/result` | `String rollupId, Class responseType` | `@Nullable T` | +| `ontology().rollups().rollups().getResult(...)` | `GET` | `/ontology/rollups/rollups/{param}/result` | `String rollupId, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().rollups().create(...)` | `POST` | `/ontology/rollups/rollups` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollups().rollups().create(...)` | `POST` | `/ontology/rollups/rollups` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().rollups().create(...)` | `POST` | `/ontology/rollups/rollups` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollups().rollups().create(...)` | `POST` | `/ontology/rollups/rollups` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().rollups().execute(...)` | `POST` | `/ontology/rollups/rollups/{param}/execute` | `String rollupId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollups().rollups().execute(...)` | `POST` | `/ontology/rollups/rollups/{param}/execute` | `String rollupId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().rollups().execute(...)` | `POST` | `/ontology/rollups/rollups/{param}/execute` | `String rollupId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollups().rollups().execute(...)` | `POST` | `/ontology/rollups/rollups/{param}/execute` | `String rollupId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().rollups().preview(...)` | `POST` | `/ontology/rollups/rollups/{param}/preview` | `String rollupId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollups().rollups().preview(...)` | `POST` | `/ontology/rollups/rollups/{param}/preview` | `String rollupId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().rollups().preview(...)` | `POST` | `/ontology/rollups/rollups/{param}/preview` | `String rollupId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollups().rollups().preview(...)` | `POST` | `/ontology/rollups/rollups/{param}/preview` | `String rollupId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().rollups().update(...)` | `PUT` | `/ontology/rollups/rollups/{param}` | `String rollupId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollups().rollups().update(...)` | `PUT` | `/ontology/rollups/rollups/{param}` | `String rollupId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().rollups().update(...)` | `PUT` | `/ontology/rollups/rollups/{param}` | `String rollupId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollups().rollups().update(...)` | `PUT` | `/ontology/rollups/rollups/{param}` | `String rollupId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().runs().list(...)` | `GET` | `/ontology/rollups/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().rollups().runs().list(...)` | `GET` | `/ontology/rollups/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().runs().list(...)` | `GET` | `/ontology/rollups/runs` | `Class responseType` | `@Nullable T` | +| `ontology().rollups().runs().list(...)` | `GET` | `/ontology/rollups/runs` | `TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().runs().get(...)` | `GET` | `/ontology/rollups/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().rollups().runs().get(...)` | `GET` | `/ontology/rollups/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().runs().get(...)` | `GET` | `/ontology/rollups/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `ontology().rollups().runs().get(...)` | `GET` | `/ontology/rollups/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().runs().create(...)` | `POST` | `/ontology/rollups/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollups().runs().create(...)` | `POST` | `/ontology/rollups/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().rollups().runs().create(...)` | `POST` | `/ontology/rollups/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().rollups().runs().create(...)` | `POST` | `/ontology/rollups/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().schemas().capabilities().list(...)` | `GET` | `/ontology/schemas/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().schemas().capabilities().list(...)` | `GET` | `/ontology/schemas/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().schemas().capabilities().list(...)` | `GET` | `/ontology/schemas/capabilities` | `Class responseType` | `@Nullable T` | +| `ontology().schemas().capabilities().list(...)` | `GET` | `/ontology/schemas/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `ontology().schemas().runs().list(...)` | `GET` | `/ontology/schemas/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().schemas().runs().list(...)` | `GET` | `/ontology/schemas/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().schemas().runs().list(...)` | `GET` | `/ontology/schemas/runs` | `Class responseType` | `@Nullable T` | +| `ontology().schemas().runs().list(...)` | `GET` | `/ontology/schemas/runs` | `TypeReference responseType` | `@Nullable T` | +| `ontology().schemas().runs().get(...)` | `GET` | `/ontology/schemas/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().schemas().runs().get(...)` | `GET` | `/ontology/schemas/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().schemas().runs().get(...)` | `GET` | `/ontology/schemas/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `ontology().schemas().runs().get(...)` | `GET` | `/ontology/schemas/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `ontology().schemas().runs().create(...)` | `POST` | `/ontology/schemas/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().schemas().runs().create(...)` | `POST` | `/ontology/schemas/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().schemas().runs().create(...)` | `POST` | `/ontology/schemas/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().schemas().runs().create(...)` | `POST` | `/ontology/schemas/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().schemas().schemas().delete(...)` | `DELETE` | `/ontology/schemas/schemas/{param}` | `String schemaId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().schemas().schemas().delete(...)` | `DELETE` | `/ontology/schemas/schemas/{param}` | `String schemaId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().schemas().schemas().delete(...)` | `DELETE` | `/ontology/schemas/schemas/{param}` | `String schemaId, Class responseType` | `@Nullable T` | +| `ontology().schemas().schemas().delete(...)` | `DELETE` | `/ontology/schemas/schemas/{param}` | `String schemaId, TypeReference responseType` | `@Nullable T` | +| `ontology().schemas().schemas().list(...)` | `GET` | `/ontology/schemas/schemas` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().schemas().schemas().list(...)` | `GET` | `/ontology/schemas/schemas` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().schemas().schemas().list(...)` | `GET` | `/ontology/schemas/schemas` | `Class responseType` | `@Nullable T` | +| `ontology().schemas().schemas().list(...)` | `GET` | `/ontology/schemas/schemas` | `TypeReference responseType` | `@Nullable T` | +| `ontology().schemas().schemas().get(...)` | `GET` | `/ontology/schemas/schemas/{param}` | `String schemaId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().schemas().schemas().get(...)` | `GET` | `/ontology/schemas/schemas/{param}` | `String schemaId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().schemas().schemas().get(...)` | `GET` | `/ontology/schemas/schemas/{param}` | `String schemaId, Class responseType` | `@Nullable T` | +| `ontology().schemas().schemas().get(...)` | `GET` | `/ontology/schemas/schemas/{param}` | `String schemaId, TypeReference responseType` | `@Nullable T` | +| `ontology().schemas().schemas().create(...)` | `POST` | `/ontology/schemas/schemas` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().schemas().schemas().create(...)` | `POST` | `/ontology/schemas/schemas` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().schemas().schemas().create(...)` | `POST` | `/ontology/schemas/schemas` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().schemas().schemas().create(...)` | `POST` | `/ontology/schemas/schemas` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().schemas().schemas().validate(...)` | `POST` | `/ontology/schemas/schemas/validate` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().schemas().schemas().validate(...)` | `POST` | `/ontology/schemas/schemas/validate` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().schemas().schemas().validate(...)` | `POST` | `/ontology/schemas/schemas/validate` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().schemas().schemas().validate(...)` | `POST` | `/ontology/schemas/schemas/validate` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().transformations().capabilities().list(...)` | `GET` | `/ontology/transformations/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().transformations().capabilities().list(...)` | `GET` | `/ontology/transformations/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().transformations().capabilities().list(...)` | `GET` | `/ontology/transformations/capabilities` | `Class responseType` | `@Nullable T` | +| `ontology().transformations().capabilities().list(...)` | `GET` | `/ontology/transformations/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `ontology().transformations().runs().list(...)` | `GET` | `/ontology/transformations/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().transformations().runs().list(...)` | `GET` | `/ontology/transformations/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().transformations().runs().list(...)` | `GET` | `/ontology/transformations/runs` | `Class responseType` | `@Nullable T` | +| `ontology().transformations().runs().list(...)` | `GET` | `/ontology/transformations/runs` | `TypeReference responseType` | `@Nullable T` | +| `ontology().transformations().runs().get(...)` | `GET` | `/ontology/transformations/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().transformations().runs().get(...)` | `GET` | `/ontology/transformations/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().transformations().runs().get(...)` | `GET` | `/ontology/transformations/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `ontology().transformations().runs().get(...)` | `GET` | `/ontology/transformations/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `ontology().transformations().runs().create(...)` | `POST` | `/ontology/transformations/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().transformations().runs().create(...)` | `POST` | `/ontology/transformations/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().transformations().runs().create(...)` | `POST` | `/ontology/transformations/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().transformations().runs().create(...)` | `POST` | `/ontology/transformations/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().transformations().transformations().create(...)` | `POST` | `/ontology/transformations/transformations` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().transformations().transformations().create(...)` | `POST` | `/ontology/transformations/transformations` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().transformations().transformations().create(...)` | `POST` | `/ontology/transformations/transformations` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().transformations().transformations().create(...)` | `POST` | `/ontology/transformations/transformations` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().validation().capabilities().list(...)` | `GET` | `/ontology/validation/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().validation().capabilities().list(...)` | `GET` | `/ontology/validation/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().validation().capabilities().list(...)` | `GET` | `/ontology/validation/capabilities` | `Class responseType` | `@Nullable T` | +| `ontology().validation().capabilities().list(...)` | `GET` | `/ontology/validation/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `ontology().validation().payloads().validate(...)` | `POST` | `/ontology/validation/payloads/validate` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().validation().payloads().validate(...)` | `POST` | `/ontology/validation/payloads/validate` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().validation().payloads().validate(...)` | `POST` | `/ontology/validation/payloads/validate` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().validation().payloads().validate(...)` | `POST` | `/ontology/validation/payloads/validate` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().validation().rules().delete(...)` | `DELETE` | `/ontology/validation/rules/{param}` | `String ruleId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().validation().rules().delete(...)` | `DELETE` | `/ontology/validation/rules/{param}` | `String ruleId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().validation().rules().delete(...)` | `DELETE` | `/ontology/validation/rules/{param}` | `String ruleId, Class responseType` | `@Nullable T` | +| `ontology().validation().rules().delete(...)` | `DELETE` | `/ontology/validation/rules/{param}` | `String ruleId, TypeReference responseType` | `@Nullable T` | +| `ontology().validation().rules().list(...)` | `GET` | `/ontology/validation/rules` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().validation().rules().list(...)` | `GET` | `/ontology/validation/rules` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().validation().rules().list(...)` | `GET` | `/ontology/validation/rules` | `Class responseType` | `@Nullable T` | +| `ontology().validation().rules().list(...)` | `GET` | `/ontology/validation/rules` | `TypeReference responseType` | `@Nullable T` | +| `ontology().validation().rules().get(...)` | `GET` | `/ontology/validation/rules/{param}` | `String ruleId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().validation().rules().get(...)` | `GET` | `/ontology/validation/rules/{param}` | `String ruleId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().validation().rules().get(...)` | `GET` | `/ontology/validation/rules/{param}` | `String ruleId, Class responseType` | `@Nullable T` | +| `ontology().validation().rules().get(...)` | `GET` | `/ontology/validation/rules/{param}` | `String ruleId, TypeReference responseType` | `@Nullable T` | +| `ontology().validation().rules().create(...)` | `POST` | `/ontology/validation/rules` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().validation().rules().create(...)` | `POST` | `/ontology/validation/rules` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().validation().rules().create(...)` | `POST` | `/ontology/validation/rules` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().validation().rules().create(...)` | `POST` | `/ontology/validation/rules` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().validation().runs().list(...)` | `GET` | `/ontology/validation/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().validation().runs().list(...)` | `GET` | `/ontology/validation/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().validation().runs().list(...)` | `GET` | `/ontology/validation/runs` | `Class responseType` | `@Nullable T` | +| `ontology().validation().runs().list(...)` | `GET` | `/ontology/validation/runs` | `TypeReference responseType` | `@Nullable T` | +| `ontology().validation().runs().get(...)` | `GET` | `/ontology/validation/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().validation().runs().get(...)` | `GET` | `/ontology/validation/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().validation().runs().get(...)` | `GET` | `/ontology/validation/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `ontology().validation().runs().get(...)` | `GET` | `/ontology/validation/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `ontology().validation().runs().create(...)` | `POST` | `/ontology/validation/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().validation().runs().create(...)` | `POST` | `/ontology/validation/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().validation().runs().create(...)` | `POST` | `/ontology/validation/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().validation().runs().create(...)` | `POST` | `/ontology/validation/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().versions().audit().verify(...)` | `POST` | `/ontology/versions/audit/verify` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().versions().audit().verify(...)` | `POST` | `/ontology/versions/audit/verify` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().versions().audit().verify(...)` | `POST` | `/ontology/versions/audit/verify` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().versions().audit().verify(...)` | `POST` | `/ontology/versions/audit/verify` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().versions().capabilities().list(...)` | `GET` | `/ontology/versions/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().versions().capabilities().list(...)` | `GET` | `/ontology/versions/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().versions().capabilities().list(...)` | `GET` | `/ontology/versions/capabilities` | `Class responseType` | `@Nullable T` | +| `ontology().versions().capabilities().list(...)` | `GET` | `/ontology/versions/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `ontology().versions().releaseBundles().list(...)` | `GET` | `/ontology/versions/release-bundles` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().versions().releaseBundles().list(...)` | `GET` | `/ontology/versions/release-bundles` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().versions().releaseBundles().list(...)` | `GET` | `/ontology/versions/release-bundles` | `Class responseType` | `@Nullable T` | +| `ontology().versions().releaseBundles().list(...)` | `GET` | `/ontology/versions/release-bundles` | `TypeReference responseType` | `@Nullable T` | +| `ontology().versions().releaseBundles().get(...)` | `GET` | `/ontology/versions/release-bundles/{param}` | `String bundleId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().versions().releaseBundles().get(...)` | `GET` | `/ontology/versions/release-bundles/{param}` | `String bundleId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().versions().releaseBundles().get(...)` | `GET` | `/ontology/versions/release-bundles/{param}` | `String bundleId, Class responseType` | `@Nullable T` | +| `ontology().versions().releaseBundles().get(...)` | `GET` | `/ontology/versions/release-bundles/{param}` | `String bundleId, TypeReference responseType` | `@Nullable T` | +| `ontology().versions().releaseBundles().create(...)` | `POST` | `/ontology/versions/release-bundles` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().versions().releaseBundles().create(...)` | `POST` | `/ontology/versions/release-bundles` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().versions().releaseBundles().create(...)` | `POST` | `/ontology/versions/release-bundles` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().versions().releaseBundles().create(...)` | `POST` | `/ontology/versions/release-bundles` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().versions().runs().list(...)` | `GET` | `/ontology/versions/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().versions().runs().list(...)` | `GET` | `/ontology/versions/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().versions().runs().list(...)` | `GET` | `/ontology/versions/runs` | `Class responseType` | `@Nullable T` | +| `ontology().versions().runs().list(...)` | `GET` | `/ontology/versions/runs` | `TypeReference responseType` | `@Nullable T` | +| `ontology().versions().runs().get(...)` | `GET` | `/ontology/versions/runs/{param}` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().versions().runs().get(...)` | `GET` | `/ontology/versions/runs/{param}` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().versions().runs().get(...)` | `GET` | `/ontology/versions/runs/{param}` | `String runId, Class responseType` | `@Nullable T` | +| `ontology().versions().runs().get(...)` | `GET` | `/ontology/versions/runs/{param}` | `String runId, TypeReference responseType` | `@Nullable T` | +| `ontology().versions().runs().create(...)` | `POST` | `/ontology/versions/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().versions().runs().create(...)` | `POST` | `/ontology/versions/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().versions().runs().create(...)` | `POST` | `/ontology/versions/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().versions().runs().create(...)` | `POST` | `/ontology/versions/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().versions().versions().delete(...)` | `DELETE` | `/ontology/versions/versions/{param}` | `String versionId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().versions().versions().delete(...)` | `DELETE` | `/ontology/versions/versions/{param}` | `String versionId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().versions().versions().delete(...)` | `DELETE` | `/ontology/versions/versions/{param}` | `String versionId, Class responseType` | `@Nullable T` | +| `ontology().versions().versions().delete(...)` | `DELETE` | `/ontology/versions/versions/{param}` | `String versionId, TypeReference responseType` | `@Nullable T` | +| `ontology().versions().versions().get(...)` | `GET` | `/ontology/versions/versions/{param}` | `String versionId, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().versions().versions().get(...)` | `GET` | `/ontology/versions/versions/{param}` | `String versionId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().versions().versions().get(...)` | `GET` | `/ontology/versions/versions/{param}` | `String versionId, Class responseType` | `@Nullable T` | +| `ontology().versions().versions().get(...)` | `GET` | `/ontology/versions/versions/{param}` | `String versionId, TypeReference responseType` | `@Nullable T` | +| `ontology().versions().versions().create(...)` | `POST` | `/ontology/versions/versions` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().versions().versions().create(...)` | `POST` | `/ontology/versions/versions` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().versions().versions().create(...)` | `POST` | `/ontology/versions/versions` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().versions().versions().create(...)` | `POST` | `/ontology/versions/versions` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().versions().versions().compare(...)` | `POST` | `/ontology/versions/versions/compare` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().versions().versions().compare(...)` | `POST` | `/ontology/versions/versions/compare` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().versions().versions().compare(...)` | `POST` | `/ontology/versions/versions/compare` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().versions().versions().compare(...)` | `POST` | `/ontology/versions/versions/compare` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().engine().ontologies().compareVersions().create(...)` | `POST` | `/ontology/engine/ontologies/compare-versions` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().engine().ontologies().compareVersions().create(...)` | `POST` | `/ontology/engine/ontologies/compare-versions` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().engine().ontologies().compareVersions().create(...)` | `POST` | `/ontology/engine/ontologies/compare-versions` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().engine().ontologies().compareVersions().create(...)` | `POST` | `/ontology/engine/ontologies/compare-versions` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().engine().ontologies().inferClasses().create(...)` | `POST` | `/ontology/engine/ontologies/infer-classes` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().engine().ontologies().inferClasses().create(...)` | `POST` | `/ontology/engine/ontologies/infer-classes` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().engine().ontologies().inferClasses().create(...)` | `POST` | `/ontology/engine/ontologies/infer-classes` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().engine().ontologies().inferClasses().create(...)` | `POST` | `/ontology/engine/ontologies/infer-classes` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().engine().ontologies().inferProperties().create(...)` | `POST` | `/ontology/engine/ontologies/infer-properties` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().engine().ontologies().inferProperties().create(...)` | `POST` | `/ontology/engine/ontologies/infer-properties` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().engine().ontologies().inferProperties().create(...)` | `POST` | `/ontology/engine/ontologies/infer-properties` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().engine().ontologies().inferProperties().create(...)` | `POST` | `/ontology/engine/ontologies/infer-properties` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().events().events().checkpoints().get(...)` | `GET` | `/ontology/events/events/checkpoints/{param}` | `String consumer, QueryParams query, Class responseType` | `@Nullable T` | +| `ontology().events().events().checkpoints().get(...)` | `GET` | `/ontology/events/events/checkpoints/{param}` | `String consumer, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `ontology().events().events().checkpoints().get(...)` | `GET` | `/ontology/events/events/checkpoints/{param}` | `String consumer, Class responseType` | `@Nullable T` | +| `ontology().events().events().checkpoints().get(...)` | `GET` | `/ontology/events/events/checkpoints/{param}` | `String consumer, TypeReference responseType` | `@Nullable T` | +| `ontology().events().events().checkpoints().create(...)` | `POST` | `/ontology/events/events/checkpoints` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().events().events().checkpoints().create(...)` | `POST` | `/ontology/events/events/checkpoints` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().events().events().checkpoints().create(...)` | `POST` | `/ontology/events/events/checkpoints` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().events().events().checkpoints().create(...)` | `POST` | `/ontology/events/events/checkpoints` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().events().events().leases().acknowledge(...)` | `POST` | `/ontology/events/events/leases/acknowledge` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().events().events().leases().acknowledge(...)` | `POST` | `/ontology/events/events/leases/acknowledge` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().events().events().leases().acknowledge(...)` | `POST` | `/ontology/events/events/leases/acknowledge` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().events().events().leases().acknowledge(...)` | `POST` | `/ontology/events/events/leases/acknowledge` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().events().events().leases().acquire(...)` | `POST` | `/ontology/events/events/leases/acquire` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().events().events().leases().acquire(...)` | `POST` | `/ontology/events/events/leases/acquire` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().events().events().leases().acquire(...)` | `POST` | `/ontology/events/events/leases/acquire` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().events().events().leases().acquire(...)` | `POST` | `/ontology/events/events/leases/acquire` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().extract().extract().coreferences().create(...)` | `POST` | `/ontology/extract/extract/coreferences` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().extract().extract().coreferences().create(...)` | `POST` | `/ontology/extract/extract/coreferences` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().extract().extract().coreferences().create(...)` | `POST` | `/ontology/extract/extract/coreferences` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().extract().extract().coreferences().create(...)` | `POST` | `/ontology/extract/extract/coreferences` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().extract().extract().entities().create(...)` | `POST` | `/ontology/extract/extract/entities` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().extract().extract().entities().create(...)` | `POST` | `/ontology/extract/extract/entities` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().extract().extract().entities().create(...)` | `POST` | `/ontology/extract/extract/entities` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().extract().extract().entities().create(...)` | `POST` | `/ontology/extract/extract/entities` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().extract().extract().events().create(...)` | `POST` | `/ontology/extract/extract/events` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().extract().extract().events().create(...)` | `POST` | `/ontology/extract/extract/events` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().extract().extract().events().create(...)` | `POST` | `/ontology/extract/extract/events` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().extract().extract().events().create(...)` | `POST` | `/ontology/extract/extract/events` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().extract().extract().relations().create(...)` | `POST` | `/ontology/extract/extract/relations` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().extract().extract().relations().create(...)` | `POST` | `/ontology/extract/extract/relations` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().extract().extract().relations().create(...)` | `POST` | `/ontology/extract/extract/relations` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().extract().extract().relations().create(...)` | `POST` | `/ontology/extract/extract/relations` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().extract().extract().triplets().create(...)` | `POST` | `/ontology/extract/extract/triplets` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().extract().extract().triplets().create(...)` | `POST` | `/ontology/extract/extract/triplets` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `ontology().extract().extract().triplets().create(...)` | `POST` | `/ontology/extract/extract/triplets` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `ontology().extract().extract().triplets().create(...)` | `POST` | `/ontology/extract/extract/triplets` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | + +The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/pipelines.md b/docs/api/pipelines.md new file mode 100644 index 0000000..fa36e66 --- /dev/null +++ b/docs/api/pipelines.md @@ -0,0 +1,54 @@ +# Pipelines API + +Service accessor: `frontal.pipelines()` (`PipelinesClient`). + +Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. + +| Method | HTTP | Route | Parameters | Response | +| --- | --- | --- | --- | --- | +| `pipelines().data().pipelines().health(...)` | `GET` | `/data/pipelines/health` | `QueryParams query, Class responseType` | `@Nullable T` | +| `pipelines().data().pipelines().health(...)` | `GET` | `/data/pipelines/health` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `pipelines().data().pipelines().health(...)` | `GET` | `/data/pipelines/health` | `Class responseType` | `@Nullable T` | +| `pipelines().data().pipelines().health(...)` | `GET` | `/data/pipelines/health` | `TypeReference responseType` | `@Nullable T` | +| `pipelines().data().pipelines().getInfo(...)` | `GET` | `/data/pipelines/info` | `QueryParams query, Class responseType` | `@Nullable T` | +| `pipelines().data().pipelines().getInfo(...)` | `GET` | `/data/pipelines/info` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `pipelines().data().pipelines().getInfo(...)` | `GET` | `/data/pipelines/info` | `Class responseType` | `@Nullable T` | +| `pipelines().data().pipelines().getInfo(...)` | `GET` | `/data/pipelines/info` | `TypeReference responseType` | `@Nullable T` | +| `pipelines().data().pipelines().capabilities().list(...)` | `GET` | `/data/pipelines/capabilities` | `QueryParams query, Class responseType` | `@Nullable T` | +| `pipelines().data().pipelines().capabilities().list(...)` | `GET` | `/data/pipelines/capabilities` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `pipelines().data().pipelines().capabilities().list(...)` | `GET` | `/data/pipelines/capabilities` | `Class responseType` | `@Nullable T` | +| `pipelines().data().pipelines().capabilities().list(...)` | `GET` | `/data/pipelines/capabilities` | `TypeReference responseType` | `@Nullable T` | +| `pipelines().data().pipelines().pipelineRuns().list(...)` | `GET` | `/data/pipelines/pipeline-runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `pipelines().data().pipelines().pipelineRuns().list(...)` | `GET` | `/data/pipelines/pipeline-runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `pipelines().data().pipelines().pipelineRuns().list(...)` | `GET` | `/data/pipelines/pipeline-runs` | `Class responseType` | `@Nullable T` | +| `pipelines().data().pipelines().pipelineRuns().list(...)` | `GET` | `/data/pipelines/pipeline-runs` | `TypeReference responseType` | `@Nullable T` | +| `pipelines().data().pipelines().pipelineRuns().get(...)` | `GET` | `/data/pipelines/pipeline-runs/{param}` | `String pipelineRunId, QueryParams query, Class responseType` | `@Nullable T` | +| `pipelines().data().pipelines().pipelineRuns().get(...)` | `GET` | `/data/pipelines/pipeline-runs/{param}` | `String pipelineRunId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `pipelines().data().pipelines().pipelineRuns().get(...)` | `GET` | `/data/pipelines/pipeline-runs/{param}` | `String pipelineRunId, Class responseType` | `@Nullable T` | +| `pipelines().data().pipelines().pipelineRuns().get(...)` | `GET` | `/data/pipelines/pipeline-runs/{param}` | `String pipelineRunId, TypeReference responseType` | `@Nullable T` | +| `pipelines().data().pipelines().pipelineRuns().get2(...)` | `STREAM` | `/data/pipelines/pipeline-runs/{param}` | `String pipelineRunId, QueryParams query` | `Flow.Publisher` | +| `pipelines().data().pipelines().pipelineRuns().get2(...)` | `STREAM` | `/data/pipelines/pipeline-runs/{param}` | `String pipelineRunId` | `Flow.Publisher` | +| `pipelines().data().pipelines().pipelineRuns().get2Blocking(...)` | `STREAM` | `/data/pipelines/pipeline-runs/{param}` | `String pipelineRunId, QueryParams query` | `SseEventIterator` | +| `pipelines().data().pipelines().pipelineRuns().get2Blocking(...)` | `STREAM` | `/data/pipelines/pipeline-runs/{param}` | `String pipelineRunId` | `SseEventIterator` | +| `pipelines().data().pipelines().pipelines().list(...)` | `GET` | `/data/pipelines/pipelines` | `QueryParams query, Class responseType` | `@Nullable T` | +| `pipelines().data().pipelines().pipelines().list(...)` | `GET` | `/data/pipelines/pipelines` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `pipelines().data().pipelines().pipelines().list(...)` | `GET` | `/data/pipelines/pipelines` | `Class responseType` | `@Nullable T` | +| `pipelines().data().pipelines().pipelines().list(...)` | `GET` | `/data/pipelines/pipelines` | `TypeReference responseType` | `@Nullable T` | +| `pipelines().data().pipelines().pipelines().get(...)` | `GET` | `/data/pipelines/pipelines/{param}` | `String pipelineId, QueryParams query, Class responseType` | `@Nullable T` | +| `pipelines().data().pipelines().pipelines().get(...)` | `GET` | `/data/pipelines/pipelines/{param}` | `String pipelineId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `pipelines().data().pipelines().pipelines().get(...)` | `GET` | `/data/pipelines/pipelines/{param}` | `String pipelineId, Class responseType` | `@Nullable T` | +| `pipelines().data().pipelines().pipelines().get(...)` | `GET` | `/data/pipelines/pipelines/{param}` | `String pipelineId, TypeReference responseType` | `@Nullable T` | +| `pipelines().data().pipelines().pipelines().create(...)` | `POST` | `/data/pipelines/pipelines` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `pipelines().data().pipelines().pipelines().create(...)` | `POST` | `/data/pipelines/pipelines` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `pipelines().data().pipelines().pipelines().create(...)` | `POST` | `/data/pipelines/pipelines` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `pipelines().data().pipelines().pipelines().create(...)` | `POST` | `/data/pipelines/pipelines` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `pipelines().data().pipelines().runs().list(...)` | `GET` | `/data/pipelines/runs` | `QueryParams query, Class responseType` | `@Nullable T` | +| `pipelines().data().pipelines().runs().list(...)` | `GET` | `/data/pipelines/runs` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `pipelines().data().pipelines().runs().list(...)` | `GET` | `/data/pipelines/runs` | `Class responseType` | `@Nullable T` | +| `pipelines().data().pipelines().runs().list(...)` | `GET` | `/data/pipelines/runs` | `TypeReference responseType` | `@Nullable T` | +| `pipelines().data().pipelines().runs().create(...)` | `POST` | `/data/pipelines/runs` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `pipelines().data().pipelines().runs().create(...)` | `POST` | `/data/pipelines/runs` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `pipelines().data().pipelines().runs().create(...)` | `POST` | `/data/pipelines/runs` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `pipelines().data().pipelines().runs().create(...)` | `POST` | `/data/pipelines/runs` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | + +The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/providers.md b/docs/api/providers.md new file mode 100644 index 0000000..406f7c8 --- /dev/null +++ b/docs/api/providers.md @@ -0,0 +1,14 @@ +# Providers API + +Service accessor: `frontal.providers()` (`ProvidersClient`). + +Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. + +| Method | HTTP | Route | Parameters | Response | +| --- | --- | --- | --- | --- | +| `providers().get(...)` | `GET` | `/providers/{param}` | `String providerSlug, QueryParams query, Class responseType` | `@Nullable T` | +| `providers().get(...)` | `GET` | `/providers/{param}` | `String providerSlug, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `providers().get(...)` | `GET` | `/providers/{param}` | `String providerSlug, Class responseType` | `@Nullable T` | +| `providers().get(...)` | `GET` | `/providers/{param}` | `String providerSlug, TypeReference responseType` | `@Nullable T` | + +The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/react.md b/docs/api/react.md new file mode 100644 index 0000000..2cbf34e --- /dev/null +++ b/docs/api/react.md @@ -0,0 +1,10 @@ +# React API + +Service accessor: `frontal.react()` (`ReactClient`). + +Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. + +| Method | HTTP | Route | Parameters | Response | +| --- | --- | --- | --- | --- | + +The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/schedules.md b/docs/api/schedules.md new file mode 100644 index 0000000..5249f9d --- /dev/null +++ b/docs/api/schedules.md @@ -0,0 +1,50 @@ +# Schedules API + +Service accessor: `frontal.schedules()` (`SchedulesClient`). + +Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. + +| Method | HTTP | Route | Parameters | Response | +| --- | --- | --- | --- | --- | +| `schedules().workflows().cron().parse(...)` | `POST` | `/workflows/cron/parse` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `schedules().workflows().cron().parse(...)` | `POST` | `/workflows/cron/parse` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `schedules().workflows().cron().parse(...)` | `POST` | `/workflows/cron/parse` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `schedules().workflows().cron().parse(...)` | `POST` | `/workflows/cron/parse` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `schedules().workflows().cron().validate(...)` | `POST` | `/workflows/cron/validate` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `schedules().workflows().cron().validate(...)` | `POST` | `/workflows/cron/validate` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `schedules().workflows().cron().validate(...)` | `POST` | `/workflows/cron/validate` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `schedules().workflows().cron().validate(...)` | `POST` | `/workflows/cron/validate` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `schedules().workflows().schedules().delete(...)` | `DELETE` | `/workflows/schedules/{param}` | `String scheduleId, QueryParams query, Class responseType` | `@Nullable T` | +| `schedules().workflows().schedules().delete(...)` | `DELETE` | `/workflows/schedules/{param}` | `String scheduleId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `schedules().workflows().schedules().delete(...)` | `DELETE` | `/workflows/schedules/{param}` | `String scheduleId, Class responseType` | `@Nullable T` | +| `schedules().workflows().schedules().delete(...)` | `DELETE` | `/workflows/schedules/{param}` | `String scheduleId, TypeReference responseType` | `@Nullable T` | +| `schedules().workflows().schedules().list(...)` | `GET` | `/workflows/schedules` | `QueryParams query, Class responseType` | `@Nullable T` | +| `schedules().workflows().schedules().list(...)` | `GET` | `/workflows/schedules` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `schedules().workflows().schedules().list(...)` | `GET` | `/workflows/schedules` | `Class responseType` | `@Nullable T` | +| `schedules().workflows().schedules().list(...)` | `GET` | `/workflows/schedules` | `TypeReference responseType` | `@Nullable T` | +| `schedules().workflows().schedules().get(...)` | `GET` | `/workflows/schedules/{param}` | `String scheduleId, QueryParams query, Class responseType` | `@Nullable T` | +| `schedules().workflows().schedules().get(...)` | `GET` | `/workflows/schedules/{param}` | `String scheduleId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `schedules().workflows().schedules().get(...)` | `GET` | `/workflows/schedules/{param}` | `String scheduleId, Class responseType` | `@Nullable T` | +| `schedules().workflows().schedules().get(...)` | `GET` | `/workflows/schedules/{param}` | `String scheduleId, TypeReference responseType` | `@Nullable T` | +| `schedules().workflows().schedules().update(...)` | `PATCH` | `/workflows/schedules/{param}` | `String scheduleId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `schedules().workflows().schedules().update(...)` | `PATCH` | `/workflows/schedules/{param}` | `String scheduleId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `schedules().workflows().schedules().update(...)` | `PATCH` | `/workflows/schedules/{param}` | `String scheduleId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `schedules().workflows().schedules().update(...)` | `PATCH` | `/workflows/schedules/{param}` | `String scheduleId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `schedules().workflows().schedules().create(...)` | `POST` | `/workflows/schedules` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `schedules().workflows().schedules().create(...)` | `POST` | `/workflows/schedules` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `schedules().workflows().schedules().create(...)` | `POST` | `/workflows/schedules` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `schedules().workflows().schedules().create(...)` | `POST` | `/workflows/schedules` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `schedules().workflows().schedules().pause(...)` | `POST` | `/workflows/schedules/{param}/pause` | `String scheduleId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `schedules().workflows().schedules().pause(...)` | `POST` | `/workflows/schedules/{param}/pause` | `String scheduleId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `schedules().workflows().schedules().pause(...)` | `POST` | `/workflows/schedules/{param}/pause` | `String scheduleId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `schedules().workflows().schedules().pause(...)` | `POST` | `/workflows/schedules/{param}/pause` | `String scheduleId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `schedules().workflows().schedules().resume(...)` | `POST` | `/workflows/schedules/{param}/resume` | `String scheduleId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `schedules().workflows().schedules().resume(...)` | `POST` | `/workflows/schedules/{param}/resume` | `String scheduleId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `schedules().workflows().schedules().resume(...)` | `POST` | `/workflows/schedules/{param}/resume` | `String scheduleId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `schedules().workflows().schedules().resume(...)` | `POST` | `/workflows/schedules/{param}/resume` | `String scheduleId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `schedules().workflows().schedules().trigger(...)` | `POST` | `/workflows/schedules/{param}/trigger` | `String scheduleId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `schedules().workflows().schedules().trigger(...)` | `POST` | `/workflows/schedules/{param}/trigger` | `String scheduleId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `schedules().workflows().schedules().trigger(...)` | `POST` | `/workflows/schedules/{param}/trigger` | `String scheduleId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `schedules().workflows().schedules().trigger(...)` | `POST` | `/workflows/schedules/{param}/trigger` | `String scheduleId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | + +The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/webhook-endpoints.md b/docs/api/webhook-endpoints.md new file mode 100644 index 0000000..f7e03db --- /dev/null +++ b/docs/api/webhook-endpoints.md @@ -0,0 +1,38 @@ +# WebhookEndpoints API + +Service accessor: `frontal.webhookEndpoints()` (`WebhookEndpointsClient`). + +Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. + +| Method | HTTP | Route | Parameters | Response | +| --- | --- | --- | --- | --- | +| `webhookEndpoints().delete(...)` | `DELETE` | `/webhook-endpoints/{param}` | `String id, QueryParams query, Class responseType` | `@Nullable T` | +| `webhookEndpoints().delete(...)` | `DELETE` | `/webhook-endpoints/{param}` | `String id, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `webhookEndpoints().delete(...)` | `DELETE` | `/webhook-endpoints/{param}` | `String id, Class responseType` | `@Nullable T` | +| `webhookEndpoints().delete(...)` | `DELETE` | `/webhook-endpoints/{param}` | `String id, TypeReference responseType` | `@Nullable T` | +| `webhookEndpoints().list(...)` | `GET` | `/webhook-endpoints` | `QueryParams query, Class responseType` | `@Nullable T` | +| `webhookEndpoints().list(...)` | `GET` | `/webhook-endpoints` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `webhookEndpoints().list(...)` | `GET` | `/webhook-endpoints` | `Class responseType` | `@Nullable T` | +| `webhookEndpoints().list(...)` | `GET` | `/webhook-endpoints` | `TypeReference responseType` | `@Nullable T` | +| `webhookEndpoints().get(...)` | `GET` | `/webhook-endpoints/{param}` | `String id, QueryParams query, Class responseType` | `@Nullable T` | +| `webhookEndpoints().get(...)` | `GET` | `/webhook-endpoints/{param}` | `String id, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `webhookEndpoints().get(...)` | `GET` | `/webhook-endpoints/{param}` | `String id, Class responseType` | `@Nullable T` | +| `webhookEndpoints().get(...)` | `GET` | `/webhook-endpoints/{param}` | `String id, TypeReference responseType` | `@Nullable T` | +| `webhookEndpoints().update(...)` | `PATCH` | `/webhook-endpoints/{param}` | `String id, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `webhookEndpoints().update(...)` | `PATCH` | `/webhook-endpoints/{param}` | `String id, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `webhookEndpoints().update(...)` | `PATCH` | `/webhook-endpoints/{param}` | `String id, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `webhookEndpoints().update(...)` | `PATCH` | `/webhook-endpoints/{param}` | `String id, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `webhookEndpoints().create(...)` | `POST` | `/webhook-endpoints` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `webhookEndpoints().create(...)` | `POST` | `/webhook-endpoints` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `webhookEndpoints().create(...)` | `POST` | `/webhook-endpoints` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `webhookEndpoints().create(...)` | `POST` | `/webhook-endpoints` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `webhookEndpoints().rotateSecret(...)` | `POST` | `/webhook-endpoints/{param}/rotate-secret` | `String id, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `webhookEndpoints().rotateSecret(...)` | `POST` | `/webhook-endpoints/{param}/rotate-secret` | `String id, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `webhookEndpoints().rotateSecret(...)` | `POST` | `/webhook-endpoints/{param}/rotate-secret` | `String id, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `webhookEndpoints().rotateSecret(...)` | `POST` | `/webhook-endpoints/{param}/rotate-secret` | `String id, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `webhookEndpoints().deliveries().list(...)` | `GET` | `/webhook-endpoints/{param}/deliveries` | `String id, QueryParams query, Class responseType` | `@Nullable T` | +| `webhookEndpoints().deliveries().list(...)` | `GET` | `/webhook-endpoints/{param}/deliveries` | `String id, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `webhookEndpoints().deliveries().list(...)` | `GET` | `/webhook-endpoints/{param}/deliveries` | `String id, Class responseType` | `@Nullable T` | +| `webhookEndpoints().deliveries().list(...)` | `GET` | `/webhook-endpoints/{param}/deliveries` | `String id, TypeReference responseType` | `@Nullable T` | + +The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/webhooks.md b/docs/api/webhooks.md new file mode 100644 index 0000000..3a38565 --- /dev/null +++ b/docs/api/webhooks.md @@ -0,0 +1,50 @@ +# Webhooks API + +Service accessor: `frontal.webhooks()` (`WebhooksClient`). + +Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. + +| Method | HTTP | Route | Parameters | Response | +| --- | --- | --- | --- | --- | +| `webhooks().delete(...)` | `DELETE` | `/webhooks/{param}` | `String webhookId, QueryParams query, Class responseType` | `@Nullable T` | +| `webhooks().delete(...)` | `DELETE` | `/webhooks/{param}` | `String webhookId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `webhooks().delete(...)` | `DELETE` | `/webhooks/{param}` | `String webhookId, Class responseType` | `@Nullable T` | +| `webhooks().delete(...)` | `DELETE` | `/webhooks/{param}` | `String webhookId, TypeReference responseType` | `@Nullable T` | +| `webhooks().list(...)` | `GET` | `/webhooks` | `QueryParams query, Class responseType` | `@Nullable T` | +| `webhooks().list(...)` | `GET` | `/webhooks` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `webhooks().list(...)` | `GET` | `/webhooks` | `Class responseType` | `@Nullable T` | +| `webhooks().list(...)` | `GET` | `/webhooks` | `TypeReference responseType` | `@Nullable T` | +| `webhooks().get(...)` | `GET` | `/webhooks/{param}` | `String webhookId, QueryParams query, Class responseType` | `@Nullable T` | +| `webhooks().get(...)` | `GET` | `/webhooks/{param}` | `String webhookId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `webhooks().get(...)` | `GET` | `/webhooks/{param}` | `String webhookId, Class responseType` | `@Nullable T` | +| `webhooks().get(...)` | `GET` | `/webhooks/{param}` | `String webhookId, TypeReference responseType` | `@Nullable T` | +| `webhooks().create(...)` | `POST` | `/webhooks` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `webhooks().create(...)` | `POST` | `/webhooks` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `webhooks().create(...)` | `POST` | `/webhooks` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `webhooks().create(...)` | `POST` | `/webhooks` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `webhooks().rotateSecret(...)` | `POST` | `/webhooks/{param}/rotate-secret` | `String webhookId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `webhooks().rotateSecret(...)` | `POST` | `/webhooks/{param}/rotate-secret` | `String webhookId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `webhooks().rotateSecret(...)` | `POST` | `/webhooks/{param}/rotate-secret` | `String webhookId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `webhooks().rotateSecret(...)` | `POST` | `/webhooks/{param}/rotate-secret` | `String webhookId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `webhooks().update(...)` | `PUT` | `/webhooks/{param}` | `String webhookId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `webhooks().update(...)` | `PUT` | `/webhooks/{param}` | `String webhookId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `webhooks().update(...)` | `PUT` | `/webhooks/{param}` | `String webhookId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `webhooks().update(...)` | `PUT` | `/webhooks/{param}` | `String webhookId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `webhooks().deliveries().list(...)` | `GET` | `/webhooks/deliveries` | `QueryParams query, Class responseType` | `@Nullable T` | +| `webhooks().deliveries().list(...)` | `GET` | `/webhooks/deliveries` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `webhooks().deliveries().list(...)` | `GET` | `/webhooks/deliveries` | `Class responseType` | `@Nullable T` | +| `webhooks().deliveries().list(...)` | `GET` | `/webhooks/deliveries` | `TypeReference responseType` | `@Nullable T` | +| `webhooks().deliveries().get(...)` | `GET` | `/webhooks/deliveries/{param}` | `String deliveryId, QueryParams query, Class responseType` | `@Nullable T` | +| `webhooks().deliveries().get(...)` | `GET` | `/webhooks/deliveries/{param}` | `String deliveryId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `webhooks().deliveries().get(...)` | `GET` | `/webhooks/deliveries/{param}` | `String deliveryId, Class responseType` | `@Nullable T` | +| `webhooks().deliveries().get(...)` | `GET` | `/webhooks/deliveries/{param}` | `String deliveryId, TypeReference responseType` | `@Nullable T` | +| `webhooks().deliveries().retry(...)` | `POST` | `/webhooks/deliveries/{param}/retry` | `String deliveryId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `webhooks().deliveries().retry(...)` | `POST` | `/webhooks/deliveries/{param}/retry` | `String deliveryId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `webhooks().deliveries().retry(...)` | `POST` | `/webhooks/deliveries/{param}/retry` | `String deliveryId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `webhooks().deliveries().retry(...)` | `POST` | `/webhooks/deliveries/{param}/retry` | `String deliveryId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `webhooks().stats().list(...)` | `GET` | `/webhooks/stats` | `QueryParams query, Class responseType` | `@Nullable T` | +| `webhooks().stats().list(...)` | `GET` | `/webhooks/stats` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `webhooks().stats().list(...)` | `GET` | `/webhooks/stats` | `Class responseType` | `@Nullable T` | +| `webhooks().stats().list(...)` | `GET` | `/webhooks/stats` | `TypeReference responseType` | `@Nullable T` | + +The generic `request(...)` methods and `Endpoints` constants remain available. diff --git a/docs/api/workflows.md b/docs/api/workflows.md new file mode 100644 index 0000000..281d069 --- /dev/null +++ b/docs/api/workflows.md @@ -0,0 +1,130 @@ +# Workflows API + +Service accessor: `frontal.workflows()` (`WorkflowsServiceClient`). + +Operations are grouped by resource path. Collection methods use `list` and `create`; item methods use `get`, `update`, and `delete`. Calls can omit `QueryParams` when no query values are needed. Use contract-defined `JsonNode` bodies and caller-selected response types where schemas are not available. + +| Method | HTTP | Route | Parameters | Response | +| --- | --- | --- | --- | --- | +| `workflows().delete(...)` | `DELETE` | `/workflows/{param}` | `String workflowId, QueryParams query, Class responseType` | `@Nullable T` | +| `workflows().delete(...)` | `DELETE` | `/workflows/{param}` | `String workflowId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `workflows().delete(...)` | `DELETE` | `/workflows/{param}` | `String workflowId, Class responseType` | `@Nullable T` | +| `workflows().delete(...)` | `DELETE` | `/workflows/{param}` | `String workflowId, TypeReference responseType` | `@Nullable T` | +| `workflows().list(...)` | `GET` | `/workflows` | `QueryParams query, Class responseType` | `@Nullable T` | +| `workflows().list(...)` | `GET` | `/workflows` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `workflows().list(...)` | `GET` | `/workflows` | `Class responseType` | `@Nullable T` | +| `workflows().list(...)` | `GET` | `/workflows` | `TypeReference responseType` | `@Nullable T` | +| `workflows().get(...)` | `GET` | `/workflows/{param}` | `String workflowId, QueryParams query, Class responseType` | `@Nullable T` | +| `workflows().get(...)` | `GET` | `/workflows/{param}` | `String workflowId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `workflows().get(...)` | `GET` | `/workflows/{param}` | `String workflowId, Class responseType` | `@Nullable T` | +| `workflows().get(...)` | `GET` | `/workflows/{param}` | `String workflowId, TypeReference responseType` | `@Nullable T` | +| `workflows().get2(...)` | `GET` | `/workflows/{param}/{param}` | `String workflowId, String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `workflows().get2(...)` | `GET` | `/workflows/{param}/{param}` | `String workflowId, String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `workflows().get2(...)` | `GET` | `/workflows/{param}/{param}` | `String workflowId, String runId, Class responseType` | `@Nullable T` | +| `workflows().get2(...)` | `GET` | `/workflows/{param}/{param}` | `String workflowId, String runId, TypeReference responseType` | `@Nullable T` | +| `workflows().summary(...)` | `GET` | `/workflows/{param}/{param}/summary` | `String workflowId, String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `workflows().summary(...)` | `GET` | `/workflows/{param}/{param}/summary` | `String workflowId, String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `workflows().summary(...)` | `GET` | `/workflows/{param}/{param}/summary` | `String workflowId, String runId, Class responseType` | `@Nullable T` | +| `workflows().summary(...)` | `GET` | `/workflows/{param}/{param}/summary` | `String workflowId, String runId, TypeReference responseType` | `@Nullable T` | +| `workflows().timeline(...)` | `GET` | `/workflows/{param}/{param}/timeline` | `String workflowId, String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `workflows().timeline(...)` | `GET` | `/workflows/{param}/{param}/timeline` | `String workflowId, String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `workflows().timeline(...)` | `GET` | `/workflows/{param}/{param}/timeline` | `String workflowId, String runId, Class responseType` | `@Nullable T` | +| `workflows().timeline(...)` | `GET` | `/workflows/{param}/{param}/timeline` | `String workflowId, String runId, TypeReference responseType` | `@Nullable T` | +| `workflows().update(...)` | `PATCH` | `/workflows/{param}` | `String workflowId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().update(...)` | `PATCH` | `/workflows/{param}` | `String workflowId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().update(...)` | `PATCH` | `/workflows/{param}` | `String workflowId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().update(...)` | `PATCH` | `/workflows/{param}` | `String workflowId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().create(...)` | `POST` | `/workflows` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().create(...)` | `POST` | `/workflows` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().create(...)` | `POST` | `/workflows` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().create(...)` | `POST` | `/workflows` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().batch(...)` | `POST` | `/workflows/batch` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().batch(...)` | `POST` | `/workflows/batch` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().batch(...)` | `POST` | `/workflows/batch` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().batch(...)` | `POST` | `/workflows/batch` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().search(...)` | `POST` | `/workflows/search` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().search(...)` | `POST` | `/workflows/search` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().search(...)` | `POST` | `/workflows/search` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().search(...)` | `POST` | `/workflows/search` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().archive(...)` | `POST` | `/workflows/{param}/archive` | `String workflowId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().archive(...)` | `POST` | `/workflows/{param}/archive` | `String workflowId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().archive(...)` | `POST` | `/workflows/{param}/archive` | `String workflowId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().archive(...)` | `POST` | `/workflows/{param}/archive` | `String workflowId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().publish(...)` | `POST` | `/workflows/{param}/publish` | `String workflowId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().publish(...)` | `POST` | `/workflows/{param}/publish` | `String workflowId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().publish(...)` | `POST` | `/workflows/{param}/publish` | `String workflowId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().publish(...)` | `POST` | `/workflows/{param}/publish` | `String workflowId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().restore(...)` | `POST` | `/workflows/{param}/restore` | `String workflowId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().restore(...)` | `POST` | `/workflows/{param}/restore` | `String workflowId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().restore(...)` | `POST` | `/workflows/{param}/restore` | `String workflowId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().restore(...)` | `POST` | `/workflows/{param}/restore` | `String workflowId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().approvals().list(...)` | `GET` | `/workflows/approvals` | `QueryParams query, Class responseType` | `@Nullable T` | +| `workflows().approvals().list(...)` | `GET` | `/workflows/approvals` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `workflows().approvals().list(...)` | `GET` | `/workflows/approvals` | `Class responseType` | `@Nullable T` | +| `workflows().approvals().list(...)` | `GET` | `/workflows/approvals` | `TypeReference responseType` | `@Nullable T` | +| `workflows().approvals().get(...)` | `GET` | `/workflows/approvals/{param}` | `String approvalId, QueryParams query, Class responseType` | `@Nullable T` | +| `workflows().approvals().get(...)` | `GET` | `/workflows/approvals/{param}` | `String approvalId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `workflows().approvals().get(...)` | `GET` | `/workflows/approvals/{param}` | `String approvalId, Class responseType` | `@Nullable T` | +| `workflows().approvals().get(...)` | `GET` | `/workflows/approvals/{param}` | `String approvalId, TypeReference responseType` | `@Nullable T` | +| `workflows().approvals().approve(...)` | `POST` | `/workflows/approvals/{param}/approve` | `String approvalId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().approvals().approve(...)` | `POST` | `/workflows/approvals/{param}/approve` | `String approvalId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().approvals().approve(...)` | `POST` | `/workflows/approvals/{param}/approve` | `String approvalId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().approvals().approve(...)` | `POST` | `/workflows/approvals/{param}/approve` | `String approvalId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().approvals().reject(...)` | `POST` | `/workflows/approvals/{param}/reject` | `String approvalId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().approvals().reject(...)` | `POST` | `/workflows/approvals/{param}/reject` | `String approvalId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().approvals().reject(...)` | `POST` | `/workflows/approvals/{param}/reject` | `String approvalId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().approvals().reject(...)` | `POST` | `/workflows/approvals/{param}/reject` | `String approvalId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().executions().list(...)` | `GET` | `/workflows/executions` | `QueryParams query, Class responseType` | `@Nullable T` | +| `workflows().executions().list(...)` | `GET` | `/workflows/executions` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `workflows().executions().list(...)` | `GET` | `/workflows/executions` | `Class responseType` | `@Nullable T` | +| `workflows().executions().list(...)` | `GET` | `/workflows/executions` | `TypeReference responseType` | `@Nullable T` | +| `workflows().executions().get(...)` | `GET` | `/workflows/executions/{param}` | `String executionId, QueryParams query, Class responseType` | `@Nullable T` | +| `workflows().executions().get(...)` | `GET` | `/workflows/executions/{param}` | `String executionId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `workflows().executions().get(...)` | `GET` | `/workflows/executions/{param}` | `String executionId, Class responseType` | `@Nullable T` | +| `workflows().executions().get(...)` | `GET` | `/workflows/executions/{param}` | `String executionId, TypeReference responseType` | `@Nullable T` | +| `workflows().executions().create(...)` | `POST` | `/workflows/executions` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().executions().create(...)` | `POST` | `/workflows/executions` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().executions().create(...)` | `POST` | `/workflows/executions` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().executions().create(...)` | `POST` | `/workflows/executions` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().tasks().get(...)` | `GET` | `/workflows/tasks/{param}` | `String taskId, QueryParams query, Class responseType` | `@Nullable T` | +| `workflows().tasks().get(...)` | `GET` | `/workflows/tasks/{param}` | `String taskId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `workflows().tasks().get(...)` | `GET` | `/workflows/tasks/{param}` | `String taskId, Class responseType` | `@Nullable T` | +| `workflows().tasks().get(...)` | `GET` | `/workflows/tasks/{param}` | `String taskId, TypeReference responseType` | `@Nullable T` | +| `workflows().tasks().cancel(...)` | `POST` | `/workflows/tasks/{param}/cancel` | `String taskId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().tasks().cancel(...)` | `POST` | `/workflows/tasks/{param}/cancel` | `String taskId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().tasks().cancel(...)` | `POST` | `/workflows/tasks/{param}/cancel` | `String taskId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().tasks().cancel(...)` | `POST` | `/workflows/tasks/{param}/cancel` | `String taskId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().tasks().retry(...)` | `POST` | `/workflows/tasks/{param}/retry` | `String taskId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().tasks().retry(...)` | `POST` | `/workflows/tasks/{param}/retry` | `String taskId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().tasks().retry(...)` | `POST` | `/workflows/tasks/{param}/retry` | `String taskId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().tasks().retry(...)` | `POST` | `/workflows/tasks/{param}/retry` | `String taskId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().templates().list(...)` | `GET` | `/workflows/templates` | `QueryParams query, Class responseType` | `@Nullable T` | +| `workflows().templates().list(...)` | `GET` | `/workflows/templates` | `QueryParams query, TypeReference responseType` | `@Nullable T` | +| `workflows().templates().list(...)` | `GET` | `/workflows/templates` | `Class responseType` | `@Nullable T` | +| `workflows().templates().list(...)` | `GET` | `/workflows/templates` | `TypeReference responseType` | `@Nullable T` | +| `workflows().templates().get(...)` | `GET` | `/workflows/templates/{param}` | `String templateId, QueryParams query, Class responseType` | `@Nullable T` | +| `workflows().templates().get(...)` | `GET` | `/workflows/templates/{param}` | `String templateId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `workflows().templates().get(...)` | `GET` | `/workflows/templates/{param}` | `String templateId, Class responseType` | `@Nullable T` | +| `workflows().templates().get(...)` | `GET` | `/workflows/templates/{param}` | `String templateId, TypeReference responseType` | `@Nullable T` | +| `workflows().templates().create(...)` | `POST` | `/workflows/templates` | `QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().templates().create(...)` | `POST` | `/workflows/templates` | `QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().templates().create(...)` | `POST` | `/workflows/templates` | `@Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().templates().create(...)` | `POST` | `/workflows/templates` | `@Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().templates().instantiate(...)` | `POST` | `/workflows/templates/{param}/instantiate` | `String templateId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().templates().instantiate(...)` | `POST` | `/workflows/templates/{param}/instantiate` | `String templateId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().templates().instantiate(...)` | `POST` | `/workflows/templates/{param}/instantiate` | `String templateId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().templates().instantiate(...)` | `POST` | `/workflows/templates/{param}/instantiate` | `String templateId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().versions().create(...)` | `POST` | `/workflows/{param}/versions` | `String workflowId, QueryParams query, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().versions().create(...)` | `POST` | `/workflows/{param}/versions` | `String workflowId, QueryParams query, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().versions().create(...)` | `POST` | `/workflows/{param}/versions` | `String workflowId, @Nullable JsonNode body, Class responseType` | `@Nullable T` | +| `workflows().versions().create(...)` | `POST` | `/workflows/{param}/versions` | `String workflowId, @Nullable JsonNode body, TypeReference responseType` | `@Nullable T` | +| `workflows().executions().tasks().list(...)` | `GET` | `/workflows/executions/{param}/tasks` | `String executionId, QueryParams query, Class responseType` | `@Nullable T` | +| `workflows().executions().tasks().list(...)` | `GET` | `/workflows/executions/{param}/tasks` | `String executionId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `workflows().executions().tasks().list(...)` | `GET` | `/workflows/executions/{param}/tasks` | `String executionId, Class responseType` | `@Nullable T` | +| `workflows().executions().tasks().list(...)` | `GET` | `/workflows/executions/{param}/tasks` | `String executionId, TypeReference responseType` | `@Nullable T` | +| `workflows().runs().steps().list(...)` | `GET` | `/workflows/runs/{param}/steps` | `String runId, QueryParams query, Class responseType` | `@Nullable T` | +| `workflows().runs().steps().list(...)` | `GET` | `/workflows/runs/{param}/steps` | `String runId, QueryParams query, TypeReference responseType` | `@Nullable T` | +| `workflows().runs().steps().list(...)` | `GET` | `/workflows/runs/{param}/steps` | `String runId, Class responseType` | `@Nullable T` | +| `workflows().runs().steps().list(...)` | `GET` | `/workflows/runs/{param}/steps` | `String runId, TypeReference responseType` | `@Nullable T` | + +The generic `request(...)` methods and `Endpoints` constants remain available. From 19331b11c4a0caed4cf13c45c37713fcd96acf0f Mon Sep 17 00:00:00 2001 From: Gabriel Fonseca Date: Fri, 9 Oct 2026 16:21:33 +0100 Subject: [PATCH 11/11] docs: restore additional documentation files removed in error --- docs/ENTERPRISE_READINESS.md | 19 + docs/api/methods-as-code.md | 724 +++++++++++++++++++++++++++++++++++ 2 files changed, 743 insertions(+) create mode 100644 docs/ENTERPRISE_READINESS.md create mode 100644 docs/api/methods-as-code.md diff --git a/docs/ENTERPRISE_READINESS.md b/docs/ENTERPRISE_READINESS.md new file mode 100644 index 0000000..f26950a --- /dev/null +++ b/docs/ENTERPRISE_READINESS.md @@ -0,0 +1,19 @@ +# Java SDK enterprise readiness + +This page summarizes the controls in the Java SDK and the work required before a production release. + +## Current controls + +- Java 17 baseline with CI on JDK 17 and 21 using Gradle. +- Shared OkHttp transport with bounded responses, request IDs, safe-read retries, and typed errors. +- MockWebServer coverage for request handling, retries, pagination, error mapping, and SSE streams. +- Contract checks that map all public and AI OpenAPI operations to Java endpoints. +- Generated named operation methods and per-service references for supported routes. Agent run lookup is grouped under agents. +- Central Portal release workflow with GPG signing required for publication. + +## Remaining release work + +- Configure Central Portal and GPG credentials as protected GitHub secrets. +- Complete a security review of transport, credential handling, and logging. +- Add operation-specific request and response models as upstream contracts provide complete schemas. +- Configure dependency scanning and release provenance for the repository. diff --git a/docs/api/methods-as-code.md b/docs/api/methods-as-code.md new file mode 100644 index 0000000..fbc1076 --- /dev/null +++ b/docs/api/methods-as-code.md @@ -0,0 +1,724 @@ +# Canonical Java calls + +Generated from the contract route catalog. Query parameters are optional; use `QueryParams` when required by the endpoint. + +## agents + +```java +client.agents().delete(agentId, responseType); +client.agents().list(responseType); +client.agents().health(responseType); +client.agents().get(agentId, responseType); +client.agents().create(body, responseType); +client.agents().rollback(agentId, body, responseType); +client.agents().update(agentId, body, responseType); +client.agents().runs().getByActionRunId(actionRunId, responseType); +client.agents().runs().get(runId, responseType); +client.agents().runs().conversation(runId, responseType); +client.agents().runs().list(agentId, responseType); +client.agents().runs().create(agentId, body, responseType); +client.agents().runs().stream(runId); +client.agents().runs().streamBlocking(runId); +client.agents().versions().list(agentId, responseType); +``` + +## ai + +```java +client.ai().health(responseType); +client.ai().internal().embed(body, responseType); +client.ai().internal().predict(body, responseType); +client.ai().internal().rerank(body, responseType); +client.ai().internal().predictForm(fields, files, responseType); +client.ai().internal().predictRaw(body, responseType); +client.ai().chat().completions().create(body, responseType); +client.ai().internal().models().list(responseType); +client.ai().internal().models().defaults(responseType); +``` + +## audit + +```java +client.audit().events().list(responseType); +client.audit().events().get(eventId, responseType); +client.audit().events().create(body, responseType); +client.audit().events().batch(body, responseType); +``` + +## auth + +```java +client.auth().getUser(responseType); +client.auth().createAuthorize(body, responseType); +client.auth().createInvite(body, responseType); +client.auth().login(body, responseType); +client.auth().logout(body, responseType); +client.auth().createOtp(body, responseType); +client.auth().createReauthenticate(body, responseType); +client.auth().createRecover(body, responseType); +client.auth().createResend(body, responseType); +client.auth().createSignup(body, responseType); +client.auth().createSso(body, responseType); +client.auth().createTokenGrantTypeIdToken(body, responseType); +client.auth().createTokenGrantTypePassword(body, responseType); +client.auth().createTokenGrantTypePkce(body, responseType); +client.auth().createTokenGrantTypeRefreshToken(body, responseType); +client.auth().verify(body, responseType); +client.auth().updateUser(body, responseType); +client.auth().account().deleteProfile(responseType); +client.auth().account().getAuditLog(responseType); +client.auth().account().getMfa(responseType); +client.auth().account().getProfile(responseType); +client.auth().account().createMfa(body, responseType); +client.auth().account().createPassword(body, responseType); +client.auth().account().updateProfile(body, responseType); +client.auth().admin().createGenerateLink(body, responseType); +client.auth().admin().logout(body, responseType); +client.auth().auth().getSession(responseType); +client.auth().auth().createSession(body, responseType); +client.auth().factors().delete(factorId, responseType); +client.auth().factors().list(responseType); +client.auth().factors().create(body, responseType); +client.auth().factors().createChallenge(factorId, body, responseType); +client.auth().factors().verify(factorId, body, responseType); +client.auth().mfa().status(responseType); +client.auth().mfa().disable(body, responseType); +client.auth().mfa().enable(body, responseType); +client.auth().mfa().setup(body, responseType); +client.auth().mfa().verify(body, responseType); +client.auth().account().mfa().delete(mfaId, responseType); +client.auth().account().mfa().get(mfaId, responseType); +client.auth().account().mfa().createChallenge(mfaId, body, responseType); +client.auth().account().mfa().verify(mfaId, body, responseType); +client.auth().account().sessions().delete(sessionId, responseType); +client.auth().account().sessions().list(responseType); +client.auth().account().sessions().extend(sessionId, body, responseType); +client.auth().admin().users().delete(userId, responseType); +client.auth().admin().users().list(responseType); +client.auth().admin().users().get(userId, responseType); +client.auth().admin().users().create(body, responseType); +client.auth().admin().users().update(userId, body, responseType); +client.auth().mfa().backupCodes().createRegenerate(body, responseType); +client.auth().user().identities().delete(identityId, responseType); +client.auth().user().identities().list(responseType); +client.auth().user().identities().create(body, responseType); +client.auth().account().security().apiKeys().delete(apiKeyId, responseType); +client.auth().account().security().apiKeys().list(responseType); +client.auth().account().security().apiKeys().get(apiKeyId, responseType); +client.auth().account().security().apiKeys().create(body, responseType); +client.auth().account().security().apiKeys().update(apiKeyId, body, responseType); +client.auth().account().security().devices().delete(deviceId, responseType); +client.auth().account().security().devices().list(responseType); +client.auth().account().security().devices().get(deviceId, responseType); +client.auth().account().security().devices().create(body, responseType); +client.auth().account().security().devices().trust(deviceId, body, responseType); +client.auth().admin().users().factors().delete(userId, factorId, responseType); +client.auth().admin().users().factors().list(userId, responseType); +``` + +## billing + +```java +client.billing().customers().usage(customerId, responseType); +client.billing().invoices().getPdf(invoiceId, responseType); +client.billing().invoices().preview(body, responseType); +client.billing().invoices().finalize(invoiceId, body, responseType); +client.billing().invoices().resourceVoid(invoiceId, body, responseType); +client.billing().meters().disable(meterId, body, responseType); +client.billing().plans().clone(planId, body, responseType); +client.billing().subscriptions().activate(subscriptionId, body, responseType); +client.billing().subscriptions().cancel(subscriptionId, body, responseType); +client.billing().subscriptions().pause(subscriptionId, body, responseType); +client.billing().subscriptions().resume(subscriptionId, body, responseType); +client.billing().wallets().createTerminate(walletId, body, responseType); +client.billing().wallets().topUp(walletId, body, responseType); +client.billing().addons().entitlements().list(addonId, responseType); +client.billing().customers().entitlements().list(customerId, responseType); +client.billing().customers().invoices().summary(customerId, responseType); +client.billing().customers().portal().get(portalId, responseType); +client.billing().customers().wallets().list(customerId, responseType); +client.billing().plans().entitlements().list(planId, responseType); +client.billing().prices().lookup().get(lookupId, responseType); +client.billing().subscriptions().entitlements().list(subscriptionId, responseType); +client.billing().wallets().balance().getRealTime(walletId, responseType); +client.billing().wallets().transactions().list(walletId, responseType); +``` + +## blob + +```java +client.blob().object().delete(objectId, objectId2, responseType); +client.blob().object().get(objectId, objectId2, responseType); +client.blob().object().copy(body, responseType); +client.blob().object().move(body, responseType); +client.blob().object().get2(objectId, objectId2, fields, files, responseType); +client.blob().object().info().get(infoId, infoId2, responseType); +client.blob().object().list().get(listId, body, responseType); +client.blob().object().sign().get(signId, signId2, body, responseType); +``` + +## connection-tests + +```java +client.connectionTests().get(connectionTestId, responseType); +``` + +## connectors + +```java +client.connectors().getCatalog(responseType); +client.connectors().catalog().get(catalogId, responseType); +client.connectors().connectionTests().get(connectionTestId, responseType); +client.connectors().diagnostics().list(responseType); +client.connectors().installations().delete(installationId, responseType); +client.connectors().installations().list(responseType); +client.connectors().installations().get(installationId, responseType); +client.connectors().installations().update(installationId, body, responseType); +client.connectors().installations().create(body, responseType); +client.connectors().installations().pause(installationId, body, responseType); +client.connectors().installations().resume(installationId, body, responseType); +client.connectors().syncRuns().replay(syncRunId, body, responseType); +``` + +## data + +```java +client.data().aggregations().health(responseType); +client.data().aggregations().getInfo(responseType); +client.data().archival().health(responseType); +client.data().archival().getInfo(responseType); +client.data().catalog().health(responseType); +client.data().catalog().getInfo(responseType); +client.data().enrichment().health(responseType); +client.data().enrichment().getInfo(responseType); +client.data().exports().health(responseType); +client.data().exports().getInfo(responseType); +client.data().ingest().health(responseType); +client.data().ingest().getInfo(responseType); +client.data().normalization().health(responseType); +client.data().normalization().getInfo(responseType); +client.data().pipelines().health(responseType); +client.data().pipelines().getInfo(responseType); +client.data().quality().health(responseType); +client.data().quality().getInfo(responseType); +client.data().query().health(responseType); +client.data().query().getInfo(responseType); +client.data().schemas().health(responseType); +client.data().schemas().getInfo(responseType); +client.data().serving().health(responseType); +client.data().serving().getInfo(responseType); +client.data().streams().health(responseType); +client.data().streams().getInfo(responseType); +client.data().sync().health(responseType); +client.data().sync().getInfo(responseType); +client.data().transformations().health(responseType); +client.data().transformations().getInfo(responseType); +client.data().aggregations().aggregations().list(responseType); +client.data().aggregations().aggregations().get(aggregationId, responseType); +client.data().aggregations().aggregations().create(body, responseType); +client.data().aggregations().capabilities().list(responseType); +client.data().aggregations().runs().list(responseType); +client.data().aggregations().runs().get(runId, responseType); +client.data().aggregations().runs().create(body, responseType); +client.data().archival().capabilities().list(responseType); +client.data().archival().runs().list(responseType); +client.data().archival().runs().get(runId, responseType); +client.data().archival().runs().create(body, responseType); +client.data().catalog().capabilities().list(responseType); +client.data().catalog().runs().list(responseType); +client.data().catalog().runs().get(runId, responseType); +client.data().catalog().runs().create(body, responseType); +client.data().enrichment().capabilities().list(responseType); +client.data().enrichment().runs().list(responseType); +client.data().enrichment().runs().get(runId, responseType); +client.data().enrichment().runs().create(body, responseType); +client.data().exports().capabilities().list(responseType); +client.data().exports().exports().list(responseType); +client.data().exports().exports().get(exportId, responseType); +client.data().exports().exports().create(body, responseType); +client.data().exports().runs().list(responseType); +client.data().exports().runs().get(runId, responseType); +client.data().exports().runs().create(body, responseType); +client.data().ingest().capabilities().list(responseType); +client.data().ingest().datasets().list(responseType); +client.data().ingest().datasets().get(datasetId, responseType); +client.data().ingest().datasets().ingest(body, responseType); +client.data().ingest().runs().list(responseType); +client.data().ingest().runs().get(runId, responseType); +client.data().ingest().runs().create(body, responseType); +client.data().ingest().schemas().list(responseType); +client.data().ingest().schemas().get(schemaRef, responseType); +client.data().normalization().capabilities().list(responseType); +client.data().normalization().runs().list(responseType); +client.data().normalization().runs().get(runId, responseType); +client.data().normalization().runs().create(body, responseType); +client.data().pipelines().capabilities().list(responseType); +client.data().pipelines().pipelineRuns().list(responseType); +client.data().pipelines().pipelineRuns().get(runId, responseType); +client.data().pipelines().pipelines().list(responseType); +client.data().pipelines().pipelines().get(definitionId, responseType); +client.data().pipelines().pipelines().create(body, responseType); +client.data().pipelines().runs().list(responseType); +client.data().pipelines().runs().get(runId, responseType); +client.data().pipelines().runs().create(body, responseType); +client.data().quality().capabilities().list(responseType); +client.data().quality().runs().list(responseType); +client.data().quality().runs().get(runId, responseType); +client.data().quality().runs().create(body, responseType); +client.data().query().capabilities().list(responseType); +client.data().query().query().federated(body, responseType); +client.data().query().runs().list(responseType); +client.data().query().runs().get(runId, responseType); +client.data().query().runs().create(body, responseType); +client.data().schemas().capabilities().list(responseType); +client.data().schemas().runs().list(responseType); +client.data().schemas().runs().get(runId, responseType); +client.data().schemas().runs().create(body, responseType); +client.data().schemas().schemas().list(responseType); +client.data().schemas().schemas().get(schemaRef, responseType); +client.data().schemas().schemas().create(body, responseType); +client.data().schemas().schemas().resolve(body, responseType); +client.data().serving().capabilities().list(responseType); +client.data().serving().runs().list(responseType); +client.data().serving().runs().get(runId, responseType); +client.data().serving().runs().create(body, responseType); +client.data().streams().capabilities().list(responseType); +client.data().streams().runs().list(responseType); +client.data().streams().runs().get(runId, responseType); +client.data().streams().runs().create(body, responseType); +client.data().streams().streams().list(responseType); +client.data().streams().streams().get(streamId, responseType); +client.data().streams().streams().create(body, responseType); +client.data().sync().capabilities().list(responseType); +client.data().sync().runs().list(responseType); +client.data().sync().runs().get(runId, responseType); +client.data().sync().runs().create(body, responseType); +client.data().transformations().capabilities().list(responseType); +client.data().transformations().runs().list(responseType); +client.data().transformations().runs().get(runId, responseType); +client.data().transformations().runs().create(body, responseType); +client.data().transformations().transformations().list(responseType); +client.data().transformations().transformations().get(transformationId, responseType); +client.data().transformations().transformations().create(body, responseType); +client.data().aggregations().aggregations().executions().create(aggregationId, body, responseType); +client.data().archival().archival().policies().list(responseType); +client.data().archival().archival().policies().get(policyId, responseType); +client.data().archival().archival().policies().create(body, responseType); +client.data().catalog().catalog().datasets().list(responseType); +client.data().catalog().catalog().datasets().get(datasetId, responseType); +client.data().catalog().catalog().sources().list(responseType); +client.data().catalog().catalog().sources().get(sourceId, responseType); +client.data().enrichment().enrichment().profiles().list(responseType); +client.data().enrichment().enrichment().profiles().get(profileId, responseType); +client.data().enrichment().enrichment().profiles().create(body, responseType); +client.data().exports().exports().executions().create(exportId, body, responseType); +client.data().ingest().datasets().artifacts().getContent(datasetId, manifestId, responseType); +client.data().normalization().normalization().profiles().list(responseType); +client.data().normalization().normalization().profiles().get(profileId, responseType); +client.data().normalization().normalization().profiles().create(body, responseType); +client.data().quality().quality().rulesets().list(responseType); +client.data().quality().quality().rulesets().get(rulesetId, responseType); +client.data().quality().quality().rulesets().create(body, responseType); +client.data().serving().serving().products().list(responseType); +client.data().serving().serving().products().get(productId, responseType); +client.data().serving().serving().products().create(body, responseType); +client.data().streams().streams().deliveries().create(streamId, body, responseType); +client.data().sync().sync().jobs().list(responseType); +client.data().sync().sync().jobs().get(jobId, responseType); +client.data().sync().sync().jobs().create(body, responseType); +client.data().transformations().transformations().executions().create(transformationId, body, responseType); +client.data().archival().archival().policies().executions().create(policyId, body, responseType); +client.data().catalog().catalog().datasets().artifacts().getContent(datasetId, manifestId, responseType); +client.data().enrichment().enrichment().profiles().executions().create(profileId, body, responseType); +client.data().normalization().normalization().profiles().executions().create(profileId, body, responseType); +client.data().quality().quality().rulesets().evaluations().create(rulesetId, body, responseType); +client.data().serving().serving().products().refreshes().create(productId, body, responseType); +client.data().sync().sync().jobs().executions().create(jobId, body, responseType); +``` + +## events + +```java +client.events().list(responseType); +client.events().getMonitoring(responseType); +client.events().get(id, responseType); +client.events().create(body, responseType); +client.events().analytics(body, responseType); +client.events().createAnalyticsV2(body, responseType); +client.events().bulk(body, responseType); +client.events().createHuggingfaceBilling(body, responseType); +client.events().query(body, responseType); +client.events().reprocess(body, responseType); +client.events().usage(body, responseType); +client.events().benchmark().createV1(body, responseType); +client.events().benchmark().createV2(body, responseType); +client.events().reprocess().createInternal(body, responseType); +client.events().usage().createMeter(body, responseType); +client.events().raw().reprocess().createAll(body, responseType); +client.events().raw().reprocess().createPending(body, responseType); +``` + +## governance + +```java +client.governance().access().check(body, responseType); +client.governance().compliance().getScore(responseType); +client.governance().permissions().list(responseType); +client.governance().permissions().get(permissionId, responseType); +client.governance().permissions().create(body, responseType); +client.governance().policies().delete(policyId, responseType); +client.governance().policies().list(responseType); +client.governance().policies().get(policyId, responseType); +client.governance().policies().create(body, responseType); +client.governance().policies().createFromTemplate(body, responseType); +client.governance().policies().validate(body, responseType); +client.governance().policies().update(policyId, body, responseType); +client.governance().roles().delete(roleId, responseType); +client.governance().roles().list(responseType); +client.governance().roles().get(roleId, responseType); +client.governance().roles().create(body, responseType); +client.governance().compliance().assessments().list(responseType); +client.governance().compliance().assessments().get(assessmentId, responseType); +client.governance().compliance().assessments().create(body, responseType); +client.governance().compliance().frameworks().list(responseType); +client.governance().compliance().violations().list(responseType); +client.governance().compliance().violations().resolve(violationId, body, responseType); +client.governance().policies().templates().list(responseType); +client.governance().policies().versions().list(policyId, responseType); +``` + +## invocations + +```java +client.invocations().create(body, responseType); +``` + +## lineage + +```java +client.lineage().getGraph(responseType); +client.lineage().createImpact(body, responseType); +client.lineage().edges().list(responseType); +client.lineage().edges().get(edgeId, responseType); +client.lineage().nodes().list(responseType); +client.lineage().nodes().get(nodeId, responseType); +client.lineage().nodes().getTrace(nodeId, responseType); +``` + +## observability + +```java +client.observability().alerts().delete(alertId, responseType); +client.observability().alerts().list(responseType); +client.observability().alerts().create(body, responseType); +client.observability().alerts().disable(alertId, body, responseType); +client.observability().alerts().enable(alertId, body, responseType); +client.observability().alerts().update(alertId, body, responseType); +client.observability().dashboards().delete(dashboardId, responseType); +client.observability().dashboards().list(responseType); +client.observability().dashboards().get(dashboardId, responseType); +client.observability().dashboards().create(body, responseType); +client.observability().dashboards().share(dashboardId, body, responseType); +client.observability().dashboards().update(dashboardId, body, responseType); +client.observability().events().create(body, responseType); +client.observability().events().batch(body, responseType); +client.observability().logs().ingest(body, responseType); +client.observability().logs().query(body, responseType); +client.observability().logs().stream(); +client.observability().logs().streamBlocking(); +client.observability().metrics().list(responseType); +client.observability().metrics().getList(responseType); +client.observability().metrics().ingest(body, responseType); +client.observability().traces().list(responseType); +client.observability().traces().get(traceId, responseType); +client.observability().traces().query(body, responseType); +client.observability().alerts().incidents().list(responseType); +client.observability().alerts().rules().delete(ruleId, responseType); +client.observability().alerts().rules().list(responseType); +client.observability().alerts().rules().get(ruleId, responseType); +client.observability().alerts().rules().create(body, responseType); +client.observability().alerts().rules().toggle(ruleId, body, responseType); +client.observability().alerts().rules().update(ruleId, body, responseType); +client.observability().events().stats().list(responseType); +``` + +## ontology + +```java +client.ontology().engine().health(responseType); +client.ontology().engine().getInfo(responseType); +client.ontology().events().health(responseType); +client.ontology().events().getInfo(responseType); +client.ontology().extract().health(responseType); +client.ontology().extract().getInfo(responseType); +client.ontology().graph().health(responseType); +client.ontology().graph().getInfo(responseType); +client.ontology().objects().health(responseType); +client.ontology().objects().getInfo(responseType); +client.ontology().reasoning().health(responseType); +client.ontology().reasoning().getInfo(responseType); +client.ontology().reasoning().createExplain(body, responseType); +client.ontology().relationships().health(responseType); +client.ontology().relationships().getInfo(responseType); +client.ontology().rollouts().health(responseType); +client.ontology().rollouts().getInfo(responseType); +client.ontology().rollups().health(responseType); +client.ontology().rollups().getInfo(responseType); +client.ontology().schemas().health(responseType); +client.ontology().schemas().getInfo(responseType); +client.ontology().transformations().health(responseType); +client.ontology().transformations().getInfo(responseType); +client.ontology().validation().health(responseType); +client.ontology().validation().getInfo(responseType); +client.ontology().versions().health(responseType); +client.ontology().versions().getInfo(responseType); +client.ontology().engine().capabilities().list(responseType); +client.ontology().engine().ontologies().export(body, responseType); +client.ontology().engine().ontologies().createExportShacl(body, responseType); +client.ontology().engine().ontologies().generate(body, responseType); +client.ontology().engine().ontologies().validate(body, responseType); +client.ontology().engine().runs().list(responseType); +client.ontology().engine().runs().get(runId, responseType); +client.ontology().engine().runs().create(body, responseType); +client.ontology().events().capabilities().list(responseType); +client.ontology().events().events().list(responseType); +client.ontology().events().events().get(eventId, responseType); +client.ontology().events().events().create(body, responseType); +client.ontology().events().runs().list(responseType); +client.ontology().events().runs().get(runId, responseType); +client.ontology().events().runs().create(body, responseType); +client.ontology().extract().capabilities().list(responseType); +client.ontology().extract().extract().analyze(body, responseType); +client.ontology().extract().extract().createArchitecture(body, responseType); +client.ontology().extract().runs().list(responseType); +client.ontology().extract().runs().get(runId, responseType); +client.ontology().extract().runs().create(body, responseType); +client.ontology().graph().capabilities().list(responseType); +client.ontology().graph().entities().get(entityId, responseType); +client.ontology().graph().entities().getProvenance(entityId, responseType); +client.ontology().graph().entities().update(entityId, body, responseType); +client.ontology().graph().graph().analyze(body, responseType); +client.ontology().graph().graph().createBuild(body, responseType); +client.ontology().graph().graph().createBulkRead(body, responseType); +client.ontology().graph().graph().createNeighborhood(body, responseType); +client.ontology().graph().graph().createPath(body, responseType); +client.ontology().graph().graph().query(body, responseType); +client.ontology().graph().relationships().get(relationshipId, responseType); +client.ontology().graph().relationships().update(relationshipId, body, responseType); +client.ontology().graph().runs().list(responseType); +client.ontology().graph().runs().get(runId, responseType); +client.ontology().graph().runs().create(body, responseType); +client.ontology().objects().capabilities().list(responseType); +client.ontology().objects().objectTypes().delete(objectTypeId, responseType); +client.ontology().objects().objectTypes().list(responseType); +client.ontology().objects().objectTypes().get(objectTypeId, responseType); +client.ontology().objects().objectTypes().update(objectTypeId, body, responseType); +client.ontology().objects().objects().delete(objectId, responseType); +client.ontology().objects().objects().list(responseType); +client.ontology().objects().objects().get(objectId, responseType); +client.ontology().objects().objects().update(objectId, body, responseType); +client.ontology().objects().runs().list(responseType); +client.ontology().objects().runs().get(runId, responseType); +client.ontology().objects().runs().create(body, responseType); +client.ontology().reasoning().capabilities().list(responseType); +client.ontology().reasoning().facts().create(body, responseType); +client.ontology().reasoning().facts().createLoadGraph(body, responseType); +client.ontology().reasoning().reason().createBackward(body, responseType); +client.ontology().reasoning().reason().createForward(body, responseType); +client.ontology().reasoning().rules().delete(ruleId, responseType); +client.ontology().reasoning().rules().list(responseType); +client.ontology().reasoning().rules().create(body, responseType); +client.ontology().reasoning().rules().update(ruleId, body, responseType); +client.ontology().reasoning().runs().list(responseType); +client.ontology().reasoning().runs().get(runId, responseType); +client.ontology().reasoning().runs().create(body, responseType); +client.ontology().relationships().capabilities().list(responseType); +client.ontology().relationships().relationshipTypes().delete(relationshipTypeId, responseType); +client.ontology().relationships().relationshipTypes().list(responseType); +client.ontology().relationships().relationships().delete(relationshipId, responseType); +client.ontology().relationships().relationships().list(responseType); +client.ontology().relationships().relationships().get(relationshipId, responseType); +client.ontology().relationships().relationships().update(relationshipId, body, responseType); +client.ontology().relationships().runs().list(responseType); +client.ontology().relationships().runs().get(runId, responseType); +client.ontology().relationships().runs().create(body, responseType); +client.ontology().rollouts().capabilities().list(responseType); +client.ontology().rollouts().rollouts().delete(rolloutId, responseType); +client.ontology().rollouts().rollouts().list(responseType); +client.ontology().rollouts().rollouts().get(rolloutId, responseType); +client.ontology().rollouts().rollouts().status(rolloutId, responseType); +client.ontology().rollouts().rollouts().create(body, responseType); +client.ontology().rollouts().rollouts().pause(rolloutId, body, responseType); +client.ontology().rollouts().rollouts().resume(rolloutId, body, responseType); +client.ontology().rollouts().rollouts().rollback(rolloutId, body, responseType); +client.ontology().rollouts().rollouts().createStart(rolloutId, body, responseType); +client.ontology().rollouts().rollouts().update(rolloutId, body, responseType); +client.ontology().rollouts().runs().list(responseType); +client.ontology().rollouts().runs().get(runId, responseType); +client.ontology().rollouts().runs().create(body, responseType); +client.ontology().rollups().capabilities().list(responseType); +client.ontology().rollups().rollupResults().get(executionId, responseType); +client.ontology().rollups().rollups().delete(rollupId, responseType); +client.ontology().rollups().rollups().list(responseType); +client.ontology().rollups().rollups().get(rollupId, responseType); +client.ontology().rollups().rollups().getResult(rollupId, responseType); +client.ontology().rollups().rollups().create(body, responseType); +client.ontology().rollups().rollups().execute(rollupId, body, responseType); +client.ontology().rollups().rollups().preview(rollupId, body, responseType); +client.ontology().rollups().rollups().update(rollupId, body, responseType); +client.ontology().rollups().runs().list(responseType); +client.ontology().rollups().runs().get(runId, responseType); +client.ontology().rollups().runs().create(body, responseType); +client.ontology().schemas().capabilities().list(responseType); +client.ontology().schemas().runs().list(responseType); +client.ontology().schemas().runs().get(runId, responseType); +client.ontology().schemas().runs().create(body, responseType); +client.ontology().schemas().schemas().delete(schemaId, responseType); +client.ontology().schemas().schemas().list(responseType); +client.ontology().schemas().schemas().get(schemaId, responseType); +client.ontology().schemas().schemas().create(body, responseType); +client.ontology().schemas().schemas().validate(body, responseType); +client.ontology().transformations().capabilities().list(responseType); +client.ontology().transformations().runs().list(responseType); +client.ontology().transformations().runs().get(runId, responseType); +client.ontology().transformations().runs().create(body, responseType); +client.ontology().transformations().transformations().create(body, responseType); +client.ontology().validation().capabilities().list(responseType); +client.ontology().validation().payloads().validate(body, responseType); +client.ontology().validation().rules().delete(ruleId, responseType); +client.ontology().validation().rules().list(responseType); +client.ontology().validation().rules().get(ruleId, responseType); +client.ontology().validation().rules().create(body, responseType); +client.ontology().validation().runs().list(responseType); +client.ontology().validation().runs().get(runId, responseType); +client.ontology().validation().runs().create(body, responseType); +client.ontology().versions().audit().verify(body, responseType); +client.ontology().versions().capabilities().list(responseType); +client.ontology().versions().releaseBundles().list(responseType); +client.ontology().versions().releaseBundles().get(bundleId, responseType); +client.ontology().versions().releaseBundles().create(body, responseType); +client.ontology().versions().runs().list(responseType); +client.ontology().versions().runs().get(runId, responseType); +client.ontology().versions().runs().create(body, responseType); +client.ontology().versions().versions().delete(versionId, responseType); +client.ontology().versions().versions().get(versionId, responseType); +client.ontology().versions().versions().create(body, responseType); +client.ontology().versions().versions().compare(body, responseType); +client.ontology().engine().ontologies().compareVersions().create(body, responseType); +client.ontology().engine().ontologies().inferClasses().create(body, responseType); +client.ontology().engine().ontologies().inferProperties().create(body, responseType); +client.ontology().events().events().checkpoints().get(consumer, responseType); +client.ontology().events().events().checkpoints().create(body, responseType); +client.ontology().events().events().leases().acknowledge(body, responseType); +client.ontology().events().events().leases().acquire(body, responseType); +client.ontology().extract().extract().coreferences().create(body, responseType); +client.ontology().extract().extract().entities().create(body, responseType); +client.ontology().extract().extract().events().create(body, responseType); +client.ontology().extract().extract().relations().create(body, responseType); +client.ontology().extract().extract().triplets().create(body, responseType); +``` + +## pipelines + +```java +client.pipelines().data().pipelines().health(responseType); +client.pipelines().data().pipelines().getInfo(responseType); +client.pipelines().data().pipelines().capabilities().list(responseType); +client.pipelines().data().pipelines().pipelineRuns().list(responseType); +client.pipelines().data().pipelines().pipelineRuns().get(pipelineRunId, responseType); +client.pipelines().data().pipelines().pipelineRuns().get2(pipelineRunId); +client.pipelines().data().pipelines().pipelineRuns().get2Blocking(pipelineRunId); +client.pipelines().data().pipelines().pipelines().list(responseType); +client.pipelines().data().pipelines().pipelines().get(pipelineId, responseType); +client.pipelines().data().pipelines().pipelines().create(body, responseType); +client.pipelines().data().pipelines().runs().list(responseType); +client.pipelines().data().pipelines().runs().create(body, responseType); +``` + +## providers + +```java +client.providers().get(providerSlug, responseType); +``` + +## react + +```java +``` + +## schedules + +```java +client.schedules().workflows().cron().parse(body, responseType); +client.schedules().workflows().cron().validate(body, responseType); +client.schedules().workflows().schedules().delete(scheduleId, responseType); +client.schedules().workflows().schedules().list(responseType); +client.schedules().workflows().schedules().get(scheduleId, responseType); +client.schedules().workflows().schedules().update(scheduleId, body, responseType); +client.schedules().workflows().schedules().create(body, responseType); +client.schedules().workflows().schedules().pause(scheduleId, body, responseType); +client.schedules().workflows().schedules().resume(scheduleId, body, responseType); +client.schedules().workflows().schedules().trigger(scheduleId, body, responseType); +``` + +## webhook-endpoints + +```java +client.webhookEndpoints().delete(id, responseType); +client.webhookEndpoints().list(responseType); +client.webhookEndpoints().get(id, responseType); +client.webhookEndpoints().update(id, body, responseType); +client.webhookEndpoints().create(body, responseType); +client.webhookEndpoints().rotateSecret(id, body, responseType); +client.webhookEndpoints().deliveries().list(id, responseType); +``` + +## webhooks + +```java +client.webhooks().delete(webhookId, responseType); +client.webhooks().list(responseType); +client.webhooks().get(webhookId, responseType); +client.webhooks().create(body, responseType); +client.webhooks().rotateSecret(webhookId, body, responseType); +client.webhooks().update(webhookId, body, responseType); +client.webhooks().deliveries().list(responseType); +client.webhooks().deliveries().get(deliveryId, responseType); +client.webhooks().deliveries().retry(deliveryId, body, responseType); +client.webhooks().stats().list(responseType); +``` + +## workflows + +```java +client.workflows().delete(workflowId, responseType); +client.workflows().list(responseType); +client.workflows().get(workflowId, responseType); +client.workflows().get2(workflowId, runId, responseType); +client.workflows().summary(workflowId, runId, responseType); +client.workflows().timeline(workflowId, runId, responseType); +client.workflows().update(workflowId, body, responseType); +client.workflows().create(body, responseType); +client.workflows().batch(body, responseType); +client.workflows().search(body, responseType); +client.workflows().archive(workflowId, body, responseType); +client.workflows().publish(workflowId, body, responseType); +client.workflows().restore(workflowId, body, responseType); +client.workflows().approvals().list(responseType); +client.workflows().approvals().get(approvalId, responseType); +client.workflows().approvals().approve(approvalId, body, responseType); +client.workflows().approvals().reject(approvalId, body, responseType); +client.workflows().executions().list(responseType); +client.workflows().executions().get(executionId, responseType); +client.workflows().executions().create(body, responseType); +client.workflows().tasks().get(taskId, responseType); +client.workflows().tasks().cancel(taskId, body, responseType); +client.workflows().tasks().retry(taskId, body, responseType); +client.workflows().templates().list(responseType); +client.workflows().templates().get(templateId, responseType); +client.workflows().templates().create(body, responseType); +client.workflows().templates().instantiate(templateId, body, responseType); +client.workflows().versions().create(workflowId, body, responseType); +client.workflows().executions().tasks().list(executionId, responseType); +client.workflows().runs().steps().list(runId, responseType); +```