Merge pull request #63 from apideck-libraries/speakeasy-sdk-regen-1756222557

chore: 🐝 Update SDK - Generate 0.20.0

Author: Amzani

.speakeasy/gen.lock

@@ -21,18 +21,19 @@ generation:
     generateNewTests: false
     skipResponseBodyAssertions: false
 java:
-  version: 0.19.6
+  version: 0.20.0
   additionalDependencies: []
   additionalPlugins: []
   artifactID: unify
+  asyncMode: enabled
   baseErrorName: ApideckError
   clientServerStatusCodesAsErrors: true
   companyEmail: [email protected]
   companyName: Apideck
   companyURL: www.apideck.com
   defaultErrorName: APIException
-  enableAsync: false
   enableCustomCodeRegions: false
+  enableStreamingUploads: false
   flattenGlobalSecurity: true
   githubURL: github.com/apideck-libraries/sdk-java
   groupID: com.apideck

.speakeasy/gen.yaml

@@ -1,21 +1,21 @@
-speakeasyVersion: 1.606.4
+speakeasyVersion: 1.611.1
 sources:
     Apideck-OAS:
         sourceNamespace: apideck-oas
-        sourceRevisionDigest: sha256:078e68a8cec3da1e448d7bc55dd01b005f0098ef6b50595d24b7ebc9c07f4b89
-        sourceBlobDigest: sha256:124328f4c187b9316e99832028dd5a8473d10f603564cf1bd2bfdbad33f8fb66
+        sourceRevisionDigest: sha256:cb0201d032f54350a28bd8c493037ef74777e49604a1b8f76718c2d0d9918db4
+        sourceBlobDigest: sha256:88de9a39fea7106d70b4526a9c8207a4c54c38a3c13136b2b27fbb947336e267
         tags:
             - latest
-            - speakeasy-sdk-regen-1755873448
-            - 10.20.11
+            - speakeasy-sdk-regen-1756222557
+            - 10.20.13
 targets:
     apideck:
         source: Apideck-OAS
         sourceNamespace: apideck-oas
-        sourceRevisionDigest: sha256:078e68a8cec3da1e448d7bc55dd01b005f0098ef6b50595d24b7ebc9c07f4b89
-        sourceBlobDigest: sha256:124328f4c187b9316e99832028dd5a8473d10f603564cf1bd2bfdbad33f8fb66
+        sourceRevisionDigest: sha256:cb0201d032f54350a28bd8c493037ef74777e49604a1b8f76718c2d0d9918db4
+        sourceBlobDigest: sha256:88de9a39fea7106d70b4526a9c8207a4c54c38a3c13136b2b27fbb947336e267
         codeSamplesNamespace: apideck-oas-java-code-samples
-        codeSamplesRevisionDigest: sha256:ea92545e2dff7135fd738b339b446c1d7c8523e0474e42ce69ba8f42dfaf5344
+        codeSamplesRevisionDigest: sha256:54eb8baab6c83d948e18f408565f292b896a31660c931e855c482b86d9b5b56c
 workflow:
     workflowVersion: 1.0.0
     speakeasyVersion: latest

.speakeasy/workflow.lock

