AsyncRawConnectionsClient.java

/**
 * This file was auto-generated by Fern from our API Definition.
 */
package com.auth0.client.mgmt;

import com.auth0.client.mgmt.core.ClientOptions;
import com.auth0.client.mgmt.core.ManagementApiException;
import com.auth0.client.mgmt.core.ManagementApiHttpResponse;
import com.auth0.client.mgmt.core.ManagementException;
import com.auth0.client.mgmt.core.MediaTypes;
import com.auth0.client.mgmt.core.ObjectMappers;
import com.auth0.client.mgmt.core.QueryStringMapper;
import com.auth0.client.mgmt.core.RequestOptions;
import com.auth0.client.mgmt.core.SyncPagingIterable;
import com.auth0.client.mgmt.errors.BadRequestError;
import com.auth0.client.mgmt.errors.ConflictError;
import com.auth0.client.mgmt.errors.ForbiddenError;
import com.auth0.client.mgmt.errors.NotFoundError;
import com.auth0.client.mgmt.errors.TooManyRequestsError;
import com.auth0.client.mgmt.errors.UnauthorizedError;
import com.auth0.client.mgmt.types.ConnectionForList;
import com.auth0.client.mgmt.types.CreateConnectionRequestContent;
import com.auth0.client.mgmt.types.CreateConnectionResponseContent;
import com.auth0.client.mgmt.types.GetConnectionRequestParameters;
import com.auth0.client.mgmt.types.GetConnectionResponseContent;
import com.auth0.client.mgmt.types.ListConnectionsCheckpointPaginatedResponseContent;
import com.auth0.client.mgmt.types.ListConnectionsQueryParameters;
import com.auth0.client.mgmt.types.UpdateConnectionRequestContent;
import com.auth0.client.mgmt.types.UpdateConnectionResponseContent;
import com.fasterxml.jackson.core.JsonProcessingException;
import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.Headers;
import okhttp3.HttpUrl;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import okhttp3.ResponseBody;
import org.jetbrains.annotations.NotNull;

public class AsyncRawConnectionsClient {
    protected final ClientOptions clientOptions;

    public AsyncRawConnectionsClient(ClientOptions clientOptions) {
        this.clientOptions = clientOptions;
    }

    /**
     * Retrieves detailed list of all <a href="https://auth0.com/docs/authenticate/identity-providers">connections</a> that match the specified strategy. If no strategy is provided, all connections within your tenant are retrieved. This action can accept a list of fields to include or exclude from the resulting list of connections.
     * <p>This endpoint supports two types of pagination:</p>
     * <p>&lt;ul&gt;
     * &lt;li&gt;Offset pagination&lt;/li&gt;
     * &lt;li&gt;Checkpoint pagination&lt;/li&gt;
     * &lt;/ul&gt;</p>
     * <p>Checkpoint pagination must be used if you need to retrieve more than 1000 connections.</p>
     * <p>&lt;h2&gt;Checkpoint Pagination&lt;/h2&gt;</p>
     * <p>To search by checkpoint, use the following parameters:</p>
     * <p>&lt;ul&gt;
     * &lt;li&gt;&lt;code&gt;from&lt;/code&gt;: Optional id from which to start selection.&lt;/li&gt;
     * &lt;li&gt;&lt;code&gt;take&lt;/code&gt;: The total amount of entries to retrieve when using the from parameter. Defaults to 50.&lt;/li&gt;
     * &lt;/ul&gt;</p>
     * <p>&lt;b&gt;Note&lt;/b&gt;: The first time you call this endpoint using checkpoint pagination, omit the &lt;code&gt;from&lt;/code&gt; parameter. If there are more results, a &lt;code&gt;next&lt;/code&gt; value is included in the response. You can use this for subsequent API calls. When &lt;code&gt;next&lt;/code&gt; is no longer included in the response, no pages are remaining.</p>
     */
    public CompletableFuture<ManagementApiHttpResponse<SyncPagingIterable<ConnectionForList>>> list() {
        return list(ListConnectionsQueryParameters.builder().build());
    }

