diff --git a/.release-please-manifest.json b/.release-please-manifest.json index e4c7212c2..9140438b9 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.465.0" + ".": "0.466.0" } \ No newline at end of file diff --git a/.stats.yml b/.stats.yml index 84bf4fe96..2c77a37fa 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 237 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/increase%2Fincrease-1a8ae6b4ff6276a68a103dca4c701c77d409afe3f08ef8435adb3527e1385ce7.yml -openapi_spec_hash: d56da3ae77306aec4c8530fba0dfe053 -config_hash: 896b006f9647a513eda3b228cf17c199 +configured_endpoints: 238 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/increase%2Fincrease-1ce680832c1cad08fe72f9d4b9df37379affbe88f539448d991039474dce6674.yml +openapi_spec_hash: 5d9c89c10f5987dc5596134d1f2c1668 +config_hash: e75db3094e90d5e48a2077b010b620f0 diff --git a/CHANGELOG.md b/CHANGELOG.md index a4dcfd6dc..cdc6af110 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog +## 0.466.0 (2026-03-12) + +Full Changelog: [v0.465.0...v0.466.0](https://github.com/Increase/increase-java/compare/v0.465.0...v0.466.0) + +### Features + +* **api:** api update ([5730903](https://github.com/Increase/increase-java/commit/573090390c2c081b4d403758c7ed8cf7c00cfe62)) + ## 0.465.0 (2026-03-12) Full Changelog: [v0.464.0...v0.465.0](https://github.com/Increase/increase-java/compare/v0.464.0...v0.465.0) diff --git a/README.md b/README.md index 97ac023a7..ac5ecd10d 100644 --- a/README.md +++ b/README.md @@ -2,8 +2,8 @@ -[![Maven Central](https://img.shields.io/maven-central/v/com.increase.api/increase-java)](https://central.sonatype.com/artifact/com.increase.api/increase-java/0.465.0) -[![javadoc](https://javadoc.io/badge2/com.increase.api/increase-java/0.465.0/javadoc.svg)](https://javadoc.io/doc/com.increase.api/increase-java/0.465.0) +[![Maven Central](https://img.shields.io/maven-central/v/com.increase.api/increase-java)](https://central.sonatype.com/artifact/com.increase.api/increase-java/0.466.0) +[![javadoc](https://javadoc.io/badge2/com.increase.api/increase-java/0.466.0/javadoc.svg)](https://javadoc.io/doc/com.increase.api/increase-java/0.466.0) @@ -13,7 +13,7 @@ The Increase Java SDK is similar to the Increase Kotlin SDK but with minor diffe -The REST API documentation can be found on [increase.com](https://increase.com/documentation). Javadocs are available on [javadoc.io](https://javadoc.io/doc/com.increase.api/increase-java/0.465.0). +The REST API documentation can be found on [increase.com](https://increase.com/documentation). Javadocs are available on [javadoc.io](https://javadoc.io/doc/com.increase.api/increase-java/0.466.0). @@ -24,7 +24,7 @@ The REST API documentation can be found on [increase.com](https://increase.com/d ### Gradle ```kotlin -implementation("com.increase.api:increase-java:0.465.0") +implementation("com.increase.api:increase-java:0.466.0") ``` ### Maven @@ -33,7 +33,7 @@ implementation("com.increase.api:increase-java:0.465.0") com.increase.api increase-java - 0.465.0 + 0.466.0 ``` diff --git a/build.gradle.kts b/build.gradle.kts index 1bad46486..2bf32b27d 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -8,7 +8,7 @@ repositories { allprojects { group = "com.increase.api" - version = "0.465.0" // x-release-please-version + version = "0.466.0" // x-release-please-version } subprojects { diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/beneficialowners/BeneficialOwnerArchiveParams.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/beneficialowners/BeneficialOwnerArchiveParams.kt new file mode 100644 index 000000000..9cb022446 --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/beneficialowners/BeneficialOwnerArchiveParams.kt @@ -0,0 +1,245 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.beneficialowners + +import com.increase.api.core.JsonValue +import com.increase.api.core.Params +import com.increase.api.core.http.Headers +import com.increase.api.core.http.QueryParams +import com.increase.api.core.toImmutable +import java.util.Objects +import java.util.Optional +import kotlin.jvm.optionals.getOrNull + +/** Archive a Beneficial Owner */ +class BeneficialOwnerArchiveParams +private constructor( + private val entityBeneficialOwnerId: String?, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, + private val additionalBodyProperties: Map, +) : Params { + + /** The identifier of the Beneficial Owner to archive. */ + fun entityBeneficialOwnerId(): Optional = Optional.ofNullable(entityBeneficialOwnerId) + + /** Additional body properties to send with the request. */ + fun _additionalBodyProperties(): Map = additionalBodyProperties + + /** Additional headers to send with the request. */ + fun _additionalHeaders(): Headers = additionalHeaders + + /** Additional query param to send with the request. */ + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun toBuilder() = Builder().from(this) + + companion object { + + @JvmStatic fun none(): BeneficialOwnerArchiveParams = builder().build() + + /** + * Returns a mutable builder for constructing an instance of [BeneficialOwnerArchiveParams]. + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [BeneficialOwnerArchiveParams]. */ + class Builder internal constructor() { + + private var entityBeneficialOwnerId: String? = null + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() + private var additionalBodyProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(beneficialOwnerArchiveParams: BeneficialOwnerArchiveParams) = apply { + entityBeneficialOwnerId = beneficialOwnerArchiveParams.entityBeneficialOwnerId + additionalHeaders = beneficialOwnerArchiveParams.additionalHeaders.toBuilder() + additionalQueryParams = beneficialOwnerArchiveParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + beneficialOwnerArchiveParams.additionalBodyProperties.toMutableMap() + } + + /** The identifier of the Beneficial Owner to archive. */ + fun entityBeneficialOwnerId(entityBeneficialOwnerId: String?) = apply { + this.entityBeneficialOwnerId = entityBeneficialOwnerId + } + + /** + * Alias for calling [Builder.entityBeneficialOwnerId] with + * `entityBeneficialOwnerId.orElse(null)`. + */ + fun entityBeneficialOwnerId(entityBeneficialOwnerId: Optional) = + entityBeneficialOwnerId(entityBeneficialOwnerId.getOrNull()) + + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) + } + + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) + } + + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.putAll(additionalHeaders) + } + + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replace(name, value) + } + + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + this.additionalQueryParams.putAll(additionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replace(key, value) + } + + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } + + fun removeAllAdditionalQueryParams(keys: Set) = apply { + additionalQueryParams.removeAll(keys) + } + + fun additionalBodyProperties(additionalBodyProperties: Map) = apply { + this.additionalBodyProperties.clear() + putAllAdditionalBodyProperties(additionalBodyProperties) + } + + fun putAdditionalBodyProperty(key: String, value: JsonValue) = apply { + additionalBodyProperties.put(key, value) + } + + fun putAllAdditionalBodyProperties(additionalBodyProperties: Map) = + apply { + this.additionalBodyProperties.putAll(additionalBodyProperties) + } + + fun removeAdditionalBodyProperty(key: String) = apply { + additionalBodyProperties.remove(key) + } + + fun removeAllAdditionalBodyProperties(keys: Set) = apply { + keys.forEach(::removeAdditionalBodyProperty) + } + + /** + * Returns an immutable instance of [BeneficialOwnerArchiveParams]. + * + * Further updates to this [Builder] will not mutate the returned instance. + */ + fun build(): BeneficialOwnerArchiveParams = + BeneficialOwnerArchiveParams( + entityBeneficialOwnerId, + additionalHeaders.build(), + additionalQueryParams.build(), + additionalBodyProperties.toImmutable(), + ) + } + + fun _body(): Optional> = + Optional.ofNullable(additionalBodyProperties.ifEmpty { null }) + + fun _pathParam(index: Int): String = + when (index) { + 0 -> entityBeneficialOwnerId ?: "" + else -> "" + } + + override fun _headers(): Headers = additionalHeaders + + override fun _queryParams(): QueryParams = additionalQueryParams + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is BeneficialOwnerArchiveParams && + entityBeneficialOwnerId == other.entityBeneficialOwnerId && + additionalHeaders == other.additionalHeaders && + additionalQueryParams == other.additionalQueryParams && + additionalBodyProperties == other.additionalBodyProperties + } + + override fun hashCode(): Int = + Objects.hash( + entityBeneficialOwnerId, + additionalHeaders, + additionalQueryParams, + additionalBodyProperties, + ) + + override fun toString() = + "BeneficialOwnerArchiveParams{entityBeneficialOwnerId=$entityBeneficialOwnerId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/async/BeneficialOwnerServiceAsync.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/async/BeneficialOwnerServiceAsync.kt index 5f0e4e71e..e7b5cfada 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/services/async/BeneficialOwnerServiceAsync.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/async/BeneficialOwnerServiceAsync.kt @@ -5,6 +5,7 @@ package com.increase.api.services.async import com.increase.api.core.ClientOptions import com.increase.api.core.RequestOptions import com.increase.api.core.http.HttpResponseFor +import com.increase.api.models.beneficialowners.BeneficialOwnerArchiveParams import com.increase.api.models.beneficialowners.BeneficialOwnerListPageAsync import com.increase.api.models.beneficialowners.BeneficialOwnerListParams import com.increase.api.models.beneficialowners.BeneficialOwnerRetrieveParams @@ -115,6 +116,45 @@ interface BeneficialOwnerServiceAsync { requestOptions: RequestOptions = RequestOptions.none(), ): CompletableFuture + /** Archive a Beneficial Owner */ + fun archive(entityBeneficialOwnerId: String): CompletableFuture = + archive(entityBeneficialOwnerId, BeneficialOwnerArchiveParams.none()) + + /** @see archive */ + fun archive( + entityBeneficialOwnerId: String, + params: BeneficialOwnerArchiveParams = BeneficialOwnerArchiveParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture = + archive( + params.toBuilder().entityBeneficialOwnerId(entityBeneficialOwnerId).build(), + requestOptions, + ) + + /** @see archive */ + fun archive( + entityBeneficialOwnerId: String, + params: BeneficialOwnerArchiveParams = BeneficialOwnerArchiveParams.none(), + ): CompletableFuture = + archive(entityBeneficialOwnerId, params, RequestOptions.none()) + + /** @see archive */ + fun archive( + params: BeneficialOwnerArchiveParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture + + /** @see archive */ + fun archive(params: BeneficialOwnerArchiveParams): CompletableFuture = + archive(params, RequestOptions.none()) + + /** @see archive */ + fun archive( + entityBeneficialOwnerId: String, + requestOptions: RequestOptions, + ): CompletableFuture = + archive(entityBeneficialOwnerId, BeneficialOwnerArchiveParams.none(), requestOptions) + /** * A view of [BeneficialOwnerServiceAsync] that provides access to raw HTTP responses for each * method. @@ -238,5 +278,52 @@ interface BeneficialOwnerServiceAsync { params: BeneficialOwnerListParams, requestOptions: RequestOptions = RequestOptions.none(), ): CompletableFuture> + + /** + * Returns a raw HTTP response for `post + * /entity_beneficial_owners/{entity_beneficial_owner_id}/archive`, but is otherwise the + * same as [BeneficialOwnerServiceAsync.archive]. + */ + fun archive( + entityBeneficialOwnerId: String + ): CompletableFuture> = + archive(entityBeneficialOwnerId, BeneficialOwnerArchiveParams.none()) + + /** @see archive */ + fun archive( + entityBeneficialOwnerId: String, + params: BeneficialOwnerArchiveParams = BeneficialOwnerArchiveParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture> = + archive( + params.toBuilder().entityBeneficialOwnerId(entityBeneficialOwnerId).build(), + requestOptions, + ) + + /** @see archive */ + fun archive( + entityBeneficialOwnerId: String, + params: BeneficialOwnerArchiveParams = BeneficialOwnerArchiveParams.none(), + ): CompletableFuture> = + archive(entityBeneficialOwnerId, params, RequestOptions.none()) + + /** @see archive */ + fun archive( + params: BeneficialOwnerArchiveParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture> + + /** @see archive */ + fun archive( + params: BeneficialOwnerArchiveParams + ): CompletableFuture> = + archive(params, RequestOptions.none()) + + /** @see archive */ + fun archive( + entityBeneficialOwnerId: String, + requestOptions: RequestOptions, + ): CompletableFuture> = + archive(entityBeneficialOwnerId, BeneficialOwnerArchiveParams.none(), requestOptions) } } diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/async/BeneficialOwnerServiceAsyncImpl.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/async/BeneficialOwnerServiceAsyncImpl.kt index d5b9997fc..bb1e342ed 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/services/async/BeneficialOwnerServiceAsyncImpl.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/async/BeneficialOwnerServiceAsyncImpl.kt @@ -16,6 +16,7 @@ import com.increase.api.core.http.HttpResponseFor import com.increase.api.core.http.json import com.increase.api.core.http.parseable import com.increase.api.core.prepareAsync +import com.increase.api.models.beneficialowners.BeneficialOwnerArchiveParams import com.increase.api.models.beneficialowners.BeneficialOwnerListPageAsync import com.increase.api.models.beneficialowners.BeneficialOwnerListPageResponse import com.increase.api.models.beneficialowners.BeneficialOwnerListParams @@ -61,6 +62,13 @@ internal constructor(private val clientOptions: ClientOptions) : BeneficialOwner // get /entity_beneficial_owners withRawResponse().list(params, requestOptions).thenApply { it.parse() } + override fun archive( + params: BeneficialOwnerArchiveParams, + requestOptions: RequestOptions, + ): CompletableFuture = + // post /entity_beneficial_owners/{entity_beneficial_owner_id}/archive + withRawResponse().archive(params, requestOptions).thenApply { it.parse() } + class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) : BeneficialOwnerServiceAsync.WithRawResponse { @@ -178,5 +186,39 @@ internal constructor(private val clientOptions: ClientOptions) : BeneficialOwner } } } + + private val archiveHandler: Handler = + jsonHandler(clientOptions.jsonMapper) + + override fun archive( + params: BeneficialOwnerArchiveParams, + requestOptions: RequestOptions, + ): CompletableFuture> { + // We check here instead of in the params builder because this can be specified + // positionally or in the params class. + checkRequired("entityBeneficialOwnerId", params.entityBeneficialOwnerId().getOrNull()) + val request = + HttpRequest.builder() + .method(HttpMethod.POST) + .baseUrl(clientOptions.baseUrl()) + .addPathSegments("entity_beneficial_owners", params._pathParam(0), "archive") + .apply { params._body().ifPresent { body(json(clientOptions.jsonMapper, it)) } } + .build() + .prepareAsync(clientOptions, params) + val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions)) + return request + .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) } + .thenApply { response -> + errorHandler.handle(response).parseable { + response + .use { archiveHandler.handle(it) } + .also { + if (requestOptions.responseValidation!!) { + it.validate() + } + } + } + } + } } } diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/BeneficialOwnerService.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/BeneficialOwnerService.kt index 9e904b15c..409cec3dc 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/BeneficialOwnerService.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/BeneficialOwnerService.kt @@ -6,6 +6,7 @@ import com.google.errorprone.annotations.MustBeClosed import com.increase.api.core.ClientOptions import com.increase.api.core.RequestOptions import com.increase.api.core.http.HttpResponseFor +import com.increase.api.models.beneficialowners.BeneficialOwnerArchiveParams import com.increase.api.models.beneficialowners.BeneficialOwnerListPage import com.increase.api.models.beneficialowners.BeneficialOwnerListParams import com.increase.api.models.beneficialowners.BeneficialOwnerRetrieveParams @@ -113,6 +114,44 @@ interface BeneficialOwnerService { requestOptions: RequestOptions = RequestOptions.none(), ): BeneficialOwnerListPage + /** Archive a Beneficial Owner */ + fun archive(entityBeneficialOwnerId: String): EntityBeneficialOwner = + archive(entityBeneficialOwnerId, BeneficialOwnerArchiveParams.none()) + + /** @see archive */ + fun archive( + entityBeneficialOwnerId: String, + params: BeneficialOwnerArchiveParams = BeneficialOwnerArchiveParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): EntityBeneficialOwner = + archive( + params.toBuilder().entityBeneficialOwnerId(entityBeneficialOwnerId).build(), + requestOptions, + ) + + /** @see archive */ + fun archive( + entityBeneficialOwnerId: String, + params: BeneficialOwnerArchiveParams = BeneficialOwnerArchiveParams.none(), + ): EntityBeneficialOwner = archive(entityBeneficialOwnerId, params, RequestOptions.none()) + + /** @see archive */ + fun archive( + params: BeneficialOwnerArchiveParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): EntityBeneficialOwner + + /** @see archive */ + fun archive(params: BeneficialOwnerArchiveParams): EntityBeneficialOwner = + archive(params, RequestOptions.none()) + + /** @see archive */ + fun archive( + entityBeneficialOwnerId: String, + requestOptions: RequestOptions, + ): EntityBeneficialOwner = + archive(entityBeneficialOwnerId, BeneficialOwnerArchiveParams.none(), requestOptions) + /** * A view of [BeneficialOwnerService] that provides access to raw HTTP responses for each * method. @@ -241,5 +280,54 @@ interface BeneficialOwnerService { params: BeneficialOwnerListParams, requestOptions: RequestOptions = RequestOptions.none(), ): HttpResponseFor + + /** + * Returns a raw HTTP response for `post + * /entity_beneficial_owners/{entity_beneficial_owner_id}/archive`, but is otherwise the + * same as [BeneficialOwnerService.archive]. + */ + @MustBeClosed + fun archive(entityBeneficialOwnerId: String): HttpResponseFor = + archive(entityBeneficialOwnerId, BeneficialOwnerArchiveParams.none()) + + /** @see archive */ + @MustBeClosed + fun archive( + entityBeneficialOwnerId: String, + params: BeneficialOwnerArchiveParams = BeneficialOwnerArchiveParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): HttpResponseFor = + archive( + params.toBuilder().entityBeneficialOwnerId(entityBeneficialOwnerId).build(), + requestOptions, + ) + + /** @see archive */ + @MustBeClosed + fun archive( + entityBeneficialOwnerId: String, + params: BeneficialOwnerArchiveParams = BeneficialOwnerArchiveParams.none(), + ): HttpResponseFor = + archive(entityBeneficialOwnerId, params, RequestOptions.none()) + + /** @see archive */ + @MustBeClosed + fun archive( + params: BeneficialOwnerArchiveParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): HttpResponseFor + + /** @see archive */ + @MustBeClosed + fun archive(params: BeneficialOwnerArchiveParams): HttpResponseFor = + archive(params, RequestOptions.none()) + + /** @see archive */ + @MustBeClosed + fun archive( + entityBeneficialOwnerId: String, + requestOptions: RequestOptions, + ): HttpResponseFor = + archive(entityBeneficialOwnerId, BeneficialOwnerArchiveParams.none(), requestOptions) } } diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/BeneficialOwnerServiceImpl.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/BeneficialOwnerServiceImpl.kt index 5b9c4bc64..7935f88b6 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/BeneficialOwnerServiceImpl.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/BeneficialOwnerServiceImpl.kt @@ -16,6 +16,7 @@ import com.increase.api.core.http.HttpResponseFor import com.increase.api.core.http.json import com.increase.api.core.http.parseable import com.increase.api.core.prepare +import com.increase.api.models.beneficialowners.BeneficialOwnerArchiveParams import com.increase.api.models.beneficialowners.BeneficialOwnerListPage import com.increase.api.models.beneficialowners.BeneficialOwnerListPageResponse import com.increase.api.models.beneficialowners.BeneficialOwnerListParams @@ -58,6 +59,13 @@ class BeneficialOwnerServiceImpl internal constructor(private val clientOptions: // get /entity_beneficial_owners withRawResponse().list(params, requestOptions).parse() + override fun archive( + params: BeneficialOwnerArchiveParams, + requestOptions: RequestOptions, + ): EntityBeneficialOwner = + // post /entity_beneficial_owners/{entity_beneficial_owner_id}/archive + withRawResponse().archive(params, requestOptions).parse() + class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) : BeneficialOwnerService.WithRawResponse { @@ -165,5 +173,36 @@ class BeneficialOwnerServiceImpl internal constructor(private val clientOptions: } } } + + private val archiveHandler: Handler = + jsonHandler(clientOptions.jsonMapper) + + override fun archive( + params: BeneficialOwnerArchiveParams, + requestOptions: RequestOptions, + ): HttpResponseFor { + // We check here instead of in the params builder because this can be specified + // positionally or in the params class. + checkRequired("entityBeneficialOwnerId", params.entityBeneficialOwnerId().getOrNull()) + val request = + HttpRequest.builder() + .method(HttpMethod.POST) + .baseUrl(clientOptions.baseUrl()) + .addPathSegments("entity_beneficial_owners", params._pathParam(0), "archive") + .apply { params._body().ifPresent { body(json(clientOptions.jsonMapper, it)) } } + .build() + .prepare(clientOptions, params) + val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions)) + val response = clientOptions.httpClient.execute(request, requestOptions) + return errorHandler.handle(response).parseable { + response + .use { archiveHandler.handle(it) } + .also { + if (requestOptions.responseValidation!!) { + it.validate() + } + } + } + } } } diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/beneficialowners/BeneficialOwnerArchiveParamsTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/beneficialowners/BeneficialOwnerArchiveParamsTest.kt new file mode 100644 index 000000000..4d725c39b --- /dev/null +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/beneficialowners/BeneficialOwnerArchiveParamsTest.kt @@ -0,0 +1,33 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.beneficialowners + +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Test + +internal class BeneficialOwnerArchiveParamsTest { + + @Test + fun create() { + BeneficialOwnerArchiveParams.builder() + .entityBeneficialOwnerId( + "entity_setup_beneficial_owner_submission_vgkyk7dj5eb4sfhdbkx7" + ) + .build() + } + + @Test + fun pathParams() { + val params = + BeneficialOwnerArchiveParams.builder() + .entityBeneficialOwnerId( + "entity_setup_beneficial_owner_submission_vgkyk7dj5eb4sfhdbkx7" + ) + .build() + + assertThat(params._pathParam(0)) + .isEqualTo("entity_setup_beneficial_owner_submission_vgkyk7dj5eb4sfhdbkx7") + // out-of-bound path param + assertThat(params._pathParam(1)).isEqualTo("") + } +} diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/async/BeneficialOwnerServiceAsyncTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/async/BeneficialOwnerServiceAsyncTest.kt index 702924f3f..a098b9ba5 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/services/async/BeneficialOwnerServiceAsyncTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/async/BeneficialOwnerServiceAsyncTest.kt @@ -115,4 +115,22 @@ internal class BeneficialOwnerServiceAsyncTest { val page = pageFuture.get() page.response().validate() } + + @Test + fun archive() { + val client = + IncreaseOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val beneficialOwnerServiceAsync = client.beneficialOwners() + + val entityBeneficialOwnerFuture = + beneficialOwnerServiceAsync.archive( + "entity_setup_beneficial_owner_submission_vgkyk7dj5eb4sfhdbkx7" + ) + + val entityBeneficialOwner = entityBeneficialOwnerFuture.get() + entityBeneficialOwner.validate() + } } diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/BeneficialOwnerServiceTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/BeneficialOwnerServiceTest.kt index f5e25d563..36de7ab86 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/BeneficialOwnerServiceTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/BeneficialOwnerServiceTest.kt @@ -112,4 +112,21 @@ internal class BeneficialOwnerServiceTest { page.response().validate() } + + @Test + fun archive() { + val client = + IncreaseOkHttpClient.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val beneficialOwnerService = client.beneficialOwners() + + val entityBeneficialOwner = + beneficialOwnerService.archive( + "entity_setup_beneficial_owner_submission_vgkyk7dj5eb4sfhdbkx7" + ) + + entityBeneficialOwner.validate() + } }