@@ -29,6 +29,7 @@ For more information about the API: [Apideck Developer Docs](https://developers.
   * [Retries](#retries)
   * [Error Handling](#error-handling)
   * [Server Selection](#server-selection)
+  * [Asynchronous Support](#asynchronous-support)
   * [Authentication](#authentication)
   * [Debugging](#debugging)
 * [Development](#development)
@@ -48,15 +49,15 @@ The samples below show how a published SDK artifact is used:
 
 Gradle:
 ```groovy
-implementation 'com.apideck:unify:0.19.6'
+implementation 'com.apideck:unify:0.20.0'
 ```
 
 Maven:
 ```xml
 <dependency>
     <groupId>com.apideck</groupId>
     <artifactId>unify</artifactId>
-    <version>0.19.6</version>
+    <version>0.20.0</version>
 </dependency>
 ```
 
@@ -115,8 +116,8 @@ public class Application {
                 .fields("id,updated_at")
                 .build();
 
+
         sdk.accounting().taxRates().list()
-                .request(req)
                 .callAsStream()
                 .forEach((AccountingTaxRatesAllResponse item) -> {
                    // handle page
@@ -125,6 +126,60 @@ public class Application {
     }
 }
 ```
+#### Asynchronous Call
+An asynchronous SDK client is also available that returns a [`CompletableFuture<T>`][comp-fut]. See [Asynchronous Support](#asynchronous-support) for more details on async benefits and reactive library integration.
+```java
+package hello.world;
+
+import com.apideck.unify.Apideck;
+import com.apideck.unify.AsyncApideck;
+import com.apideck.unify.models.components.TaxRatesFilter;
+import com.apideck.unify.models.operations.AccountingTaxRatesAllRequest;
+import com.apideck.unify.models.operations.async.AccountingTaxRatesAllResponse;
+import java.util.Map;
+import reactor.core.publisher.Flux;
+
+public class Application {
+
+    public static void main(String[] args) {
+
+        AsyncApideck sdk = Apideck.builder()
+                .consumerId("test-consumer")
+                .appId("dSBdXd2H6Mqwfg0atXHXYcysLJE9qyn1VwBtXHX")
+                .apiKey(System.getenv().getOrDefault("API_KEY", ""))
+            .build()
+            .async();
+
+        AccountingTaxRatesAllRequest req = AccountingTaxRatesAllRequest.builder()
+                .serviceId("salesforce")
+                .filter(TaxRatesFilter.builder()
+                    .assets(true)
+                    .equity(true)
+                    .expenses(true)
+                    .liabilities(true)
+                    .revenue(true)
+                    .build())
+                .passThrough(Map.ofEntries(
+                    Map.entry("search", "San Francisco")))
+                .fields("id,updated_at")
+                .build();
+
+
+        var b = sdk.accounting().taxRates().list();
+
+        // Example using Project Reactor (illustrative) - pages
+        Flux<AccountingTaxRatesAllResponse> pageFlux = Flux.from(b.callAsPublisher());
+        pageFlux.subscribe(
+            page -> System.out.println(page),
+            error -> error.printStackTrace(),
+            () -> System.out.println("Pagination completed")
+        );
+
+    }
+}
+```
+
+[comp-fut]: https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CompletableFuture.html
 <!-- End SDK Example Usage [usage] -->
 
 <!-- Start Available Resources and Operations [operations] -->
@@ -637,6 +692,14 @@ public class Application {
 ### [vault()](docs/sdks/vault/README.md)
 
 
+#### [vault().connectionConsent()](docs/sdks/connectionconsent/README.md)
+
+* [update](docs/sdks/connectionconsent/README.md#update) - Update consent state
+
+#### [vault().connectionConsents()](docs/sdks/connectionconsents/README.md)
+
+* [list](docs/sdks/connectionconsents/README.md#list) - Get consent records
+
 #### [vault().connectionCustomMappings()](docs/sdks/connectioncustommappings/README.md)
 
 * [list](docs/sdks/connectioncustommappings/README.md#list) - List connection custom mappings
@@ -713,7 +776,6 @@ For certain operations, you can also use the `callAsStreamUnwrapped` method that
 
 Here's an example depicting the different ways to use pagination:
 
-
 ```java
 package hello.world;
 
@@ -750,8 +812,8 @@ public class Application {
                 .fields("id,updated_at")
                 .build();
 
-        var b = sdk.accounting().taxRates().list()
-                .request(req);
+
+        var b = sdk.accounting().taxRates().list();
 
         // Iterate through all pages using a traditional for-each loop
         // Each iteration returns a complete page response
@@ -772,6 +834,60 @@ public class Application {
     }
 }
 ```
+#### Asynchronous Pagination
+An asynchronous SDK client is also available for pagination that returns a [`Flow.Publisher<T>`][flow-pub]. For async pagination, you can use `callAsPublisher()` to get pages as a publisher, or `callAsPublisherUnwrapped()` to get individual items directly. See [Asynchronous Support](#asynchronous-support) for more details on async benefits and reactive library integration.
+```java
+package hello.world;
+
+import com.apideck.unify.Apideck;
+import com.apideck.unify.AsyncApideck;
+import com.apideck.unify.models.components.TaxRatesFilter;
+import com.apideck.unify.models.operations.AccountingTaxRatesAllRequest;
+import com.apideck.unify.models.operations.async.AccountingTaxRatesAllResponse;
+import java.util.Map;
+import reactor.core.publisher.Flux;
+
+public class Application {
+
+    public static void main(String[] args) {
+
+        AsyncApideck sdk = Apideck.builder()
+                .consumerId("test-consumer")
+                .appId("dSBdXd2H6Mqwfg0atXHXYcysLJE9qyn1VwBtXHX")
+                .apiKey(System.getenv().getOrDefault("API_KEY", ""))
+            .build()
+            .async();
+
+        AccountingTaxRatesAllRequest req = AccountingTaxRatesAllRequest.builder()
+                .serviceId("salesforce")
+                .filter(TaxRatesFilter.builder()
+                    .assets(true)
+                    .equity(true)
+                    .expenses(true)
+                    .liabilities(true)
+                    .revenue(true)
+                    .build())
+                .passThrough(Map.ofEntries(
+                    Map.entry("search", "San Francisco")))
+                .fields("id,updated_at")
+                .build();
+
+
+        var b = sdk.accounting().taxRates().list();
+
+        // Example using Project Reactor (illustrative) - pages
+        Flux<AccountingTaxRatesAllResponse> pageFlux = Flux.from(b.callAsPublisher());
+        pageFlux.subscribe(
+            page -> System.out.println(page),
+            error -> error.printStackTrace(),
+            () -> System.out.println("Pagination completed")
+        );
+
+    }
+}
+```
+
+[flow-pub]: https://docs.oracle.com/javase/9/docs/api/java/util/concurrent/Flow.Publisher.html
 <!-- End Pagination [pagination] -->
 
 <!-- Start Retries [retries] -->
@@ -818,8 +934,8 @@ public class Application {
                 .fields("id,updated_at")
                 .build();
 
+
         sdk.accounting().taxRates().list()
-                .request(req)
                 .retryConfig(RetryConfig.builder()
                     .backoff(BackoffStrategy.builder()
                         .initialInterval(1L, TimeUnit.MILLISECONDS)
@@ -888,8 +1004,8 @@ public class Application {
                 .fields("id,updated_at")
                 .build();
 
+
         sdk.accounting().taxRates().list()
-                .request(req)
                 .callAsStream()
                 .forEach((AccountingTaxRatesAllResponse item) -> {
                    // handle page
@@ -953,8 +1069,8 @@ public class Application {
                 .fields("id,updated_at")
                 .build();
 
+
         sdk.accounting().taxRates().list()
-                .request(req)
                 .callAsStream()
                 .forEach((AccountingTaxRatesAllResponse item) -> {
                    // handle page
@@ -1007,8 +1123,8 @@ public class Application {
                 .fields("id,updated_at")
                 .build();
 
+
         sdk.accounting().taxRates().list()
-                .request(req)
                 .callAsStream()
                 .forEach((AccountingTaxRatesAllResponse item) -> {
                    // handle page
@@ -1055,14 +1171,77 @@ public class Application {
                 .serverURL("https://upload.apideck.com")
                 .call();
 
-        if (res.createAttachmentResponse().isPresent()) {
-            // handle response
-        }
     }
 }
 ```
 <!-- End Server Selection [server] -->
 
+<!-- Start Asynchronous Support [async-support] -->
+## Asynchronous Support
+
+The SDK provides comprehensive asynchronous support using Java's [`CompletableFuture<T>`][comp-fut] and [Reactive Streams `Publisher<T>`][reactive-streams] APIs. This design makes no assumptions about your choice of reactive toolkit, allowing seamless integration with any reactive library.
+
+<details>
+<summary>Why Use Async?</summary>
+
+Asynchronous operations provide several key benefits:
+
+- **Non-blocking I/O**: Your threads stay free for other work while operations are in flight
+- **Better resource utilization**: Handle more concurrent operations with fewer threads
+- **Improved scalability**: Build highly responsive applications that can handle thousands of concurrent requests
+- **Reactive integration**: Works seamlessly with reactive streams and backpressure handling
+
+</details>
+
+<details>
+<summary>Reactive Library Integration</summary>
+
+The SDK returns [Reactive Streams `Publisher<T>`][reactive-streams] instances for operations dealing with streams involving multiple I/O interactions. We use Reactive Streams instead of JDK Flow API to provide broader compatibility with the reactive ecosystem, as most reactive libraries natively support Reactive Streams.
+
+**Why Reactive Streams over JDK Flow?**
+- **Broader ecosystem compatibility**: Most reactive libraries (Project Reactor, RxJava, Akka Streams, etc.) natively support Reactive Streams
+- **Industry standard**: Reactive Streams is the de facto standard for reactive programming in Java
+- **Better interoperability**: Seamless integration without additional adapters for most use cases
+
+**Integration with Popular Libraries:**
+- **Project Reactor**: Use `Flux.from(publisher)` to convert to Reactor types
+- **RxJava**: Use `Flowable.fromPublisher(publisher)` for RxJava integration
+- **Akka Streams**: Use `Source.fromPublisher(publisher)` for Akka Streams integration
+- **Vert.x**: Use `ReadStream.fromPublisher(vertx, publisher)` for Vert.x reactive streams
+- **Mutiny**: Use `Multi.createFrom().publisher(publisher)` for Quarkus Mutiny integration
+
+**For JDK Flow API Integration:**
+If you need JDK Flow API compatibility (e.g., for Quarkus/Mutiny 2), you can use adapters:
+```java
+// Convert Reactive Streams Publisher to Flow Publisher
+Flow.Publisher<T> flowPublisher = FlowAdapters.toFlowPublisher(reactiveStreamsPublisher);
+
+// Convert Flow Publisher to Reactive Streams Publisher
+Publisher<T> reactiveStreamsPublisher = FlowAdapters.toPublisher(flowPublisher);
+```
+
+For standard single-response operations, the SDK returns `CompletableFuture<T>` for straightforward async execution.
+
+</details>
+
+<details>
+<summary>Supported Operations</summary>
+
+Async support is available for:
+
+- **[Server-sent Events](#server-sent-event-streaming)**: Stream real-time events with Reactive Streams `Publisher<T>`
+- **[JSONL Streaming](#jsonl-streaming)**: Process streaming JSON lines asynchronously
+- **[Pagination](#pagination)**: Iterate through paginated results using `callAsPublisher()` and `callAsPublisherUnwrapped()`
+- **[File Uploads](#file-uploads)**: Upload files asynchronously with progress tracking
+- **[File Downloads](#file-downloads)**: Download files asynchronously with streaming support
+- **[Standard Operations](#example)**: All regular API calls return `CompletableFuture<T>` for async execution
+
+</details>
+
+[comp-fut]: https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CompletableFuture.html
+[reactive-streams]: https://www.reactive-streams.org/
+<!-- End Asynchronous Support [async-support] -->
+
 <!-- Start Authentication [security] -->
 ## Authentication
 
@@ -1110,8 +1289,8 @@ public class Application {
                 .fields("id,updated_at")
                 .build();
 
+
         sdk.accounting().taxRates().list()
-                .request(req)
                 .callAsStream()
                 .forEach((AccountingTaxRatesAllResponse item) -> {
                    // handle page

README.md

@@ -458,4 +458,14 @@ Based on:
 ### Generated
 - [java v0.19.6] .
 ### Releases
-- [Maven Central v0.19.6] https://central.sonatype.com/artifact/com.apideck/unify/0.19.6 - .
+- [Maven Central v0.19.6] https://central.sonatype.com/artifact/com.apideck/unify/0.19.6 - .
+
+## 2025-09-08 00:13:18
+### Changes
+Based on:
+- OpenAPI Doc  
+- Speakeasy CLI 1.611.1 (2.694.1) https://github.com/speakeasy-api/speakeasy
+### Generated
+- [java v0.20.0] .
+### Releases
+- [Maven Central v0.20.0] https://central.sonatype.com/artifact/com.apideck/unify/0.20.0 - .