    /**
     * Retrieves detailed list of all &lt;a href=&quot;https://auth0.com/docs/authenticate/identity-providers&quot;&gt;connections&lt;/a&gt; that match the specified strategy. If no strategy is provided, all connections within your tenant are retrieved. This action can accept a list of fields to include or exclude from the resulting list of connections.
     * <p>This endpoint supports two types of pagination:</p>
     * <p>&lt;ul&gt;
     * &lt;li&gt;Offset pagination&lt;/li&gt;
     * &lt;li&gt;Checkpoint pagination&lt;/li&gt;
     * &lt;/ul&gt;</p>
     * <p>Checkpoint pagination must be used if you need to retrieve more than 1000 connections.</p>
     * <p>&lt;h2&gt;Checkpoint Pagination&lt;/h2&gt;</p>
     * <p>To search by checkpoint, use the following parameters:</p>
     * <p>&lt;ul&gt;
     * &lt;li&gt;&lt;code&gt;from&lt;/code&gt;: Optional id from which to start selection.&lt;/li&gt;
     * &lt;li&gt;&lt;code&gt;take&lt;/code&gt;: The total amount of entries to retrieve when using the from parameter. Defaults to 50.&lt;/li&gt;
     * &lt;/ul&gt;</p>
     * <p>&lt;b&gt;Note&lt;/b&gt;: The first time you call this endpoint using checkpoint pagination, omit the &lt;code&gt;from&lt;/code&gt; parameter. If there are more results, a &lt;code&gt;next&lt;/code&gt; value is included in the response. You can use this for subsequent API calls. When &lt;code&gt;next&lt;/code&gt; is no longer included in the response, no pages are remaining.</p>
     */
    public CompletableFuture<ManagementApiHttpResponse<SyncPagingIterable<ConnectionForList>>> list(
            ListConnectionsQueryParameters request) {
        return list(request, null);
    }

