diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 39ba1f879..bc54c8a6a 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.450.0" + ".": "0.451.0" } \ No newline at end of file diff --git a/.stats.yml b/.stats.yml index 93d127a29..73242f912 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 233 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/increase%2Fincrease-1ed184e346fa8c739f7de410b940df9f160681dd818eed4ec1e48b40451007d0.yml -openapi_spec_hash: 0bc3978204acc7949c98e1d098bf5e1c -config_hash: ca482105d83c23b2986f1c9c441c4343 +configured_endpoints: 234 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/increase%2Fincrease-e4cf84ebe7ee8dbfbaa709d310fb62f12631f4b69f7aa73be2a88f149c726dc3.yml +openapi_spec_hash: 123949338534df87debdfbd846fc40b1 +config_hash: 890ca5fa6b8209d4eaac90550c7dc62c diff --git a/CHANGELOG.md b/CHANGELOG.md index 2d8415cfc..2a9842cfa 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog +## 0.451.0 (2026-03-05) + +Full Changelog: [v0.450.0...v0.451.0](https://github.com/Increase/increase-java/compare/v0.450.0...v0.451.0) + +### Features + +* **api:** api update ([6ccb367](https://github.com/Increase/increase-java/commit/6ccb3671df8630483ca1fd2596bd154296247eec)) + ## 0.450.0 (2026-03-05) Full Changelog: [v0.449.0...v0.450.0](https://github.com/Increase/increase-java/compare/v0.449.0...v0.450.0) diff --git a/README.md b/README.md index 5d51a13f5..a22cd7614 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.450.0) -[![javadoc](https://javadoc.io/badge2/com.increase.api/increase-java/0.450.0/javadoc.svg)](https://javadoc.io/doc/com.increase.api/increase-java/0.450.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.451.0) +[![javadoc](https://javadoc.io/badge2/com.increase.api/increase-java/0.451.0/javadoc.svg)](https://javadoc.io/doc/com.increase.api/increase-java/0.451.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.450.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.451.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.450.0") +implementation("com.increase.api:increase-java:0.451.0") ``` ### Maven @@ -33,7 +33,7 @@ implementation("com.increase.api:increase-java:0.450.0") com.increase.api increase-java - 0.450.0 + 0.451.0 ``` diff --git a/build.gradle.kts b/build.gradle.kts index 824f5b624..f71285a6c 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -8,7 +8,7 @@ repositories { allprojects { group = "com.increase.api" - version = "0.450.0" // x-release-please-version + version = "0.451.0" // x-release-please-version } subprojects { diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/inboundcheckdeposits/InboundCheckDepositAdjustmentParams.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/inboundcheckdeposits/InboundCheckDepositAdjustmentParams.kt new file mode 100644 index 000000000..cad4fcdd3 --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/inboundcheckdeposits/InboundCheckDepositAdjustmentParams.kt @@ -0,0 +1,685 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.simulations.inboundcheckdeposits + +import com.fasterxml.jackson.annotation.JsonAnyGetter +import com.fasterxml.jackson.annotation.JsonAnySetter +import com.fasterxml.jackson.annotation.JsonCreator +import com.fasterxml.jackson.annotation.JsonProperty +import com.increase.api.core.Enum +import com.increase.api.core.ExcludeMissing +import com.increase.api.core.JsonField +import com.increase.api.core.JsonMissing +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.errors.IncreaseInvalidDataException +import java.util.Collections +import java.util.Objects +import java.util.Optional +import kotlin.jvm.optionals.getOrNull + +/** + * Simulates an adjustment on an Inbound Check Deposit. The Inbound Check Deposit must have a + * `status` of `accepted`. + */ +class InboundCheckDepositAdjustmentParams +private constructor( + private val inboundCheckDepositId: String?, + private val body: Body, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, +) : Params { + + /** The identifier of the Inbound Check Deposit to adjust. */ + fun inboundCheckDepositId(): Optional = Optional.ofNullable(inboundCheckDepositId) + + /** + * The adjustment amount in cents. Defaults to the amount of the Inbound Check Deposit. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun amount(): Optional = body.amount() + + /** + * The reason for the adjustment. Defaults to `wrong_payee_credit`. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun reason(): Optional = body.reason() + + /** + * Returns the raw JSON value of [amount]. + * + * Unlike [amount], this method doesn't throw if the JSON field has an unexpected type. + */ + fun _amount(): JsonField = body._amount() + + /** + * Returns the raw JSON value of [reason]. + * + * Unlike [reason], this method doesn't throw if the JSON field has an unexpected type. + */ + fun _reason(): JsonField = body._reason() + + fun _additionalBodyProperties(): Map = body._additionalProperties() + + /** 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(): InboundCheckDepositAdjustmentParams = builder().build() + + /** + * Returns a mutable builder for constructing an instance of + * [InboundCheckDepositAdjustmentParams]. + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [InboundCheckDepositAdjustmentParams]. */ + class Builder internal constructor() { + + private var inboundCheckDepositId: String? = null + private var body: Body.Builder = Body.builder() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() + + @JvmSynthetic + internal fun from( + inboundCheckDepositAdjustmentParams: InboundCheckDepositAdjustmentParams + ) = apply { + inboundCheckDepositId = inboundCheckDepositAdjustmentParams.inboundCheckDepositId + body = inboundCheckDepositAdjustmentParams.body.toBuilder() + additionalHeaders = inboundCheckDepositAdjustmentParams.additionalHeaders.toBuilder() + additionalQueryParams = + inboundCheckDepositAdjustmentParams.additionalQueryParams.toBuilder() + } + + /** The identifier of the Inbound Check Deposit to adjust. */ + fun inboundCheckDepositId(inboundCheckDepositId: String?) = apply { + this.inboundCheckDepositId = inboundCheckDepositId + } + + /** + * Alias for calling [Builder.inboundCheckDepositId] with + * `inboundCheckDepositId.orElse(null)`. + */ + fun inboundCheckDepositId(inboundCheckDepositId: Optional) = + inboundCheckDepositId(inboundCheckDepositId.getOrNull()) + + /** + * Sets the entire request body. + * + * This is generally only useful if you are already constructing the body separately. + * Otherwise, it's more convenient to use the top-level setters instead: + * - [amount] + * - [reason] + */ + fun body(body: Body) = apply { this.body = body.toBuilder() } + + /** The adjustment amount in cents. Defaults to the amount of the Inbound Check Deposit. */ + fun amount(amount: Long) = apply { body.amount(amount) } + + /** + * Sets [Builder.amount] to an arbitrary JSON value. + * + * You should usually call [Builder.amount] with a well-typed [Long] value instead. This + * method is primarily for setting the field to an undocumented or not yet supported value. + */ + fun amount(amount: JsonField) = apply { body.amount(amount) } + + /** The reason for the adjustment. Defaults to `wrong_payee_credit`. */ + fun reason(reason: Reason) = apply { body.reason(reason) } + + /** + * Sets [Builder.reason] to an arbitrary JSON value. + * + * You should usually call [Builder.reason] with a well-typed [Reason] value instead. This + * method is primarily for setting the field to an undocumented or not yet supported value. + */ + fun reason(reason: JsonField) = apply { body.reason(reason) } + + fun additionalBodyProperties(additionalBodyProperties: Map) = apply { + body.additionalProperties(additionalBodyProperties) + } + + fun putAdditionalBodyProperty(key: String, value: JsonValue) = apply { + body.putAdditionalProperty(key, value) + } + + fun putAllAdditionalBodyProperties(additionalBodyProperties: Map) = + apply { + body.putAllAdditionalProperties(additionalBodyProperties) + } + + fun removeAdditionalBodyProperty(key: String) = apply { body.removeAdditionalProperty(key) } + + fun removeAllAdditionalBodyProperties(keys: Set) = apply { + body.removeAllAdditionalProperties(keys) + } + + 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) + } + + /** + * Returns an immutable instance of [InboundCheckDepositAdjustmentParams]. + * + * Further updates to this [Builder] will not mutate the returned instance. + */ + fun build(): InboundCheckDepositAdjustmentParams = + InboundCheckDepositAdjustmentParams( + inboundCheckDepositId, + body.build(), + additionalHeaders.build(), + additionalQueryParams.build(), + ) + } + + fun _body(): Body = body + + fun _pathParam(index: Int): String = + when (index) { + 0 -> inboundCheckDepositId ?: "" + else -> "" + } + + override fun _headers(): Headers = additionalHeaders + + override fun _queryParams(): QueryParams = additionalQueryParams + + class Body + @JsonCreator(mode = JsonCreator.Mode.DISABLED) + private constructor( + private val amount: JsonField, + private val reason: JsonField, + private val additionalProperties: MutableMap, + ) { + + @JsonCreator + private constructor( + @JsonProperty("amount") @ExcludeMissing amount: JsonField = JsonMissing.of(), + @JsonProperty("reason") @ExcludeMissing reason: JsonField = JsonMissing.of(), + ) : this(amount, reason, mutableMapOf()) + + /** + * The adjustment amount in cents. Defaults to the amount of the Inbound Check Deposit. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if + * the server responded with an unexpected value). + */ + fun amount(): Optional = amount.getOptional("amount") + + /** + * The reason for the adjustment. Defaults to `wrong_payee_credit`. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if + * the server responded with an unexpected value). + */ + fun reason(): Optional = reason.getOptional("reason") + + /** + * Returns the raw JSON value of [amount]. + * + * Unlike [amount], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("amount") @ExcludeMissing fun _amount(): JsonField = amount + + /** + * Returns the raw JSON value of [reason]. + * + * Unlike [reason], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("reason") @ExcludeMissing fun _reason(): JsonField = reason + + @JsonAnySetter + private fun putAdditionalProperty(key: String, value: JsonValue) { + additionalProperties.put(key, value) + } + + @JsonAnyGetter + @ExcludeMissing + fun _additionalProperties(): Map = + Collections.unmodifiableMap(additionalProperties) + + fun toBuilder() = Builder().from(this) + + companion object { + + /** Returns a mutable builder for constructing an instance of [Body]. */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [Body]. */ + class Builder internal constructor() { + + private var amount: JsonField = JsonMissing.of() + private var reason: JsonField = JsonMissing.of() + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(body: Body) = apply { + amount = body.amount + reason = body.reason + additionalProperties = body.additionalProperties.toMutableMap() + } + + /** + * The adjustment amount in cents. Defaults to the amount of the Inbound Check Deposit. + */ + fun amount(amount: Long) = amount(JsonField.of(amount)) + + /** + * Sets [Builder.amount] to an arbitrary JSON value. + * + * You should usually call [Builder.amount] with a well-typed [Long] value instead. This + * method is primarily for setting the field to an undocumented or not yet supported + * value. + */ + fun amount(amount: JsonField) = apply { this.amount = amount } + + /** The reason for the adjustment. Defaults to `wrong_payee_credit`. */ + fun reason(reason: Reason) = reason(JsonField.of(reason)) + + /** + * Sets [Builder.reason] to an arbitrary JSON value. + * + * You should usually call [Builder.reason] with a well-typed [Reason] value instead. + * This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun reason(reason: JsonField) = apply { this.reason = reason } + + fun additionalProperties(additionalProperties: Map) = apply { + this.additionalProperties.clear() + putAllAdditionalProperties(additionalProperties) + } + + fun putAdditionalProperty(key: String, value: JsonValue) = apply { + additionalProperties.put(key, value) + } + + fun putAllAdditionalProperties(additionalProperties: Map) = apply { + this.additionalProperties.putAll(additionalProperties) + } + + fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) } + + fun removeAllAdditionalProperties(keys: Set) = apply { + keys.forEach(::removeAdditionalProperty) + } + + /** + * Returns an immutable instance of [Body]. + * + * Further updates to this [Builder] will not mutate the returned instance. + */ + fun build(): Body = Body(amount, reason, additionalProperties.toMutableMap()) + } + + private var validated: Boolean = false + + fun validate(): Body = apply { + if (validated) { + return@apply + } + + amount() + reason().ifPresent { it.validate() } + validated = true + } + + fun isValid(): Boolean = + try { + validate() + true + } catch (e: IncreaseInvalidDataException) { + false + } + + /** + * Returns a score indicating how many valid values are contained in this object + * recursively. + * + * Used for best match union deserialization. + */ + @JvmSynthetic + internal fun validity(): Int = + (if (amount.asKnown().isPresent) 1 else 0) + + (reason.asKnown().getOrNull()?.validity() ?: 0) + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is Body && + amount == other.amount && + reason == other.reason && + additionalProperties == other.additionalProperties + } + + private val hashCode: Int by lazy { Objects.hash(amount, reason, additionalProperties) } + + override fun hashCode(): Int = hashCode + + override fun toString() = + "Body{amount=$amount, reason=$reason, additionalProperties=$additionalProperties}" + } + + /** The reason for the adjustment. Defaults to `wrong_payee_credit`. */ + class Reason @JsonCreator private constructor(private val value: JsonField) : Enum { + + /** + * Returns this class instance's raw value. + * + * This is usually only useful if this instance was deserialized from data that doesn't + * match any known member, and you want to know that value. For example, if the SDK is on an + * older version than the API, then the API may respond with new members that the SDK is + * unaware of. + */ + @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField = value + + companion object { + + /** + * The return was initiated too late and the receiving institution has responded with a + * Late Return Claim. + */ + @JvmField val LATE_RETURN = of("late_return") + + /** + * The check was deposited to the wrong payee and the depositing institution has + * reimbursed the funds with a Wrong Payee Credit. + */ + @JvmField val WRONG_PAYEE_CREDIT = of("wrong_payee_credit") + + /** + * The check was deposited with a different amount than what was written on the check. + */ + @JvmField val ADJUSTED_AMOUNT = of("adjusted_amount") + + /** + * The recipient was not able to process the check. This usually happens for e.g., low + * quality images. + */ + @JvmField val NON_CONFORMING_ITEM = of("non_conforming_item") + + /** The check has already been deposited elsewhere and so this is a duplicate. */ + @JvmField val PAID = of("paid") + + @JvmStatic fun of(value: String) = Reason(JsonField.of(value)) + } + + /** An enum containing [Reason]'s known values. */ + enum class Known { + /** + * The return was initiated too late and the receiving institution has responded with a + * Late Return Claim. + */ + LATE_RETURN, + /** + * The check was deposited to the wrong payee and the depositing institution has + * reimbursed the funds with a Wrong Payee Credit. + */ + WRONG_PAYEE_CREDIT, + /** + * The check was deposited with a different amount than what was written on the check. + */ + ADJUSTED_AMOUNT, + /** + * The recipient was not able to process the check. This usually happens for e.g., low + * quality images. + */ + NON_CONFORMING_ITEM, + /** The check has already been deposited elsewhere and so this is a duplicate. */ + PAID, + } + + /** + * An enum containing [Reason]'s known values, as well as an [_UNKNOWN] member. + * + * An instance of [Reason] can contain an unknown value in a couple of cases: + * - It was deserialized from data that doesn't match any known member. For example, if the + * SDK is on an older version than the API, then the API may respond with new members that + * the SDK is unaware of. + * - It was constructed with an arbitrary value using the [of] method. + */ + enum class Value { + /** + * The return was initiated too late and the receiving institution has responded with a + * Late Return Claim. + */ + LATE_RETURN, + /** + * The check was deposited to the wrong payee and the depositing institution has + * reimbursed the funds with a Wrong Payee Credit. + */ + WRONG_PAYEE_CREDIT, + /** + * The check was deposited with a different amount than what was written on the check. + */ + ADJUSTED_AMOUNT, + /** + * The recipient was not able to process the check. This usually happens for e.g., low + * quality images. + */ + NON_CONFORMING_ITEM, + /** The check has already been deposited elsewhere and so this is a duplicate. */ + PAID, + /** An enum member indicating that [Reason] was instantiated with an unknown value. */ + _UNKNOWN, + } + + /** + * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN] + * if the class was instantiated with an unknown value. + * + * Use the [known] method instead if you're certain the value is always known or if you want + * to throw for the unknown case. + */ + fun value(): Value = + when (this) { + LATE_RETURN -> Value.LATE_RETURN + WRONG_PAYEE_CREDIT -> Value.WRONG_PAYEE_CREDIT + ADJUSTED_AMOUNT -> Value.ADJUSTED_AMOUNT + NON_CONFORMING_ITEM -> Value.NON_CONFORMING_ITEM + PAID -> Value.PAID + else -> Value._UNKNOWN + } + + /** + * Returns an enum member corresponding to this class instance's value. + * + * Use the [value] method instead if you're uncertain the value is always known and don't + * want to throw for the unknown case. + * + * @throws IncreaseInvalidDataException if this class instance's value is a not a known + * member. + */ + fun known(): Known = + when (this) { + LATE_RETURN -> Known.LATE_RETURN + WRONG_PAYEE_CREDIT -> Known.WRONG_PAYEE_CREDIT + ADJUSTED_AMOUNT -> Known.ADJUSTED_AMOUNT + NON_CONFORMING_ITEM -> Known.NON_CONFORMING_ITEM + PAID -> Known.PAID + else -> throw IncreaseInvalidDataException("Unknown Reason: $value") + } + + /** + * Returns this class instance's primitive wire representation. + * + * This differs from the [toString] method because that method is primarily for debugging + * and generally doesn't throw. + * + * @throws IncreaseInvalidDataException if this class instance's value does not have the + * expected primitive type. + */ + fun asString(): String = + _value().asString().orElseThrow { + IncreaseInvalidDataException("Value is not a String") + } + + private var validated: Boolean = false + + fun validate(): Reason = apply { + if (validated) { + return@apply + } + + known() + validated = true + } + + fun isValid(): Boolean = + try { + validate() + true + } catch (e: IncreaseInvalidDataException) { + false + } + + /** + * Returns a score indicating how many valid values are contained in this object + * recursively. + * + * Used for best match union deserialization. + */ + @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1 + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is Reason && value == other.value + } + + override fun hashCode() = value.hashCode() + + override fun toString() = value.toString() + } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is InboundCheckDepositAdjustmentParams && + inboundCheckDepositId == other.inboundCheckDepositId && + body == other.body && + additionalHeaders == other.additionalHeaders && + additionalQueryParams == other.additionalQueryParams + } + + override fun hashCode(): Int = + Objects.hash(inboundCheckDepositId, body, additionalHeaders, additionalQueryParams) + + override fun toString() = + "InboundCheckDepositAdjustmentParams{inboundCheckDepositId=$inboundCheckDepositId, body=$body, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/InboundCheckDepositServiceAsync.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/InboundCheckDepositServiceAsync.kt index 53967c501..60801d567 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/InboundCheckDepositServiceAsync.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/InboundCheckDepositServiceAsync.kt @@ -6,6 +6,7 @@ import com.increase.api.core.ClientOptions import com.increase.api.core.RequestOptions import com.increase.api.core.http.HttpResponseFor import com.increase.api.models.inboundcheckdeposits.InboundCheckDeposit +import com.increase.api.models.simulations.inboundcheckdeposits.InboundCheckDepositAdjustmentParams import com.increase.api.models.simulations.inboundcheckdeposits.InboundCheckDepositCreateParams import java.util.concurrent.CompletableFuture import java.util.function.Consumer @@ -40,6 +41,53 @@ interface InboundCheckDepositServiceAsync { requestOptions: RequestOptions = RequestOptions.none(), ): CompletableFuture + /** + * Simulates an adjustment on an Inbound Check Deposit. The Inbound Check Deposit must have a + * `status` of `accepted`. + */ + fun adjustment(inboundCheckDepositId: String): CompletableFuture = + adjustment(inboundCheckDepositId, InboundCheckDepositAdjustmentParams.none()) + + /** @see adjustment */ + fun adjustment( + inboundCheckDepositId: String, + params: InboundCheckDepositAdjustmentParams = InboundCheckDepositAdjustmentParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture = + adjustment( + params.toBuilder().inboundCheckDepositId(inboundCheckDepositId).build(), + requestOptions, + ) + + /** @see adjustment */ + fun adjustment( + inboundCheckDepositId: String, + params: InboundCheckDepositAdjustmentParams = InboundCheckDepositAdjustmentParams.none(), + ): CompletableFuture = + adjustment(inboundCheckDepositId, params, RequestOptions.none()) + + /** @see adjustment */ + fun adjustment( + params: InboundCheckDepositAdjustmentParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture + + /** @see adjustment */ + fun adjustment( + params: InboundCheckDepositAdjustmentParams + ): CompletableFuture = adjustment(params, RequestOptions.none()) + + /** @see adjustment */ + fun adjustment( + inboundCheckDepositId: String, + requestOptions: RequestOptions, + ): CompletableFuture = + adjustment( + inboundCheckDepositId, + InboundCheckDepositAdjustmentParams.none(), + requestOptions, + ) + /** * A view of [InboundCheckDepositServiceAsync] that provides access to raw HTTP responses for * each method. @@ -69,5 +117,57 @@ interface InboundCheckDepositServiceAsync { params: InboundCheckDepositCreateParams, requestOptions: RequestOptions = RequestOptions.none(), ): CompletableFuture> + + /** + * Returns a raw HTTP response for `post + * /simulations/inbound_check_deposits/{inbound_check_deposit_id}/adjustment`, but is + * otherwise the same as [InboundCheckDepositServiceAsync.adjustment]. + */ + fun adjustment( + inboundCheckDepositId: String + ): CompletableFuture> = + adjustment(inboundCheckDepositId, InboundCheckDepositAdjustmentParams.none()) + + /** @see adjustment */ + fun adjustment( + inboundCheckDepositId: String, + params: InboundCheckDepositAdjustmentParams = + InboundCheckDepositAdjustmentParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture> = + adjustment( + params.toBuilder().inboundCheckDepositId(inboundCheckDepositId).build(), + requestOptions, + ) + + /** @see adjustment */ + fun adjustment( + inboundCheckDepositId: String, + params: InboundCheckDepositAdjustmentParams = InboundCheckDepositAdjustmentParams.none(), + ): CompletableFuture> = + adjustment(inboundCheckDepositId, params, RequestOptions.none()) + + /** @see adjustment */ + fun adjustment( + params: InboundCheckDepositAdjustmentParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture> + + /** @see adjustment */ + fun adjustment( + params: InboundCheckDepositAdjustmentParams + ): CompletableFuture> = + adjustment(params, RequestOptions.none()) + + /** @see adjustment */ + fun adjustment( + inboundCheckDepositId: String, + requestOptions: RequestOptions, + ): CompletableFuture> = + adjustment( + inboundCheckDepositId, + InboundCheckDepositAdjustmentParams.none(), + requestOptions, + ) } } diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/InboundCheckDepositServiceAsyncImpl.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/InboundCheckDepositServiceAsyncImpl.kt index 51b92b0fa..a83bc8c91 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/InboundCheckDepositServiceAsyncImpl.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/InboundCheckDepositServiceAsyncImpl.kt @@ -4,6 +4,7 @@ package com.increase.api.services.async.simulations import com.increase.api.core.ClientOptions import com.increase.api.core.RequestOptions +import com.increase.api.core.checkRequired import com.increase.api.core.handlers.errorBodyHandler import com.increase.api.core.handlers.errorHandler import com.increase.api.core.handlers.jsonHandler @@ -16,9 +17,11 @@ 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.inboundcheckdeposits.InboundCheckDeposit +import com.increase.api.models.simulations.inboundcheckdeposits.InboundCheckDepositAdjustmentParams import com.increase.api.models.simulations.inboundcheckdeposits.InboundCheckDepositCreateParams import java.util.concurrent.CompletableFuture import java.util.function.Consumer +import kotlin.jvm.optionals.getOrNull class InboundCheckDepositServiceAsyncImpl internal constructor(private val clientOptions: ClientOptions) : InboundCheckDepositServiceAsync { @@ -44,6 +47,13 @@ internal constructor(private val clientOptions: ClientOptions) : InboundCheckDep // post /simulations/inbound_check_deposits withRawResponse().create(params, requestOptions).thenApply { it.parse() } + override fun adjustment( + params: InboundCheckDepositAdjustmentParams, + requestOptions: RequestOptions, + ): CompletableFuture = + // post /simulations/inbound_check_deposits/{inbound_check_deposit_id}/adjustment + withRawResponse().adjustment(params, requestOptions).thenApply { it.parse() } + class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) : InboundCheckDepositServiceAsync.WithRawResponse { @@ -87,5 +97,44 @@ internal constructor(private val clientOptions: ClientOptions) : InboundCheckDep } } } + + private val adjustmentHandler: Handler = + jsonHandler(clientOptions.jsonMapper) + + override fun adjustment( + params: InboundCheckDepositAdjustmentParams, + requestOptions: RequestOptions, + ): CompletableFuture> { + // We check here instead of in the params builder because this can be specified + // positionally or in the params class. + checkRequired("inboundCheckDepositId", params.inboundCheckDepositId().getOrNull()) + val request = + HttpRequest.builder() + .method(HttpMethod.POST) + .baseUrl(clientOptions.baseUrl()) + .addPathSegments( + "simulations", + "inbound_check_deposits", + params._pathParam(0), + "adjustment", + ) + .body(json(clientOptions.jsonMapper, params._body())) + .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 { adjustmentHandler.handle(it) } + .also { + if (requestOptions.responseValidation!!) { + it.validate() + } + } + } + } + } } } diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/InboundCheckDepositService.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/InboundCheckDepositService.kt index 9011dc1b3..44d4f56f9 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/InboundCheckDepositService.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/InboundCheckDepositService.kt @@ -7,6 +7,7 @@ import com.increase.api.core.ClientOptions import com.increase.api.core.RequestOptions import com.increase.api.core.http.HttpResponseFor import com.increase.api.models.inboundcheckdeposits.InboundCheckDeposit +import com.increase.api.models.simulations.inboundcheckdeposits.InboundCheckDepositAdjustmentParams import com.increase.api.models.simulations.inboundcheckdeposits.InboundCheckDepositCreateParams import java.util.function.Consumer @@ -40,6 +41,51 @@ interface InboundCheckDepositService { requestOptions: RequestOptions = RequestOptions.none(), ): InboundCheckDeposit + /** + * Simulates an adjustment on an Inbound Check Deposit. The Inbound Check Deposit must have a + * `status` of `accepted`. + */ + fun adjustment(inboundCheckDepositId: String): InboundCheckDeposit = + adjustment(inboundCheckDepositId, InboundCheckDepositAdjustmentParams.none()) + + /** @see adjustment */ + fun adjustment( + inboundCheckDepositId: String, + params: InboundCheckDepositAdjustmentParams = InboundCheckDepositAdjustmentParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): InboundCheckDeposit = + adjustment( + params.toBuilder().inboundCheckDepositId(inboundCheckDepositId).build(), + requestOptions, + ) + + /** @see adjustment */ + fun adjustment( + inboundCheckDepositId: String, + params: InboundCheckDepositAdjustmentParams = InboundCheckDepositAdjustmentParams.none(), + ): InboundCheckDeposit = adjustment(inboundCheckDepositId, params, RequestOptions.none()) + + /** @see adjustment */ + fun adjustment( + params: InboundCheckDepositAdjustmentParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): InboundCheckDeposit + + /** @see adjustment */ + fun adjustment(params: InboundCheckDepositAdjustmentParams): InboundCheckDeposit = + adjustment(params, RequestOptions.none()) + + /** @see adjustment */ + fun adjustment( + inboundCheckDepositId: String, + requestOptions: RequestOptions, + ): InboundCheckDeposit = + adjustment( + inboundCheckDepositId, + InboundCheckDepositAdjustmentParams.none(), + requestOptions, + ) + /** * A view of [InboundCheckDepositService] that provides access to raw HTTP responses for each * method. @@ -69,5 +115,60 @@ interface InboundCheckDepositService { params: InboundCheckDepositCreateParams, requestOptions: RequestOptions = RequestOptions.none(), ): HttpResponseFor + + /** + * Returns a raw HTTP response for `post + * /simulations/inbound_check_deposits/{inbound_check_deposit_id}/adjustment`, but is + * otherwise the same as [InboundCheckDepositService.adjustment]. + */ + @MustBeClosed + fun adjustment(inboundCheckDepositId: String): HttpResponseFor = + adjustment(inboundCheckDepositId, InboundCheckDepositAdjustmentParams.none()) + + /** @see adjustment */ + @MustBeClosed + fun adjustment( + inboundCheckDepositId: String, + params: InboundCheckDepositAdjustmentParams = + InboundCheckDepositAdjustmentParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): HttpResponseFor = + adjustment( + params.toBuilder().inboundCheckDepositId(inboundCheckDepositId).build(), + requestOptions, + ) + + /** @see adjustment */ + @MustBeClosed + fun adjustment( + inboundCheckDepositId: String, + params: InboundCheckDepositAdjustmentParams = InboundCheckDepositAdjustmentParams.none(), + ): HttpResponseFor = + adjustment(inboundCheckDepositId, params, RequestOptions.none()) + + /** @see adjustment */ + @MustBeClosed + fun adjustment( + params: InboundCheckDepositAdjustmentParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): HttpResponseFor + + /** @see adjustment */ + @MustBeClosed + fun adjustment( + params: InboundCheckDepositAdjustmentParams + ): HttpResponseFor = adjustment(params, RequestOptions.none()) + + /** @see adjustment */ + @MustBeClosed + fun adjustment( + inboundCheckDepositId: String, + requestOptions: RequestOptions, + ): HttpResponseFor = + adjustment( + inboundCheckDepositId, + InboundCheckDepositAdjustmentParams.none(), + requestOptions, + ) } } diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/InboundCheckDepositServiceImpl.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/InboundCheckDepositServiceImpl.kt index 6aecc2213..a7e7af18b 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/InboundCheckDepositServiceImpl.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/InboundCheckDepositServiceImpl.kt @@ -4,6 +4,7 @@ package com.increase.api.services.blocking.simulations import com.increase.api.core.ClientOptions import com.increase.api.core.RequestOptions +import com.increase.api.core.checkRequired import com.increase.api.core.handlers.errorBodyHandler import com.increase.api.core.handlers.errorHandler import com.increase.api.core.handlers.jsonHandler @@ -16,8 +17,10 @@ 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.inboundcheckdeposits.InboundCheckDeposit +import com.increase.api.models.simulations.inboundcheckdeposits.InboundCheckDepositAdjustmentParams import com.increase.api.models.simulations.inboundcheckdeposits.InboundCheckDepositCreateParams import java.util.function.Consumer +import kotlin.jvm.optionals.getOrNull class InboundCheckDepositServiceImpl internal constructor(private val clientOptions: ClientOptions) : InboundCheckDepositService { @@ -40,6 +43,13 @@ internal constructor(private val clientOptions: ClientOptions) : InboundCheckDep // post /simulations/inbound_check_deposits withRawResponse().create(params, requestOptions).parse() + override fun adjustment( + params: InboundCheckDepositAdjustmentParams, + requestOptions: RequestOptions, + ): InboundCheckDeposit = + // post /simulations/inbound_check_deposits/{inbound_check_deposit_id}/adjustment + withRawResponse().adjustment(params, requestOptions).parse() + class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) : InboundCheckDepositService.WithRawResponse { @@ -80,5 +90,41 @@ internal constructor(private val clientOptions: ClientOptions) : InboundCheckDep } } } + + private val adjustmentHandler: Handler = + jsonHandler(clientOptions.jsonMapper) + + override fun adjustment( + params: InboundCheckDepositAdjustmentParams, + requestOptions: RequestOptions, + ): HttpResponseFor { + // We check here instead of in the params builder because this can be specified + // positionally or in the params class. + checkRequired("inboundCheckDepositId", params.inboundCheckDepositId().getOrNull()) + val request = + HttpRequest.builder() + .method(HttpMethod.POST) + .baseUrl(clientOptions.baseUrl()) + .addPathSegments( + "simulations", + "inbound_check_deposits", + params._pathParam(0), + "adjustment", + ) + .body(json(clientOptions.jsonMapper, params._body())) + .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 { adjustmentHandler.handle(it) } + .also { + if (requestOptions.responseValidation!!) { + it.validate() + } + } + } + } } } diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/inboundcheckdeposits/InboundCheckDepositAdjustmentParamsTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/inboundcheckdeposits/InboundCheckDepositAdjustmentParamsTest.kt new file mode 100644 index 000000000..8d8d849c2 --- /dev/null +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/inboundcheckdeposits/InboundCheckDepositAdjustmentParamsTest.kt @@ -0,0 +1,55 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.simulations.inboundcheckdeposits + +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Test + +internal class InboundCheckDepositAdjustmentParamsTest { + + @Test + fun create() { + InboundCheckDepositAdjustmentParams.builder() + .inboundCheckDepositId("inbound_check_deposit_zoshvqybq0cjjm31mra") + .amount(1000L) + .reason(InboundCheckDepositAdjustmentParams.Reason.LATE_RETURN) + .build() + } + + @Test + fun pathParams() { + val params = + InboundCheckDepositAdjustmentParams.builder() + .inboundCheckDepositId("inbound_check_deposit_zoshvqybq0cjjm31mra") + .build() + + assertThat(params._pathParam(0)).isEqualTo("inbound_check_deposit_zoshvqybq0cjjm31mra") + // out-of-bound path param + assertThat(params._pathParam(1)).isEqualTo("") + } + + @Test + fun body() { + val params = + InboundCheckDepositAdjustmentParams.builder() + .inboundCheckDepositId("inbound_check_deposit_zoshvqybq0cjjm31mra") + .amount(1000L) + .reason(InboundCheckDepositAdjustmentParams.Reason.LATE_RETURN) + .build() + + val body = params._body() + + assertThat(body.amount()).contains(1000L) + assertThat(body.reason()).contains(InboundCheckDepositAdjustmentParams.Reason.LATE_RETURN) + } + + @Test + fun bodyWithoutOptionalFields() { + val params = + InboundCheckDepositAdjustmentParams.builder() + .inboundCheckDepositId("inbound_check_deposit_zoshvqybq0cjjm31mra") + .build() + + val body = params._body() + } +} diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/InboundCheckDepositServiceAsyncTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/InboundCheckDepositServiceAsyncTest.kt index 5bc3ae5ce..5c8d75982 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/InboundCheckDepositServiceAsyncTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/InboundCheckDepositServiceAsyncTest.kt @@ -4,6 +4,7 @@ package com.increase.api.services.async.simulations import com.increase.api.TestServerExtension import com.increase.api.client.okhttp.IncreaseOkHttpClientAsync +import com.increase.api.models.simulations.inboundcheckdeposits.InboundCheckDepositAdjustmentParams import com.increase.api.models.simulations.inboundcheckdeposits.InboundCheckDepositCreateParams import org.junit.jupiter.api.Test import org.junit.jupiter.api.extension.ExtendWith @@ -35,4 +36,26 @@ internal class InboundCheckDepositServiceAsyncTest { val inboundCheckDeposit = inboundCheckDepositFuture.get() inboundCheckDeposit.validate() } + + @Test + fun adjustment() { + val client = + IncreaseOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val inboundCheckDepositServiceAsync = client.simulations().inboundCheckDeposits() + + val inboundCheckDepositFuture = + inboundCheckDepositServiceAsync.adjustment( + InboundCheckDepositAdjustmentParams.builder() + .inboundCheckDepositId("inbound_check_deposit_zoshvqybq0cjjm31mra") + .amount(1000L) + .reason(InboundCheckDepositAdjustmentParams.Reason.LATE_RETURN) + .build() + ) + + val inboundCheckDeposit = inboundCheckDepositFuture.get() + inboundCheckDeposit.validate() + } } diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/InboundCheckDepositServiceTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/InboundCheckDepositServiceTest.kt index fa0410139..738b43136 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/InboundCheckDepositServiceTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/InboundCheckDepositServiceTest.kt @@ -4,6 +4,7 @@ package com.increase.api.services.blocking.simulations import com.increase.api.TestServerExtension import com.increase.api.client.okhttp.IncreaseOkHttpClient +import com.increase.api.models.simulations.inboundcheckdeposits.InboundCheckDepositAdjustmentParams import com.increase.api.models.simulations.inboundcheckdeposits.InboundCheckDepositCreateParams import org.junit.jupiter.api.Test import org.junit.jupiter.api.extension.ExtendWith @@ -34,4 +35,25 @@ internal class InboundCheckDepositServiceTest { inboundCheckDeposit.validate() } + + @Test + fun adjustment() { + val client = + IncreaseOkHttpClient.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val inboundCheckDepositService = client.simulations().inboundCheckDeposits() + + val inboundCheckDeposit = + inboundCheckDepositService.adjustment( + InboundCheckDepositAdjustmentParams.builder() + .inboundCheckDepositId("inbound_check_deposit_zoshvqybq0cjjm31mra") + .amount(1000L) + .reason(InboundCheckDepositAdjustmentParams.Reason.LATE_RETURN) + .build() + ) + + inboundCheckDeposit.validate() + } }