diff --git a/.release-please-manifest.json b/.release-please-manifest.json index b7101200d..8d6ed7aed 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.258.0" + ".": "0.259.0" } \ No newline at end of file diff --git a/.stats.yml b/.stats.yml index 327b8df67..18daa6ba3 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 201 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/increase%2Fincrease-e25bdcd9c9cd987962f1507200b619dc7c32f91b940e5ca9110f24bdb294b14a.yml -openapi_spec_hash: 693a205b039e410d9a6b49a5b0ccc72c -config_hash: 97774f946585cecb19181a1817870d0b +configured_endpoints: 202 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/increase%2Fincrease-a7e0e17a385ddfb049d0fe4e5d05785901cf40f464c51399d7c2cd1f863696c0.yml +openapi_spec_hash: b4bca6edf466e9061a72c98207f92c6d +config_hash: a185e9a72778cc4658ea73fb3a7f1354 diff --git a/CHANGELOG.md b/CHANGELOG.md index 46a66a940..8f14bba58 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog +## 0.259.0 (2025-07-09) + +Full Changelog: [v0.258.0...v0.259.0](https://github.com/Increase/increase-java/compare/v0.258.0...v0.259.0) + +### Features + +* **api:** api update ([cfd4529](https://github.com/Increase/increase-java/commit/cfd452993df828b39ad9b2b3587a87cea7db5220)) + ## 0.258.0 (2025-07-08) Full Changelog: [v0.257.0...v0.258.0](https://github.com/Increase/increase-java/compare/v0.257.0...v0.258.0) diff --git a/README.md b/README.md index 12ecdb1eb..7738c1f13 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.258.0) -[![javadoc](https://javadoc.io/badge2/com.increase.api/increase-java/0.258.0/javadoc.svg)](https://javadoc.io/doc/com.increase.api/increase-java/0.258.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.259.0) +[![javadoc](https://javadoc.io/badge2/com.increase.api/increase-java/0.259.0/javadoc.svg)](https://javadoc.io/doc/com.increase.api/increase-java/0.259.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.258.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.259.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.258.0") +implementation("com.increase.api:increase-java:0.259.0") ``` ### Maven @@ -33,7 +33,7 @@ implementation("com.increase.api:increase-java:0.258.0") com.increase.api increase-java - 0.258.0 + 0.259.0 ``` diff --git a/build.gradle.kts b/build.gradle.kts index 73e1be1dc..b577b14ff 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -8,7 +8,7 @@ repositories { allprojects { group = "com.increase.api" - version = "0.258.0" // x-release-please-version + version = "0.259.0" // x-release-please-version } subprojects { diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/inboundwiretransfers/InboundWireTransferListParams.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/inboundwiretransfers/InboundWireTransferListParams.kt index 905edbff7..70935de38 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/inboundwiretransfers/InboundWireTransferListParams.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/inboundwiretransfers/InboundWireTransferListParams.kt @@ -25,6 +25,7 @@ private constructor( private val cursor: String?, private val limit: Long?, private val status: Status?, + private val wireDrawdownRequestId: String?, private val additionalHeaders: Headers, private val additionalQueryParams: QueryParams, ) : Params { @@ -45,6 +46,9 @@ private constructor( fun status(): Optional = Optional.ofNullable(status) + /** Filter Inbound Wire Transfers to ones belonging to the specified Wire Drawdown Request. */ + fun wireDrawdownRequestId(): Optional = Optional.ofNullable(wireDrawdownRequestId) + fun _additionalHeaders(): Headers = additionalHeaders fun _additionalQueryParams(): QueryParams = additionalQueryParams @@ -71,6 +75,7 @@ private constructor( private var cursor: String? = null private var limit: Long? = null private var status: Status? = null + private var wireDrawdownRequestId: String? = null private var additionalHeaders: Headers.Builder = Headers.builder() private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() @@ -82,6 +87,7 @@ private constructor( cursor = inboundWireTransferListParams.cursor limit = inboundWireTransferListParams.limit status = inboundWireTransferListParams.status + wireDrawdownRequestId = inboundWireTransferListParams.wireDrawdownRequestId additionalHeaders = inboundWireTransferListParams.additionalHeaders.toBuilder() additionalQueryParams = inboundWireTransferListParams.additionalQueryParams.toBuilder() } @@ -132,6 +138,20 @@ private constructor( /** Alias for calling [Builder.status] with `status.orElse(null)`. */ fun status(status: Optional) = status(status.getOrNull()) + /** + * Filter Inbound Wire Transfers to ones belonging to the specified Wire Drawdown Request. + */ + fun wireDrawdownRequestId(wireDrawdownRequestId: String?) = apply { + this.wireDrawdownRequestId = wireDrawdownRequestId + } + + /** + * Alias for calling [Builder.wireDrawdownRequestId] with + * `wireDrawdownRequestId.orElse(null)`. + */ + fun wireDrawdownRequestId(wireDrawdownRequestId: Optional) = + wireDrawdownRequestId(wireDrawdownRequestId.getOrNull()) + fun additionalHeaders(additionalHeaders: Headers) = apply { this.additionalHeaders.clear() putAllAdditionalHeaders(additionalHeaders) @@ -243,6 +263,7 @@ private constructor( cursor, limit, status, + wireDrawdownRequestId, additionalHeaders.build(), additionalQueryParams.build(), ) @@ -290,6 +311,7 @@ private constructor( } } } + wireDrawdownRequestId?.let { put("wire_drawdown_request_id", it) } putAll(additionalQueryParams) } .build() @@ -754,11 +776,11 @@ private constructor( return true } - return /* spotless:off */ other is InboundWireTransferListParams && accountId == other.accountId && accountNumberId == other.accountNumberId && createdAt == other.createdAt && cursor == other.cursor && limit == other.limit && status == other.status && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + return /* spotless:off */ other is InboundWireTransferListParams && accountId == other.accountId && accountNumberId == other.accountNumberId && createdAt == other.createdAt && cursor == other.cursor && limit == other.limit && status == other.status && wireDrawdownRequestId == other.wireDrawdownRequestId && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ } - override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountId, accountNumberId, createdAt, cursor, limit, status, additionalHeaders, additionalQueryParams) /* spotless:on */ + override fun hashCode(): Int = /* spotless:off */ Objects.hash(accountId, accountNumberId, createdAt, cursor, limit, status, wireDrawdownRequestId, additionalHeaders, additionalQueryParams) /* spotless:on */ override fun toString() = - "InboundWireTransferListParams{accountId=$accountId, accountNumberId=$accountNumberId, createdAt=$createdAt, cursor=$cursor, limit=$limit, status=$status, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" + "InboundWireTransferListParams{accountId=$accountId, accountNumberId=$accountNumberId, createdAt=$createdAt, cursor=$cursor, limit=$limit, status=$status, wireDrawdownRequestId=$wireDrawdownRequestId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" } diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/inboundwiretransfers/InboundWireTransferCreateParams.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/inboundwiretransfers/InboundWireTransferCreateParams.kt index 110c67986..ab3d3d571 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/inboundwiretransfers/InboundWireTransferCreateParams.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/inboundwiretransfers/InboundWireTransferCreateParams.kt @@ -179,6 +179,14 @@ private constructor( */ fun senderReference(): Optional = body.senderReference() + /** + * The identifier of a Wire Drawdown Request the inbound Wire Transfer is fulfilling. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun wireDrawdownRequestId(): Optional = body.wireDrawdownRequestId() + /** * Returns the raw JSON value of [accountNumberId]. * @@ -314,6 +322,14 @@ private constructor( */ fun _senderReference(): JsonField = body._senderReference() + /** + * Returns the raw JSON value of [wireDrawdownRequestId]. + * + * Unlike [wireDrawdownRequestId], this method doesn't throw if the JSON field has an unexpected + * type. + */ + fun _wireDrawdownRequestId(): JsonField = body._wireDrawdownRequestId() + fun _additionalBodyProperties(): Map = body._additionalProperties() fun _additionalHeaders(): Headers = additionalHeaders @@ -692,6 +708,22 @@ private constructor( body.senderReference(senderReference) } + /** The identifier of a Wire Drawdown Request the inbound Wire Transfer is fulfilling. */ + fun wireDrawdownRequestId(wireDrawdownRequestId: String) = apply { + body.wireDrawdownRequestId(wireDrawdownRequestId) + } + + /** + * Sets [Builder.wireDrawdownRequestId] to an arbitrary JSON value. + * + * You should usually call [Builder.wireDrawdownRequestId] with a well-typed [String] value + * instead. This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun wireDrawdownRequestId(wireDrawdownRequestId: JsonField) = apply { + body.wireDrawdownRequestId(wireDrawdownRequestId) + } + fun additionalBodyProperties(additionalBodyProperties: Map) = apply { body.additionalProperties(additionalBodyProperties) } @@ -855,6 +887,7 @@ private constructor( private val originatorToBeneficiaryInformationLine3: JsonField, private val originatorToBeneficiaryInformationLine4: JsonField, private val senderReference: JsonField, + private val wireDrawdownRequestId: JsonField, private val additionalProperties: MutableMap, ) { @@ -909,6 +942,9 @@ private constructor( @JsonProperty("sender_reference") @ExcludeMissing senderReference: JsonField = JsonMissing.of(), + @JsonProperty("wire_drawdown_request_id") + @ExcludeMissing + wireDrawdownRequestId: JsonField = JsonMissing.of(), ) : this( accountNumberId, amount, @@ -927,6 +963,7 @@ private constructor( originatorToBeneficiaryInformationLine3, originatorToBeneficiaryInformationLine4, senderReference, + wireDrawdownRequestId, mutableMapOf(), ) @@ -1100,6 +1137,15 @@ private constructor( */ fun senderReference(): Optional = senderReference.getOptional("sender_reference") + /** + * The identifier of a Wire Drawdown Request the inbound Wire Transfer is fulfilling. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if + * the server responded with an unexpected value). + */ + fun wireDrawdownRequestId(): Optional = + wireDrawdownRequestId.getOptional("wire_drawdown_request_id") + /** * Returns the raw JSON value of [accountNumberId]. * @@ -1271,6 +1317,16 @@ private constructor( @ExcludeMissing fun _senderReference(): JsonField = senderReference + /** + * Returns the raw JSON value of [wireDrawdownRequestId]. + * + * Unlike [wireDrawdownRequestId], this method doesn't throw if the JSON field has an + * unexpected type. + */ + @JsonProperty("wire_drawdown_request_id") + @ExcludeMissing + fun _wireDrawdownRequestId(): JsonField = wireDrawdownRequestId + @JsonAnySetter private fun putAdditionalProperty(key: String, value: JsonValue) { additionalProperties.put(key, value) @@ -1321,6 +1377,7 @@ private constructor( private var originatorToBeneficiaryInformationLine4: JsonField = JsonMissing.of() private var senderReference: JsonField = JsonMissing.of() + private var wireDrawdownRequestId: JsonField = JsonMissing.of() private var additionalProperties: MutableMap = mutableMapOf() @JvmSynthetic @@ -1346,6 +1403,7 @@ private constructor( originatorToBeneficiaryInformationLine4 = body.originatorToBeneficiaryInformationLine4 senderReference = body.senderReference + wireDrawdownRequestId = body.wireDrawdownRequestId additionalProperties = body.additionalProperties.toMutableMap() } @@ -1674,6 +1732,23 @@ private constructor( this.senderReference = senderReference } + /** + * The identifier of a Wire Drawdown Request the inbound Wire Transfer is fulfilling. + */ + fun wireDrawdownRequestId(wireDrawdownRequestId: String) = + wireDrawdownRequestId(JsonField.of(wireDrawdownRequestId)) + + /** + * Sets [Builder.wireDrawdownRequestId] to an arbitrary JSON value. + * + * You should usually call [Builder.wireDrawdownRequestId] with a well-typed [String] + * value instead. This method is primarily for setting the field to an undocumented or + * not yet supported value. + */ + fun wireDrawdownRequestId(wireDrawdownRequestId: JsonField) = apply { + this.wireDrawdownRequestId = wireDrawdownRequestId + } + fun additionalProperties(additionalProperties: Map) = apply { this.additionalProperties.clear() putAllAdditionalProperties(additionalProperties) @@ -1725,6 +1800,7 @@ private constructor( originatorToBeneficiaryInformationLine3, originatorToBeneficiaryInformationLine4, senderReference, + wireDrawdownRequestId, additionalProperties.toMutableMap(), ) } @@ -1753,6 +1829,7 @@ private constructor( originatorToBeneficiaryInformationLine3() originatorToBeneficiaryInformationLine4() senderReference() + wireDrawdownRequestId() validated = true } @@ -1788,24 +1865,25 @@ private constructor( (if (originatorToBeneficiaryInformationLine2.asKnown().isPresent) 1 else 0) + (if (originatorToBeneficiaryInformationLine3.asKnown().isPresent) 1 else 0) + (if (originatorToBeneficiaryInformationLine4.asKnown().isPresent) 1 else 0) + - (if (senderReference.asKnown().isPresent) 1 else 0) + (if (senderReference.asKnown().isPresent) 1 else 0) + + (if (wireDrawdownRequestId.asKnown().isPresent) 1 else 0) override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is Body && accountNumberId == other.accountNumberId && amount == other.amount && beneficiaryAddressLine1 == other.beneficiaryAddressLine1 && beneficiaryAddressLine2 == other.beneficiaryAddressLine2 && beneficiaryAddressLine3 == other.beneficiaryAddressLine3 && beneficiaryName == other.beneficiaryName && beneficiaryReference == other.beneficiaryReference && originatorAddressLine1 == other.originatorAddressLine1 && originatorAddressLine2 == other.originatorAddressLine2 && originatorAddressLine3 == other.originatorAddressLine3 && originatorName == other.originatorName && originatorRoutingNumber == other.originatorRoutingNumber && originatorToBeneficiaryInformationLine1 == other.originatorToBeneficiaryInformationLine1 && originatorToBeneficiaryInformationLine2 == other.originatorToBeneficiaryInformationLine2 && originatorToBeneficiaryInformationLine3 == other.originatorToBeneficiaryInformationLine3 && originatorToBeneficiaryInformationLine4 == other.originatorToBeneficiaryInformationLine4 && senderReference == other.senderReference && additionalProperties == other.additionalProperties /* spotless:on */ + return /* spotless:off */ other is Body && accountNumberId == other.accountNumberId && amount == other.amount && beneficiaryAddressLine1 == other.beneficiaryAddressLine1 && beneficiaryAddressLine2 == other.beneficiaryAddressLine2 && beneficiaryAddressLine3 == other.beneficiaryAddressLine3 && beneficiaryName == other.beneficiaryName && beneficiaryReference == other.beneficiaryReference && originatorAddressLine1 == other.originatorAddressLine1 && originatorAddressLine2 == other.originatorAddressLine2 && originatorAddressLine3 == other.originatorAddressLine3 && originatorName == other.originatorName && originatorRoutingNumber == other.originatorRoutingNumber && originatorToBeneficiaryInformationLine1 == other.originatorToBeneficiaryInformationLine1 && originatorToBeneficiaryInformationLine2 == other.originatorToBeneficiaryInformationLine2 && originatorToBeneficiaryInformationLine3 == other.originatorToBeneficiaryInformationLine3 && originatorToBeneficiaryInformationLine4 == other.originatorToBeneficiaryInformationLine4 && senderReference == other.senderReference && wireDrawdownRequestId == other.wireDrawdownRequestId && additionalProperties == other.additionalProperties /* spotless:on */ } /* spotless:off */ - private val hashCode: Int by lazy { Objects.hash(accountNumberId, amount, beneficiaryAddressLine1, beneficiaryAddressLine2, beneficiaryAddressLine3, beneficiaryName, beneficiaryReference, originatorAddressLine1, originatorAddressLine2, originatorAddressLine3, originatorName, originatorRoutingNumber, originatorToBeneficiaryInformationLine1, originatorToBeneficiaryInformationLine2, originatorToBeneficiaryInformationLine3, originatorToBeneficiaryInformationLine4, senderReference, additionalProperties) } + private val hashCode: Int by lazy { Objects.hash(accountNumberId, amount, beneficiaryAddressLine1, beneficiaryAddressLine2, beneficiaryAddressLine3, beneficiaryName, beneficiaryReference, originatorAddressLine1, originatorAddressLine2, originatorAddressLine3, originatorName, originatorRoutingNumber, originatorToBeneficiaryInformationLine1, originatorToBeneficiaryInformationLine2, originatorToBeneficiaryInformationLine3, originatorToBeneficiaryInformationLine4, senderReference, wireDrawdownRequestId, additionalProperties) } /* spotless:on */ override fun hashCode(): Int = hashCode override fun toString() = - "Body{accountNumberId=$accountNumberId, amount=$amount, beneficiaryAddressLine1=$beneficiaryAddressLine1, beneficiaryAddressLine2=$beneficiaryAddressLine2, beneficiaryAddressLine3=$beneficiaryAddressLine3, beneficiaryName=$beneficiaryName, beneficiaryReference=$beneficiaryReference, originatorAddressLine1=$originatorAddressLine1, originatorAddressLine2=$originatorAddressLine2, originatorAddressLine3=$originatorAddressLine3, originatorName=$originatorName, originatorRoutingNumber=$originatorRoutingNumber, originatorToBeneficiaryInformationLine1=$originatorToBeneficiaryInformationLine1, originatorToBeneficiaryInformationLine2=$originatorToBeneficiaryInformationLine2, originatorToBeneficiaryInformationLine3=$originatorToBeneficiaryInformationLine3, originatorToBeneficiaryInformationLine4=$originatorToBeneficiaryInformationLine4, senderReference=$senderReference, additionalProperties=$additionalProperties}" + "Body{accountNumberId=$accountNumberId, amount=$amount, beneficiaryAddressLine1=$beneficiaryAddressLine1, beneficiaryAddressLine2=$beneficiaryAddressLine2, beneficiaryAddressLine3=$beneficiaryAddressLine3, beneficiaryName=$beneficiaryName, beneficiaryReference=$beneficiaryReference, originatorAddressLine1=$originatorAddressLine1, originatorAddressLine2=$originatorAddressLine2, originatorAddressLine3=$originatorAddressLine3, originatorName=$originatorName, originatorRoutingNumber=$originatorRoutingNumber, originatorToBeneficiaryInformationLine1=$originatorToBeneficiaryInformationLine1, originatorToBeneficiaryInformationLine2=$originatorToBeneficiaryInformationLine2, originatorToBeneficiaryInformationLine3=$originatorToBeneficiaryInformationLine3, originatorToBeneficiaryInformationLine4=$originatorToBeneficiaryInformationLine4, senderReference=$senderReference, wireDrawdownRequestId=$wireDrawdownRequestId, additionalProperties=$additionalProperties}" } override fun equals(other: Any?): Boolean { diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/wiredrawdownrequests/WireDrawdownRequestRefuseParams.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/wiredrawdownrequests/WireDrawdownRequestRefuseParams.kt new file mode 100644 index 000000000..f5cb11892 --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/wiredrawdownrequests/WireDrawdownRequestRefuseParams.kt @@ -0,0 +1,235 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.simulations.wiredrawdownrequests + +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 + +/** Simulates a Wire Drawdown Request being refused by the debtor. */ +class WireDrawdownRequestRefuseParams +private constructor( + private val wireDrawdownRequestId: String?, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, + private val additionalBodyProperties: Map, +) : Params { + + /** The identifier of the Wire Drawdown Request you wish to refuse. */ + fun wireDrawdownRequestId(): Optional = Optional.ofNullable(wireDrawdownRequestId) + + fun _additionalBodyProperties(): Map = additionalBodyProperties + + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun toBuilder() = Builder().from(this) + + companion object { + + @JvmStatic fun none(): WireDrawdownRequestRefuseParams = builder().build() + + /** + * Returns a mutable builder for constructing an instance of + * [WireDrawdownRequestRefuseParams]. + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [WireDrawdownRequestRefuseParams]. */ + class Builder internal constructor() { + + private var wireDrawdownRequestId: 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(wireDrawdownRequestRefuseParams: WireDrawdownRequestRefuseParams) = + apply { + wireDrawdownRequestId = wireDrawdownRequestRefuseParams.wireDrawdownRequestId + additionalHeaders = wireDrawdownRequestRefuseParams.additionalHeaders.toBuilder() + additionalQueryParams = + wireDrawdownRequestRefuseParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + wireDrawdownRequestRefuseParams.additionalBodyProperties.toMutableMap() + } + + /** The identifier of the Wire Drawdown Request you wish to refuse. */ + fun wireDrawdownRequestId(wireDrawdownRequestId: String?) = apply { + this.wireDrawdownRequestId = wireDrawdownRequestId + } + + /** + * Alias for calling [Builder.wireDrawdownRequestId] with + * `wireDrawdownRequestId.orElse(null)`. + */ + fun wireDrawdownRequestId(wireDrawdownRequestId: Optional) = + wireDrawdownRequestId(wireDrawdownRequestId.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 [WireDrawdownRequestRefuseParams]. + * + * Further updates to this [Builder] will not mutate the returned instance. + */ + fun build(): WireDrawdownRequestRefuseParams = + WireDrawdownRequestRefuseParams( + wireDrawdownRequestId, + additionalHeaders.build(), + additionalQueryParams.build(), + additionalBodyProperties.toImmutable(), + ) + } + + fun _body(): Optional> = + Optional.ofNullable(additionalBodyProperties.ifEmpty { null }) + + fun _pathParam(index: Int): String = + when (index) { + 0 -> wireDrawdownRequestId ?: "" + else -> "" + } + + override fun _headers(): Headers = additionalHeaders + + override fun _queryParams(): QueryParams = additionalQueryParams + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is WireDrawdownRequestRefuseParams && wireDrawdownRequestId == other.wireDrawdownRequestId && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(wireDrawdownRequestId, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "WireDrawdownRequestRefuseParams{wireDrawdownRequestId=$wireDrawdownRequestId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/async/SimulationServiceAsync.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/async/SimulationServiceAsync.kt index 0e428faae..3625238b8 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/services/async/SimulationServiceAsync.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/async/SimulationServiceAsync.kt @@ -29,6 +29,7 @@ import com.increase.api.services.async.simulations.InterestPaymentServiceAsync import com.increase.api.services.async.simulations.PhysicalCardServiceAsync import com.increase.api.services.async.simulations.ProgramServiceAsync import com.increase.api.services.async.simulations.RealTimePaymentsTransferServiceAsync +import com.increase.api.services.async.simulations.WireDrawdownRequestServiceAsync import com.increase.api.services.async.simulations.WireTransferServiceAsync import java.util.function.Consumer @@ -80,6 +81,8 @@ interface SimulationServiceAsync { fun inboundWireTransfers(): InboundWireTransferServiceAsync + fun wireDrawdownRequests(): WireDrawdownRequestServiceAsync + fun inboundWireDrawdownRequests(): InboundWireDrawdownRequestServiceAsync fun checkTransfers(): CheckTransferServiceAsync @@ -149,6 +152,8 @@ interface SimulationServiceAsync { fun inboundWireTransfers(): InboundWireTransferServiceAsync.WithRawResponse + fun wireDrawdownRequests(): WireDrawdownRequestServiceAsync.WithRawResponse + fun inboundWireDrawdownRequests(): InboundWireDrawdownRequestServiceAsync.WithRawResponse fun checkTransfers(): CheckTransferServiceAsync.WithRawResponse diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/async/SimulationServiceAsyncImpl.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/async/SimulationServiceAsyncImpl.kt index b4ddb37c0..162d2812d 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/services/async/SimulationServiceAsyncImpl.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/async/SimulationServiceAsyncImpl.kt @@ -55,6 +55,8 @@ import com.increase.api.services.async.simulations.ProgramServiceAsync import com.increase.api.services.async.simulations.ProgramServiceAsyncImpl import com.increase.api.services.async.simulations.RealTimePaymentsTransferServiceAsync import com.increase.api.services.async.simulations.RealTimePaymentsTransferServiceAsyncImpl +import com.increase.api.services.async.simulations.WireDrawdownRequestServiceAsync +import com.increase.api.services.async.simulations.WireDrawdownRequestServiceAsyncImpl import com.increase.api.services.async.simulations.WireTransferServiceAsync import com.increase.api.services.async.simulations.WireTransferServiceAsyncImpl import java.util.function.Consumer @@ -134,6 +136,10 @@ class SimulationServiceAsyncImpl internal constructor(private val clientOptions: InboundWireTransferServiceAsyncImpl(clientOptions) } + private val wireDrawdownRequests: WireDrawdownRequestServiceAsync by lazy { + WireDrawdownRequestServiceAsyncImpl(clientOptions) + } + private val inboundWireDrawdownRequests: InboundWireDrawdownRequestServiceAsync by lazy { InboundWireDrawdownRequestServiceAsyncImpl(clientOptions) } @@ -212,6 +218,8 @@ class SimulationServiceAsyncImpl internal constructor(private val clientOptions: override fun inboundWireTransfers(): InboundWireTransferServiceAsync = inboundWireTransfers + override fun wireDrawdownRequests(): WireDrawdownRequestServiceAsync = wireDrawdownRequests + override fun inboundWireDrawdownRequests(): InboundWireDrawdownRequestServiceAsync = inboundWireDrawdownRequests @@ -309,6 +317,10 @@ class SimulationServiceAsyncImpl internal constructor(private val clientOptions: InboundWireTransferServiceAsyncImpl.WithRawResponseImpl(clientOptions) } + private val wireDrawdownRequests: WireDrawdownRequestServiceAsync.WithRawResponse by lazy { + WireDrawdownRequestServiceAsyncImpl.WithRawResponseImpl(clientOptions) + } + private val inboundWireDrawdownRequests: InboundWireDrawdownRequestServiceAsync.WithRawResponse by lazy { InboundWireDrawdownRequestServiceAsyncImpl.WithRawResponseImpl(clientOptions) @@ -402,6 +414,9 @@ class SimulationServiceAsyncImpl internal constructor(private val clientOptions: override fun inboundWireTransfers(): InboundWireTransferServiceAsync.WithRawResponse = inboundWireTransfers + override fun wireDrawdownRequests(): WireDrawdownRequestServiceAsync.WithRawResponse = + wireDrawdownRequests + override fun inboundWireDrawdownRequests(): InboundWireDrawdownRequestServiceAsync.WithRawResponse = inboundWireDrawdownRequests diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/WireDrawdownRequestServiceAsync.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/WireDrawdownRequestServiceAsync.kt new file mode 100644 index 000000000..33581f9c8 --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/WireDrawdownRequestServiceAsync.kt @@ -0,0 +1,128 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.services.async.simulations + +import com.increase.api.core.ClientOptions +import com.increase.api.core.RequestOptions +import com.increase.api.core.http.HttpResponseFor +import com.increase.api.models.simulations.wiredrawdownrequests.WireDrawdownRequestRefuseParams +import com.increase.api.models.wiredrawdownrequests.WireDrawdownRequest +import java.util.concurrent.CompletableFuture +import java.util.function.Consumer + +interface WireDrawdownRequestServiceAsync { + + /** + * Returns a view of this service that provides access to raw HTTP responses for each method. + */ + fun withRawResponse(): WithRawResponse + + /** + * Returns a view of this service with the given option modifications applied. + * + * The original service is not modified. + */ + fun withOptions(modifier: Consumer): WireDrawdownRequestServiceAsync + + /** Simulates a Wire Drawdown Request being refused by the debtor. */ + fun refuse(wireDrawdownRequestId: String): CompletableFuture = + refuse(wireDrawdownRequestId, WireDrawdownRequestRefuseParams.none()) + + /** @see [refuse] */ + fun refuse( + wireDrawdownRequestId: String, + params: WireDrawdownRequestRefuseParams = WireDrawdownRequestRefuseParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture = + refuse( + params.toBuilder().wireDrawdownRequestId(wireDrawdownRequestId).build(), + requestOptions, + ) + + /** @see [refuse] */ + fun refuse( + wireDrawdownRequestId: String, + params: WireDrawdownRequestRefuseParams = WireDrawdownRequestRefuseParams.none(), + ): CompletableFuture = + refuse(wireDrawdownRequestId, params, RequestOptions.none()) + + /** @see [refuse] */ + fun refuse( + params: WireDrawdownRequestRefuseParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture + + /** @see [refuse] */ + fun refuse(params: WireDrawdownRequestRefuseParams): CompletableFuture = + refuse(params, RequestOptions.none()) + + /** @see [refuse] */ + fun refuse( + wireDrawdownRequestId: String, + requestOptions: RequestOptions, + ): CompletableFuture = + refuse(wireDrawdownRequestId, WireDrawdownRequestRefuseParams.none(), requestOptions) + + /** + * A view of [WireDrawdownRequestServiceAsync] that provides access to raw HTTP responses for + * each method. + */ + interface WithRawResponse { + + /** + * Returns a view of this service with the given option modifications applied. + * + * The original service is not modified. + */ + fun withOptions( + modifier: Consumer + ): WireDrawdownRequestServiceAsync.WithRawResponse + + /** + * Returns a raw HTTP response for `post + * /simulations/wire_drawdown_requests/{wire_drawdown_request_id}/refuse`, but is otherwise + * the same as [WireDrawdownRequestServiceAsync.refuse]. + */ + fun refuse( + wireDrawdownRequestId: String + ): CompletableFuture> = + refuse(wireDrawdownRequestId, WireDrawdownRequestRefuseParams.none()) + + /** @see [refuse] */ + fun refuse( + wireDrawdownRequestId: String, + params: WireDrawdownRequestRefuseParams = WireDrawdownRequestRefuseParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture> = + refuse( + params.toBuilder().wireDrawdownRequestId(wireDrawdownRequestId).build(), + requestOptions, + ) + + /** @see [refuse] */ + fun refuse( + wireDrawdownRequestId: String, + params: WireDrawdownRequestRefuseParams = WireDrawdownRequestRefuseParams.none(), + ): CompletableFuture> = + refuse(wireDrawdownRequestId, params, RequestOptions.none()) + + /** @see [refuse] */ + fun refuse( + params: WireDrawdownRequestRefuseParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture> + + /** @see [refuse] */ + fun refuse( + params: WireDrawdownRequestRefuseParams + ): CompletableFuture> = + refuse(params, RequestOptions.none()) + + /** @see [refuse] */ + fun refuse( + wireDrawdownRequestId: String, + requestOptions: RequestOptions, + ): CompletableFuture> = + refuse(wireDrawdownRequestId, WireDrawdownRequestRefuseParams.none(), requestOptions) + } +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/WireDrawdownRequestServiceAsyncImpl.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/WireDrawdownRequestServiceAsyncImpl.kt new file mode 100644 index 000000000..f9d18d271 --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/WireDrawdownRequestServiceAsyncImpl.kt @@ -0,0 +1,101 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.services.async.simulations + +import com.increase.api.core.ClientOptions +import com.increase.api.core.JsonValue +import com.increase.api.core.RequestOptions +import com.increase.api.core.checkRequired +import com.increase.api.core.handlers.errorHandler +import com.increase.api.core.handlers.jsonHandler +import com.increase.api.core.handlers.withErrorHandler +import com.increase.api.core.http.HttpMethod +import com.increase.api.core.http.HttpRequest +import com.increase.api.core.http.HttpResponse.Handler +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.simulations.wiredrawdownrequests.WireDrawdownRequestRefuseParams +import com.increase.api.models.wiredrawdownrequests.WireDrawdownRequest +import java.util.concurrent.CompletableFuture +import java.util.function.Consumer +import kotlin.jvm.optionals.getOrNull + +class WireDrawdownRequestServiceAsyncImpl +internal constructor(private val clientOptions: ClientOptions) : WireDrawdownRequestServiceAsync { + + private val withRawResponse: WireDrawdownRequestServiceAsync.WithRawResponse by lazy { + WithRawResponseImpl(clientOptions) + } + + override fun withRawResponse(): WireDrawdownRequestServiceAsync.WithRawResponse = + withRawResponse + + override fun withOptions( + modifier: Consumer + ): WireDrawdownRequestServiceAsync = + WireDrawdownRequestServiceAsyncImpl( + clientOptions.toBuilder().apply(modifier::accept).build() + ) + + override fun refuse( + params: WireDrawdownRequestRefuseParams, + requestOptions: RequestOptions, + ): CompletableFuture = + // post /simulations/wire_drawdown_requests/{wire_drawdown_request_id}/refuse + withRawResponse().refuse(params, requestOptions).thenApply { it.parse() } + + class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) : + WireDrawdownRequestServiceAsync.WithRawResponse { + + private val errorHandler: Handler = errorHandler(clientOptions.jsonMapper) + + override fun withOptions( + modifier: Consumer + ): WireDrawdownRequestServiceAsync.WithRawResponse = + WireDrawdownRequestServiceAsyncImpl.WithRawResponseImpl( + clientOptions.toBuilder().apply(modifier::accept).build() + ) + + private val refuseHandler: Handler = + jsonHandler(clientOptions.jsonMapper) + .withErrorHandler(errorHandler) + + override fun refuse( + params: WireDrawdownRequestRefuseParams, + requestOptions: RequestOptions, + ): CompletableFuture> { + // We check here instead of in the params builder because this can be specified + // positionally or in the params class. + checkRequired("wireDrawdownRequestId", params.wireDrawdownRequestId().getOrNull()) + val request = + HttpRequest.builder() + .method(HttpMethod.POST) + .baseUrl(clientOptions.baseUrl()) + .addPathSegments( + "simulations", + "wire_drawdown_requests", + params._pathParam(0), + "refuse", + ) + .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 -> + response.parseable { + response + .use { refuseHandler.handle(it) } + .also { + if (requestOptions.responseValidation!!) { + it.validate() + } + } + } + } + } + } +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/SimulationService.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/SimulationService.kt index 537ef1968..c9d6e82fe 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/SimulationService.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/SimulationService.kt @@ -29,6 +29,7 @@ import com.increase.api.services.blocking.simulations.InterestPaymentService import com.increase.api.services.blocking.simulations.PhysicalCardService import com.increase.api.services.blocking.simulations.ProgramService import com.increase.api.services.blocking.simulations.RealTimePaymentsTransferService +import com.increase.api.services.blocking.simulations.WireDrawdownRequestService import com.increase.api.services.blocking.simulations.WireTransferService import java.util.function.Consumer @@ -80,6 +81,8 @@ interface SimulationService { fun inboundWireTransfers(): InboundWireTransferService + fun wireDrawdownRequests(): WireDrawdownRequestService + fun inboundWireDrawdownRequests(): InboundWireDrawdownRequestService fun checkTransfers(): CheckTransferService @@ -146,6 +149,8 @@ interface SimulationService { fun inboundWireTransfers(): InboundWireTransferService.WithRawResponse + fun wireDrawdownRequests(): WireDrawdownRequestService.WithRawResponse + fun inboundWireDrawdownRequests(): InboundWireDrawdownRequestService.WithRawResponse fun checkTransfers(): CheckTransferService.WithRawResponse diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/SimulationServiceImpl.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/SimulationServiceImpl.kt index 8e71ebf01..d954b81ba 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/SimulationServiceImpl.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/SimulationServiceImpl.kt @@ -55,6 +55,8 @@ import com.increase.api.services.blocking.simulations.ProgramService import com.increase.api.services.blocking.simulations.ProgramServiceImpl import com.increase.api.services.blocking.simulations.RealTimePaymentsTransferService import com.increase.api.services.blocking.simulations.RealTimePaymentsTransferServiceImpl +import com.increase.api.services.blocking.simulations.WireDrawdownRequestService +import com.increase.api.services.blocking.simulations.WireDrawdownRequestServiceImpl import com.increase.api.services.blocking.simulations.WireTransferService import com.increase.api.services.blocking.simulations.WireTransferServiceImpl import java.util.function.Consumer @@ -128,6 +130,10 @@ class SimulationServiceImpl internal constructor(private val clientOptions: Clie InboundWireTransferServiceImpl(clientOptions) } + private val wireDrawdownRequests: WireDrawdownRequestService by lazy { + WireDrawdownRequestServiceImpl(clientOptions) + } + private val inboundWireDrawdownRequests: InboundWireDrawdownRequestService by lazy { InboundWireDrawdownRequestServiceImpl(clientOptions) } @@ -205,6 +211,8 @@ class SimulationServiceImpl internal constructor(private val clientOptions: Clie override fun inboundWireTransfers(): InboundWireTransferService = inboundWireTransfers + override fun wireDrawdownRequests(): WireDrawdownRequestService = wireDrawdownRequests + override fun inboundWireDrawdownRequests(): InboundWireDrawdownRequestService = inboundWireDrawdownRequests @@ -301,6 +309,10 @@ class SimulationServiceImpl internal constructor(private val clientOptions: Clie InboundWireTransferServiceImpl.WithRawResponseImpl(clientOptions) } + private val wireDrawdownRequests: WireDrawdownRequestService.WithRawResponse by lazy { + WireDrawdownRequestServiceImpl.WithRawResponseImpl(clientOptions) + } + private val inboundWireDrawdownRequests: InboundWireDrawdownRequestService.WithRawResponse by lazy { InboundWireDrawdownRequestServiceImpl.WithRawResponseImpl(clientOptions) @@ -392,6 +404,9 @@ class SimulationServiceImpl internal constructor(private val clientOptions: Clie override fun inboundWireTransfers(): InboundWireTransferService.WithRawResponse = inboundWireTransfers + override fun wireDrawdownRequests(): WireDrawdownRequestService.WithRawResponse = + wireDrawdownRequests + override fun inboundWireDrawdownRequests(): InboundWireDrawdownRequestService.WithRawResponse = inboundWireDrawdownRequests diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/WireDrawdownRequestService.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/WireDrawdownRequestService.kt new file mode 100644 index 000000000..7c11908e9 --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/WireDrawdownRequestService.kt @@ -0,0 +1,126 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.services.blocking.simulations + +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.simulations.wiredrawdownrequests.WireDrawdownRequestRefuseParams +import com.increase.api.models.wiredrawdownrequests.WireDrawdownRequest +import java.util.function.Consumer + +interface WireDrawdownRequestService { + + /** + * Returns a view of this service that provides access to raw HTTP responses for each method. + */ + fun withRawResponse(): WithRawResponse + + /** + * Returns a view of this service with the given option modifications applied. + * + * The original service is not modified. + */ + fun withOptions(modifier: Consumer): WireDrawdownRequestService + + /** Simulates a Wire Drawdown Request being refused by the debtor. */ + fun refuse(wireDrawdownRequestId: String): WireDrawdownRequest = + refuse(wireDrawdownRequestId, WireDrawdownRequestRefuseParams.none()) + + /** @see [refuse] */ + fun refuse( + wireDrawdownRequestId: String, + params: WireDrawdownRequestRefuseParams = WireDrawdownRequestRefuseParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): WireDrawdownRequest = + refuse( + params.toBuilder().wireDrawdownRequestId(wireDrawdownRequestId).build(), + requestOptions, + ) + + /** @see [refuse] */ + fun refuse( + wireDrawdownRequestId: String, + params: WireDrawdownRequestRefuseParams = WireDrawdownRequestRefuseParams.none(), + ): WireDrawdownRequest = refuse(wireDrawdownRequestId, params, RequestOptions.none()) + + /** @see [refuse] */ + fun refuse( + params: WireDrawdownRequestRefuseParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): WireDrawdownRequest + + /** @see [refuse] */ + fun refuse(params: WireDrawdownRequestRefuseParams): WireDrawdownRequest = + refuse(params, RequestOptions.none()) + + /** @see [refuse] */ + fun refuse(wireDrawdownRequestId: String, requestOptions: RequestOptions): WireDrawdownRequest = + refuse(wireDrawdownRequestId, WireDrawdownRequestRefuseParams.none(), requestOptions) + + /** + * A view of [WireDrawdownRequestService] that provides access to raw HTTP responses for each + * method. + */ + interface WithRawResponse { + + /** + * Returns a view of this service with the given option modifications applied. + * + * The original service is not modified. + */ + fun withOptions( + modifier: Consumer + ): WireDrawdownRequestService.WithRawResponse + + /** + * Returns a raw HTTP response for `post + * /simulations/wire_drawdown_requests/{wire_drawdown_request_id}/refuse`, but is otherwise + * the same as [WireDrawdownRequestService.refuse]. + */ + @MustBeClosed + fun refuse(wireDrawdownRequestId: String): HttpResponseFor = + refuse(wireDrawdownRequestId, WireDrawdownRequestRefuseParams.none()) + + /** @see [refuse] */ + @MustBeClosed + fun refuse( + wireDrawdownRequestId: String, + params: WireDrawdownRequestRefuseParams = WireDrawdownRequestRefuseParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): HttpResponseFor = + refuse( + params.toBuilder().wireDrawdownRequestId(wireDrawdownRequestId).build(), + requestOptions, + ) + + /** @see [refuse] */ + @MustBeClosed + fun refuse( + wireDrawdownRequestId: String, + params: WireDrawdownRequestRefuseParams = WireDrawdownRequestRefuseParams.none(), + ): HttpResponseFor = + refuse(wireDrawdownRequestId, params, RequestOptions.none()) + + /** @see [refuse] */ + @MustBeClosed + fun refuse( + params: WireDrawdownRequestRefuseParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): HttpResponseFor + + /** @see [refuse] */ + @MustBeClosed + fun refuse(params: WireDrawdownRequestRefuseParams): HttpResponseFor = + refuse(params, RequestOptions.none()) + + /** @see [refuse] */ + @MustBeClosed + fun refuse( + wireDrawdownRequestId: String, + requestOptions: RequestOptions, + ): HttpResponseFor = + refuse(wireDrawdownRequestId, WireDrawdownRequestRefuseParams.none(), requestOptions) + } +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/WireDrawdownRequestServiceImpl.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/WireDrawdownRequestServiceImpl.kt new file mode 100644 index 000000000..f1c0c4832 --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/WireDrawdownRequestServiceImpl.kt @@ -0,0 +1,94 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.services.blocking.simulations + +import com.increase.api.core.ClientOptions +import com.increase.api.core.JsonValue +import com.increase.api.core.RequestOptions +import com.increase.api.core.checkRequired +import com.increase.api.core.handlers.errorHandler +import com.increase.api.core.handlers.jsonHandler +import com.increase.api.core.handlers.withErrorHandler +import com.increase.api.core.http.HttpMethod +import com.increase.api.core.http.HttpRequest +import com.increase.api.core.http.HttpResponse.Handler +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.simulations.wiredrawdownrequests.WireDrawdownRequestRefuseParams +import com.increase.api.models.wiredrawdownrequests.WireDrawdownRequest +import java.util.function.Consumer +import kotlin.jvm.optionals.getOrNull + +class WireDrawdownRequestServiceImpl +internal constructor(private val clientOptions: ClientOptions) : WireDrawdownRequestService { + + private val withRawResponse: WireDrawdownRequestService.WithRawResponse by lazy { + WithRawResponseImpl(clientOptions) + } + + override fun withRawResponse(): WireDrawdownRequestService.WithRawResponse = withRawResponse + + override fun withOptions( + modifier: Consumer + ): WireDrawdownRequestService = + WireDrawdownRequestServiceImpl(clientOptions.toBuilder().apply(modifier::accept).build()) + + override fun refuse( + params: WireDrawdownRequestRefuseParams, + requestOptions: RequestOptions, + ): WireDrawdownRequest = + // post /simulations/wire_drawdown_requests/{wire_drawdown_request_id}/refuse + withRawResponse().refuse(params, requestOptions).parse() + + class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) : + WireDrawdownRequestService.WithRawResponse { + + private val errorHandler: Handler = errorHandler(clientOptions.jsonMapper) + + override fun withOptions( + modifier: Consumer + ): WireDrawdownRequestService.WithRawResponse = + WireDrawdownRequestServiceImpl.WithRawResponseImpl( + clientOptions.toBuilder().apply(modifier::accept).build() + ) + + private val refuseHandler: Handler = + jsonHandler(clientOptions.jsonMapper) + .withErrorHandler(errorHandler) + + override fun refuse( + params: WireDrawdownRequestRefuseParams, + requestOptions: RequestOptions, + ): HttpResponseFor { + // We check here instead of in the params builder because this can be specified + // positionally or in the params class. + checkRequired("wireDrawdownRequestId", params.wireDrawdownRequestId().getOrNull()) + val request = + HttpRequest.builder() + .method(HttpMethod.POST) + .baseUrl(clientOptions.baseUrl()) + .addPathSegments( + "simulations", + "wire_drawdown_requests", + params._pathParam(0), + "refuse", + ) + .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 response.parseable { + response + .use { refuseHandler.handle(it) } + .also { + if (requestOptions.responseValidation!!) { + it.validate() + } + } + } + } + } +} diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/inboundwiretransfers/InboundWireTransferListParamsTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/inboundwiretransfers/InboundWireTransferListParamsTest.kt index 7f11fd930..d4da9b531 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/inboundwiretransfers/InboundWireTransferListParamsTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/inboundwiretransfers/InboundWireTransferListParamsTest.kt @@ -29,6 +29,7 @@ internal class InboundWireTransferListParamsTest { .addIn(InboundWireTransferListParams.Status.In.PENDING) .build() ) + .wireDrawdownRequestId("wire_drawdown_request_id") .build() } @@ -53,6 +54,7 @@ internal class InboundWireTransferListParamsTest { .addIn(InboundWireTransferListParams.Status.In.PENDING) .build() ) + .wireDrawdownRequestId("wire_drawdown_request_id") .build() val queryParams = params._queryParams() @@ -69,6 +71,7 @@ internal class InboundWireTransferListParamsTest { .put("cursor", "cursor") .put("limit", "1") .put("status.in", listOf("pending").joinToString(",")) + .put("wire_drawdown_request_id", "wire_drawdown_request_id") .build() ) } diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/inboundwiretransfers/InboundWireTransferCreateParamsTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/inboundwiretransfers/InboundWireTransferCreateParamsTest.kt index 9c0472190..63735b78c 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/inboundwiretransfers/InboundWireTransferCreateParamsTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/inboundwiretransfers/InboundWireTransferCreateParamsTest.kt @@ -27,6 +27,7 @@ internal class InboundWireTransferCreateParamsTest { .originatorToBeneficiaryInformationLine3("x") .originatorToBeneficiaryInformationLine4("x") .senderReference("x") + .wireDrawdownRequestId("wire_drawdown_request_id") .build() } @@ -51,6 +52,7 @@ internal class InboundWireTransferCreateParamsTest { .originatorToBeneficiaryInformationLine3("x") .originatorToBeneficiaryInformationLine4("x") .senderReference("x") + .wireDrawdownRequestId("wire_drawdown_request_id") .build() val body = params._body() @@ -72,6 +74,7 @@ internal class InboundWireTransferCreateParamsTest { assertThat(body.originatorToBeneficiaryInformationLine3()).contains("x") assertThat(body.originatorToBeneficiaryInformationLine4()).contains("x") assertThat(body.senderReference()).contains("x") + assertThat(body.wireDrawdownRequestId()).contains("wire_drawdown_request_id") } @Test diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/wiredrawdownrequests/WireDrawdownRequestRefuseParamsTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/wiredrawdownrequests/WireDrawdownRequestRefuseParamsTest.kt new file mode 100644 index 000000000..61744a61a --- /dev/null +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/wiredrawdownrequests/WireDrawdownRequestRefuseParamsTest.kt @@ -0,0 +1,28 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.simulations.wiredrawdownrequests + +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Test + +internal class WireDrawdownRequestRefuseParamsTest { + + @Test + fun create() { + WireDrawdownRequestRefuseParams.builder() + .wireDrawdownRequestId("wire_drawdown_request_q6lmocus3glo0lr2bfv3") + .build() + } + + @Test + fun pathParams() { + val params = + WireDrawdownRequestRefuseParams.builder() + .wireDrawdownRequestId("wire_drawdown_request_q6lmocus3glo0lr2bfv3") + .build() + + assertThat(params._pathParam(0)).isEqualTo("wire_drawdown_request_q6lmocus3glo0lr2bfv3") + // out-of-bound path param + assertThat(params._pathParam(1)).isEqualTo("") + } +} diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/InboundWireTransferServiceAsyncTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/InboundWireTransferServiceAsyncTest.kt index 100917e6b..319e56c3c 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/InboundWireTransferServiceAsyncTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/InboundWireTransferServiceAsyncTest.kt @@ -40,6 +40,7 @@ internal class InboundWireTransferServiceAsyncTest { .originatorToBeneficiaryInformationLine3("x") .originatorToBeneficiaryInformationLine4("x") .senderReference("x") + .wireDrawdownRequestId("wire_drawdown_request_id") .build() ) diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/WireDrawdownRequestServiceAsyncTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/WireDrawdownRequestServiceAsyncTest.kt new file mode 100644 index 000000000..50e55d134 --- /dev/null +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/WireDrawdownRequestServiceAsyncTest.kt @@ -0,0 +1,28 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.services.async.simulations + +import com.increase.api.TestServerExtension +import com.increase.api.client.okhttp.IncreaseOkHttpClientAsync +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +internal class WireDrawdownRequestServiceAsyncTest { + + @Test + fun refuse() { + val client = + IncreaseOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val wireDrawdownRequestServiceAsync = client.simulations().wireDrawdownRequests() + + val wireDrawdownRequestFuture = + wireDrawdownRequestServiceAsync.refuse("wire_drawdown_request_q6lmocus3glo0lr2bfv3") + + val wireDrawdownRequest = wireDrawdownRequestFuture.get() + wireDrawdownRequest.validate() + } +} diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/InboundWireTransferServiceTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/InboundWireTransferServiceTest.kt index 24824bed9..fe7e089c7 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/InboundWireTransferServiceTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/InboundWireTransferServiceTest.kt @@ -40,6 +40,7 @@ internal class InboundWireTransferServiceTest { .originatorToBeneficiaryInformationLine3("x") .originatorToBeneficiaryInformationLine4("x") .senderReference("x") + .wireDrawdownRequestId("wire_drawdown_request_id") .build() ) diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/WireDrawdownRequestServiceTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/WireDrawdownRequestServiceTest.kt new file mode 100644 index 000000000..9be55a3bf --- /dev/null +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/WireDrawdownRequestServiceTest.kt @@ -0,0 +1,27 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.services.blocking.simulations + +import com.increase.api.TestServerExtension +import com.increase.api.client.okhttp.IncreaseOkHttpClient +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +internal class WireDrawdownRequestServiceTest { + + @Test + fun refuse() { + val client = + IncreaseOkHttpClient.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val wireDrawdownRequestService = client.simulations().wireDrawdownRequests() + + val wireDrawdownRequest = + wireDrawdownRequestService.refuse("wire_drawdown_request_q6lmocus3glo0lr2bfv3") + + wireDrawdownRequest.validate() + } +}