    /**
     * Retrieves detailed list of all &lt;a href=&quot;https://auth0.com/docs/authenticate/identity-providers&quot;&gt;connections&lt;/a&gt; that match the specified strategy. If no strategy is provided, all connections within your tenant are retrieved. This action can accept a list of fields to include or exclude from the resulting list of connections.
     * <p>This endpoint supports two types of pagination:</p>
     * <p>&lt;ul&gt;
     * &lt;li&gt;Offset pagination&lt;/li&gt;
     * &lt;li&gt;Checkpoint pagination&lt;/li&gt;
     * &lt;/ul&gt;</p>
     * <p>Checkpoint pagination must be used if you need to retrieve more than 1000 connections.</p>
     * <p>&lt;h2&gt;Checkpoint Pagination&lt;/h2&gt;</p>
     * <p>To search by checkpoint, use the following parameters:</p>
     * <p>&lt;ul&gt;
     * &lt;li&gt;&lt;code&gt;from&lt;/code&gt;: Optional id from which to start selection.&lt;/li&gt;
     * &lt;li&gt;&lt;code&gt;take&lt;/code&gt;: The total amount of entries to retrieve when using the from parameter. Defaults to 50.&lt;/li&gt;
     * &lt;/ul&gt;</p>
     * <p>&lt;b&gt;Note&lt;/b&gt;: The first time you call this endpoint using checkpoint pagination, omit the &lt;code&gt;from&lt;/code&gt; parameter. If there are more results, a &lt;code&gt;next&lt;/code&gt; value is included in the response. You can use this for subsequent API calls. When &lt;code&gt;next&lt;/code&gt; is no longer included in the response, no pages are remaining.</p>
     */
    public CompletableFuture<ManagementApiHttpResponse<SyncPagingIterable<ConnectionForList>>> list(
            ListConnectionsQueryParameters request, RequestOptions requestOptions) {
        HttpUrl.Builder httpUrl = HttpUrl.parse(this.clientOptions.environment().getUrl())
                .newBuilder()
                .addPathSegments("connections");
        if (!request.getFrom().isAbsent()) {
            QueryStringMapper.addQueryParameter(
                    httpUrl, "from", request.getFrom().orElse(null), false);
        }
        QueryStringMapper.addQueryParameter(httpUrl, "take", request.getTake().orElse(50), false);
        if (!request.getName().isAbsent()) {
            QueryStringMapper.addQueryParameter(
                    httpUrl, "name", request.getName().orElse(null), false);
        }
        if (!request.getFields().isAbsent()) {
            QueryStringMapper.addQueryParameter(
                    httpUrl, "fields", request.getFields().orElse(null), false);
        }
        if (!request.getIncludeFields().isAbsent()) {
            QueryStringMapper.addQueryParameter(
                    httpUrl, "include_fields", request.getIncludeFields().orElse(null), false);
        }
        if (request.getStrategy().isPresent()) {
            QueryStringMapper.addQueryParameter(
                    httpUrl, "strategy", request.getStrategy().get(), true);
        }
        Request.Builder _requestBuilder = new Request.Builder()
                .url(httpUrl.build())
                .method("GET", null)
                .headers(Headers.of(clientOptions.headers(requestOptions)))
                .addHeader("Accept", "application/json");
        Request okhttpRequest = _requestBuilder.build();
        OkHttpClient client = clientOptions.httpClient();
        if (requestOptions != null && requestOptions.getTimeout().isPresent()) {
            client = clientOptions.httpClientWithTimeout(requestOptions);
        }
        CompletableFuture<ManagementApiHttpResponse<SyncPagingIterable<ConnectionForList>>> future =
                new CompletableFuture<>();
        client.newCall(okhttpRequest).enqueue(new Callback() {
            @Override
            public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
                try (ResponseBody responseBody = response.body()) {
                    String responseBodyString = responseBody != null ? responseBody.string() : "{}";
                    if (response.isSuccessful()) {
                        ListConnectionsCheckpointPaginatedResponseContent parsedResponse =
                                ObjectMappers.JSON_MAPPER.readValue(
                                        responseBodyString, ListConnectionsCheckpointPaginatedResponseContent.class);
                        Optional<String> startingAfter = parsedResponse.getNext();
                        ListConnectionsQueryParameters nextRequest = ListConnectionsQueryParameters.builder()
                                .from(request)
                                .from(startingAfter)
                                .build();
                        List<ConnectionForList> result =
                                parsedResponse.getConnections().orElse(Collections.emptyList());
                        future.complete(new ManagementApiHttpResponse<>(
                                new SyncPagingIterable<ConnectionForList>(
                                        startingAfter.isPresent(), result, parsedResponse, () -> {
                                            try {
                                                return list(nextRequest, requestOptions)
                                                        .get()
                                                        .body();
                                            } catch (InterruptedException | ExecutionException e) {
                                                throw new RuntimeException(e);
                                            }
                                        }),
                                response));
                        return;
                    }
                    try {
                        switch (response.code()) {
                            case 400:
                                future.completeExceptionally(new BadRequestError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                            case 401:
                                future.completeExceptionally(new UnauthorizedError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                            case 403:
                                future.completeExceptionally(new ForbiddenError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                            case 429:
                                future.completeExceptionally(new TooManyRequestsError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                        }
                    } catch (JsonProcessingException ignored) {
                        // unable to map error response, throwing generic error
                    }
                    Object errorBody = ObjectMappers.parseErrorBody(responseBodyString);
                    future.completeExceptionally(new ManagementApiException(
                            "Error with status code " + response.code(), response.code(), errorBody, response));
                    return;
                } catch (IOException e) {
                    future.completeExceptionally(new ManagementException("Network error executing HTTP request", e));
                }
            }

            @Override
            public void onFailure(@NotNull Call call, @NotNull IOException e) {
                future.completeExceptionally(new ManagementException("Network error executing HTTP request", e));
            }
        });
        return future;
    }

    /**
     * Creates a new connection according to the JSON object received in &lt;code&gt;body&lt;/code&gt;.
     * <p>&lt;b&gt;Note:&lt;/b&gt; If a connection with the same name was recently deleted and had a large number of associated users, the deletion may still be processing. Creating a new connection with that name before the deletion completes may fail or produce unexpected results.</p>
     */
    public CompletableFuture<ManagementApiHttpResponse<CreateConnectionResponseContent>> create(
            CreateConnectionRequestContent request) {
        return create(request, null);
    }

    /**
     * Creates a new connection according to the JSON object received in &lt;code&gt;body&lt;/code&gt;.
     * <p>&lt;b&gt;Note:&lt;/b&gt; If a connection with the same name was recently deleted and had a large number of associated users, the deletion may still be processing. Creating a new connection with that name before the deletion completes may fail or produce unexpected results.</p>
     */
    public CompletableFuture<ManagementApiHttpResponse<CreateConnectionResponseContent>> create(
            CreateConnectionRequestContent request, RequestOptions requestOptions) {
        HttpUrl httpUrl = HttpUrl.parse(this.clientOptions.environment().getUrl())
                .newBuilder()
                .addPathSegments("connections")
                .build();
        RequestBody body;
        try {
            body = RequestBody.create(
                    ObjectMappers.JSON_MAPPER.writeValueAsBytes(request), MediaTypes.APPLICATION_JSON);
        } catch (JsonProcessingException e) {
            throw new ManagementException("Failed to serialize request", e);
        }
        Request okhttpRequest = new Request.Builder()
                .url(httpUrl)
                .method("POST", body)
                .headers(Headers.of(clientOptions.headers(requestOptions)))
                .addHeader("Content-Type", "application/json")
                .addHeader("Accept", "application/json")
                .build();
        OkHttpClient client = clientOptions.httpClient();
        if (requestOptions != null && requestOptions.getTimeout().isPresent()) {
            client = clientOptions.httpClientWithTimeout(requestOptions);
        }
        CompletableFuture<ManagementApiHttpResponse<CreateConnectionResponseContent>> future =
                new CompletableFuture<>();
        client.newCall(okhttpRequest).enqueue(new Callback() {
            @Override
            public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
                try (ResponseBody responseBody = response.body()) {
                    String responseBodyString = responseBody != null ? responseBody.string() : "{}";
                    if (response.isSuccessful()) {
                        future.complete(new ManagementApiHttpResponse<>(
                                ObjectMappers.JSON_MAPPER.readValue(
                                        responseBodyString, CreateConnectionResponseContent.class),
                                response));
                        return;
                    }
                    try {
                        switch (response.code()) {
                            case 400:
                                future.completeExceptionally(new BadRequestError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                            case 401:
                                future.completeExceptionally(new UnauthorizedError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                            case 403:
                                future.completeExceptionally(new ForbiddenError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                            case 409:
                                future.completeExceptionally(new ConflictError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                            case 429:
                                future.completeExceptionally(new TooManyRequestsError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                        }
                    } catch (JsonProcessingException ignored) {
                        // unable to map error response, throwing generic error
                    }
                    Object errorBody = ObjectMappers.parseErrorBody(responseBodyString);
                    future.completeExceptionally(new ManagementApiException(
                            "Error with status code " + response.code(), response.code(), errorBody, response));
                    return;
                } catch (IOException e) {
                    future.completeExceptionally(new ManagementException("Network error executing HTTP request", e));
                }
            }

            @Override
            public void onFailure(@NotNull Call call, @NotNull IOException e) {
                future.completeExceptionally(new ManagementException("Network error executing HTTP request", e));
            }
        });
        return future;
    }

    /**
     * Retrieve details for a specified &lt;a href=&quot;https://auth0.com/docs/authenticate/identity-providers&quot;&gt;connection&lt;/a&gt; along with options that can be used for identity provider configuration.
     */
    public CompletableFuture<ManagementApiHttpResponse<GetConnectionResponseContent>> get(String id) {
        return get(id, GetConnectionRequestParameters.builder().build());
    }

    /**
     * Retrieve details for a specified &lt;a href=&quot;https://auth0.com/docs/authenticate/identity-providers&quot;&gt;connection&lt;/a&gt; along with options that can be used for identity provider configuration.
     */
    public CompletableFuture<ManagementApiHttpResponse<GetConnectionResponseContent>> get(
            String id, GetConnectionRequestParameters request) {
        return get(id, request, null);
    }

    /**
     * Retrieve details for a specified &lt;a href=&quot;https://auth0.com/docs/authenticate/identity-providers&quot;&gt;connection&lt;/a&gt; along with options that can be used for identity provider configuration.
     */
    public CompletableFuture<ManagementApiHttpResponse<GetConnectionResponseContent>> get(
            String id, GetConnectionRequestParameters request, RequestOptions requestOptions) {
        HttpUrl.Builder httpUrl = HttpUrl.parse(this.clientOptions.environment().getUrl())
                .newBuilder()
                .addPathSegments("connections")
                .addPathSegment(id);
        if (!request.getFields().isAbsent()) {
            QueryStringMapper.addQueryParameter(
                    httpUrl, "fields", request.getFields().orElse(null), false);
        }
        if (!request.getIncludeFields().isAbsent()) {
            QueryStringMapper.addQueryParameter(
                    httpUrl, "include_fields", request.getIncludeFields().orElse(null), false);
        }
        Request.Builder _requestBuilder = new Request.Builder()
                .url(httpUrl.build())
                .method("GET", null)
                .headers(Headers.of(clientOptions.headers(requestOptions)))
                .addHeader("Accept", "application/json");
        Request okhttpRequest = _requestBuilder.build();
        OkHttpClient client = clientOptions.httpClient();
        if (requestOptions != null && requestOptions.getTimeout().isPresent()) {
            client = clientOptions.httpClientWithTimeout(requestOptions);
        }
        CompletableFuture<ManagementApiHttpResponse<GetConnectionResponseContent>> future = new CompletableFuture<>();
        client.newCall(okhttpRequest).enqueue(new Callback() {
            @Override
            public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
                try (ResponseBody responseBody = response.body()) {
                    String responseBodyString = responseBody != null ? responseBody.string() : "{}";
                    if (response.isSuccessful()) {
                        future.complete(new ManagementApiHttpResponse<>(
                                ObjectMappers.JSON_MAPPER.readValue(
                                        responseBodyString, GetConnectionResponseContent.class),
                                response));
                        return;
                    }
                    try {
                        switch (response.code()) {
                            case 400:
                                future.completeExceptionally(new BadRequestError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                            case 401:
                                future.completeExceptionally(new UnauthorizedError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                            case 403:
                                future.completeExceptionally(new ForbiddenError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                            case 404:
                                future.completeExceptionally(new NotFoundError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                            case 429:
                                future.completeExceptionally(new TooManyRequestsError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                        }
                    } catch (JsonProcessingException ignored) {
                        // unable to map error response, throwing generic error
                    }
                    Object errorBody = ObjectMappers.parseErrorBody(responseBodyString);
                    future.completeExceptionally(new ManagementApiException(
                            "Error with status code " + response.code(), response.code(), errorBody, response));
                    return;
                } catch (IOException e) {
                    future.completeExceptionally(new ManagementException("Network error executing HTTP request", e));
                }
            }

            @Override
            public void onFailure(@NotNull Call call, @NotNull IOException e) {
                future.completeExceptionally(new ManagementException("Network error executing HTTP request", e));
            }
        });
        return future;
    }

    /**
     * Removes a specific &lt;a href=&quot;https://auth0.com/docs/authenticate/identity-providers&quot;&gt;connection&lt;/a&gt; from your tenant. This action cannot be undone. Once removed, users can no longer use this connection to authenticate.
     * <p>&lt;b&gt;Note:&lt;/b&gt; If your connection has a large amount of users associated with it, please be aware that this operation can be long running after the response is returned and may impact concurrent &lt;a href=&quot;https://auth0.com/docs/api/management/v2/connections/post-connections&quot;&gt;create connection&lt;/a&gt; requests, if they use an identical connection name.</p>
     */
    public CompletableFuture<ManagementApiHttpResponse<Void>> delete(String id) {
        return delete(id, null);
    }

    /**
     * Removes a specific &lt;a href=&quot;https://auth0.com/docs/authenticate/identity-providers&quot;&gt;connection&lt;/a&gt; from your tenant. This action cannot be undone. Once removed, users can no longer use this connection to authenticate.
     * <p>&lt;b&gt;Note:&lt;/b&gt; If your connection has a large amount of users associated with it, please be aware that this operation can be long running after the response is returned and may impact concurrent &lt;a href=&quot;https://auth0.com/docs/api/management/v2/connections/post-connections&quot;&gt;create connection&lt;/a&gt; requests, if they use an identical connection name.</p>
     */
    public CompletableFuture<ManagementApiHttpResponse<Void>> delete(String id, RequestOptions requestOptions) {
        HttpUrl httpUrl = HttpUrl.parse(this.clientOptions.environment().getUrl())
                .newBuilder()
                .addPathSegments("connections")
                .addPathSegment(id)
                .build();
        Request okhttpRequest = new Request.Builder()
                .url(httpUrl)
                .method("DELETE", null)
                .headers(Headers.of(clientOptions.headers(requestOptions)))
                .addHeader("Accept", "application/json")
                .build();
        OkHttpClient client = clientOptions.httpClient();
        if (requestOptions != null && requestOptions.getTimeout().isPresent()) {
            client = clientOptions.httpClientWithTimeout(requestOptions);
        }
        CompletableFuture<ManagementApiHttpResponse<Void>> future = new CompletableFuture<>();
        client.newCall(okhttpRequest).enqueue(new Callback() {
            @Override
            public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
                try (ResponseBody responseBody = response.body()) {
                    if (response.isSuccessful()) {
                        future.complete(new ManagementApiHttpResponse<>(null, response));
                        return;
                    }
                    String responseBodyString = responseBody != null ? responseBody.string() : "{}";
                    try {
                        switch (response.code()) {
                            case 400:
                                future.completeExceptionally(new BadRequestError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                            case 401:
                                future.completeExceptionally(new UnauthorizedError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                            case 403:
                                future.completeExceptionally(new ForbiddenError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                            case 429:
                                future.completeExceptionally(new TooManyRequestsError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                        }
                    } catch (JsonProcessingException ignored) {
                        // unable to map error response, throwing generic error
                    }
                    Object errorBody = ObjectMappers.parseErrorBody(responseBodyString);
                    future.completeExceptionally(new ManagementApiException(
                            "Error with status code " + response.code(), response.code(), errorBody, response));
                    return;
                } catch (IOException e) {
                    future.completeExceptionally(new ManagementException("Network error executing HTTP request", e));
                }
            }

            @Override
            public void onFailure(@NotNull Call call, @NotNull IOException e) {
                future.completeExceptionally(new ManagementException("Network error executing HTTP request", e));
            }
        });
        return future;
    }

    /**
     * Update details for a specific &lt;a href=&quot;https://auth0.com/docs/authenticate/identity-providers&quot;&gt;connection&lt;/a&gt;, including option properties for identity provider configuration.
     * <p>&lt;b&gt;Note&lt;/b&gt;: If you use the &lt;code&gt;options&lt;/code&gt; parameter, the entire &lt;code&gt;options&lt;/code&gt; object is overriden. To avoid partial data or other issues, ensure all parameters are present when using this option.</p>
     */
    public CompletableFuture<ManagementApiHttpResponse<UpdateConnectionResponseContent>> update(String id) {
        return update(id, UpdateConnectionRequestContent.builder().build());
    }

    /**
     * Update details for a specific &lt;a href=&quot;https://auth0.com/docs/authenticate/identity-providers&quot;&gt;connection&lt;/a&gt;, including option properties for identity provider configuration.
     * <p>&lt;b&gt;Note&lt;/b&gt;: If you use the &lt;code&gt;options&lt;/code&gt; parameter, the entire &lt;code&gt;options&lt;/code&gt; object is overriden. To avoid partial data or other issues, ensure all parameters are present when using this option.</p>
     */
    public CompletableFuture<ManagementApiHttpResponse<UpdateConnectionResponseContent>> update(
            String id, UpdateConnectionRequestContent request) {
        return update(id, request, null);
    }

    /**
     * Update details for a specific &lt;a href=&quot;https://auth0.com/docs/authenticate/identity-providers&quot;&gt;connection&lt;/a&gt;, including option properties for identity provider configuration.
     * <p>&lt;b&gt;Note&lt;/b&gt;: If you use the &lt;code&gt;options&lt;/code&gt; parameter, the entire &lt;code&gt;options&lt;/code&gt; object is overriden. To avoid partial data or other issues, ensure all parameters are present when using this option.</p>
     */
    public CompletableFuture<ManagementApiHttpResponse<UpdateConnectionResponseContent>> update(
            String id, UpdateConnectionRequestContent request, RequestOptions requestOptions) {
        HttpUrl httpUrl = HttpUrl.parse(this.clientOptions.environment().getUrl())
                .newBuilder()
                .addPathSegments("connections")
                .addPathSegment(id)
                .build();
        RequestBody body;
        try {
            body = RequestBody.create(
                    ObjectMappers.JSON_MAPPER.writeValueAsBytes(request), MediaTypes.APPLICATION_JSON);
        } catch (JsonProcessingException e) {
            throw new ManagementException("Failed to serialize request", e);
        }
        Request okhttpRequest = new Request.Builder()
                .url(httpUrl)
                .method("PATCH", body)
                .headers(Headers.of(clientOptions.headers(requestOptions)))
                .addHeader("Content-Type", "application/json")
                .addHeader("Accept", "application/json")
                .build();
        OkHttpClient client = clientOptions.httpClient();
        if (requestOptions != null && requestOptions.getTimeout().isPresent()) {
            client = clientOptions.httpClientWithTimeout(requestOptions);
        }
        CompletableFuture<ManagementApiHttpResponse<UpdateConnectionResponseContent>> future =
                new CompletableFuture<>();
        client.newCall(okhttpRequest).enqueue(new Callback() {
            @Override
            public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
                try (ResponseBody responseBody = response.body()) {
                    String responseBodyString = responseBody != null ? responseBody.string() : "{}";
                    if (response.isSuccessful()) {
                        future.complete(new ManagementApiHttpResponse<>(
                                ObjectMappers.JSON_MAPPER.readValue(
                                        responseBodyString, UpdateConnectionResponseContent.class),
                                response));
                        return;
                    }
                    try {
                        switch (response.code()) {
                            case 400:
                                future.completeExceptionally(new BadRequestError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                            case 401:
                                future.completeExceptionally(new UnauthorizedError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                            case 403:
                                future.completeExceptionally(new ForbiddenError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                            case 404:
                                future.completeExceptionally(new NotFoundError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                            case 409:
                                future.completeExceptionally(new ConflictError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                            case 429:
                                future.completeExceptionally(new TooManyRequestsError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                        }
                    } catch (JsonProcessingException ignored) {
                        // unable to map error response, throwing generic error
                    }
                    Object errorBody = ObjectMappers.parseErrorBody(responseBodyString);
                    future.completeExceptionally(new ManagementApiException(
                            "Error with status code " + response.code(), response.code(), errorBody, response));
                    return;
                } catch (IOException e) {
                    future.completeExceptionally(new ManagementException("Network error executing HTTP request", e));
                }
            }

            @Override
            public void onFailure(@NotNull Call call, @NotNull IOException e) {
                future.completeExceptionally(new ManagementException("Network error executing HTTP request", e));
            }
        });
        return future;
    }

    /**
     * Retrieves the status of an ad/ldap connection referenced by its &lt;code&gt;ID&lt;/code&gt;. &lt;code&gt;200 OK&lt;/code&gt; http status code response is returned  when the connection is online, otherwise a &lt;code&gt;404&lt;/code&gt; status code is returned along with an error message
     */
    public CompletableFuture<ManagementApiHttpResponse<Void>> checkStatus(String id) {
        return checkStatus(id, null);
    }

    /**
     * Retrieves the status of an ad/ldap connection referenced by its &lt;code&gt;ID&lt;/code&gt;. &lt;code&gt;200 OK&lt;/code&gt; http status code response is returned  when the connection is online, otherwise a &lt;code&gt;404&lt;/code&gt; status code is returned along with an error message
     */
    public CompletableFuture<ManagementApiHttpResponse<Void>> checkStatus(String id, RequestOptions requestOptions) {
        HttpUrl httpUrl = HttpUrl.parse(this.clientOptions.environment().getUrl())
                .newBuilder()
                .addPathSegments("connections")
                .addPathSegment(id)
                .addPathSegments("status")
                .build();
        Request okhttpRequest = new Request.Builder()
                .url(httpUrl)
                .method("GET", null)
                .headers(Headers.of(clientOptions.headers(requestOptions)))
                .addHeader("Accept", "application/json")
                .build();
        OkHttpClient client = clientOptions.httpClient();
        if (requestOptions != null && requestOptions.getTimeout().isPresent()) {
            client = clientOptions.httpClientWithTimeout(requestOptions);
        }
        CompletableFuture<ManagementApiHttpResponse<Void>> future = new CompletableFuture<>();
        client.newCall(okhttpRequest).enqueue(new Callback() {
            @Override
            public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
                try (ResponseBody responseBody = response.body()) {
                    if (response.isSuccessful()) {
                        future.complete(new ManagementApiHttpResponse<>(null, response));
                        return;
                    }
                    String responseBodyString = responseBody != null ? responseBody.string() : "{}";
                    try {
                        switch (response.code()) {
                            case 400:
                                future.completeExceptionally(new BadRequestError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                            case 401:
                                future.completeExceptionally(new UnauthorizedError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                            case 403:
                                future.completeExceptionally(new ForbiddenError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                            case 404:
                                future.completeExceptionally(new NotFoundError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                            case 429:
                                future.completeExceptionally(new TooManyRequestsError(
                                        ObjectMappers.JSON_MAPPER.readValue(responseBodyString, Object.class),
                                        response));
                                return;
                        }
                    } catch (JsonProcessingException ignored) {
                        // unable to map error response, throwing generic error
                    }
                    Object errorBody = ObjectMappers.parseErrorBody(responseBodyString);
                    future.completeExceptionally(new ManagementApiException(
                            "Error with status code " + response.code(), response.code(), errorBody, response));
                    return;
                } catch (IOException e) {
                    future.completeExceptionally(new ManagementException("Network error executing HTTP request", e));
                }
            }

            @Override
            public void onFailure(@NotNull Call call, @NotNull IOException e) {
                future.completeExceptionally(new ManagementException("Network error executing HTTP request", e));
            }
        });
        return future;
    }
}