diff --git a/.release-please-manifest.json b/.release-please-manifest.json index f8336dd24..78058d763 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.385.0" + ".": "0.386.0" } \ No newline at end of file diff --git a/.stats.yml b/.stats.yml index e5b11df29..bc6173cca 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 230 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/increase%2Fincrease-acaa7510acabd57dfdde78063277cef0c611dd42abd998e5f1f851c4655e8fd0.yml -openapi_spec_hash: d0684f4b10e09e2585ad70360531501c -config_hash: ff2eb5f192b4de36611b37b27961c2d8 +configured_endpoints: 231 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/increase%2Fincrease-2304a782c25d2a6b9586de2f6e2b536b5abbf62735f9c18ed0551607f134b714.yml +openapi_spec_hash: 67d6de7181215abe88dcc3da557a1e0d +config_hash: 5a0bf28bf735edf93f36c6c808711847 diff --git a/CHANGELOG.md b/CHANGELOG.md index c60d4109e..1d675761d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog +## 0.386.0 (2025-12-18) + +Full Changelog: [v0.385.0...v0.386.0](https://github.com/Increase/increase-java/compare/v0.385.0...v0.386.0) + +### Features + +* **api:** api update ([2cc8bbb](https://github.com/Increase/increase-java/commit/2cc8bbbad2ecc3572645983f5256cc5c89117143)) + ## 0.385.0 (2025-12-17) Full Changelog: [v0.384.0...v0.385.0](https://github.com/Increase/increase-java/compare/v0.384.0...v0.385.0) diff --git a/README.md b/README.md index 7c6b48242..0edb3dd46 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.385.0) -[![javadoc](https://javadoc.io/badge2/com.increase.api/increase-java/0.385.0/javadoc.svg)](https://javadoc.io/doc/com.increase.api/increase-java/0.385.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.386.0) +[![javadoc](https://javadoc.io/badge2/com.increase.api/increase-java/0.386.0/javadoc.svg)](https://javadoc.io/doc/com.increase.api/increase-java/0.386.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.385.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.386.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.385.0") +implementation("com.increase.api:increase-java:0.386.0") ``` ### Maven @@ -33,7 +33,7 @@ implementation("com.increase.api:increase-java:0.385.0") com.increase.api increase-java - 0.385.0 + 0.386.0 ``` diff --git a/build.gradle.kts b/build.gradle.kts index 6fc9bc392..f01f4d5c2 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -8,7 +8,7 @@ repositories { allprojects { group = "com.increase.api" - version = "0.385.0" // x-release-please-version + version = "0.386.0" // x-release-please-version } subprojects { diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/exports/Export.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/exports/Export.kt index 6938a66d6..e690d5faf 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/exports/Export.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/exports/Export.kt @@ -20,10 +20,10 @@ import java.util.Optional import kotlin.jvm.optionals.getOrNull /** - * Exports are batch summaries of your Increase data. You can make them from the API or dashboard. - * Since they can take a while, they are generated asynchronously. We send a webhook when they are - * ready. For more information, please read our - * [Exports documentation](https://increase.com/documentation/exports). + * Exports are generated files. Some exports can contain a lot of data, like a CSV of your + * transactions. Others can be a single document, like a tax form. Since they can take a while, they + * are generated asynchronously. We send a webhook when they are ready. For more information, please + * read our [Exports documentation](https://increase.com/documentation/exports). */ class Export @JsonCreator(mode = JsonCreator.Mode.DISABLED) diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/exports/ExportCreateParams.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/exports/ExportCreateParams.kt index 907e1eb7b..ca42d2d08 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/exports/ExportCreateParams.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/exports/ExportCreateParams.kt @@ -57,6 +57,16 @@ private constructor( */ fun accountStatementOfx(): Optional = body.accountStatementOfx() + /** + * Options for the created export. Required if `category` is equal to + * `account_verification_letter`. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun accountVerificationLetter(): Optional = + body.accountVerificationLetter() + /** * Options for the created export. Required if `category` is equal to `balance_csv`. * @@ -83,6 +93,14 @@ private constructor( */ fun entityCsv(): Optional = body.entityCsv() + /** + * Options for the created export. Required if `category` is equal to `funding_instructions`. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun fundingInstructions(): Optional = body.fundingInstructions() + /** * Options for the created export. Required if `category` is equal to `transaction_csv`. * @@ -122,6 +140,15 @@ private constructor( */ fun _accountStatementOfx(): JsonField = body._accountStatementOfx() + /** + * Returns the raw JSON value of [accountVerificationLetter]. + * + * Unlike [accountVerificationLetter], this method doesn't throw if the JSON field has an + * unexpected type. + */ + fun _accountVerificationLetter(): JsonField = + body._accountVerificationLetter() + /** * Returns the raw JSON value of [balanceCsv]. * @@ -145,6 +172,14 @@ private constructor( */ fun _entityCsv(): JsonField = body._entityCsv() + /** + * Returns the raw JSON value of [fundingInstructions]. + * + * Unlike [fundingInstructions], this method doesn't throw if the JSON field has an unexpected + * type. + */ + fun _fundingInstructions(): JsonField = body._fundingInstructions() + /** * Returns the raw JSON value of [transactionCsv]. * @@ -204,8 +239,8 @@ private constructor( * - [category] * - [accountStatementBai2] * - [accountStatementOfx] + * - [accountVerificationLetter] * - [balanceCsv] - * - [bookkeepingAccountBalanceCsv] * - etc. */ fun body(body: Body) = apply { this.body = body.toBuilder() } @@ -260,6 +295,26 @@ private constructor( body.accountStatementOfx(accountStatementOfx) } + /** + * Options for the created export. Required if `category` is equal to + * `account_verification_letter`. + */ + fun accountVerificationLetter(accountVerificationLetter: AccountVerificationLetter) = + apply { + body.accountVerificationLetter(accountVerificationLetter) + } + + /** + * Sets [Builder.accountVerificationLetter] to an arbitrary JSON value. + * + * You should usually call [Builder.accountVerificationLetter] with a well-typed + * [AccountVerificationLetter] value instead. This method is primarily for setting the field + * to an undocumented or not yet supported value. + */ + fun accountVerificationLetter( + accountVerificationLetter: JsonField + ) = apply { body.accountVerificationLetter(accountVerificationLetter) } + /** Options for the created export. Required if `category` is equal to `balance_csv`. */ fun balanceCsv(balanceCsv: BalanceCsv) = apply { body.balanceCsv(balanceCsv) } @@ -303,6 +358,25 @@ private constructor( */ fun entityCsv(entityCsv: JsonField) = apply { body.entityCsv(entityCsv) } + /** + * Options for the created export. Required if `category` is equal to + * `funding_instructions`. + */ + fun fundingInstructions(fundingInstructions: FundingInstructions) = apply { + body.fundingInstructions(fundingInstructions) + } + + /** + * Sets [Builder.fundingInstructions] to an arbitrary JSON value. + * + * You should usually call [Builder.fundingInstructions] with a well-typed + * [FundingInstructions] value instead. This method is primarily for setting the field to an + * undocumented or not yet supported value. + */ + fun fundingInstructions(fundingInstructions: JsonField) = apply { + body.fundingInstructions(fundingInstructions) + } + /** Options for the created export. Required if `category` is equal to `transaction_csv`. */ fun transactionCsv(transactionCsv: TransactionCsv) = apply { body.transactionCsv(transactionCsv) @@ -480,9 +554,11 @@ private constructor( private val category: JsonField, private val accountStatementBai2: JsonField, private val accountStatementOfx: JsonField, + private val accountVerificationLetter: JsonField, private val balanceCsv: JsonField, private val bookkeepingAccountBalanceCsv: JsonField, private val entityCsv: JsonField, + private val fundingInstructions: JsonField, private val transactionCsv: JsonField, private val vendorCsv: JsonField, private val additionalProperties: MutableMap, @@ -499,6 +575,9 @@ private constructor( @JsonProperty("account_statement_ofx") @ExcludeMissing accountStatementOfx: JsonField = JsonMissing.of(), + @JsonProperty("account_verification_letter") + @ExcludeMissing + accountVerificationLetter: JsonField = JsonMissing.of(), @JsonProperty("balance_csv") @ExcludeMissing balanceCsv: JsonField = JsonMissing.of(), @@ -509,6 +588,9 @@ private constructor( @JsonProperty("entity_csv") @ExcludeMissing entityCsv: JsonField = JsonMissing.of(), + @JsonProperty("funding_instructions") + @ExcludeMissing + fundingInstructions: JsonField = JsonMissing.of(), @JsonProperty("transaction_csv") @ExcludeMissing transactionCsv: JsonField = JsonMissing.of(), @@ -519,9 +601,11 @@ private constructor( category, accountStatementBai2, accountStatementOfx, + accountVerificationLetter, balanceCsv, bookkeepingAccountBalanceCsv, entityCsv, + fundingInstructions, transactionCsv, vendorCsv, mutableMapOf(), @@ -555,6 +639,16 @@ private constructor( fun accountStatementOfx(): Optional = accountStatementOfx.getOptional("account_statement_ofx") + /** + * Options for the created export. Required if `category` is equal to + * `account_verification_letter`. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if + * the server responded with an unexpected value). + */ + fun accountVerificationLetter(): Optional = + accountVerificationLetter.getOptional("account_verification_letter") + /** * Options for the created export. Required if `category` is equal to `balance_csv`. * @@ -581,6 +675,16 @@ private constructor( */ fun entityCsv(): Optional = entityCsv.getOptional("entity_csv") + /** + * Options for the created export. Required if `category` is equal to + * `funding_instructions`. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if + * the server responded with an unexpected value). + */ + fun fundingInstructions(): Optional = + fundingInstructions.getOptional("funding_instructions") + /** * Options for the created export. Required if `category` is equal to `transaction_csv`. * @@ -625,6 +729,17 @@ private constructor( @ExcludeMissing fun _accountStatementOfx(): JsonField = accountStatementOfx + /** + * Returns the raw JSON value of [accountVerificationLetter]. + * + * Unlike [accountVerificationLetter], this method doesn't throw if the JSON field has an + * unexpected type. + */ + @JsonProperty("account_verification_letter") + @ExcludeMissing + fun _accountVerificationLetter(): JsonField = + accountVerificationLetter + /** * Returns the raw JSON value of [balanceCsv]. * @@ -654,6 +769,16 @@ private constructor( @ExcludeMissing fun _entityCsv(): JsonField = entityCsv + /** + * Returns the raw JSON value of [fundingInstructions]. + * + * Unlike [fundingInstructions], this method doesn't throw if the JSON field has an + * unexpected type. + */ + @JsonProperty("funding_instructions") + @ExcludeMissing + fun _fundingInstructions(): JsonField = fundingInstructions + /** * Returns the raw JSON value of [transactionCsv]. * @@ -704,10 +829,13 @@ private constructor( private var category: JsonField? = null private var accountStatementBai2: JsonField = JsonMissing.of() private var accountStatementOfx: JsonField = JsonMissing.of() + private var accountVerificationLetter: JsonField = + JsonMissing.of() private var balanceCsv: JsonField = JsonMissing.of() private var bookkeepingAccountBalanceCsv: JsonField = JsonMissing.of() private var entityCsv: JsonField = JsonMissing.of() + private var fundingInstructions: JsonField = JsonMissing.of() private var transactionCsv: JsonField = JsonMissing.of() private var vendorCsv: JsonField = JsonMissing.of() private var additionalProperties: MutableMap = mutableMapOf() @@ -717,9 +845,11 @@ private constructor( category = body.category accountStatementBai2 = body.accountStatementBai2 accountStatementOfx = body.accountStatementOfx + accountVerificationLetter = body.accountVerificationLetter balanceCsv = body.balanceCsv bookkeepingAccountBalanceCsv = body.bookkeepingAccountBalanceCsv entityCsv = body.entityCsv + fundingInstructions = body.fundingInstructions transactionCsv = body.transactionCsv vendorCsv = body.vendorCsv additionalProperties = body.additionalProperties.toMutableMap() @@ -774,6 +904,24 @@ private constructor( this.accountStatementOfx = accountStatementOfx } + /** + * Options for the created export. Required if `category` is equal to + * `account_verification_letter`. + */ + fun accountVerificationLetter(accountVerificationLetter: AccountVerificationLetter) = + accountVerificationLetter(JsonField.of(accountVerificationLetter)) + + /** + * Sets [Builder.accountVerificationLetter] to an arbitrary JSON value. + * + * You should usually call [Builder.accountVerificationLetter] with a well-typed + * [AccountVerificationLetter] value instead. This method is primarily for setting the + * field to an undocumented or not yet supported value. + */ + fun accountVerificationLetter( + accountVerificationLetter: JsonField + ) = apply { this.accountVerificationLetter = accountVerificationLetter } + /** Options for the created export. Required if `category` is equal to `balance_csv`. */ fun balanceCsv(balanceCsv: BalanceCsv) = balanceCsv(JsonField.of(balanceCsv)) @@ -819,6 +967,24 @@ private constructor( */ fun entityCsv(entityCsv: JsonField) = apply { this.entityCsv = entityCsv } + /** + * Options for the created export. Required if `category` is equal to + * `funding_instructions`. + */ + fun fundingInstructions(fundingInstructions: FundingInstructions) = + fundingInstructions(JsonField.of(fundingInstructions)) + + /** + * Sets [Builder.fundingInstructions] to an arbitrary JSON value. + * + * You should usually call [Builder.fundingInstructions] with a well-typed + * [FundingInstructions] value instead. This method is primarily for setting the field + * to an undocumented or not yet supported value. + */ + fun fundingInstructions(fundingInstructions: JsonField) = apply { + this.fundingInstructions = fundingInstructions + } + /** * Options for the created export. Required if `category` is equal to `transaction_csv`. */ @@ -884,9 +1050,11 @@ private constructor( checkRequired("category", category), accountStatementBai2, accountStatementOfx, + accountVerificationLetter, balanceCsv, bookkeepingAccountBalanceCsv, entityCsv, + fundingInstructions, transactionCsv, vendorCsv, additionalProperties.toMutableMap(), @@ -903,9 +1071,11 @@ private constructor( category().validate() accountStatementBai2().ifPresent { it.validate() } accountStatementOfx().ifPresent { it.validate() } + accountVerificationLetter().ifPresent { it.validate() } balanceCsv().ifPresent { it.validate() } bookkeepingAccountBalanceCsv().ifPresent { it.validate() } entityCsv().ifPresent { it.validate() } + fundingInstructions().ifPresent { it.validate() } transactionCsv().ifPresent { it.validate() } vendorCsv().ifPresent { it.validate() } validated = true @@ -930,9 +1100,11 @@ private constructor( (category.asKnown().getOrNull()?.validity() ?: 0) + (accountStatementBai2.asKnown().getOrNull()?.validity() ?: 0) + (accountStatementOfx.asKnown().getOrNull()?.validity() ?: 0) + + (accountVerificationLetter.asKnown().getOrNull()?.validity() ?: 0) + (balanceCsv.asKnown().getOrNull()?.validity() ?: 0) + (bookkeepingAccountBalanceCsv.asKnown().getOrNull()?.validity() ?: 0) + (entityCsv.asKnown().getOrNull()?.validity() ?: 0) + + (fundingInstructions.asKnown().getOrNull()?.validity() ?: 0) + (transactionCsv.asKnown().getOrNull()?.validity() ?: 0) + (vendorCsv.asKnown().getOrNull()?.validity() ?: 0) @@ -945,9 +1117,11 @@ private constructor( category == other.category && accountStatementBai2 == other.accountStatementBai2 && accountStatementOfx == other.accountStatementOfx && + accountVerificationLetter == other.accountVerificationLetter && balanceCsv == other.balanceCsv && bookkeepingAccountBalanceCsv == other.bookkeepingAccountBalanceCsv && entityCsv == other.entityCsv && + fundingInstructions == other.fundingInstructions && transactionCsv == other.transactionCsv && vendorCsv == other.vendorCsv && additionalProperties == other.additionalProperties @@ -958,9 +1132,11 @@ private constructor( category, accountStatementBai2, accountStatementOfx, + accountVerificationLetter, balanceCsv, bookkeepingAccountBalanceCsv, entityCsv, + fundingInstructions, transactionCsv, vendorCsv, additionalProperties, @@ -970,7 +1146,7 @@ private constructor( override fun hashCode(): Int = hashCode override fun toString() = - "Body{category=$category, accountStatementBai2=$accountStatementBai2, accountStatementOfx=$accountStatementOfx, balanceCsv=$balanceCsv, bookkeepingAccountBalanceCsv=$bookkeepingAccountBalanceCsv, entityCsv=$entityCsv, transactionCsv=$transactionCsv, vendorCsv=$vendorCsv, additionalProperties=$additionalProperties}" + "Body{category=$category, accountStatementBai2=$accountStatementBai2, accountStatementOfx=$accountStatementOfx, accountVerificationLetter=$accountVerificationLetter, balanceCsv=$balanceCsv, bookkeepingAccountBalanceCsv=$bookkeepingAccountBalanceCsv, entityCsv=$entityCsv, fundingInstructions=$fundingInstructions, transactionCsv=$transactionCsv, vendorCsv=$vendorCsv, additionalProperties=$additionalProperties}" } /** The type of Export to create. */ @@ -1015,6 +1191,12 @@ private constructor( /** Export a CSV of vendors added to the third-party risk management dashboard. */ @JvmField val VENDOR_CSV = of("vendor_csv") + /** A PDF of an account verification letter. */ + @JvmField val ACCOUNT_VERIFICATION_LETTER = of("account_verification_letter") + + /** A PDF of funding instructions. */ + @JvmField val FUNDING_INSTRUCTIONS = of("funding_instructions") + @JvmStatic fun of(value: String) = Category(JsonField.of(value)) } @@ -1040,6 +1222,10 @@ private constructor( ENTITY_CSV, /** Export a CSV of vendors added to the third-party risk management dashboard. */ VENDOR_CSV, + /** A PDF of an account verification letter. */ + ACCOUNT_VERIFICATION_LETTER, + /** A PDF of funding instructions. */ + FUNDING_INSTRUCTIONS, } /** @@ -1072,6 +1258,10 @@ private constructor( ENTITY_CSV, /** Export a CSV of vendors added to the third-party risk management dashboard. */ VENDOR_CSV, + /** A PDF of an account verification letter. */ + ACCOUNT_VERIFICATION_LETTER, + /** A PDF of funding instructions. */ + FUNDING_INSTRUCTIONS, /** An enum member indicating that [Category] was instantiated with an unknown value. */ _UNKNOWN, } @@ -1092,6 +1282,8 @@ private constructor( BOOKKEEPING_ACCOUNT_BALANCE_CSV -> Value.BOOKKEEPING_ACCOUNT_BALANCE_CSV ENTITY_CSV -> Value.ENTITY_CSV VENDOR_CSV -> Value.VENDOR_CSV + ACCOUNT_VERIFICATION_LETTER -> Value.ACCOUNT_VERIFICATION_LETTER + FUNDING_INSTRUCTIONS -> Value.FUNDING_INSTRUCTIONS else -> Value._UNKNOWN } @@ -1113,6 +1305,8 @@ private constructor( BOOKKEEPING_ACCOUNT_BALANCE_CSV -> Known.BOOKKEEPING_ACCOUNT_BALANCE_CSV ENTITY_CSV -> Known.ENTITY_CSV VENDOR_CSV -> Known.VENDOR_CSV + ACCOUNT_VERIFICATION_LETTER -> Known.ACCOUNT_VERIFICATION_LETTER + FUNDING_INSTRUCTIONS -> Known.FUNDING_INSTRUCTIONS else -> throw IncreaseInvalidDataException("Unknown Category: $value") } @@ -1918,6 +2112,223 @@ private constructor( "AccountStatementOfx{accountId=$accountId, createdAt=$createdAt, additionalProperties=$additionalProperties}" } + /** + * Options for the created export. Required if `category` is equal to + * `account_verification_letter`. + */ + class AccountVerificationLetter + @JsonCreator(mode = JsonCreator.Mode.DISABLED) + private constructor( + private val accountNumberId: JsonField, + private val balanceDate: JsonField, + private val additionalProperties: MutableMap, + ) { + + @JsonCreator + private constructor( + @JsonProperty("account_number_id") + @ExcludeMissing + accountNumberId: JsonField = JsonMissing.of(), + @JsonProperty("balance_date") + @ExcludeMissing + balanceDate: JsonField = JsonMissing.of(), + ) : this(accountNumberId, balanceDate, mutableMapOf()) + + /** + * The Account Number to create a letter for. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type or is + * unexpectedly missing or null (e.g. if the server responded with an unexpected value). + */ + fun accountNumberId(): String = accountNumberId.getRequired("account_number_id") + + /** + * The date of the balance to include in the letter. Defaults to the current date. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if + * the server responded with an unexpected value). + */ + fun balanceDate(): Optional = balanceDate.getOptional("balance_date") + + /** + * Returns the raw JSON value of [accountNumberId]. + * + * Unlike [accountNumberId], this method doesn't throw if the JSON field has an unexpected + * type. + */ + @JsonProperty("account_number_id") + @ExcludeMissing + fun _accountNumberId(): JsonField = accountNumberId + + /** + * Returns the raw JSON value of [balanceDate]. + * + * Unlike [balanceDate], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("balance_date") + @ExcludeMissing + fun _balanceDate(): JsonField = balanceDate + + @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 + * [AccountVerificationLetter]. + * + * The following fields are required: + * ```java + * .accountNumberId() + * ``` + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [AccountVerificationLetter]. */ + class Builder internal constructor() { + + private var accountNumberId: JsonField? = null + private var balanceDate: JsonField = JsonMissing.of() + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(accountVerificationLetter: AccountVerificationLetter) = apply { + accountNumberId = accountVerificationLetter.accountNumberId + balanceDate = accountVerificationLetter.balanceDate + additionalProperties = accountVerificationLetter.additionalProperties.toMutableMap() + } + + /** The Account Number to create a letter for. */ + fun accountNumberId(accountNumberId: String) = + accountNumberId(JsonField.of(accountNumberId)) + + /** + * Sets [Builder.accountNumberId] to an arbitrary JSON value. + * + * You should usually call [Builder.accountNumberId] with a well-typed [String] value + * instead. This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun accountNumberId(accountNumberId: JsonField) = apply { + this.accountNumberId = accountNumberId + } + + /** The date of the balance to include in the letter. Defaults to the current date. */ + fun balanceDate(balanceDate: LocalDate) = balanceDate(JsonField.of(balanceDate)) + + /** + * Sets [Builder.balanceDate] to an arbitrary JSON value. + * + * You should usually call [Builder.balanceDate] with a well-typed [LocalDate] value + * instead. This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun balanceDate(balanceDate: JsonField) = apply { + this.balanceDate = balanceDate + } + + 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 [AccountVerificationLetter]. + * + * Further updates to this [Builder] will not mutate the returned instance. + * + * The following fields are required: + * ```java + * .accountNumberId() + * ``` + * + * @throws IllegalStateException if any required field is unset. + */ + fun build(): AccountVerificationLetter = + AccountVerificationLetter( + checkRequired("accountNumberId", accountNumberId), + balanceDate, + additionalProperties.toMutableMap(), + ) + } + + private var validated: Boolean = false + + fun validate(): AccountVerificationLetter = apply { + if (validated) { + return@apply + } + + accountNumberId() + balanceDate() + 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 (accountNumberId.asKnown().isPresent) 1 else 0) + + (if (balanceDate.asKnown().isPresent) 1 else 0) + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is AccountVerificationLetter && + accountNumberId == other.accountNumberId && + balanceDate == other.balanceDate && + additionalProperties == other.additionalProperties + } + + private val hashCode: Int by lazy { + Objects.hash(accountNumberId, balanceDate, additionalProperties) + } + + override fun hashCode(): Int = hashCode + + override fun toString() = + "AccountVerificationLetter{accountNumberId=$accountNumberId, balanceDate=$balanceDate, additionalProperties=$additionalProperties}" + } + /** Options for the created export. Required if `category` is equal to `balance_csv`. */ class BalanceCsv @JsonCreator(mode = JsonCreator.Mode.DISABLED) @@ -3409,6 +3820,177 @@ private constructor( "EntityCsv{status=$status, additionalProperties=$additionalProperties}" } + /** + * Options for the created export. Required if `category` is equal to `funding_instructions`. + */ + class FundingInstructions + @JsonCreator(mode = JsonCreator.Mode.DISABLED) + private constructor( + private val accountNumberId: JsonField, + private val additionalProperties: MutableMap, + ) { + + @JsonCreator + private constructor( + @JsonProperty("account_number_id") + @ExcludeMissing + accountNumberId: JsonField = JsonMissing.of() + ) : this(accountNumberId, mutableMapOf()) + + /** + * The Account Number to create funding instructions for. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type or is + * unexpectedly missing or null (e.g. if the server responded with an unexpected value). + */ + fun accountNumberId(): String = accountNumberId.getRequired("account_number_id") + + /** + * Returns the raw JSON value of [accountNumberId]. + * + * Unlike [accountNumberId], this method doesn't throw if the JSON field has an unexpected + * type. + */ + @JsonProperty("account_number_id") + @ExcludeMissing + fun _accountNumberId(): JsonField = accountNumberId + + @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 [FundingInstructions]. + * + * The following fields are required: + * ```java + * .accountNumberId() + * ``` + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [FundingInstructions]. */ + class Builder internal constructor() { + + private var accountNumberId: JsonField? = null + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(fundingInstructions: FundingInstructions) = apply { + accountNumberId = fundingInstructions.accountNumberId + additionalProperties = fundingInstructions.additionalProperties.toMutableMap() + } + + /** The Account Number to create funding instructions for. */ + fun accountNumberId(accountNumberId: String) = + accountNumberId(JsonField.of(accountNumberId)) + + /** + * Sets [Builder.accountNumberId] to an arbitrary JSON value. + * + * You should usually call [Builder.accountNumberId] with a well-typed [String] value + * instead. This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun accountNumberId(accountNumberId: JsonField) = apply { + this.accountNumberId = accountNumberId + } + + 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 [FundingInstructions]. + * + * Further updates to this [Builder] will not mutate the returned instance. + * + * The following fields are required: + * ```java + * .accountNumberId() + * ``` + * + * @throws IllegalStateException if any required field is unset. + */ + fun build(): FundingInstructions = + FundingInstructions( + checkRequired("accountNumberId", accountNumberId), + additionalProperties.toMutableMap(), + ) + } + + private var validated: Boolean = false + + fun validate(): FundingInstructions = apply { + if (validated) { + return@apply + } + + accountNumberId() + 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 (accountNumberId.asKnown().isPresent) 1 else 0) + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is FundingInstructions && + accountNumberId == other.accountNumberId && + additionalProperties == other.additionalProperties + } + + private val hashCode: Int by lazy { Objects.hash(accountNumberId, additionalProperties) } + + override fun hashCode(): Int = hashCode + + override fun toString() = + "FundingInstructions{accountNumberId=$accountNumberId, additionalProperties=$additionalProperties}" + } + /** Options for the created export. Required if `category` is equal to `transaction_csv`. */ class TransactionCsv @JsonCreator(mode = JsonCreator.Mode.DISABLED) diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/exports/ExportCreateParams.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/exports/ExportCreateParams.kt new file mode 100644 index 000000000..218ef3e44 --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/exports/ExportCreateParams.kt @@ -0,0 +1,418 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.simulations.exports + +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.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.checkRequired +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 + +/** Simulates a tax form export being generated. */ +class ExportCreateParams +private constructor( + private val body: Body, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, +) : Params { + + /** + * The identifier of the Account the tax document is for. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type or is + * unexpectedly missing or null (e.g. if the server responded with an unexpected value). + */ + fun accountId(): String = body.accountId() + + /** + * Returns the raw JSON value of [accountId]. + * + * Unlike [accountId], this method doesn't throw if the JSON field has an unexpected type. + */ + fun _accountId(): JsonField = body._accountId() + + 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 { + + /** + * Returns a mutable builder for constructing an instance of [ExportCreateParams]. + * + * The following fields are required: + * ```java + * .accountId() + * ``` + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [ExportCreateParams]. */ + class Builder internal constructor() { + + 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(exportCreateParams: ExportCreateParams) = apply { + body = exportCreateParams.body.toBuilder() + additionalHeaders = exportCreateParams.additionalHeaders.toBuilder() + additionalQueryParams = exportCreateParams.additionalQueryParams.toBuilder() + } + + /** + * 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: + * - [accountId] + */ + fun body(body: Body) = apply { this.body = body.toBuilder() } + + /** The identifier of the Account the tax document is for. */ + fun accountId(accountId: String) = apply { body.accountId(accountId) } + + /** + * Sets [Builder.accountId] to an arbitrary JSON value. + * + * You should usually call [Builder.accountId] with a well-typed [String] value instead. + * This method is primarily for setting the field to an undocumented or not yet supported + * value. + */ + fun accountId(accountId: JsonField) = apply { body.accountId(accountId) } + + 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 [ExportCreateParams]. + * + * Further updates to this [Builder] will not mutate the returned instance. + * + * The following fields are required: + * ```java + * .accountId() + * ``` + * + * @throws IllegalStateException if any required field is unset. + */ + fun build(): ExportCreateParams = + ExportCreateParams( + body.build(), + additionalHeaders.build(), + additionalQueryParams.build(), + ) + } + + fun _body(): Body = body + + override fun _headers(): Headers = additionalHeaders + + override fun _queryParams(): QueryParams = additionalQueryParams + + class Body + @JsonCreator(mode = JsonCreator.Mode.DISABLED) + private constructor( + private val accountId: JsonField, + private val additionalProperties: MutableMap, + ) { + + @JsonCreator + private constructor( + @JsonProperty("account_id") + @ExcludeMissing + accountId: JsonField = JsonMissing.of() + ) : this(accountId, mutableMapOf()) + + /** + * The identifier of the Account the tax document is for. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type or is + * unexpectedly missing or null (e.g. if the server responded with an unexpected value). + */ + fun accountId(): String = accountId.getRequired("account_id") + + /** + * Returns the raw JSON value of [accountId]. + * + * Unlike [accountId], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("account_id") @ExcludeMissing fun _accountId(): JsonField = accountId + + @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]. + * + * The following fields are required: + * ```java + * .accountId() + * ``` + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [Body]. */ + class Builder internal constructor() { + + private var accountId: JsonField? = null + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(body: Body) = apply { + accountId = body.accountId + additionalProperties = body.additionalProperties.toMutableMap() + } + + /** The identifier of the Account the tax document is for. */ + fun accountId(accountId: String) = accountId(JsonField.of(accountId)) + + /** + * Sets [Builder.accountId] to an arbitrary JSON value. + * + * You should usually call [Builder.accountId] with a well-typed [String] value instead. + * This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun accountId(accountId: JsonField) = apply { this.accountId = accountId } + + 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. + * + * The following fields are required: + * ```java + * .accountId() + * ``` + * + * @throws IllegalStateException if any required field is unset. + */ + fun build(): Body = + Body(checkRequired("accountId", accountId), additionalProperties.toMutableMap()) + } + + private var validated: Boolean = false + + fun validate(): Body = apply { + if (validated) { + return@apply + } + + accountId() + 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 (accountId.asKnown().isPresent) 1 else 0) + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is Body && + accountId == other.accountId && + additionalProperties == other.additionalProperties + } + + private val hashCode: Int by lazy { Objects.hash(accountId, additionalProperties) } + + override fun hashCode(): Int = hashCode + + override fun toString() = + "Body{accountId=$accountId, additionalProperties=$additionalProperties}" + } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is ExportCreateParams && + body == other.body && + additionalHeaders == other.additionalHeaders && + additionalQueryParams == other.additionalQueryParams + } + + override fun hashCode(): Int = Objects.hash(body, additionalHeaders, additionalQueryParams) + + override fun toString() = + "ExportCreateParams{body=$body, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" +} 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 92761ca75..a065803d2 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 @@ -20,6 +20,7 @@ import com.increase.api.services.async.simulations.CheckDepositServiceAsync import com.increase.api.services.async.simulations.CheckTransferServiceAsync import com.increase.api.services.async.simulations.DigitalWalletTokenRequestServiceAsync import com.increase.api.services.async.simulations.DocumentServiceAsync +import com.increase.api.services.async.simulations.ExportServiceAsync import com.increase.api.services.async.simulations.InboundAchTransferServiceAsync import com.increase.api.services.async.simulations.InboundCheckDepositServiceAsync import com.increase.api.services.async.simulations.InboundFednowTransferServiceAsync @@ -110,6 +111,8 @@ interface SimulationServiceAsync { fun documents(): DocumentServiceAsync + fun exports(): ExportServiceAsync + fun cardTokens(): CardTokenServiceAsync /** @@ -188,6 +191,8 @@ interface SimulationServiceAsync { fun documents(): DocumentServiceAsync.WithRawResponse + fun exports(): ExportServiceAsync.WithRawResponse + fun cardTokens(): CardTokenServiceAsync.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 01be0bcd8..cf2ce443f 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 @@ -37,6 +37,8 @@ import com.increase.api.services.async.simulations.DigitalWalletTokenRequestServ import com.increase.api.services.async.simulations.DigitalWalletTokenRequestServiceAsyncImpl import com.increase.api.services.async.simulations.DocumentServiceAsync import com.increase.api.services.async.simulations.DocumentServiceAsyncImpl +import com.increase.api.services.async.simulations.ExportServiceAsync +import com.increase.api.services.async.simulations.ExportServiceAsyncImpl import com.increase.api.services.async.simulations.InboundAchTransferServiceAsync import com.increase.api.services.async.simulations.InboundAchTransferServiceAsyncImpl import com.increase.api.services.async.simulations.InboundCheckDepositServiceAsync @@ -191,6 +193,8 @@ class SimulationServiceAsyncImpl internal constructor(private val clientOptions: private val documents: DocumentServiceAsync by lazy { DocumentServiceAsyncImpl(clientOptions) } + private val exports: ExportServiceAsync by lazy { ExportServiceAsyncImpl(clientOptions) } + private val cardTokens: CardTokenServiceAsync by lazy { CardTokenServiceAsyncImpl(clientOptions) } @@ -266,6 +270,8 @@ class SimulationServiceAsyncImpl internal constructor(private val clientOptions: override fun documents(): DocumentServiceAsync = documents + override fun exports(): ExportServiceAsync = exports + override fun cardTokens(): CardTokenServiceAsync = cardTokens class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) : @@ -398,6 +404,10 @@ class SimulationServiceAsyncImpl internal constructor(private val clientOptions: DocumentServiceAsyncImpl.WithRawResponseImpl(clientOptions) } + private val exports: ExportServiceAsync.WithRawResponse by lazy { + ExportServiceAsyncImpl.WithRawResponseImpl(clientOptions) + } + private val cardTokens: CardTokenServiceAsync.WithRawResponse by lazy { CardTokenServiceAsyncImpl.WithRawResponseImpl(clientOptions) } @@ -488,6 +498,8 @@ class SimulationServiceAsyncImpl internal constructor(private val clientOptions: override fun documents(): DocumentServiceAsync.WithRawResponse = documents + override fun exports(): ExportServiceAsync.WithRawResponse = exports + override fun cardTokens(): CardTokenServiceAsync.WithRawResponse = cardTokens } } diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/ExportServiceAsync.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/ExportServiceAsync.kt new file mode 100644 index 000000000..a61ecd272 --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/ExportServiceAsync.kt @@ -0,0 +1,64 @@ +// 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.exports.Export +import com.increase.api.models.simulations.exports.ExportCreateParams +import java.util.concurrent.CompletableFuture +import java.util.function.Consumer + +interface ExportServiceAsync { + + /** + * 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): ExportServiceAsync + + /** Simulates a tax form export being generated. */ + fun create(params: ExportCreateParams): CompletableFuture = + create(params, RequestOptions.none()) + + /** @see create */ + fun create( + params: ExportCreateParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture + + /** + * A view of [ExportServiceAsync] 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 + ): ExportServiceAsync.WithRawResponse + + /** + * Returns a raw HTTP response for `post /simulations/exports`, but is otherwise the same as + * [ExportServiceAsync.create]. + */ + fun create(params: ExportCreateParams): CompletableFuture> = + create(params, RequestOptions.none()) + + /** @see create */ + fun create( + params: ExportCreateParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture> + } +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/ExportServiceAsyncImpl.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/ExportServiceAsyncImpl.kt new file mode 100644 index 000000000..882ffefd3 --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/ExportServiceAsyncImpl.kt @@ -0,0 +1,85 @@ +// 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.handlers.errorBodyHandler +import com.increase.api.core.handlers.errorHandler +import com.increase.api.core.handlers.jsonHandler +import com.increase.api.core.http.HttpMethod +import com.increase.api.core.http.HttpRequest +import com.increase.api.core.http.HttpResponse +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.exports.Export +import com.increase.api.models.simulations.exports.ExportCreateParams +import java.util.concurrent.CompletableFuture +import java.util.function.Consumer + +class ExportServiceAsyncImpl internal constructor(private val clientOptions: ClientOptions) : + ExportServiceAsync { + + private val withRawResponse: ExportServiceAsync.WithRawResponse by lazy { + WithRawResponseImpl(clientOptions) + } + + override fun withRawResponse(): ExportServiceAsync.WithRawResponse = withRawResponse + + override fun withOptions(modifier: Consumer): ExportServiceAsync = + ExportServiceAsyncImpl(clientOptions.toBuilder().apply(modifier::accept).build()) + + override fun create( + params: ExportCreateParams, + requestOptions: RequestOptions, + ): CompletableFuture = + // post /simulations/exports + withRawResponse().create(params, requestOptions).thenApply { it.parse() } + + class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) : + ExportServiceAsync.WithRawResponse { + + private val errorHandler: Handler = + errorHandler(errorBodyHandler(clientOptions.jsonMapper)) + + override fun withOptions( + modifier: Consumer + ): ExportServiceAsync.WithRawResponse = + ExportServiceAsyncImpl.WithRawResponseImpl( + clientOptions.toBuilder().apply(modifier::accept).build() + ) + + private val createHandler: Handler = jsonHandler(clientOptions.jsonMapper) + + override fun create( + params: ExportCreateParams, + requestOptions: RequestOptions, + ): CompletableFuture> { + val request = + HttpRequest.builder() + .method(HttpMethod.POST) + .baseUrl(clientOptions.baseUrl()) + .addPathSegments("simulations", "exports") + .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 { createHandler.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 633e26933..2b6b3098d 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 @@ -20,6 +20,7 @@ import com.increase.api.services.blocking.simulations.CheckDepositService import com.increase.api.services.blocking.simulations.CheckTransferService import com.increase.api.services.blocking.simulations.DigitalWalletTokenRequestService import com.increase.api.services.blocking.simulations.DocumentService +import com.increase.api.services.blocking.simulations.ExportService import com.increase.api.services.blocking.simulations.InboundAchTransferService import com.increase.api.services.blocking.simulations.InboundCheckDepositService import com.increase.api.services.blocking.simulations.InboundFednowTransferService @@ -110,6 +111,8 @@ interface SimulationService { fun documents(): DocumentService + fun exports(): ExportService + fun cardTokens(): CardTokenService /** A view of [SimulationService] that provides access to raw HTTP responses for each method. */ @@ -185,6 +188,8 @@ interface SimulationService { fun documents(): DocumentService.WithRawResponse + fun exports(): ExportService.WithRawResponse + fun cardTokens(): CardTokenService.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 31dea2bf2..9b47f23e7 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 @@ -37,6 +37,8 @@ import com.increase.api.services.blocking.simulations.DigitalWalletTokenRequestS import com.increase.api.services.blocking.simulations.DigitalWalletTokenRequestServiceImpl import com.increase.api.services.blocking.simulations.DocumentService import com.increase.api.services.blocking.simulations.DocumentServiceImpl +import com.increase.api.services.blocking.simulations.ExportService +import com.increase.api.services.blocking.simulations.ExportServiceImpl import com.increase.api.services.blocking.simulations.InboundAchTransferService import com.increase.api.services.blocking.simulations.InboundAchTransferServiceImpl import com.increase.api.services.blocking.simulations.InboundCheckDepositService @@ -184,6 +186,8 @@ class SimulationServiceImpl internal constructor(private val clientOptions: Clie private val documents: DocumentService by lazy { DocumentServiceImpl(clientOptions) } + private val exports: ExportService by lazy { ExportServiceImpl(clientOptions) } + private val cardTokens: CardTokenService by lazy { CardTokenServiceImpl(clientOptions) } override fun withRawResponse(): SimulationService.WithRawResponse = withRawResponse @@ -256,6 +260,8 @@ class SimulationServiceImpl internal constructor(private val clientOptions: Clie override fun documents(): DocumentService = documents + override fun exports(): ExportService = exports + override fun cardTokens(): CardTokenService = cardTokens class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) : @@ -386,6 +392,10 @@ class SimulationServiceImpl internal constructor(private val clientOptions: Clie DocumentServiceImpl.WithRawResponseImpl(clientOptions) } + private val exports: ExportService.WithRawResponse by lazy { + ExportServiceImpl.WithRawResponseImpl(clientOptions) + } + private val cardTokens: CardTokenService.WithRawResponse by lazy { CardTokenServiceImpl.WithRawResponseImpl(clientOptions) } @@ -473,6 +483,8 @@ class SimulationServiceImpl internal constructor(private val clientOptions: Clie override fun documents(): DocumentService.WithRawResponse = documents + override fun exports(): ExportService.WithRawResponse = exports + override fun cardTokens(): CardTokenService.WithRawResponse = cardTokens } } diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/ExportService.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/ExportService.kt new file mode 100644 index 000000000..3dfde152b --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/ExportService.kt @@ -0,0 +1,61 @@ +// 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.exports.Export +import com.increase.api.models.simulations.exports.ExportCreateParams +import java.util.function.Consumer + +interface ExportService { + + /** + * 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): ExportService + + /** Simulates a tax form export being generated. */ + fun create(params: ExportCreateParams): Export = create(params, RequestOptions.none()) + + /** @see create */ + fun create( + params: ExportCreateParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): Export + + /** A view of [ExportService] 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): ExportService.WithRawResponse + + /** + * Returns a raw HTTP response for `post /simulations/exports`, but is otherwise the same as + * [ExportService.create]. + */ + @MustBeClosed + fun create(params: ExportCreateParams): HttpResponseFor = + create(params, RequestOptions.none()) + + /** @see create */ + @MustBeClosed + fun create( + params: ExportCreateParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): HttpResponseFor + } +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/ExportServiceImpl.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/ExportServiceImpl.kt new file mode 100644 index 000000000..1275a1cee --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/ExportServiceImpl.kt @@ -0,0 +1,78 @@ +// 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.RequestOptions +import com.increase.api.core.handlers.errorBodyHandler +import com.increase.api.core.handlers.errorHandler +import com.increase.api.core.handlers.jsonHandler +import com.increase.api.core.http.HttpMethod +import com.increase.api.core.http.HttpRequest +import com.increase.api.core.http.HttpResponse +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.exports.Export +import com.increase.api.models.simulations.exports.ExportCreateParams +import java.util.function.Consumer + +class ExportServiceImpl internal constructor(private val clientOptions: ClientOptions) : + ExportService { + + private val withRawResponse: ExportService.WithRawResponse by lazy { + WithRawResponseImpl(clientOptions) + } + + override fun withRawResponse(): ExportService.WithRawResponse = withRawResponse + + override fun withOptions(modifier: Consumer): ExportService = + ExportServiceImpl(clientOptions.toBuilder().apply(modifier::accept).build()) + + override fun create(params: ExportCreateParams, requestOptions: RequestOptions): Export = + // post /simulations/exports + withRawResponse().create(params, requestOptions).parse() + + class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) : + ExportService.WithRawResponse { + + private val errorHandler: Handler = + errorHandler(errorBodyHandler(clientOptions.jsonMapper)) + + override fun withOptions( + modifier: Consumer + ): ExportService.WithRawResponse = + ExportServiceImpl.WithRawResponseImpl( + clientOptions.toBuilder().apply(modifier::accept).build() + ) + + private val createHandler: Handler = jsonHandler(clientOptions.jsonMapper) + + override fun create( + params: ExportCreateParams, + requestOptions: RequestOptions, + ): HttpResponseFor { + val request = + HttpRequest.builder() + .method(HttpMethod.POST) + .baseUrl(clientOptions.baseUrl()) + .addPathSegments("simulations", "exports") + .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 { createHandler.handle(it) } + .also { + if (requestOptions.responseValidation!!) { + it.validate() + } + } + } + } + } +} diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/exports/ExportCreateParamsTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/exports/ExportCreateParamsTest.kt index 363777e84..3e4a1e184 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/exports/ExportCreateParamsTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/exports/ExportCreateParamsTest.kt @@ -33,6 +33,12 @@ internal class ExportCreateParamsTest { ) .build() ) + .accountVerificationLetter( + ExportCreateParams.AccountVerificationLetter.builder() + .accountNumberId("account_number_id") + .balanceDate(LocalDate.parse("2019-12-27")) + .build() + ) .balanceCsv( ExportCreateParams.BalanceCsv.builder() .accountId("account_id") @@ -69,6 +75,11 @@ internal class ExportCreateParamsTest { ) .build() ) + .fundingInstructions( + ExportCreateParams.FundingInstructions.builder() + .accountNumberId("account_number_id") + .build() + ) .transactionCsv( ExportCreateParams.TransactionCsv.builder() .accountId("account_in71c4amph0vgo2qllky") @@ -112,6 +123,12 @@ internal class ExportCreateParamsTest { ) .build() ) + .accountVerificationLetter( + ExportCreateParams.AccountVerificationLetter.builder() + .accountNumberId("account_number_id") + .balanceDate(LocalDate.parse("2019-12-27")) + .build() + ) .balanceCsv( ExportCreateParams.BalanceCsv.builder() .accountId("account_id") @@ -148,6 +165,11 @@ internal class ExportCreateParamsTest { ) .build() ) + .fundingInstructions( + ExportCreateParams.FundingInstructions.builder() + .accountNumberId("account_number_id") + .build() + ) .transactionCsv( ExportCreateParams.TransactionCsv.builder() .accountId("account_in71c4amph0vgo2qllky") @@ -190,6 +212,13 @@ internal class ExportCreateParamsTest { ) .build() ) + assertThat(body.accountVerificationLetter()) + .contains( + ExportCreateParams.AccountVerificationLetter.builder() + .accountNumberId("account_number_id") + .balanceDate(LocalDate.parse("2019-12-27")) + .build() + ) assertThat(body.balanceCsv()) .contains( ExportCreateParams.BalanceCsv.builder() @@ -229,6 +258,12 @@ internal class ExportCreateParamsTest { ) .build() ) + assertThat(body.fundingInstructions()) + .contains( + ExportCreateParams.FundingInstructions.builder() + .accountNumberId("account_number_id") + .build() + ) assertThat(body.transactionCsv()) .contains( ExportCreateParams.TransactionCsv.builder() diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/exports/ExportCreateParamsTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/exports/ExportCreateParamsTest.kt new file mode 100644 index 000000000..0caed7faf --- /dev/null +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/exports/ExportCreateParamsTest.kt @@ -0,0 +1,23 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.simulations.exports + +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Test + +internal class ExportCreateParamsTest { + + @Test + fun create() { + ExportCreateParams.builder().accountId("account_in71c4amph0vgo2qllky").build() + } + + @Test + fun body() { + val params = ExportCreateParams.builder().accountId("account_in71c4amph0vgo2qllky").build() + + val body = params._body() + + assertThat(body.accountId()).isEqualTo("account_in71c4amph0vgo2qllky") + } +} diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/async/ExportServiceAsyncTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/async/ExportServiceAsyncTest.kt index b044e39d9..500b6284b 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/services/async/ExportServiceAsyncTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/async/ExportServiceAsyncTest.kt @@ -46,6 +46,12 @@ internal class ExportServiceAsyncTest { ) .build() ) + .accountVerificationLetter( + ExportCreateParams.AccountVerificationLetter.builder() + .accountNumberId("account_number_id") + .balanceDate(LocalDate.parse("2019-12-27")) + .build() + ) .balanceCsv( ExportCreateParams.BalanceCsv.builder() .accountId("account_id") @@ -82,6 +88,11 @@ internal class ExportServiceAsyncTest { ) .build() ) + .fundingInstructions( + ExportCreateParams.FundingInstructions.builder() + .accountNumberId("account_number_id") + .build() + ) .transactionCsv( ExportCreateParams.TransactionCsv.builder() .accountId("account_in71c4amph0vgo2qllky") diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/ExportServiceAsyncTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/ExportServiceAsyncTest.kt new file mode 100644 index 000000000..58e9f5b2c --- /dev/null +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/ExportServiceAsyncTest.kt @@ -0,0 +1,31 @@ +// 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 com.increase.api.models.simulations.exports.ExportCreateParams +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +internal class ExportServiceAsyncTest { + + @Test + fun create() { + val client = + IncreaseOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val exportServiceAsync = client.simulations().exports() + + val exportFuture = + exportServiceAsync.create( + ExportCreateParams.builder().accountId("account_in71c4amph0vgo2qllky").build() + ) + + val export = exportFuture.get() + export.validate() + } +} diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/ExportServiceTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/ExportServiceTest.kt index c98cd80d1..b588d693e 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/ExportServiceTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/ExportServiceTest.kt @@ -46,6 +46,12 @@ internal class ExportServiceTest { ) .build() ) + .accountVerificationLetter( + ExportCreateParams.AccountVerificationLetter.builder() + .accountNumberId("account_number_id") + .balanceDate(LocalDate.parse("2019-12-27")) + .build() + ) .balanceCsv( ExportCreateParams.BalanceCsv.builder() .accountId("account_id") @@ -82,6 +88,11 @@ internal class ExportServiceTest { ) .build() ) + .fundingInstructions( + ExportCreateParams.FundingInstructions.builder() + .accountNumberId("account_number_id") + .build() + ) .transactionCsv( ExportCreateParams.TransactionCsv.builder() .accountId("account_in71c4amph0vgo2qllky") diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/ExportServiceTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/ExportServiceTest.kt new file mode 100644 index 000000000..70769797b --- /dev/null +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/ExportServiceTest.kt @@ -0,0 +1,30 @@ +// 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 com.increase.api.models.simulations.exports.ExportCreateParams +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +internal class ExportServiceTest { + + @Test + fun create() { + val client = + IncreaseOkHttpClient.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val exportService = client.simulations().exports() + + val export = + exportService.create( + ExportCreateParams.builder().accountId("account_in71c4amph0vgo2qllky").build() + ) + + export.validate() + } +}