From cc003ab75d99cba17f4e77b744c81fdead69af8e Mon Sep 17 00:00:00 2001 From: "increase-releases[bot]" <285999079+increase-releases[bot]@users.noreply.github.com> Date: Tue, 9 Jun 2026 16:42:19 +0000 Subject: [PATCH] feat(api): api update --- .github/workflows/ci.yml | 59 +- .github/workflows/publish-sonatype.yml | 8 +- .github/workflows/release.yml | 1 + .stats.yml | 5 +- increase-java-core/build.gradle.kts | 1 - .../kotlin/com/increase/api/core/Utils.kt | 5 - .../achprenotifications/AchPrenotification.kt | 21 +- .../AchPrenotificationCreateParams.kt | 12 +- .../api/models/achtransfers/AchTransfer.kt | 17 +- .../api/models/carddisputes/CardDispute.kt | 290 ++++++++- .../carddisputes/CardDisputeListParams.kt | 18 + .../api/models/cardpayments/CardPayment.kt | 459 +++++++++++++- .../cardpushtransfers/CardPushTransfer.kt | 334 +++++++++- .../com/increase/api/models/cards/Card.kt | 40 +- .../models/checktransfers/CheckTransfer.kt | 35 +- .../DeclinedTransaction.kt | 6 +- .../digitalwallettokens/DigitalWalletToken.kt | 421 ++++++++++++- .../increase/api/models/entities/Entity.kt | 9 +- .../com/increase/api/models/events/Event.kt | 36 ++ .../api/models/events/EventListParams.kt | 36 ++ .../api/models/events/UnwrapWebhookEvent.kt | 36 ++ .../eventsubscriptions/EventSubscription.kt | 36 ++ .../EventSubscriptionCreateParams.kt | 36 ++ .../com/increase/api/models/exports/Export.kt | 108 +++- .../api/models/exports/ExportCreateParams.kt | 582 +++++++++++++++++- .../models/fednowtransfers/FednowTransfer.kt | 352 ++++++++++- .../InboundWireTransfer.kt | 43 +- .../pendingtransactions/PendingTransaction.kt | 438 ++++++++++++- .../PhysicalCardProfile.kt | 269 +++++++- .../api/models/physicalcards/PhysicalCard.kt | 21 +- .../realtimedecisions/RealTimeDecision.kt | 421 ++++++++++++- ...ransferCreateNotificationOfChangeParams.kt | 9 + .../CardAuthorizationCreateParams.kt | 6 +- .../CardBalanceInquiryCreateParams.kt | 6 +- .../checkdeposits/CheckDepositSubmitParams.kt | 89 ++- ...DigitalWalletTokenRequestCreateResponse.kt | 27 + .../entities/EntityUpdateValidationParams.kt | 6 +- .../InboundWireTransferCreateParams.kt | 65 +- .../physicalcards/PhysicalCardCreateParams.kt | 18 +- .../api/models/transactions/Transaction.kt | 61 +- .../WireDrawdownRequest.kt | 130 +++- .../CardDisputeListPageResponseTest.kt | 18 + .../models/carddisputes/CardDisputeTest.kt | 19 + .../CardPaymentListPageResponseTest.kt | 128 ++++ .../models/cardpayments/CardPaymentTest.kt | 108 ++++ .../CardPushTransferListPageResponseTest.kt | 18 + .../cardpushtransfers/CardPushTransferTest.kt | 18 + .../models/cards/CardListPageResponseTest.kt | 3 + .../com/increase/api/models/cards/CardTest.kt | 3 + .../CheckTransferListPageResponseTest.kt | 12 +- .../checktransfers/CheckTransferTest.kt | 6 +- .../DigitalWalletTokenListPageResponseTest.kt | 15 + .../DigitalWalletTokenTest.kt | 16 + .../models/entities/EntityCreateParamsTest.kt | 12 +- .../entities/EntityListPageResponseTest.kt | 18 +- .../api/models/entities/EntityTest.kt | 18 +- .../models/exports/ExportCreateParamsTest.kt | 40 ++ .../exports/ExportListPageResponseTest.kt | 10 + .../increase/api/models/exports/ExportTest.kt | 6 + .../FednowTransferListPageResponseTest.kt | 24 + .../fednowtransfers/FednowTransferTest.kt | 25 + ...InboundWireTransferListPageResponseTest.kt | 3 + .../InboundWireTransferTest.kt | 3 + .../PendingTransactionListPageResponseTest.kt | 33 + .../PendingTransactionTest.kt | 27 + ...PhysicalCardProfileListPageResponseTest.kt | 18 + .../PhysicalCardProfileTest.kt | 8 + .../realtimedecisions/RealTimeDecisionTest.kt | 27 + .../CardAuthorizationCreateResponseTest.kt | 33 + .../CheckDepositSubmitParamsTest.kt | 3 + .../InboundWireTransferCreateParamsTest.kt | 3 + .../SwiftTransferCreateParamsTest.kt | 10 +- .../SwiftTransferListPageResponseTest.kt | 6 +- .../swifttransfers/SwiftTransferTest.kt | 6 +- .../TransactionListPageResponseTest.kt | 3 + .../models/transactions/TransactionTest.kt | 3 + ...WireDrawdownRequestListPageResponseTest.kt | 6 + .../WireDrawdownRequestTest.kt | 7 + .../services/async/EntityServiceAsyncTest.kt | 4 +- .../services/async/ExportServiceAsyncTest.kt | 13 + .../async/SwiftTransferServiceAsyncTest.kt | 2 +- .../CheckDepositServiceAsyncTest.kt | 1 + .../InboundWireTransferServiceAsyncTest.kt | 1 + .../services/blocking/EntityServiceTest.kt | 4 +- .../services/blocking/ExportServiceTest.kt | 13 + .../blocking/SwiftTransferServiceTest.kt | 2 +- .../simulations/CheckDepositServiceTest.kt | 1 + .../InboundWireTransferServiceTest.kt | 1 + release-please-config.json | 3 +- scripts/mock | 15 +- 90 files changed, 5166 insertions(+), 182 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index b0b055c32..6833b4926 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -1,30 +1,71 @@ name: CI on: push: - branches: [main] + branches: + - '**' + - '!integrated/**' + - '!stl-preview-head/**' + - '!stl-preview-base/**' + - '!generated' + - '!codegen/**' + - 'codegen/stl/**' pull_request: + branches-ignore: + - 'stl-preview-head/**' + - 'stl-preview-base/**' jobs: - ci: + lint: timeout-minutes: 15 + name: lint runs-on: ubuntu-latest + if: (github.event_name == 'push' || github.event.pull_request.head.repo.fork) && (github.event_name != 'push' || github.event.head_commit.message != 'codegen metadata') + steps: - - uses: actions/checkout@v6 + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 - - uses: actions/setup-java@v5 + - name: Set up Java + uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5.2.0 with: distribution: temurin java-version: | 8 21 + cache: gradle - - uses: gradle/actions/setup-gradle@v4 + - name: Set up Gradle + uses: gradle/actions/setup-gradle@ed408507eac070d1f99cc633dbcf757c94c7933a # v4.4.3 - - name: Lint + - name: Run lints run: ./scripts/lint - - name: Build + build: + timeout-minutes: 15 + name: build + permissions: + contents: read + id-token: write + runs-on: ubuntu-latest + if: (github.event_name == 'push' || github.event.pull_request.head.repo.fork) && (github.event_name != 'push' || github.event.head_commit.message != 'codegen metadata') + + steps: + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + + - name: Set up Java + uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5.2.0 + with: + distribution: temurin + java-version: | + 8 + 21 + cache: gradle + + - name: Set up Gradle + uses: gradle/actions/setup-gradle@ed408507eac070d1f99cc633dbcf757c94c7933a # v4.4.3 + + - name: Build SDK run: ./scripts/build - - name: Test - run: ./scripts/test + + + diff --git a/.github/workflows/publish-sonatype.yml b/.github/workflows/publish-sonatype.yml index 30b24fbab..9afbf89ba 100644 --- a/.github/workflows/publish-sonatype.yml +++ b/.github/workflows/publish-sonatype.yml @@ -1,13 +1,9 @@ -# This workflow is triggered when a GitHub release is created. -# It can also be run manually to re-publish to Sonatype in case it failed for some reason. -# You can run this workflow by navigating to https://www.github.com/Increase/increase-java/actions/workflows/publish-sonatype.yml +# workflow for re-running publishing to Sonatype in case it fails for some reason +# you can run this workflow by navigating to https://www.github.com/Increase/increase-java/actions/workflows/publish-sonatype.yml name: Publish Sonatype on: workflow_dispatch: - release: - types: [published] - jobs: publish: name: publish diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 54206fe48..5b14a38c2 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -1,3 +1,4 @@ + name: release on: diff --git a/.stats.yml b/.stats.yml index 74942c3c5..bfa522263 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,3 @@ configured_endpoints: 238 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/increase/increase-beca94b958f84df1e88f5e26405a66965fbf81a0c0c33b5201f0ec8d06e13ff0.yml -openapi_spec_hash: e201015ba263f8cf966969629dd16dfa -config_hash: ac050010e5453883d5e5fa603554a2e0 +openapi_spec_hash: 7b61a8bc0fde8199b971f717ac481e62 +config_hash: 551f6b64efce488b750380ec344c957a diff --git a/increase-java-core/build.gradle.kts b/increase-java-core/build.gradle.kts index 4bc845bc9..dc63be49f 100644 --- a/increase-java-core/build.gradle.kts +++ b/increase-java-core/build.gradle.kts @@ -28,7 +28,6 @@ dependencies { implementation("com.fasterxml.jackson.datatype:jackson-datatype-jdk8:2.18.2") implementation("com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.18.2") implementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.18.2") - implementation("com.google.guava:guava:33.0.0-jre") testImplementation(kotlin("test")) testImplementation(project(":increase-java-client-okhttp")) diff --git a/increase-java-core/src/main/kotlin/com/increase/api/core/Utils.kt b/increase-java-core/src/main/kotlin/com/increase/api/core/Utils.kt index c48f2909f..cfc21efda 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/core/Utils.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/core/Utils.kt @@ -2,7 +2,6 @@ package com.increase.api.core -import com.increase.api.core.http.Headers import com.increase.api.errors.IncreaseInvalidDataException import java.util.Collections import java.util.SortedMap @@ -98,10 +97,6 @@ internal fun Any?.contentToString(): String { return string } -@JvmSynthetic -internal fun Headers.getRequiredHeader(name: String): String = - values(name).firstOrNull() ?: throw IncreaseInvalidDataException("Could not find $name header") - internal interface Enum /** diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/achprenotifications/AchPrenotification.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/achprenotifications/AchPrenotification.kt index b87551824..1dfc58f27 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/achprenotifications/AchPrenotification.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/achprenotifications/AchPrenotification.kt @@ -1113,10 +1113,10 @@ private constructor( companion object { - /** The Prenotification is for an anticipated credit. */ + /** Credit */ @JvmField val CREDIT = of("credit") - /** The Prenotification is for an anticipated debit. */ + /** Debit */ @JvmField val DEBIT = of("debit") @JvmStatic fun of(value: String) = CreditDebitIndicator(JsonField.of(value)) @@ -1124,9 +1124,9 @@ private constructor( /** An enum containing [CreditDebitIndicator]'s known values. */ enum class Known { - /** The Prenotification is for an anticipated credit. */ + /** Credit */ CREDIT, - /** The Prenotification is for an anticipated debit. */ + /** Debit */ DEBIT, } @@ -1141,9 +1141,9 @@ private constructor( * - It was constructed with an arbitrary value using the [of] method. */ enum class Value { - /** The Prenotification is for an anticipated credit. */ + /** Credit */ CREDIT, - /** The Prenotification is for an anticipated debit. */ + /** Debit */ DEBIT, /** * An enum member indicating that [CreditDebitIndicator] was instantiated with an @@ -2092,6 +2092,9 @@ private constructor( /** A savings account. */ @JvmField val SAVINGS = of("savings") + /** A loan account used in a lender-borrower relationship. Uncommon. */ + @JvmField val LOAN = of("loan") + /** A bank's general ledger. Uncommon. */ @JvmField val GENERAL_LEDGER = of("general_ledger") @@ -2104,6 +2107,8 @@ private constructor( CHECKING, /** A savings account. */ SAVINGS, + /** A loan account used in a lender-borrower relationship. Uncommon. */ + LOAN, /** A bank's general ledger. Uncommon. */ GENERAL_LEDGER, } @@ -2124,6 +2129,8 @@ private constructor( CHECKING, /** A savings account. */ SAVINGS, + /** A loan account used in a lender-borrower relationship. Uncommon. */ + LOAN, /** A bank's general ledger. Uncommon. */ GENERAL_LEDGER, /** @@ -2144,6 +2151,7 @@ private constructor( when (this) { CHECKING -> Value.CHECKING SAVINGS -> Value.SAVINGS + LOAN -> Value.LOAN GENERAL_LEDGER -> Value.GENERAL_LEDGER else -> Value._UNKNOWN } @@ -2161,6 +2169,7 @@ private constructor( when (this) { CHECKING -> Known.CHECKING SAVINGS -> Known.SAVINGS + LOAN -> Known.LOAN GENERAL_LEDGER -> Known.GENERAL_LEDGER else -> throw IncreaseInvalidDataException( diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/achprenotifications/AchPrenotificationCreateParams.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/achprenotifications/AchPrenotificationCreateParams.kt index 62cd6276d..17b7729e8 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/achprenotifications/AchPrenotificationCreateParams.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/achprenotifications/AchPrenotificationCreateParams.kt @@ -1384,10 +1384,10 @@ private constructor( companion object { - /** The Prenotification is for an anticipated credit. */ + /** Credit */ @JvmField val CREDIT = of("credit") - /** The Prenotification is for an anticipated debit. */ + /** Debit */ @JvmField val DEBIT = of("debit") @JvmStatic fun of(value: String) = CreditDebitIndicator(JsonField.of(value)) @@ -1395,9 +1395,9 @@ private constructor( /** An enum containing [CreditDebitIndicator]'s known values. */ enum class Known { - /** The Prenotification is for an anticipated credit. */ + /** Credit */ CREDIT, - /** The Prenotification is for an anticipated debit. */ + /** Debit */ DEBIT, } @@ -1412,9 +1412,9 @@ private constructor( * - It was constructed with an arbitrary value using the [of] method. */ enum class Value { - /** The Prenotification is for an anticipated credit. */ + /** Credit */ CREDIT, - /** The Prenotification is for an anticipated debit. */ + /** Debit */ DEBIT, /** * An enum member indicating that [CreditDebitIndicator] was instantiated with an diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/achtransfers/AchTransfer.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/achtransfers/AchTransfer.kt index 44e7e3134..aa08fa8b4 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/achtransfers/AchTransfer.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/achtransfers/AchTransfer.kt @@ -404,8 +404,8 @@ private constructor( fun network(): Network = network.getRequired("network") /** - * If the receiving bank accepts the transfer but notifies that future transfers should use - * different details, this will contain those details. + * If the receiving bank notifies that future transfers should use different details, this will + * contain those details. * * @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). @@ -1373,8 +1373,8 @@ private constructor( fun network(network: JsonField) = apply { this.network = network } /** - * If the receiving bank accepts the transfer but notifies that future transfers should use - * different details, this will contain those details. + * If the receiving bank notifies that future transfers should use different details, this + * will contain those details. */ fun notificationsOfChange(notificationsOfChange: List) = notificationsOfChange(JsonField.of(notificationsOfChange)) @@ -7141,6 +7141,9 @@ private constructor( /** A savings account. */ @JvmField val SAVINGS = of("savings") + /** A loan account used in a lender-borrower relationship. Uncommon. */ + @JvmField val LOAN = of("loan") + /** A bank's general ledger. Uncommon. */ @JvmField val GENERAL_LEDGER = of("general_ledger") @@ -7153,6 +7156,8 @@ private constructor( CHECKING, /** A savings account. */ SAVINGS, + /** A loan account used in a lender-borrower relationship. Uncommon. */ + LOAN, /** A bank's general ledger. Uncommon. */ GENERAL_LEDGER, } @@ -7173,6 +7178,8 @@ private constructor( CHECKING, /** A savings account. */ SAVINGS, + /** A loan account used in a lender-borrower relationship. Uncommon. */ + LOAN, /** A bank's general ledger. Uncommon. */ GENERAL_LEDGER, /** @@ -7193,6 +7200,7 @@ private constructor( when (this) { CHECKING -> Value.CHECKING SAVINGS -> Value.SAVINGS + LOAN -> Value.LOAN GENERAL_LEDGER -> Value.GENERAL_LEDGER else -> Value._UNKNOWN } @@ -7210,6 +7218,7 @@ private constructor( when (this) { CHECKING -> Known.CHECKING SAVINGS -> Known.SAVINGS + LOAN -> Known.LOAN GENERAL_LEDGER -> Known.GENERAL_LEDGER else -> throw IncreaseInvalidDataException( diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/carddisputes/CardDispute.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/carddisputes/CardDispute.kt index 93cf88a9b..44f117314 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/carddisputes/CardDispute.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/carddisputes/CardDispute.kt @@ -37,6 +37,7 @@ private constructor( private val idempotencyKey: JsonField, private val loss: JsonField, private val network: JsonField, + private val rejection: JsonField, private val status: JsonField, private val type: JsonField, private val userSubmissionRequiredBy: JsonField, @@ -62,6 +63,9 @@ private constructor( idempotencyKey: JsonField = JsonMissing.of(), @JsonProperty("loss") @ExcludeMissing loss: JsonField = JsonMissing.of(), @JsonProperty("network") @ExcludeMissing network: JsonField = JsonMissing.of(), + @JsonProperty("rejection") + @ExcludeMissing + rejection: JsonField = JsonMissing.of(), @JsonProperty("status") @ExcludeMissing status: JsonField = JsonMissing.of(), @JsonProperty("type") @ExcludeMissing type: JsonField = JsonMissing.of(), @JsonProperty("user_submission_required_by") @@ -81,6 +85,7 @@ private constructor( idempotencyKey, loss, network, + rejection, status, type, userSubmissionRequiredBy, @@ -158,6 +163,14 @@ private constructor( */ fun network(): Network = network.getRequired("network") + /** + * If the Card Dispute has been rejected, this will contain details of the rejection. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun rejection(): Optional = rejection.getOptional("rejection") + /** * The status of the Card Dispute. * @@ -274,6 +287,13 @@ private constructor( */ @JsonProperty("network") @ExcludeMissing fun _network(): JsonField = network + /** + * Returns the raw JSON value of [rejection]. + * + * Unlike [rejection], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("rejection") @ExcludeMissing fun _rejection(): JsonField = rejection + /** * Returns the raw JSON value of [status]. * @@ -348,6 +368,7 @@ private constructor( * .idempotencyKey() * .loss() * .network() + * .rejection() * .status() * .type() * .userSubmissionRequiredBy() @@ -370,6 +391,7 @@ private constructor( private var idempotencyKey: JsonField? = null private var loss: JsonField? = null private var network: JsonField? = null + private var rejection: JsonField? = null private var status: JsonField? = null private var type: JsonField? = null private var userSubmissionRequiredBy: JsonField? = null @@ -388,6 +410,7 @@ private constructor( idempotencyKey = cardDispute.idempotencyKey loss = cardDispute.loss network = cardDispute.network + rejection = cardDispute.rejection status = cardDispute.status type = cardDispute.type userSubmissionRequiredBy = cardDispute.userSubmissionRequiredBy @@ -510,6 +533,21 @@ private constructor( */ fun network(network: JsonField) = apply { this.network = network } + /** If the Card Dispute has been rejected, this will contain details of the rejection. */ + fun rejection(rejection: Rejection?) = rejection(JsonField.ofNullable(rejection)) + + /** Alias for calling [Builder.rejection] with `rejection.orElse(null)`. */ + fun rejection(rejection: Optional) = rejection(rejection.getOrNull()) + + /** + * Sets [Builder.rejection] to an arbitrary JSON value. + * + * You should usually call [Builder.rejection] with a well-typed [Rejection] value instead. + * This method is primarily for setting the field to an undocumented or not yet supported + * value. + */ + fun rejection(rejection: JsonField) = apply { this.rejection = rejection } + /** The status of the Card Dispute. */ fun status(status: Status) = status(JsonField.of(status)) @@ -641,6 +679,7 @@ private constructor( * .idempotencyKey() * .loss() * .network() + * .rejection() * .status() * .type() * .userSubmissionRequiredBy() @@ -661,6 +700,7 @@ private constructor( checkRequired("idempotencyKey", idempotencyKey), checkRequired("loss", loss), checkRequired("network", network), + checkRequired("rejection", rejection), checkRequired("status", status), checkRequired("type", type), checkRequired("userSubmissionRequiredBy", userSubmissionRequiredBy), @@ -694,6 +734,7 @@ private constructor( idempotencyKey() loss().ifPresent { it.validate() } network().validate() + rejection().ifPresent { it.validate() } status().validate() type().validate() userSubmissionRequiredBy() @@ -726,6 +767,7 @@ private constructor( (if (idempotencyKey.asKnown().isPresent) 1 else 0) + (loss.asKnown().getOrNull()?.validity() ?: 0) + (network.asKnown().getOrNull()?.validity() ?: 0) + + (rejection.asKnown().getOrNull()?.validity() ?: 0) + (status.asKnown().getOrNull()?.validity() ?: 0) + (type.asKnown().getOrNull()?.validity() ?: 0) + (if (userSubmissionRequiredBy.asKnown().isPresent) 1 else 0) + @@ -1236,6 +1278,232 @@ private constructor( override fun toString() = value.toString() } + /** If the Card Dispute has been rejected, this will contain details of the rejection. */ + class Rejection + @JsonCreator(mode = JsonCreator.Mode.DISABLED) + private constructor( + private val explanation: JsonField, + private val rejectedAt: JsonField, + private val additionalProperties: MutableMap, + ) { + + @JsonCreator + private constructor( + @JsonProperty("explanation") + @ExcludeMissing + explanation: JsonField = JsonMissing.of(), + @JsonProperty("rejected_at") + @ExcludeMissing + rejectedAt: JsonField = JsonMissing.of(), + ) : this(explanation, rejectedAt, mutableMapOf()) + + /** + * Why the Card Dispute was rejected. + * + * @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 explanation(): String = explanation.getRequired("explanation") + + /** + * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date and time at which the Card + * Dispute was rejected. + * + * @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 rejectedAt(): OffsetDateTime = rejectedAt.getRequired("rejected_at") + + /** + * Returns the raw JSON value of [explanation]. + * + * Unlike [explanation], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("explanation") + @ExcludeMissing + fun _explanation(): JsonField = explanation + + /** + * Returns the raw JSON value of [rejectedAt]. + * + * Unlike [rejectedAt], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("rejected_at") + @ExcludeMissing + fun _rejectedAt(): JsonField = rejectedAt + + @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 [Rejection]. + * + * The following fields are required: + * ```java + * .explanation() + * .rejectedAt() + * ``` + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [Rejection]. */ + class Builder internal constructor() { + + private var explanation: JsonField? = null + private var rejectedAt: JsonField? = null + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(rejection: Rejection) = apply { + explanation = rejection.explanation + rejectedAt = rejection.rejectedAt + additionalProperties = rejection.additionalProperties.toMutableMap() + } + + /** Why the Card Dispute was rejected. */ + fun explanation(explanation: String) = explanation(JsonField.of(explanation)) + + /** + * Sets [Builder.explanation] to an arbitrary JSON value. + * + * You should usually call [Builder.explanation] with a well-typed [String] value + * instead. This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun explanation(explanation: JsonField) = apply { + this.explanation = explanation + } + + /** + * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date and time at which the + * Card Dispute was rejected. + */ + fun rejectedAt(rejectedAt: OffsetDateTime) = rejectedAt(JsonField.of(rejectedAt)) + + /** + * Sets [Builder.rejectedAt] to an arbitrary JSON value. + * + * You should usually call [Builder.rejectedAt] with a well-typed [OffsetDateTime] value + * instead. This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun rejectedAt(rejectedAt: JsonField) = apply { + this.rejectedAt = rejectedAt + } + + 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 [Rejection]. + * + * Further updates to this [Builder] will not mutate the returned instance. + * + * The following fields are required: + * ```java + * .explanation() + * .rejectedAt() + * ``` + * + * @throws IllegalStateException if any required field is unset. + */ + fun build(): Rejection = + Rejection( + checkRequired("explanation", explanation), + checkRequired("rejectedAt", rejectedAt), + additionalProperties.toMutableMap(), + ) + } + + private var validated: Boolean = false + + /** + * Validates that the types of all values in this object match their expected types + * recursively. + * + * This method is _not_ forwards compatible with new types from the API for existing fields. + * + * @throws IncreaseInvalidDataException if any value type in this object doesn't match its + * expected type. + */ + fun validate(): Rejection = apply { + if (validated) { + return@apply + } + + explanation() + rejectedAt() + 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 (explanation.asKnown().isPresent) 1 else 0) + + (if (rejectedAt.asKnown().isPresent) 1 else 0) + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is Rejection && + explanation == other.explanation && + rejectedAt == other.rejectedAt && + additionalProperties == other.additionalProperties + } + + private val hashCode: Int by lazy { + Objects.hash(explanation, rejectedAt, additionalProperties) + } + + override fun hashCode(): Int = hashCode + + override fun toString() = + "Rejection{explanation=$explanation, rejectedAt=$rejectedAt, additionalProperties=$additionalProperties}" + } + /** The status of the Card Dispute. */ class Status @JsonCreator private constructor(private val value: JsonField) : Enum { @@ -1278,6 +1546,12 @@ private constructor( /** The Card Dispute has been won and no further action can be taken. */ @JvmField val WON = of("won") + /** + * The Card Dispute has been reviewed and rejected, please review the explanation for + * more details. + */ + @JvmField val REJECTED = of("rejected") + @JvmStatic fun of(value: String) = Status(JsonField.of(value)) } @@ -1300,6 +1574,11 @@ private constructor( LOST, /** The Card Dispute has been won and no further action can be taken. */ WON, + /** + * The Card Dispute has been reviewed and rejected, please review the explanation for + * more details. + */ + REJECTED, } /** @@ -1329,6 +1608,11 @@ private constructor( LOST, /** The Card Dispute has been won and no further action can be taken. */ WON, + /** + * The Card Dispute has been reviewed and rejected, please review the explanation for + * more details. + */ + REJECTED, /** An enum member indicating that [Status] was instantiated with an unknown value. */ _UNKNOWN, } @@ -1349,6 +1633,7 @@ private constructor( PENDING_RESPONSE -> Value.PENDING_RESPONSE LOST -> Value.LOST WON -> Value.WON + REJECTED -> Value.REJECTED else -> Value._UNKNOWN } @@ -1370,6 +1655,7 @@ private constructor( PENDING_RESPONSE -> Known.PENDING_RESPONSE LOST -> Known.LOST WON -> Known.WON + REJECTED -> Known.REJECTED else -> throw IncreaseInvalidDataException("Unknown Status: $value") } @@ -43163,6 +43449,7 @@ private constructor( idempotencyKey == other.idempotencyKey && loss == other.loss && network == other.network && + rejection == other.rejection && status == other.status && type == other.type && userSubmissionRequiredBy == other.userSubmissionRequiredBy && @@ -43182,6 +43469,7 @@ private constructor( idempotencyKey, loss, network, + rejection, status, type, userSubmissionRequiredBy, @@ -43195,5 +43483,5 @@ private constructor( override fun hashCode(): Int = hashCode override fun toString() = - "CardDispute{id=$id, amount=$amount, cardId=$cardId, createdAt=$createdAt, disputedTransactionId=$disputedTransactionId, idempotencyKey=$idempotencyKey, loss=$loss, network=$network, status=$status, type=$type, userSubmissionRequiredBy=$userSubmissionRequiredBy, visa=$visa, win=$win, withdrawal=$withdrawal, additionalProperties=$additionalProperties}" + "CardDispute{id=$id, amount=$amount, cardId=$cardId, createdAt=$createdAt, disputedTransactionId=$disputedTransactionId, idempotencyKey=$idempotencyKey, loss=$loss, network=$network, rejection=$rejection, status=$status, type=$type, userSubmissionRequiredBy=$userSubmissionRequiredBy, visa=$visa, win=$win, withdrawal=$withdrawal, additionalProperties=$additionalProperties}" } diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/carddisputes/CardDisputeListParams.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/carddisputes/CardDisputeListParams.kt index 94a21b2a2..56e5bd5c3 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/carddisputes/CardDisputeListParams.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/carddisputes/CardDisputeListParams.kt @@ -613,6 +613,12 @@ private constructor( /** The Card Dispute has been won and no further action can be taken. */ @JvmField val WON = of("won") + /** + * The Card Dispute has been reviewed and rejected, please review the explanation + * for more details. + */ + @JvmField val REJECTED = of("rejected") + @JvmStatic fun of(value: String) = In(JsonField.of(value)) } @@ -635,6 +641,11 @@ private constructor( LOST, /** The Card Dispute has been won and no further action can be taken. */ WON, + /** + * The Card Dispute has been reviewed and rejected, please review the explanation + * for more details. + */ + REJECTED, } /** @@ -664,6 +675,11 @@ private constructor( LOST, /** The Card Dispute has been won and no further action can be taken. */ WON, + /** + * The Card Dispute has been reviewed and rejected, please review the explanation + * for more details. + */ + REJECTED, /** An enum member indicating that [In] was instantiated with an unknown value. */ _UNKNOWN, } @@ -684,6 +700,7 @@ private constructor( PENDING_RESPONSE -> Value.PENDING_RESPONSE LOST -> Value.LOST WON -> Value.WON + REJECTED -> Value.REJECTED else -> Value._UNKNOWN } @@ -705,6 +722,7 @@ private constructor( PENDING_RESPONSE -> Known.PENDING_RESPONSE LOST -> Known.LOST WON -> Known.WON + REJECTED -> Known.REJECTED else -> throw IncreaseInvalidDataException("Unknown In: $value") } diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/cardpayments/CardPayment.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/cardpayments/CardPayment.kt index 0fa498335..13a6250d3 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/cardpayments/CardPayment.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/cardpayments/CardPayment.kt @@ -685,8 +685,9 @@ private constructor( /** * A Card Financial object. This field will be present in the JSON response if and only if - * `category` is equal to `card_financial`. Card Financials are temporary holds placed on a - * customer's funds with the intent to later clear a transaction. + * `category` is equal to `card_financial`. Card Financials are card transactions that have + * cleared and settled. Unlike a Card Settlement, which clears a previous authorization, a + * Card Financial is authorized and cleared in a single message. * * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if * the server responded with an unexpected value). @@ -1142,8 +1143,9 @@ private constructor( /** * A Card Financial object. This field will be present in the JSON response if and only - * if `category` is equal to `card_financial`. Card Financials are temporary holds - * placed on a customer's funds with the intent to later clear a transaction. + * if `category` is equal to `card_financial`. Card Financials are card transactions + * that have cleared and settled. Unlike a Card Settlement, which clears a previous + * authorization, a Card Financial is authorized and cleared in a single message. */ fun cardFinancial(cardFinancial: CardFinancial?) = cardFinancial(JsonField.ofNullable(cardFinancial)) @@ -8690,6 +8692,7 @@ private constructor( private val digitalWalletTokenId: JsonField, private val direction: JsonField, private val expiresAt: JsonField, + private val healthcare: JsonField, private val merchantAcceptorId: JsonField, private val merchantCategoryCode: JsonField, private val merchantCity: JsonField, @@ -8738,6 +8741,9 @@ private constructor( @JsonProperty("expires_at") @ExcludeMissing expiresAt: JsonField = JsonMissing.of(), + @JsonProperty("healthcare") + @ExcludeMissing + healthcare: JsonField = JsonMissing.of(), @JsonProperty("merchant_acceptor_id") @ExcludeMissing merchantAcceptorId: JsonField = JsonMissing.of(), @@ -8806,6 +8812,7 @@ private constructor( digitalWalletTokenId, direction, expiresAt, + healthcare, merchantAcceptorId, merchantCategoryCode, merchantCity, @@ -8919,6 +8926,15 @@ private constructor( */ fun expiresAt(): OffsetDateTime = expiresAt.getRequired("expires_at") + /** + * The healthcare-related fields for this authorization. Only present for specific + * programs. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. + * if the server responded with an unexpected value). + */ + fun healthcare(): Optional = healthcare.getOptional("healthcare") + /** * The merchant identifier (commonly abbreviated as MID) of the merchant the card is * transacting with. @@ -9194,6 +9210,16 @@ private constructor( @ExcludeMissing fun _expiresAt(): JsonField = expiresAt + /** + * Returns the raw JSON value of [healthcare]. + * + * Unlike [healthcare], this method doesn't throw if the JSON field has an unexpected + * type. + */ + @JsonProperty("healthcare") + @ExcludeMissing + fun _healthcare(): JsonField = healthcare + /** * Returns the raw JSON value of [merchantAcceptorId]. * @@ -9419,6 +9445,7 @@ private constructor( * .digitalWalletTokenId() * .direction() * .expiresAt() + * .healthcare() * .merchantAcceptorId() * .merchantCategoryCode() * .merchantCity() @@ -9456,6 +9483,7 @@ private constructor( private var digitalWalletTokenId: JsonField? = null private var direction: JsonField? = null private var expiresAt: JsonField? = null + private var healthcare: JsonField? = null private var merchantAcceptorId: JsonField? = null private var merchantCategoryCode: JsonField? = null private var merchantCity: JsonField? = null @@ -9489,6 +9517,7 @@ private constructor( digitalWalletTokenId = cardAuthorization.digitalWalletTokenId direction = cardAuthorization.direction expiresAt = cardAuthorization.expiresAt + healthcare = cardAuthorization.healthcare merchantAcceptorId = cardAuthorization.merchantAcceptorId merchantCategoryCode = cardAuthorization.merchantCategoryCode merchantCity = cardAuthorization.merchantCity @@ -9662,6 +9691,28 @@ private constructor( this.expiresAt = expiresAt } + /** + * The healthcare-related fields for this authorization. Only present for specific + * programs. + */ + fun healthcare(healthcare: Healthcare?) = + healthcare(JsonField.ofNullable(healthcare)) + + /** Alias for calling [Builder.healthcare] with `healthcare.orElse(null)`. */ + fun healthcare(healthcare: Optional) = + healthcare(healthcare.getOrNull()) + + /** + * Sets [Builder.healthcare] to an arbitrary JSON value. + * + * You should usually call [Builder.healthcare] with a well-typed [Healthcare] value + * instead. This method is primarily for setting the field to an undocumented or not + * yet supported value. + */ + fun healthcare(healthcare: JsonField) = apply { + this.healthcare = healthcare + } + /** * The merchant identifier (commonly abbreviated as MID) of the merchant the card is * transacting with. @@ -10093,6 +10144,7 @@ private constructor( * .digitalWalletTokenId() * .direction() * .expiresAt() + * .healthcare() * .merchantAcceptorId() * .merchantCategoryCode() * .merchantCity() @@ -10128,6 +10180,7 @@ private constructor( checkRequired("digitalWalletTokenId", digitalWalletTokenId), checkRequired("direction", direction), checkRequired("expiresAt", expiresAt), + checkRequired("healthcare", healthcare), checkRequired("merchantAcceptorId", merchantAcceptorId), checkRequired("merchantCategoryCode", merchantCategoryCode), checkRequired("merchantCity", merchantCity), @@ -10178,6 +10231,7 @@ private constructor( digitalWalletTokenId() direction().validate() expiresAt() + healthcare().ifPresent { it.validate() } merchantAcceptorId() merchantCategoryCode() merchantCity() @@ -10226,6 +10280,7 @@ private constructor( (if (digitalWalletTokenId.asKnown().isPresent) 1 else 0) + (direction.asKnown().getOrNull()?.validity() ?: 0) + (if (expiresAt.asKnown().isPresent) 1 else 0) + + (healthcare.asKnown().getOrNull()?.validity() ?: 0) + (if (merchantAcceptorId.asKnown().isPresent) 1 else 0) + (if (merchantCategoryCode.asKnown().isPresent) 1 else 0) + (if (merchantCity.asKnown().isPresent) 1 else 0) + @@ -13731,6 +13786,387 @@ private constructor( override fun toString() = value.toString() } + /** + * The healthcare-related fields for this authorization. Only present for specific + * programs. + */ + class Healthcare + @JsonCreator(mode = JsonCreator.Mode.DISABLED) + private constructor( + private val merchantNinetyPercentEligibility: + JsonField, + private val additionalProperties: MutableMap, + ) { + + @JsonCreator + private constructor( + @JsonProperty("merchant_ninety_percent_eligibility") + @ExcludeMissing + merchantNinetyPercentEligibility: JsonField = + JsonMissing.of() + ) : this(merchantNinetyPercentEligibility, mutableMapOf()) + + /** + * The merchant's eligibility under the Internal Revenue Service's 90% Rule for + * Flexible Spending Account (FSA) and Health Savings Account (HSA) eligible + * products. The eligibility is determined based on the list of merchants maintained + * by the Special Interest Group for IIAS Standards (SIGIS). + * + * @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 merchantNinetyPercentEligibility(): MerchantNinetyPercentEligibility = + merchantNinetyPercentEligibility.getRequired( + "merchant_ninety_percent_eligibility" + ) + + /** + * Returns the raw JSON value of [merchantNinetyPercentEligibility]. + * + * Unlike [merchantNinetyPercentEligibility], this method doesn't throw if the JSON + * field has an unexpected type. + */ + @JsonProperty("merchant_ninety_percent_eligibility") + @ExcludeMissing + fun _merchantNinetyPercentEligibility(): + JsonField = merchantNinetyPercentEligibility + + @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 [Healthcare]. + * + * The following fields are required: + * ```java + * .merchantNinetyPercentEligibility() + * ``` + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [Healthcare]. */ + class Builder internal constructor() { + + private var merchantNinetyPercentEligibility: + JsonField? = + null + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(healthcare: Healthcare) = apply { + merchantNinetyPercentEligibility = + healthcare.merchantNinetyPercentEligibility + additionalProperties = healthcare.additionalProperties.toMutableMap() + } + + /** + * The merchant's eligibility under the Internal Revenue Service's 90% Rule for + * Flexible Spending Account (FSA) and Health Savings Account (HSA) eligible + * products. The eligibility is determined based on the list of merchants + * maintained by the Special Interest Group for IIAS Standards (SIGIS). + */ + fun merchantNinetyPercentEligibility( + merchantNinetyPercentEligibility: MerchantNinetyPercentEligibility + ) = + merchantNinetyPercentEligibility( + JsonField.of(merchantNinetyPercentEligibility) + ) + + /** + * Sets [Builder.merchantNinetyPercentEligibility] to an arbitrary JSON value. + * + * You should usually call [Builder.merchantNinetyPercentEligibility] with a + * well-typed [MerchantNinetyPercentEligibility] value instead. This method is + * primarily for setting the field to an undocumented or not yet supported + * value. + */ + fun merchantNinetyPercentEligibility( + merchantNinetyPercentEligibility: + JsonField + ) = apply { + this.merchantNinetyPercentEligibility = merchantNinetyPercentEligibility + } + + 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 [Healthcare]. + * + * Further updates to this [Builder] will not mutate the returned instance. + * + * The following fields are required: + * ```java + * .merchantNinetyPercentEligibility() + * ``` + * + * @throws IllegalStateException if any required field is unset. + */ + fun build(): Healthcare = + Healthcare( + checkRequired( + "merchantNinetyPercentEligibility", + merchantNinetyPercentEligibility, + ), + additionalProperties.toMutableMap(), + ) + } + + private var validated: Boolean = false + + /** + * Validates that the types of all values in this object match their expected types + * recursively. + * + * This method is _not_ forwards compatible with new types from the API for existing + * fields. + * + * @throws IncreaseInvalidDataException if any value type in this object doesn't + * match its expected type. + */ + fun validate(): Healthcare = apply { + if (validated) { + return@apply + } + + merchantNinetyPercentEligibility().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 = + (merchantNinetyPercentEligibility.asKnown().getOrNull()?.validity() ?: 0) + + /** + * The merchant's eligibility under the Internal Revenue Service's 90% Rule for + * Flexible Spending Account (FSA) and Health Savings Account (HSA) eligible + * products. The eligibility is determined based on the list of merchants maintained + * by the Special Interest Group for IIAS Standards (SIGIS). + */ + class MerchantNinetyPercentEligibility + @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 merchant is eligible for treatment under the 90% rule. */ + @JvmField val ELIGIBLE = of("eligible") + + /** The merchant is not eligible for treatment under the 90% rule. */ + @JvmField val NOT_ELIGIBLE = of("not_eligible") + + @JvmStatic + fun of(value: String) = + MerchantNinetyPercentEligibility(JsonField.of(value)) + } + + /** An enum containing [MerchantNinetyPercentEligibility]'s known values. */ + enum class Known { + /** The merchant is eligible for treatment under the 90% rule. */ + ELIGIBLE, + /** The merchant is not eligible for treatment under the 90% rule. */ + NOT_ELIGIBLE, + } + + /** + * An enum containing [MerchantNinetyPercentEligibility]'s known values, as well + * as an [_UNKNOWN] member. + * + * An instance of [MerchantNinetyPercentEligibility] 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 merchant is eligible for treatment under the 90% rule. */ + ELIGIBLE, + /** The merchant is not eligible for treatment under the 90% rule. */ + NOT_ELIGIBLE, + /** + * An enum member indicating that [MerchantNinetyPercentEligibility] 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) { + ELIGIBLE -> Value.ELIGIBLE + NOT_ELIGIBLE -> Value.NOT_ELIGIBLE + 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) { + ELIGIBLE -> Known.ELIGIBLE + NOT_ELIGIBLE -> Known.NOT_ELIGIBLE + else -> + throw IncreaseInvalidDataException( + "Unknown MerchantNinetyPercentEligibility: $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 + + /** + * Validates that the types of all values in this object match their expected + * types recursively. + * + * This method is _not_ forwards compatible with new types from the API for + * existing fields. + * + * @throws IncreaseInvalidDataException if any value type in this object doesn't + * match its expected type. + */ + fun validate(): MerchantNinetyPercentEligibility = 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 MerchantNinetyPercentEligibility && 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 Healthcare && + merchantNinetyPercentEligibility == + other.merchantNinetyPercentEligibility && + additionalProperties == other.additionalProperties + } + + private val hashCode: Int by lazy { + Objects.hash(merchantNinetyPercentEligibility, additionalProperties) + } + + override fun hashCode(): Int = hashCode + + override fun toString() = + "Healthcare{merchantNinetyPercentEligibility=$merchantNinetyPercentEligibility, additionalProperties=$additionalProperties}" + } + /** Fields specific to the `network`. */ class NetworkDetails @JsonCreator(mode = JsonCreator.Mode.DISABLED) @@ -19598,6 +20034,7 @@ private constructor( digitalWalletTokenId == other.digitalWalletTokenId && direction == other.direction && expiresAt == other.expiresAt && + healthcare == other.healthcare && merchantAcceptorId == other.merchantAcceptorId && merchantCategoryCode == other.merchantCategoryCode && merchantCity == other.merchantCity && @@ -19632,6 +20069,7 @@ private constructor( digitalWalletTokenId, direction, expiresAt, + healthcare, merchantAcceptorId, merchantCategoryCode, merchantCity, @@ -19659,7 +20097,7 @@ private constructor( override fun hashCode(): Int = hashCode override fun toString() = - "CardAuthorization{id=$id, actioner=$actioner, additionalAmounts=$additionalAmounts, amount=$amount, cardPaymentId=$cardPaymentId, currency=$currency, digitalWalletTokenId=$digitalWalletTokenId, direction=$direction, expiresAt=$expiresAt, merchantAcceptorId=$merchantAcceptorId, merchantCategoryCode=$merchantCategoryCode, merchantCity=$merchantCity, merchantCountry=$merchantCountry, merchantDescriptor=$merchantDescriptor, merchantPostalCode=$merchantPostalCode, merchantState=$merchantState, networkDetails=$networkDetails, networkIdentifiers=$networkIdentifiers, networkRiskScore=$networkRiskScore, pendingTransactionId=$pendingTransactionId, physicalCardId=$physicalCardId, presentmentAmount=$presentmentAmount, presentmentCurrency=$presentmentCurrency, processingCategory=$processingCategory, realTimeDecisionId=$realTimeDecisionId, schemeFees=$schemeFees, terminalId=$terminalId, type=$type, verification=$verification, additionalProperties=$additionalProperties}" + "CardAuthorization{id=$id, actioner=$actioner, additionalAmounts=$additionalAmounts, amount=$amount, cardPaymentId=$cardPaymentId, currency=$currency, digitalWalletTokenId=$digitalWalletTokenId, direction=$direction, expiresAt=$expiresAt, healthcare=$healthcare, merchantAcceptorId=$merchantAcceptorId, merchantCategoryCode=$merchantCategoryCode, merchantCity=$merchantCity, merchantCountry=$merchantCountry, merchantDescriptor=$merchantDescriptor, merchantPostalCode=$merchantPostalCode, merchantState=$merchantState, networkDetails=$networkDetails, networkIdentifiers=$networkIdentifiers, networkRiskScore=$networkRiskScore, pendingTransactionId=$pendingTransactionId, physicalCardId=$physicalCardId, presentmentAmount=$presentmentAmount, presentmentCurrency=$presentmentCurrency, processingCategory=$processingCategory, realTimeDecisionId=$realTimeDecisionId, schemeFees=$schemeFees, terminalId=$terminalId, type=$type, verification=$verification, additionalProperties=$additionalProperties}" } /** @@ -38712,7 +39150,7 @@ private constructor( /** The attempted card transaction is not allowed per Increase's terms. */ @JvmField val TRANSACTION_NOT_ALLOWED = of("transaction_not_allowed") - /** The transaction was blocked by a Limit. */ + /** The transaction was blocked by a limit or an authorization control. */ @JvmField val BREACHES_LIMIT = of("breaches_limit") /** Your application declined the transaction via webhook. */ @@ -38786,7 +39224,7 @@ private constructor( CARD_EXPIRATION_MISMATCH, /** The attempted card transaction is not allowed per Increase's terms. */ TRANSACTION_NOT_ALLOWED, - /** The transaction was blocked by a Limit. */ + /** The transaction was blocked by a limit or an authorization control. */ BREACHES_LIMIT, /** Your application declined the transaction via webhook. */ WEBHOOK_DECLINED, @@ -38855,7 +39293,7 @@ private constructor( CARD_EXPIRATION_MISMATCH, /** The attempted card transaction is not allowed per Increase's terms. */ TRANSACTION_NOT_ALLOWED, - /** The transaction was blocked by a Limit. */ + /** The transaction was blocked by a limit or an authorization control. */ BREACHES_LIMIT, /** Your application declined the transaction via webhook. */ WEBHOOK_DECLINED, @@ -42071,8 +42509,9 @@ private constructor( /** * A Card Financial object. This field will be present in the JSON response if and only if - * `category` is equal to `card_financial`. Card Financials are temporary holds placed on a - * customer's funds with the intent to later clear a transaction. + * `category` is equal to `card_financial`. Card Financials are card transactions that have + * cleared and settled. Unlike a Card Settlement, which clears a previous authorization, a + * Card Financial is authorized and cleared in a single message. */ class CardFinancial @JsonCreator(mode = JsonCreator.Mode.DISABLED) diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/cardpushtransfers/CardPushTransfer.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/cardpushtransfers/CardPushTransfer.kt index 59c86b323..249a06856 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/cardpushtransfers/CardPushTransfer.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/cardpushtransfers/CardPushTransfer.kt @@ -36,11 +36,17 @@ private constructor( private val idempotencyKey: JsonField, private val merchantCategoryCode: JsonField, private val merchantCityName: JsonField, + private val merchantLegalBusinessName: JsonField, private val merchantName: JsonField, private val merchantNamePrefix: JsonField, private val merchantPostalCode: JsonField, private val merchantState: JsonField, + private val merchantStreetAddress: JsonField, private val presentmentAmount: JsonField, + private val recipientAddressCity: JsonField, + private val recipientAddressLine1: JsonField, + private val recipientAddressPostalCode: JsonField, + private val recipientAddressState: JsonField, private val recipientName: JsonField, private val route: JsonField, private val senderAddressCity: JsonField, @@ -88,6 +94,9 @@ private constructor( @JsonProperty("merchant_city_name") @ExcludeMissing merchantCityName: JsonField = JsonMissing.of(), + @JsonProperty("merchant_legal_business_name") + @ExcludeMissing + merchantLegalBusinessName: JsonField = JsonMissing.of(), @JsonProperty("merchant_name") @ExcludeMissing merchantName: JsonField = JsonMissing.of(), @@ -100,9 +109,24 @@ private constructor( @JsonProperty("merchant_state") @ExcludeMissing merchantState: JsonField = JsonMissing.of(), + @JsonProperty("merchant_street_address") + @ExcludeMissing + merchantStreetAddress: JsonField = JsonMissing.of(), @JsonProperty("presentment_amount") @ExcludeMissing presentmentAmount: JsonField = JsonMissing.of(), + @JsonProperty("recipient_address_city") + @ExcludeMissing + recipientAddressCity: JsonField = JsonMissing.of(), + @JsonProperty("recipient_address_line1") + @ExcludeMissing + recipientAddressLine1: JsonField = JsonMissing.of(), + @JsonProperty("recipient_address_postal_code") + @ExcludeMissing + recipientAddressPostalCode: JsonField = JsonMissing.of(), + @JsonProperty("recipient_address_state") + @ExcludeMissing + recipientAddressState: JsonField = JsonMissing.of(), @JsonProperty("recipient_name") @ExcludeMissing recipientName: JsonField = JsonMissing.of(), @@ -144,11 +168,17 @@ private constructor( idempotencyKey, merchantCategoryCode, merchantCityName, + merchantLegalBusinessName, merchantName, merchantNamePrefix, merchantPostalCode, merchantState, + merchantStreetAddress, presentmentAmount, + recipientAddressCity, + recipientAddressLine1, + recipientAddressPostalCode, + recipientAddressState, recipientName, route, senderAddressCity, @@ -278,6 +308,15 @@ private constructor( */ fun merchantCityName(): String = merchantCityName.getRequired("merchant_city_name") + /** + * The legal business name of the merchant (generally your business) sending the transfer. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun merchantLegalBusinessName(): Optional = + merchantLegalBusinessName.getOptional("merchant_legal_business_name") + /** * The merchant name shows up as the statement descriptor for the transfer. This is typically * the name of your business or organization. @@ -313,6 +352,15 @@ private constructor( */ fun merchantState(): String = merchantState.getRequired("merchant_state") + /** + * The street address of the merchant (generally your business) sending the transfer. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun merchantStreetAddress(): Optional = + merchantStreetAddress.getOptional("merchant_street_address") + /** * The amount that was transferred. The receiving bank will have converted this to the * cardholder's currency. The amount that is applied to your Increase account matches the @@ -323,6 +371,42 @@ private constructor( */ fun presentmentAmount(): PresentmentAmount = presentmentAmount.getRequired("presentment_amount") + /** + * The city of the recipient. Required if the card is issued in Canada. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun recipientAddressCity(): Optional = + recipientAddressCity.getOptional("recipient_address_city") + + /** + * The first line of the recipient's address. Required if the card is issued in Canada. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun recipientAddressLine1(): Optional = + recipientAddressLine1.getOptional("recipient_address_line1") + + /** + * The postal code of the recipient. Required if the card is issued in Canada. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun recipientAddressPostalCode(): Optional = + recipientAddressPostalCode.getOptional("recipient_address_postal_code") + + /** + * The state or province of the recipient. Required if the card is issued in Canada. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun recipientAddressState(): Optional = + recipientAddressState.getOptional("recipient_address_state") + /** * The name of the funds recipient. * @@ -525,6 +609,16 @@ private constructor( @ExcludeMissing fun _merchantCityName(): JsonField = merchantCityName + /** + * Returns the raw JSON value of [merchantLegalBusinessName]. + * + * Unlike [merchantLegalBusinessName], this method doesn't throw if the JSON field has an + * unexpected type. + */ + @JsonProperty("merchant_legal_business_name") + @ExcludeMissing + fun _merchantLegalBusinessName(): JsonField = merchantLegalBusinessName + /** * Returns the raw JSON value of [merchantName]. * @@ -563,6 +657,16 @@ private constructor( @ExcludeMissing fun _merchantState(): JsonField = merchantState + /** + * Returns the raw JSON value of [merchantStreetAddress]. + * + * Unlike [merchantStreetAddress], this method doesn't throw if the JSON field has an unexpected + * type. + */ + @JsonProperty("merchant_street_address") + @ExcludeMissing + fun _merchantStreetAddress(): JsonField = merchantStreetAddress + /** * Returns the raw JSON value of [presentmentAmount]. * @@ -573,6 +677,46 @@ private constructor( @ExcludeMissing fun _presentmentAmount(): JsonField = presentmentAmount + /** + * Returns the raw JSON value of [recipientAddressCity]. + * + * Unlike [recipientAddressCity], this method doesn't throw if the JSON field has an unexpected + * type. + */ + @JsonProperty("recipient_address_city") + @ExcludeMissing + fun _recipientAddressCity(): JsonField = recipientAddressCity + + /** + * Returns the raw JSON value of [recipientAddressLine1]. + * + * Unlike [recipientAddressLine1], this method doesn't throw if the JSON field has an unexpected + * type. + */ + @JsonProperty("recipient_address_line1") + @ExcludeMissing + fun _recipientAddressLine1(): JsonField = recipientAddressLine1 + + /** + * Returns the raw JSON value of [recipientAddressPostalCode]. + * + * Unlike [recipientAddressPostalCode], this method doesn't throw if the JSON field has an + * unexpected type. + */ + @JsonProperty("recipient_address_postal_code") + @ExcludeMissing + fun _recipientAddressPostalCode(): JsonField = recipientAddressPostalCode + + /** + * Returns the raw JSON value of [recipientAddressState]. + * + * Unlike [recipientAddressState], this method doesn't throw if the JSON field has an unexpected + * type. + */ + @JsonProperty("recipient_address_state") + @ExcludeMissing + fun _recipientAddressState(): JsonField = recipientAddressState + /** * Returns the raw JSON value of [recipientName]. * @@ -701,11 +845,17 @@ private constructor( * .idempotencyKey() * .merchantCategoryCode() * .merchantCityName() + * .merchantLegalBusinessName() * .merchantName() * .merchantNamePrefix() * .merchantPostalCode() * .merchantState() + * .merchantStreetAddress() * .presentmentAmount() + * .recipientAddressCity() + * .recipientAddressLine1() + * .recipientAddressPostalCode() + * .recipientAddressState() * .recipientName() * .route() * .senderAddressCity() @@ -738,11 +888,17 @@ private constructor( private var idempotencyKey: JsonField? = null private var merchantCategoryCode: JsonField? = null private var merchantCityName: JsonField? = null + private var merchantLegalBusinessName: JsonField? = null private var merchantName: JsonField? = null private var merchantNamePrefix: JsonField? = null private var merchantPostalCode: JsonField? = null private var merchantState: JsonField? = null + private var merchantStreetAddress: JsonField? = null private var presentmentAmount: JsonField? = null + private var recipientAddressCity: JsonField? = null + private var recipientAddressLine1: JsonField? = null + private var recipientAddressPostalCode: JsonField? = null + private var recipientAddressState: JsonField? = null private var recipientName: JsonField? = null private var route: JsonField? = null private var senderAddressCity: JsonField? = null @@ -771,11 +927,17 @@ private constructor( idempotencyKey = cardPushTransfer.idempotencyKey merchantCategoryCode = cardPushTransfer.merchantCategoryCode merchantCityName = cardPushTransfer.merchantCityName + merchantLegalBusinessName = cardPushTransfer.merchantLegalBusinessName merchantName = cardPushTransfer.merchantName merchantNamePrefix = cardPushTransfer.merchantNamePrefix merchantPostalCode = cardPushTransfer.merchantPostalCode merchantState = cardPushTransfer.merchantState + merchantStreetAddress = cardPushTransfer.merchantStreetAddress presentmentAmount = cardPushTransfer.presentmentAmount + recipientAddressCity = cardPushTransfer.recipientAddressCity + recipientAddressLine1 = cardPushTransfer.recipientAddressLine1 + recipientAddressPostalCode = cardPushTransfer.recipientAddressPostalCode + recipientAddressState = cardPushTransfer.recipientAddressState recipientName = cardPushTransfer.recipientName route = cardPushTransfer.route senderAddressCity = cardPushTransfer.senderAddressCity @@ -1008,6 +1170,30 @@ private constructor( this.merchantCityName = merchantCityName } + /** + * The legal business name of the merchant (generally your business) sending the transfer. + */ + fun merchantLegalBusinessName(merchantLegalBusinessName: String?) = + merchantLegalBusinessName(JsonField.ofNullable(merchantLegalBusinessName)) + + /** + * Alias for calling [Builder.merchantLegalBusinessName] with + * `merchantLegalBusinessName.orElse(null)`. + */ + fun merchantLegalBusinessName(merchantLegalBusinessName: Optional) = + merchantLegalBusinessName(merchantLegalBusinessName.getOrNull()) + + /** + * Sets [Builder.merchantLegalBusinessName] to an arbitrary JSON value. + * + * You should usually call [Builder.merchantLegalBusinessName] with a well-typed [String] + * value instead. This method is primarily for setting the field to an undocumented or not + * yet supported value. + */ + fun merchantLegalBusinessName(merchantLegalBusinessName: JsonField) = apply { + this.merchantLegalBusinessName = merchantLegalBusinessName + } + /** * The merchant name shows up as the statement descriptor for the transfer. This is * typically the name of your business or organization. @@ -1073,6 +1259,28 @@ private constructor( this.merchantState = merchantState } + /** The street address of the merchant (generally your business) sending the transfer. */ + fun merchantStreetAddress(merchantStreetAddress: String?) = + merchantStreetAddress(JsonField.ofNullable(merchantStreetAddress)) + + /** + * Alias for calling [Builder.merchantStreetAddress] with + * `merchantStreetAddress.orElse(null)`. + */ + fun merchantStreetAddress(merchantStreetAddress: Optional) = + merchantStreetAddress(merchantStreetAddress.getOrNull()) + + /** + * Sets [Builder.merchantStreetAddress] to an arbitrary JSON value. + * + * You should usually call [Builder.merchantStreetAddress] with a well-typed [String] value + * instead. This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun merchantStreetAddress(merchantStreetAddress: JsonField) = apply { + this.merchantStreetAddress = merchantStreetAddress + } + /** * The amount that was transferred. The receiving bank will have converted this to the * cardholder's currency. The amount that is applied to your Increase account matches the @@ -1092,6 +1300,94 @@ private constructor( this.presentmentAmount = presentmentAmount } + /** The city of the recipient. Required if the card is issued in Canada. */ + fun recipientAddressCity(recipientAddressCity: String?) = + recipientAddressCity(JsonField.ofNullable(recipientAddressCity)) + + /** + * Alias for calling [Builder.recipientAddressCity] with + * `recipientAddressCity.orElse(null)`. + */ + fun recipientAddressCity(recipientAddressCity: Optional) = + recipientAddressCity(recipientAddressCity.getOrNull()) + + /** + * Sets [Builder.recipientAddressCity] to an arbitrary JSON value. + * + * You should usually call [Builder.recipientAddressCity] with a well-typed [String] value + * instead. This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun recipientAddressCity(recipientAddressCity: JsonField) = apply { + this.recipientAddressCity = recipientAddressCity + } + + /** The first line of the recipient's address. Required if the card is issued in Canada. */ + fun recipientAddressLine1(recipientAddressLine1: String?) = + recipientAddressLine1(JsonField.ofNullable(recipientAddressLine1)) + + /** + * Alias for calling [Builder.recipientAddressLine1] with + * `recipientAddressLine1.orElse(null)`. + */ + fun recipientAddressLine1(recipientAddressLine1: Optional) = + recipientAddressLine1(recipientAddressLine1.getOrNull()) + + /** + * Sets [Builder.recipientAddressLine1] to an arbitrary JSON value. + * + * You should usually call [Builder.recipientAddressLine1] with a well-typed [String] value + * instead. This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun recipientAddressLine1(recipientAddressLine1: JsonField) = apply { + this.recipientAddressLine1 = recipientAddressLine1 + } + + /** The postal code of the recipient. Required if the card is issued in Canada. */ + fun recipientAddressPostalCode(recipientAddressPostalCode: String?) = + recipientAddressPostalCode(JsonField.ofNullable(recipientAddressPostalCode)) + + /** + * Alias for calling [Builder.recipientAddressPostalCode] with + * `recipientAddressPostalCode.orElse(null)`. + */ + fun recipientAddressPostalCode(recipientAddressPostalCode: Optional) = + recipientAddressPostalCode(recipientAddressPostalCode.getOrNull()) + + /** + * Sets [Builder.recipientAddressPostalCode] to an arbitrary JSON value. + * + * You should usually call [Builder.recipientAddressPostalCode] with a well-typed [String] + * value instead. This method is primarily for setting the field to an undocumented or not + * yet supported value. + */ + fun recipientAddressPostalCode(recipientAddressPostalCode: JsonField) = apply { + this.recipientAddressPostalCode = recipientAddressPostalCode + } + + /** The state or province of the recipient. Required if the card is issued in Canada. */ + fun recipientAddressState(recipientAddressState: String?) = + recipientAddressState(JsonField.ofNullable(recipientAddressState)) + + /** + * Alias for calling [Builder.recipientAddressState] with + * `recipientAddressState.orElse(null)`. + */ + fun recipientAddressState(recipientAddressState: Optional) = + recipientAddressState(recipientAddressState.getOrNull()) + + /** + * Sets [Builder.recipientAddressState] to an arbitrary JSON value. + * + * You should usually call [Builder.recipientAddressState] with a well-typed [String] value + * instead. This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun recipientAddressState(recipientAddressState: JsonField) = apply { + this.recipientAddressState = recipientAddressState + } + /** The name of the funds recipient. */ fun recipientName(recipientName: String) = recipientName(JsonField.of(recipientName)) @@ -1286,11 +1582,17 @@ private constructor( * .idempotencyKey() * .merchantCategoryCode() * .merchantCityName() + * .merchantLegalBusinessName() * .merchantName() * .merchantNamePrefix() * .merchantPostalCode() * .merchantState() + * .merchantStreetAddress() * .presentmentAmount() + * .recipientAddressCity() + * .recipientAddressLine1() + * .recipientAddressPostalCode() + * .recipientAddressState() * .recipientName() * .route() * .senderAddressCity() @@ -1321,11 +1623,17 @@ private constructor( checkRequired("idempotencyKey", idempotencyKey), checkRequired("merchantCategoryCode", merchantCategoryCode), checkRequired("merchantCityName", merchantCityName), + checkRequired("merchantLegalBusinessName", merchantLegalBusinessName), checkRequired("merchantName", merchantName), checkRequired("merchantNamePrefix", merchantNamePrefix), checkRequired("merchantPostalCode", merchantPostalCode), checkRequired("merchantState", merchantState), + checkRequired("merchantStreetAddress", merchantStreetAddress), checkRequired("presentmentAmount", presentmentAmount), + checkRequired("recipientAddressCity", recipientAddressCity), + checkRequired("recipientAddressLine1", recipientAddressLine1), + checkRequired("recipientAddressPostalCode", recipientAddressPostalCode), + checkRequired("recipientAddressState", recipientAddressState), checkRequired("recipientName", recipientName), checkRequired("route", route), checkRequired("senderAddressCity", senderAddressCity), @@ -1369,11 +1677,17 @@ private constructor( idempotencyKey() merchantCategoryCode() merchantCityName() + merchantLegalBusinessName() merchantName() merchantNamePrefix() merchantPostalCode() merchantState() + merchantStreetAddress() presentmentAmount().validate() + recipientAddressCity() + recipientAddressLine1() + recipientAddressPostalCode() + recipientAddressState() recipientName() route().validate() senderAddressCity() @@ -1416,11 +1730,17 @@ private constructor( (if (idempotencyKey.asKnown().isPresent) 1 else 0) + (if (merchantCategoryCode.asKnown().isPresent) 1 else 0) + (if (merchantCityName.asKnown().isPresent) 1 else 0) + + (if (merchantLegalBusinessName.asKnown().isPresent) 1 else 0) + (if (merchantName.asKnown().isPresent) 1 else 0) + (if (merchantNamePrefix.asKnown().isPresent) 1 else 0) + (if (merchantPostalCode.asKnown().isPresent) 1 else 0) + (if (merchantState.asKnown().isPresent) 1 else 0) + + (if (merchantStreetAddress.asKnown().isPresent) 1 else 0) + (presentmentAmount.asKnown().getOrNull()?.validity() ?: 0) + + (if (recipientAddressCity.asKnown().isPresent) 1 else 0) + + (if (recipientAddressLine1.asKnown().isPresent) 1 else 0) + + (if (recipientAddressPostalCode.asKnown().isPresent) 1 else 0) + + (if (recipientAddressState.asKnown().isPresent) 1 else 0) + (if (recipientName.asKnown().isPresent) 1 else 0) + (route.asKnown().getOrNull()?.validity() ?: 0) + (if (senderAddressCity.asKnown().isPresent) 1 else 0) + @@ -7484,11 +7804,17 @@ private constructor( idempotencyKey == other.idempotencyKey && merchantCategoryCode == other.merchantCategoryCode && merchantCityName == other.merchantCityName && + merchantLegalBusinessName == other.merchantLegalBusinessName && merchantName == other.merchantName && merchantNamePrefix == other.merchantNamePrefix && merchantPostalCode == other.merchantPostalCode && merchantState == other.merchantState && + merchantStreetAddress == other.merchantStreetAddress && presentmentAmount == other.presentmentAmount && + recipientAddressCity == other.recipientAddressCity && + recipientAddressLine1 == other.recipientAddressLine1 && + recipientAddressPostalCode == other.recipientAddressPostalCode && + recipientAddressState == other.recipientAddressState && recipientName == other.recipientName && route == other.route && senderAddressCity == other.senderAddressCity && @@ -7518,11 +7844,17 @@ private constructor( idempotencyKey, merchantCategoryCode, merchantCityName, + merchantLegalBusinessName, merchantName, merchantNamePrefix, merchantPostalCode, merchantState, + merchantStreetAddress, presentmentAmount, + recipientAddressCity, + recipientAddressLine1, + recipientAddressPostalCode, + recipientAddressState, recipientName, route, senderAddressCity, @@ -7541,5 +7873,5 @@ private constructor( override fun hashCode(): Int = hashCode override fun toString() = - "CardPushTransfer{id=$id, acceptance=$acceptance, accountId=$accountId, approval=$approval, businessApplicationIdentifier=$businessApplicationIdentifier, cancellation=$cancellation, cardTokenId=$cardTokenId, createdAt=$createdAt, createdBy=$createdBy, decline=$decline, idempotencyKey=$idempotencyKey, merchantCategoryCode=$merchantCategoryCode, merchantCityName=$merchantCityName, merchantName=$merchantName, merchantNamePrefix=$merchantNamePrefix, merchantPostalCode=$merchantPostalCode, merchantState=$merchantState, presentmentAmount=$presentmentAmount, recipientName=$recipientName, route=$route, senderAddressCity=$senderAddressCity, senderAddressLine1=$senderAddressLine1, senderAddressPostalCode=$senderAddressPostalCode, senderAddressState=$senderAddressState, senderName=$senderName, sourceAccountNumberId=$sourceAccountNumberId, status=$status, submission=$submission, type=$type, additionalProperties=$additionalProperties}" + "CardPushTransfer{id=$id, acceptance=$acceptance, accountId=$accountId, approval=$approval, businessApplicationIdentifier=$businessApplicationIdentifier, cancellation=$cancellation, cardTokenId=$cardTokenId, createdAt=$createdAt, createdBy=$createdBy, decline=$decline, idempotencyKey=$idempotencyKey, merchantCategoryCode=$merchantCategoryCode, merchantCityName=$merchantCityName, merchantLegalBusinessName=$merchantLegalBusinessName, merchantName=$merchantName, merchantNamePrefix=$merchantNamePrefix, merchantPostalCode=$merchantPostalCode, merchantState=$merchantState, merchantStreetAddress=$merchantStreetAddress, presentmentAmount=$presentmentAmount, recipientAddressCity=$recipientAddressCity, recipientAddressLine1=$recipientAddressLine1, recipientAddressPostalCode=$recipientAddressPostalCode, recipientAddressState=$recipientAddressState, recipientName=$recipientName, route=$route, senderAddressCity=$senderAddressCity, senderAddressLine1=$senderAddressLine1, senderAddressPostalCode=$senderAddressPostalCode, senderAddressState=$senderAddressState, senderName=$senderName, sourceAccountNumberId=$sourceAccountNumberId, status=$status, submission=$submission, type=$type, additionalProperties=$additionalProperties}" } diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/cards/Card.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/cards/Card.kt index 223fb61b6..4bbb84ea8 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/cards/Card.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/cards/Card.kt @@ -34,6 +34,7 @@ private constructor( private val accountId: JsonField, private val authorizationControls: JsonField, private val billingAddress: JsonField, + private val bin: JsonField, private val createdAt: JsonField, private val description: JsonField, private val digitalWallet: JsonField, @@ -57,6 +58,7 @@ private constructor( @JsonProperty("billing_address") @ExcludeMissing billingAddress: JsonField = JsonMissing.of(), + @JsonProperty("bin") @ExcludeMissing bin: JsonField = JsonMissing.of(), @JsonProperty("created_at") @ExcludeMissing createdAt: JsonField = JsonMissing.of(), @@ -84,6 +86,7 @@ private constructor( accountId, authorizationControls, billingAddress, + bin, createdAt, description, digitalWallet, @@ -130,6 +133,14 @@ private constructor( */ fun billingAddress(): BillingAddress = billingAddress.getRequired("billing_address") + /** + * The Bank Identification Number (BIN) of the Card. + * + * @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 bin(): String = bin.getRequired("bin") + /** * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date and time at which the Card was * created. @@ -247,6 +258,13 @@ private constructor( @ExcludeMissing fun _billingAddress(): JsonField = billingAddress + /** + * Returns the raw JSON value of [bin]. + * + * Unlike [bin], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("bin") @ExcludeMissing fun _bin(): JsonField = bin + /** * Returns the raw JSON value of [createdAt]. * @@ -350,6 +368,7 @@ private constructor( * .accountId() * .authorizationControls() * .billingAddress() + * .bin() * .createdAt() * .description() * .digitalWallet() @@ -372,6 +391,7 @@ private constructor( private var accountId: JsonField? = null private var authorizationControls: JsonField? = null private var billingAddress: JsonField? = null + private var bin: JsonField? = null private var createdAt: JsonField? = null private var description: JsonField? = null private var digitalWallet: JsonField? = null @@ -390,6 +410,7 @@ private constructor( accountId = card.accountId authorizationControls = card.authorizationControls billingAddress = card.billingAddress + bin = card.bin createdAt = card.createdAt description = card.description digitalWallet = card.digitalWallet @@ -463,6 +484,17 @@ private constructor( this.billingAddress = billingAddress } + /** The Bank Identification Number (BIN) of the Card. */ + fun bin(bin: String) = bin(JsonField.of(bin)) + + /** + * Sets [Builder.bin] to an arbitrary JSON value. + * + * You should usually call [Builder.bin] with a well-typed [String] value instead. This + * method is primarily for setting the field to an undocumented or not yet supported value. + */ + fun bin(bin: JsonField) = apply { this.bin = bin } + /** * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date and time at which the Card * was created. @@ -645,6 +677,7 @@ private constructor( * .accountId() * .authorizationControls() * .billingAddress() + * .bin() * .createdAt() * .description() * .digitalWallet() @@ -665,6 +698,7 @@ private constructor( checkRequired("accountId", accountId), checkRequired("authorizationControls", authorizationControls), checkRequired("billingAddress", billingAddress), + checkRequired("bin", bin), checkRequired("createdAt", createdAt), checkRequired("description", description), checkRequired("digitalWallet", digitalWallet), @@ -698,6 +732,7 @@ private constructor( accountId() authorizationControls().ifPresent { it.validate() } billingAddress().validate() + bin() createdAt() description() digitalWallet().ifPresent { it.validate() } @@ -730,6 +765,7 @@ private constructor( (if (accountId.asKnown().isPresent) 1 else 0) + (authorizationControls.asKnown().getOrNull()?.validity() ?: 0) + (billingAddress.asKnown().getOrNull()?.validity() ?: 0) + + (if (bin.asKnown().isPresent) 1 else 0) + (if (createdAt.asKnown().isPresent) 1 else 0) + (if (description.asKnown().isPresent) 1 else 0) + (digitalWallet.asKnown().getOrNull()?.validity() ?: 0) + @@ -5788,6 +5824,7 @@ private constructor( accountId == other.accountId && authorizationControls == other.authorizationControls && billingAddress == other.billingAddress && + bin == other.bin && createdAt == other.createdAt && description == other.description && digitalWallet == other.digitalWallet && @@ -5807,6 +5844,7 @@ private constructor( accountId, authorizationControls, billingAddress, + bin, createdAt, description, digitalWallet, @@ -5824,5 +5862,5 @@ private constructor( override fun hashCode(): Int = hashCode override fun toString() = - "Card{id=$id, accountId=$accountId, authorizationControls=$authorizationControls, billingAddress=$billingAddress, createdAt=$createdAt, description=$description, digitalWallet=$digitalWallet, entityId=$entityId, expirationMonth=$expirationMonth, expirationYear=$expirationYear, idempotencyKey=$idempotencyKey, last4=$last4, status=$status, type=$type, additionalProperties=$additionalProperties}" + "Card{id=$id, accountId=$accountId, authorizationControls=$authorizationControls, billingAddress=$billingAddress, bin=$bin, createdAt=$createdAt, description=$description, digitalWallet=$digitalWallet, entityId=$entityId, expirationMonth=$expirationMonth, expirationYear=$expirationYear, idempotencyKey=$idempotencyKey, last4=$last4, status=$status, type=$type, additionalProperties=$additionalProperties}" } diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/checktransfers/CheckTransfer.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/checktransfers/CheckTransfer.kt index e9dbd294e..1ba55261e 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/checktransfers/CheckTransfer.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/checktransfers/CheckTransfer.kt @@ -3518,11 +3518,10 @@ private constructor( /** * The shipping method for the check. * - * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if - * the server responded with an unexpected value). + * @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 shippingMethod(): Optional = - shippingMethod.getOptional("shipping_method") + fun shippingMethod(): ShippingMethod = shippingMethod.getRequired("shipping_method") /** * The signature that will appear on the check. @@ -3859,12 +3858,8 @@ private constructor( } /** The shipping method for the check. */ - fun shippingMethod(shippingMethod: ShippingMethod?) = - shippingMethod(JsonField.ofNullable(shippingMethod)) - - /** Alias for calling [Builder.shippingMethod] with `shippingMethod.orElse(null)`. */ - fun shippingMethod(shippingMethod: Optional) = - shippingMethod(shippingMethod.getOrNull()) + fun shippingMethod(shippingMethod: ShippingMethod) = + shippingMethod(JsonField.of(shippingMethod)) /** * Sets [Builder.shippingMethod] to an arbitrary JSON value. @@ -3998,7 +3993,7 @@ private constructor( payer().forEach { it.validate() } recipientName() returnAddress().ifPresent { it.validate() } - shippingMethod().ifPresent { it.validate() } + shippingMethod().validate() signature().validate() trackingUpdates().forEach { it.validate() } validated = true @@ -5781,7 +5776,11 @@ private constructor( /** The check has been processed for delivery. */ @JvmField val PROCESSED_FOR_DELIVERY = of("processed_for_delivery") - /** The check has been delivered. */ + /** + * The check has been delivered. Note that some couriers track delivery status + * based on driver location data rather than an explicit scan. While uncommon, a + * single check may have more than one delivered event. + */ @JvmField val DELIVERED = of("delivered") /** @@ -5803,7 +5802,11 @@ private constructor( IN_TRANSIT, /** The check has been processed for delivery. */ PROCESSED_FOR_DELIVERY, - /** The check has been delivered. */ + /** + * The check has been delivered. Note that some couriers track delivery status + * based on driver location data rather than an explicit scan. While uncommon, a + * single check may have more than one delivered event. + */ DELIVERED, /** * There is an issue preventing delivery. The delivery will be attempted again @@ -5829,7 +5832,11 @@ private constructor( IN_TRANSIT, /** The check has been processed for delivery. */ PROCESSED_FOR_DELIVERY, - /** The check has been delivered. */ + /** + * The check has been delivered. Note that some couriers track delivery status + * based on driver location data rather than an explicit scan. While uncommon, a + * single check may have more than one delivered event. + */ DELIVERED, /** * There is an issue preventing delivery. The delivery will be attempted again diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/declinedtransactions/DeclinedTransaction.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/declinedtransactions/DeclinedTransaction.kt index 1a0a6cd9d..01145a355 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/declinedtransactions/DeclinedTransaction.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/declinedtransactions/DeclinedTransaction.kt @@ -11055,7 +11055,7 @@ private constructor( /** The attempted card transaction is not allowed per Increase's terms. */ @JvmField val TRANSACTION_NOT_ALLOWED = of("transaction_not_allowed") - /** The transaction was blocked by a Limit. */ + /** The transaction was blocked by a limit or an authorization control. */ @JvmField val BREACHES_LIMIT = of("breaches_limit") /** Your application declined the transaction via webhook. */ @@ -11129,7 +11129,7 @@ private constructor( CARD_EXPIRATION_MISMATCH, /** The attempted card transaction is not allowed per Increase's terms. */ TRANSACTION_NOT_ALLOWED, - /** The transaction was blocked by a Limit. */ + /** The transaction was blocked by a limit or an authorization control. */ BREACHES_LIMIT, /** Your application declined the transaction via webhook. */ WEBHOOK_DECLINED, @@ -11198,7 +11198,7 @@ private constructor( CARD_EXPIRATION_MISMATCH, /** The attempted card transaction is not allowed per Increase's terms. */ TRANSACTION_NOT_ALLOWED, - /** The transaction was blocked by a Limit. */ + /** The transaction was blocked by a limit or an authorization control. */ BREACHES_LIMIT, /** Your application declined the transaction via webhook. */ WEBHOOK_DECLINED, diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/digitalwallettokens/DigitalWalletToken.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/digitalwallettokens/DigitalWalletToken.kt index fce67d731..695bd2771 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/digitalwallettokens/DigitalWalletToken.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/digitalwallettokens/DigitalWalletToken.kt @@ -32,6 +32,7 @@ private constructor( private val cardId: JsonField, private val cardholder: JsonField, private val createdAt: JsonField, + private val decline: JsonField, private val device: JsonField, private val dynamicPrimaryAccountNumber: JsonField, private val status: JsonField, @@ -51,6 +52,7 @@ private constructor( @JsonProperty("created_at") @ExcludeMissing createdAt: JsonField = JsonMissing.of(), + @JsonProperty("decline") @ExcludeMissing decline: JsonField = JsonMissing.of(), @JsonProperty("device") @ExcludeMissing device: JsonField = JsonMissing.of(), @JsonProperty("dynamic_primary_account_number") @ExcludeMissing @@ -66,6 +68,7 @@ private constructor( cardId, cardholder, createdAt, + decline, device, dynamicPrimaryAccountNumber, status, @@ -108,6 +111,14 @@ private constructor( */ fun createdAt(): OffsetDateTime = createdAt.getRequired("created_at") + /** + * If the Digital Wallet Token was declined during provisioning, details about the decline. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun decline(): Optional = decline.getOptional("decline") + /** * The device that was used to create the Digital Wallet Token. * @@ -190,6 +201,13 @@ private constructor( @ExcludeMissing fun _createdAt(): JsonField = createdAt + /** + * Returns the raw JSON value of [decline]. + * + * Unlike [decline], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("decline") @ExcludeMissing fun _decline(): JsonField = decline + /** * Returns the raw JSON value of [device]. * @@ -261,6 +279,7 @@ private constructor( * .cardId() * .cardholder() * .createdAt() + * .decline() * .device() * .dynamicPrimaryAccountNumber() * .status() @@ -279,6 +298,7 @@ private constructor( private var cardId: JsonField? = null private var cardholder: JsonField? = null private var createdAt: JsonField? = null + private var decline: JsonField? = null private var device: JsonField? = null private var dynamicPrimaryAccountNumber: JsonField? = null private var status: JsonField? = null @@ -293,6 +313,7 @@ private constructor( cardId = digitalWalletToken.cardId cardholder = digitalWalletToken.cardholder createdAt = digitalWalletToken.createdAt + decline = digitalWalletToken.decline device = digitalWalletToken.device dynamicPrimaryAccountNumber = digitalWalletToken.dynamicPrimaryAccountNumber status = digitalWalletToken.status @@ -351,6 +372,22 @@ private constructor( */ fun createdAt(createdAt: JsonField) = apply { this.createdAt = createdAt } + /** + * If the Digital Wallet Token was declined during provisioning, details about the decline. + */ + fun decline(decline: Decline?) = decline(JsonField.ofNullable(decline)) + + /** Alias for calling [Builder.decline] with `decline.orElse(null)`. */ + fun decline(decline: Optional) = decline(decline.getOrNull()) + + /** + * Sets [Builder.decline] to an arbitrary JSON value. + * + * You should usually call [Builder.decline] with a well-typed [Decline] value instead. This + * method is primarily for setting the field to an undocumented or not yet supported value. + */ + fun decline(decline: JsonField) = apply { this.decline = decline } + /** The device that was used to create the Digital Wallet Token. */ fun device(device: Device) = device(JsonField.of(device)) @@ -481,6 +518,7 @@ private constructor( * .cardId() * .cardholder() * .createdAt() + * .decline() * .device() * .dynamicPrimaryAccountNumber() * .status() @@ -497,6 +535,7 @@ private constructor( checkRequired("cardId", cardId), checkRequired("cardholder", cardholder), checkRequired("createdAt", createdAt), + checkRequired("decline", decline), checkRequired("device", device), checkRequired("dynamicPrimaryAccountNumber", dynamicPrimaryAccountNumber), checkRequired("status", status), @@ -526,6 +565,7 @@ private constructor( cardId() cardholder().validate() createdAt() + decline().ifPresent { it.validate() } device().validate() dynamicPrimaryAccountNumber().ifPresent { it.validate() } status().validate() @@ -554,6 +594,7 @@ private constructor( (if (cardId.asKnown().isPresent) 1 else 0) + (cardholder.asKnown().getOrNull()?.validity() ?: 0) + (if (createdAt.asKnown().isPresent) 1 else 0) + + (decline.asKnown().getOrNull()?.validity() ?: 0) + (device.asKnown().getOrNull()?.validity() ?: 0) + (dynamicPrimaryAccountNumber.asKnown().getOrNull()?.validity() ?: 0) + (status.asKnown().getOrNull()?.validity() ?: 0) + @@ -730,6 +771,364 @@ private constructor( "Cardholder{name=$name, additionalProperties=$additionalProperties}" } + /** If the Digital Wallet Token was declined during provisioning, details about the decline. */ + class Decline + @JsonCreator(mode = JsonCreator.Mode.DISABLED) + private constructor( + private val reason: JsonField, + private val additionalProperties: MutableMap, + ) { + + @JsonCreator + private constructor( + @JsonProperty("reason") @ExcludeMissing reason: JsonField = JsonMissing.of() + ) : this(reason, mutableMapOf()) + + /** + * The reason the token provisioning was declined. + * + * @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 reason(): Reason = reason.getRequired("reason") + + /** + * 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 [Decline]. + * + * The following fields are required: + * ```java + * .reason() + * ``` + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [Decline]. */ + class Builder internal constructor() { + + private var reason: JsonField? = null + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(decline: Decline) = apply { + reason = decline.reason + additionalProperties = decline.additionalProperties.toMutableMap() + } + + /** The reason the token provisioning was declined. */ + 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 [Decline]. + * + * Further updates to this [Builder] will not mutate the returned instance. + * + * The following fields are required: + * ```java + * .reason() + * ``` + * + * @throws IllegalStateException if any required field is unset. + */ + fun build(): Decline = + Decline(checkRequired("reason", reason), additionalProperties.toMutableMap()) + } + + private var validated: Boolean = false + + /** + * Validates that the types of all values in this object match their expected types + * recursively. + * + * This method is _not_ forwards compatible with new types from the API for existing fields. + * + * @throws IncreaseInvalidDataException if any value type in this object doesn't match its + * expected type. + */ + fun validate(): Decline = apply { + if (validated) { + return@apply + } + + reason().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 = (reason.asKnown().getOrNull()?.validity() ?: 0) + + /** The reason the token provisioning was declined. */ + 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 card is not active. */ + @JvmField val CARD_NOT_ACTIVE = of("card_not_active") + + /** The card does not have a two-factor authentication method. */ + @JvmField val NO_VERIFICATION_METHOD = of("no_verification_method") + + /** Your webhook timed out when evaluating the token provisioning attempt. */ + @JvmField val WEBHOOK_TIMED_OUT = of("webhook_timed_out") + + /** Your webhook declined the token provisioning attempt. */ + @JvmField val WEBHOOK_DECLINED = of("webhook_declined") + + /** + * The tokenization attempt failed because the Card Verification Code (CVC) was + * incorrect. + */ + @JvmField + val INCORRECT_CARD_VERIFICATION_CODE = of("incorrect_card_verification_code") + + /** The tokenization attempt was declined by the token requestor. */ + @JvmField val DECLINED_BY_TOKEN_REQUESTOR = of("declined_by_token_requestor") + + @JvmStatic fun of(value: String) = Reason(JsonField.of(value)) + } + + /** An enum containing [Reason]'s known values. */ + enum class Known { + /** The card is not active. */ + CARD_NOT_ACTIVE, + /** The card does not have a two-factor authentication method. */ + NO_VERIFICATION_METHOD, + /** Your webhook timed out when evaluating the token provisioning attempt. */ + WEBHOOK_TIMED_OUT, + /** Your webhook declined the token provisioning attempt. */ + WEBHOOK_DECLINED, + /** + * The tokenization attempt failed because the Card Verification Code (CVC) was + * incorrect. + */ + INCORRECT_CARD_VERIFICATION_CODE, + /** The tokenization attempt was declined by the token requestor. */ + DECLINED_BY_TOKEN_REQUESTOR, + } + + /** + * 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 card is not active. */ + CARD_NOT_ACTIVE, + /** The card does not have a two-factor authentication method. */ + NO_VERIFICATION_METHOD, + /** Your webhook timed out when evaluating the token provisioning attempt. */ + WEBHOOK_TIMED_OUT, + /** Your webhook declined the token provisioning attempt. */ + WEBHOOK_DECLINED, + /** + * The tokenization attempt failed because the Card Verification Code (CVC) was + * incorrect. + */ + INCORRECT_CARD_VERIFICATION_CODE, + /** The tokenization attempt was declined by the token requestor. */ + DECLINED_BY_TOKEN_REQUESTOR, + /** + * 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) { + CARD_NOT_ACTIVE -> Value.CARD_NOT_ACTIVE + NO_VERIFICATION_METHOD -> Value.NO_VERIFICATION_METHOD + WEBHOOK_TIMED_OUT -> Value.WEBHOOK_TIMED_OUT + WEBHOOK_DECLINED -> Value.WEBHOOK_DECLINED + INCORRECT_CARD_VERIFICATION_CODE -> Value.INCORRECT_CARD_VERIFICATION_CODE + DECLINED_BY_TOKEN_REQUESTOR -> Value.DECLINED_BY_TOKEN_REQUESTOR + 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) { + CARD_NOT_ACTIVE -> Known.CARD_NOT_ACTIVE + NO_VERIFICATION_METHOD -> Known.NO_VERIFICATION_METHOD + WEBHOOK_TIMED_OUT -> Known.WEBHOOK_TIMED_OUT + WEBHOOK_DECLINED -> Known.WEBHOOK_DECLINED + INCORRECT_CARD_VERIFICATION_CODE -> Known.INCORRECT_CARD_VERIFICATION_CODE + DECLINED_BY_TOKEN_REQUESTOR -> Known.DECLINED_BY_TOKEN_REQUESTOR + 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 + + /** + * Validates that the types of all values in this object match their expected types + * recursively. + * + * This method is _not_ forwards compatible with new types from the API for existing + * fields. + * + * @throws IncreaseInvalidDataException if any value type in this object doesn't match + * its expected type. + */ + 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 Decline && + reason == other.reason && + additionalProperties == other.additionalProperties + } + + private val hashCode: Int by lazy { Objects.hash(reason, additionalProperties) } + + override fun hashCode(): Int = hashCode + + override fun toString() = + "Decline{reason=$reason, additionalProperties=$additionalProperties}" + } + /** The device that was used to create the Digital Wallet Token. */ class Device @JsonCreator(mode = JsonCreator.Mode.DISABLED) @@ -1488,6 +1887,9 @@ private constructor( /** The digital wallet token has been permanently canceled. */ @JvmField val DEACTIVATED = of("deactivated") + /** The digital wallet token was declined during provisioning. */ + @JvmField val DECLINED = of("declined") + @JvmStatic fun of(value: String) = Status(JsonField.of(value)) } @@ -1504,6 +1906,8 @@ private constructor( SUSPENDED, /** The digital wallet token has been permanently canceled. */ DEACTIVATED, + /** The digital wallet token was declined during provisioning. */ + DECLINED, } /** @@ -1527,6 +1931,8 @@ private constructor( SUSPENDED, /** The digital wallet token has been permanently canceled. */ DEACTIVATED, + /** The digital wallet token was declined during provisioning. */ + DECLINED, /** An enum member indicating that [Status] was instantiated with an unknown value. */ _UNKNOWN, } @@ -1544,6 +1950,7 @@ private constructor( INACTIVE -> Value.INACTIVE SUSPENDED -> Value.SUSPENDED DEACTIVATED -> Value.DEACTIVATED + DECLINED -> Value.DECLINED else -> Value._UNKNOWN } @@ -1562,6 +1969,7 @@ private constructor( INACTIVE -> Known.INACTIVE SUSPENDED -> Known.SUSPENDED DEACTIVATED -> Known.DEACTIVATED + DECLINED -> Known.DECLINED else -> throw IncreaseInvalidDataException("Unknown Status: $value") } @@ -2155,6 +2563,9 @@ private constructor( /** The digital wallet token has been permanently canceled. */ @JvmField val DEACTIVATED = of("deactivated") + /** The digital wallet token was declined during provisioning. */ + @JvmField val DECLINED = of("declined") + @JvmStatic fun of(value: String) = Status(JsonField.of(value)) } @@ -2171,6 +2582,8 @@ private constructor( SUSPENDED, /** The digital wallet token has been permanently canceled. */ DEACTIVATED, + /** The digital wallet token was declined during provisioning. */ + DECLINED, } /** @@ -2194,6 +2607,8 @@ private constructor( SUSPENDED, /** The digital wallet token has been permanently canceled. */ DEACTIVATED, + /** The digital wallet token was declined during provisioning. */ + DECLINED, /** * An enum member indicating that [Status] was instantiated with an unknown value. */ @@ -2213,6 +2628,7 @@ private constructor( INACTIVE -> Value.INACTIVE SUSPENDED -> Value.SUSPENDED DEACTIVATED -> Value.DEACTIVATED + DECLINED -> Value.DECLINED else -> Value._UNKNOWN } @@ -2231,6 +2647,7 @@ private constructor( INACTIVE -> Known.INACTIVE SUSPENDED -> Known.SUSPENDED DEACTIVATED -> Known.DEACTIVATED + DECLINED -> Known.DECLINED else -> throw IncreaseInvalidDataException("Unknown Status: $value") } @@ -2327,6 +2744,7 @@ private constructor( cardId == other.cardId && cardholder == other.cardholder && createdAt == other.createdAt && + decline == other.decline && device == other.device && dynamicPrimaryAccountNumber == other.dynamicPrimaryAccountNumber && status == other.status && @@ -2342,6 +2760,7 @@ private constructor( cardId, cardholder, createdAt, + decline, device, dynamicPrimaryAccountNumber, status, @@ -2355,5 +2774,5 @@ private constructor( override fun hashCode(): Int = hashCode override fun toString() = - "DigitalWalletToken{id=$id, cardId=$cardId, cardholder=$cardholder, createdAt=$createdAt, device=$device, dynamicPrimaryAccountNumber=$dynamicPrimaryAccountNumber, status=$status, tokenRequestor=$tokenRequestor, type=$type, updates=$updates, additionalProperties=$additionalProperties}" + "DigitalWalletToken{id=$id, cardId=$cardId, cardholder=$cardholder, createdAt=$createdAt, decline=$decline, device=$device, dynamicPrimaryAccountNumber=$dynamicPrimaryAccountNumber, status=$status, tokenRequestor=$tokenRequestor, type=$type, updates=$updates, additionalProperties=$additionalProperties}" } diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/entities/Entity.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/entities/Entity.kt index 6bc495f19..167032821 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/entities/Entity.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/entities/Entity.kt @@ -14206,8 +14206,7 @@ private constructor( companion object { /** - * The entity's tax identifier could not be validated. Update the tax ID with - * the + * The entity's tax identifier could not be verified. Update the tax ID with the * [update an entity API](/documentation/api/entities#update-an-entity.corporation.legal_identifier). */ @JvmField val ENTITY_TAX_IDENTIFIER = of("entity_tax_identifier") @@ -14238,8 +14237,7 @@ private constructor( /** An enum containing [Category]'s known values. */ enum class Known { /** - * The entity's tax identifier could not be validated. Update the tax ID with - * the + * The entity's tax identifier could not be verified. Update the tax ID with the * [update an entity API](/documentation/api/entities#update-an-entity.corporation.legal_identifier). */ ENTITY_TAX_IDENTIFIER, @@ -14273,8 +14271,7 @@ private constructor( */ enum class Value { /** - * The entity's tax identifier could not be validated. Update the tax ID with - * the + * The entity's tax identifier could not be verified. Update the tax ID with the * [update an entity API](/documentation/api/entities#update-an-entity.corporation.legal_identifier). */ ENTITY_TAX_IDENTIFIER, diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/events/Event.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/events/Event.kt index 5b74f9740..ffd337105 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/events/Event.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/events/Event.kt @@ -629,6 +629,18 @@ private constructor( /** Occurs whenever an IntraFi Exclusion is updated. */ @JvmField val INTRAFI_EXCLUSION_UPDATED = of("intrafi_exclusion.updated") + /** Occurs whenever a Loan Application is created. */ + @JvmField val LOAN_APPLICATION_CREATED = of("loan_application.created") + + /** Occurs whenever a Loan Application is updated. */ + @JvmField val LOAN_APPLICATION_UPDATED = of("loan_application.updated") + + /** Occurs whenever a Loan Offer is created. */ + @JvmField val LOAN_OFFER_CREATED = of("loan_offer.created") + + /** Occurs whenever a Loan Offer is updated. */ + @JvmField val LOAN_OFFER_UPDATED = of("loan_offer.updated") + /** Occurs whenever a Lockbox is created. */ @JvmField val LOCKBOX_CREATED = of("lockbox.created") @@ -926,6 +938,14 @@ private constructor( INTRAFI_EXCLUSION_CREATED, /** Occurs whenever an IntraFi Exclusion is updated. */ INTRAFI_EXCLUSION_UPDATED, + /** Occurs whenever a Loan Application is created. */ + LOAN_APPLICATION_CREATED, + /** Occurs whenever a Loan Application is updated. */ + LOAN_APPLICATION_UPDATED, + /** Occurs whenever a Loan Offer is created. */ + LOAN_OFFER_CREATED, + /** Occurs whenever a Loan Offer is updated. */ + LOAN_OFFER_UPDATED, /** Occurs whenever a Lockbox is created. */ LOCKBOX_CREATED, /** Occurs whenever a Lockbox is updated. */ @@ -1171,6 +1191,14 @@ private constructor( INTRAFI_EXCLUSION_CREATED, /** Occurs whenever an IntraFi Exclusion is updated. */ INTRAFI_EXCLUSION_UPDATED, + /** Occurs whenever a Loan Application is created. */ + LOAN_APPLICATION_CREATED, + /** Occurs whenever a Loan Application is updated. */ + LOAN_APPLICATION_UPDATED, + /** Occurs whenever a Loan Offer is created. */ + LOAN_OFFER_CREATED, + /** Occurs whenever a Loan Offer is updated. */ + LOAN_OFFER_UPDATED, /** Occurs whenever a Lockbox is created. */ LOCKBOX_CREATED, /** Occurs whenever a Lockbox is updated. */ @@ -1346,6 +1374,10 @@ private constructor( INTRAFI_ACCOUNT_ENROLLMENT_UPDATED -> Value.INTRAFI_ACCOUNT_ENROLLMENT_UPDATED INTRAFI_EXCLUSION_CREATED -> Value.INTRAFI_EXCLUSION_CREATED INTRAFI_EXCLUSION_UPDATED -> Value.INTRAFI_EXCLUSION_UPDATED + LOAN_APPLICATION_CREATED -> Value.LOAN_APPLICATION_CREATED + LOAN_APPLICATION_UPDATED -> Value.LOAN_APPLICATION_UPDATED + LOAN_OFFER_CREATED -> Value.LOAN_OFFER_CREATED + LOAN_OFFER_UPDATED -> Value.LOAN_OFFER_UPDATED LOCKBOX_CREATED -> Value.LOCKBOX_CREATED LOCKBOX_UPDATED -> Value.LOCKBOX_UPDATED OAUTH_CONNECTION_CREATED -> Value.OAUTH_CONNECTION_CREATED @@ -1479,6 +1511,10 @@ private constructor( INTRAFI_ACCOUNT_ENROLLMENT_UPDATED -> Known.INTRAFI_ACCOUNT_ENROLLMENT_UPDATED INTRAFI_EXCLUSION_CREATED -> Known.INTRAFI_EXCLUSION_CREATED INTRAFI_EXCLUSION_UPDATED -> Known.INTRAFI_EXCLUSION_UPDATED + LOAN_APPLICATION_CREATED -> Known.LOAN_APPLICATION_CREATED + LOAN_APPLICATION_UPDATED -> Known.LOAN_APPLICATION_UPDATED + LOAN_OFFER_CREATED -> Known.LOAN_OFFER_CREATED + LOAN_OFFER_UPDATED -> Known.LOAN_OFFER_UPDATED LOCKBOX_CREATED -> Known.LOCKBOX_CREATED LOCKBOX_UPDATED -> Known.LOCKBOX_UPDATED OAUTH_CONNECTION_CREATED -> Known.OAUTH_CONNECTION_CREATED diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/events/EventListParams.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/events/EventListParams.kt index f218104aa..881b821a2 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/events/EventListParams.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/events/EventListParams.kt @@ -654,6 +654,18 @@ private constructor( /** Occurs whenever an IntraFi Exclusion is updated. */ @JvmField val INTRAFI_EXCLUSION_UPDATED = of("intrafi_exclusion.updated") + /** Occurs whenever a Loan Application is created. */ + @JvmField val LOAN_APPLICATION_CREATED = of("loan_application.created") + + /** Occurs whenever a Loan Application is updated. */ + @JvmField val LOAN_APPLICATION_UPDATED = of("loan_application.updated") + + /** Occurs whenever a Loan Offer is created. */ + @JvmField val LOAN_OFFER_CREATED = of("loan_offer.created") + + /** Occurs whenever a Loan Offer is updated. */ + @JvmField val LOAN_OFFER_UPDATED = of("loan_offer.updated") + /** Occurs whenever a Lockbox is created. */ @JvmField val LOCKBOX_CREATED = of("lockbox.created") @@ -953,6 +965,14 @@ private constructor( INTRAFI_EXCLUSION_CREATED, /** Occurs whenever an IntraFi Exclusion is updated. */ INTRAFI_EXCLUSION_UPDATED, + /** Occurs whenever a Loan Application is created. */ + LOAN_APPLICATION_CREATED, + /** Occurs whenever a Loan Application is updated. */ + LOAN_APPLICATION_UPDATED, + /** Occurs whenever a Loan Offer is created. */ + LOAN_OFFER_CREATED, + /** Occurs whenever a Loan Offer is updated. */ + LOAN_OFFER_UPDATED, /** Occurs whenever a Lockbox is created. */ LOCKBOX_CREATED, /** Occurs whenever a Lockbox is updated. */ @@ -1200,6 +1220,14 @@ private constructor( INTRAFI_EXCLUSION_CREATED, /** Occurs whenever an IntraFi Exclusion is updated. */ INTRAFI_EXCLUSION_UPDATED, + /** Occurs whenever a Loan Application is created. */ + LOAN_APPLICATION_CREATED, + /** Occurs whenever a Loan Application is updated. */ + LOAN_APPLICATION_UPDATED, + /** Occurs whenever a Loan Offer is created. */ + LOAN_OFFER_CREATED, + /** Occurs whenever a Loan Offer is updated. */ + LOAN_OFFER_UPDATED, /** Occurs whenever a Lockbox is created. */ LOCKBOX_CREATED, /** Occurs whenever a Lockbox is updated. */ @@ -1378,6 +1406,10 @@ private constructor( INTRAFI_ACCOUNT_ENROLLMENT_UPDATED -> Value.INTRAFI_ACCOUNT_ENROLLMENT_UPDATED INTRAFI_EXCLUSION_CREATED -> Value.INTRAFI_EXCLUSION_CREATED INTRAFI_EXCLUSION_UPDATED -> Value.INTRAFI_EXCLUSION_UPDATED + LOAN_APPLICATION_CREATED -> Value.LOAN_APPLICATION_CREATED + LOAN_APPLICATION_UPDATED -> Value.LOAN_APPLICATION_UPDATED + LOAN_OFFER_CREATED -> Value.LOAN_OFFER_CREATED + LOAN_OFFER_UPDATED -> Value.LOAN_OFFER_UPDATED LOCKBOX_CREATED -> Value.LOCKBOX_CREATED LOCKBOX_UPDATED -> Value.LOCKBOX_UPDATED OAUTH_CONNECTION_CREATED -> Value.OAUTH_CONNECTION_CREATED @@ -1512,6 +1544,10 @@ private constructor( INTRAFI_ACCOUNT_ENROLLMENT_UPDATED -> Known.INTRAFI_ACCOUNT_ENROLLMENT_UPDATED INTRAFI_EXCLUSION_CREATED -> Known.INTRAFI_EXCLUSION_CREATED INTRAFI_EXCLUSION_UPDATED -> Known.INTRAFI_EXCLUSION_UPDATED + LOAN_APPLICATION_CREATED -> Known.LOAN_APPLICATION_CREATED + LOAN_APPLICATION_UPDATED -> Known.LOAN_APPLICATION_UPDATED + LOAN_OFFER_CREATED -> Known.LOAN_OFFER_CREATED + LOAN_OFFER_UPDATED -> Known.LOAN_OFFER_UPDATED LOCKBOX_CREATED -> Known.LOCKBOX_CREATED LOCKBOX_UPDATED -> Known.LOCKBOX_UPDATED OAUTH_CONNECTION_CREATED -> Known.OAUTH_CONNECTION_CREATED diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/events/UnwrapWebhookEvent.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/events/UnwrapWebhookEvent.kt index 1a68194bb..a2bc46a15 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/events/UnwrapWebhookEvent.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/events/UnwrapWebhookEvent.kt @@ -629,6 +629,18 @@ private constructor( /** Occurs whenever an IntraFi Exclusion is updated. */ @JvmField val INTRAFI_EXCLUSION_UPDATED = of("intrafi_exclusion.updated") + /** Occurs whenever a Loan Application is created. */ + @JvmField val LOAN_APPLICATION_CREATED = of("loan_application.created") + + /** Occurs whenever a Loan Application is updated. */ + @JvmField val LOAN_APPLICATION_UPDATED = of("loan_application.updated") + + /** Occurs whenever a Loan Offer is created. */ + @JvmField val LOAN_OFFER_CREATED = of("loan_offer.created") + + /** Occurs whenever a Loan Offer is updated. */ + @JvmField val LOAN_OFFER_UPDATED = of("loan_offer.updated") + /** Occurs whenever a Lockbox is created. */ @JvmField val LOCKBOX_CREATED = of("lockbox.created") @@ -926,6 +938,14 @@ private constructor( INTRAFI_EXCLUSION_CREATED, /** Occurs whenever an IntraFi Exclusion is updated. */ INTRAFI_EXCLUSION_UPDATED, + /** Occurs whenever a Loan Application is created. */ + LOAN_APPLICATION_CREATED, + /** Occurs whenever a Loan Application is updated. */ + LOAN_APPLICATION_UPDATED, + /** Occurs whenever a Loan Offer is created. */ + LOAN_OFFER_CREATED, + /** Occurs whenever a Loan Offer is updated. */ + LOAN_OFFER_UPDATED, /** Occurs whenever a Lockbox is created. */ LOCKBOX_CREATED, /** Occurs whenever a Lockbox is updated. */ @@ -1171,6 +1191,14 @@ private constructor( INTRAFI_EXCLUSION_CREATED, /** Occurs whenever an IntraFi Exclusion is updated. */ INTRAFI_EXCLUSION_UPDATED, + /** Occurs whenever a Loan Application is created. */ + LOAN_APPLICATION_CREATED, + /** Occurs whenever a Loan Application is updated. */ + LOAN_APPLICATION_UPDATED, + /** Occurs whenever a Loan Offer is created. */ + LOAN_OFFER_CREATED, + /** Occurs whenever a Loan Offer is updated. */ + LOAN_OFFER_UPDATED, /** Occurs whenever a Lockbox is created. */ LOCKBOX_CREATED, /** Occurs whenever a Lockbox is updated. */ @@ -1346,6 +1374,10 @@ private constructor( INTRAFI_ACCOUNT_ENROLLMENT_UPDATED -> Value.INTRAFI_ACCOUNT_ENROLLMENT_UPDATED INTRAFI_EXCLUSION_CREATED -> Value.INTRAFI_EXCLUSION_CREATED INTRAFI_EXCLUSION_UPDATED -> Value.INTRAFI_EXCLUSION_UPDATED + LOAN_APPLICATION_CREATED -> Value.LOAN_APPLICATION_CREATED + LOAN_APPLICATION_UPDATED -> Value.LOAN_APPLICATION_UPDATED + LOAN_OFFER_CREATED -> Value.LOAN_OFFER_CREATED + LOAN_OFFER_UPDATED -> Value.LOAN_OFFER_UPDATED LOCKBOX_CREATED -> Value.LOCKBOX_CREATED LOCKBOX_UPDATED -> Value.LOCKBOX_UPDATED OAUTH_CONNECTION_CREATED -> Value.OAUTH_CONNECTION_CREATED @@ -1479,6 +1511,10 @@ private constructor( INTRAFI_ACCOUNT_ENROLLMENT_UPDATED -> Known.INTRAFI_ACCOUNT_ENROLLMENT_UPDATED INTRAFI_EXCLUSION_CREATED -> Known.INTRAFI_EXCLUSION_CREATED INTRAFI_EXCLUSION_UPDATED -> Known.INTRAFI_EXCLUSION_UPDATED + LOAN_APPLICATION_CREATED -> Known.LOAN_APPLICATION_CREATED + LOAN_APPLICATION_UPDATED -> Known.LOAN_APPLICATION_UPDATED + LOAN_OFFER_CREATED -> Known.LOAN_OFFER_CREATED + LOAN_OFFER_UPDATED -> Known.LOAN_OFFER_UPDATED LOCKBOX_CREATED -> Known.LOCKBOX_CREATED LOCKBOX_UPDATED -> Known.LOCKBOX_UPDATED OAUTH_CONNECTION_CREATED -> Known.OAUTH_CONNECTION_CREATED diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/eventsubscriptions/EventSubscription.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/eventsubscriptions/EventSubscription.kt index 3718aef1b..6f4f0a771 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/eventsubscriptions/EventSubscription.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/eventsubscriptions/EventSubscription.kt @@ -923,6 +923,18 @@ private constructor( /** Occurs whenever an IntraFi Exclusion is updated. */ @JvmField val INTRAFI_EXCLUSION_UPDATED = of("intrafi_exclusion.updated") + /** Occurs whenever a Loan Application is created. */ + @JvmField val LOAN_APPLICATION_CREATED = of("loan_application.created") + + /** Occurs whenever a Loan Application is updated. */ + @JvmField val LOAN_APPLICATION_UPDATED = of("loan_application.updated") + + /** Occurs whenever a Loan Offer is created. */ + @JvmField val LOAN_OFFER_CREATED = of("loan_offer.created") + + /** Occurs whenever a Loan Offer is updated. */ + @JvmField val LOAN_OFFER_UPDATED = of("loan_offer.updated") + /** Occurs whenever a Lockbox is created. */ @JvmField val LOCKBOX_CREATED = of("lockbox.created") @@ -1222,6 +1234,14 @@ private constructor( INTRAFI_EXCLUSION_CREATED, /** Occurs whenever an IntraFi Exclusion is updated. */ INTRAFI_EXCLUSION_UPDATED, + /** Occurs whenever a Loan Application is created. */ + LOAN_APPLICATION_CREATED, + /** Occurs whenever a Loan Application is updated. */ + LOAN_APPLICATION_UPDATED, + /** Occurs whenever a Loan Offer is created. */ + LOAN_OFFER_CREATED, + /** Occurs whenever a Loan Offer is updated. */ + LOAN_OFFER_UPDATED, /** Occurs whenever a Lockbox is created. */ LOCKBOX_CREATED, /** Occurs whenever a Lockbox is updated. */ @@ -1469,6 +1489,14 @@ private constructor( INTRAFI_EXCLUSION_CREATED, /** Occurs whenever an IntraFi Exclusion is updated. */ INTRAFI_EXCLUSION_UPDATED, + /** Occurs whenever a Loan Application is created. */ + LOAN_APPLICATION_CREATED, + /** Occurs whenever a Loan Application is updated. */ + LOAN_APPLICATION_UPDATED, + /** Occurs whenever a Loan Offer is created. */ + LOAN_OFFER_CREATED, + /** Occurs whenever a Loan Offer is updated. */ + LOAN_OFFER_UPDATED, /** Occurs whenever a Lockbox is created. */ LOCKBOX_CREATED, /** Occurs whenever a Lockbox is updated. */ @@ -1650,6 +1678,10 @@ private constructor( INTRAFI_ACCOUNT_ENROLLMENT_UPDATED -> Value.INTRAFI_ACCOUNT_ENROLLMENT_UPDATED INTRAFI_EXCLUSION_CREATED -> Value.INTRAFI_EXCLUSION_CREATED INTRAFI_EXCLUSION_UPDATED -> Value.INTRAFI_EXCLUSION_UPDATED + LOAN_APPLICATION_CREATED -> Value.LOAN_APPLICATION_CREATED + LOAN_APPLICATION_UPDATED -> Value.LOAN_APPLICATION_UPDATED + LOAN_OFFER_CREATED -> Value.LOAN_OFFER_CREATED + LOAN_OFFER_UPDATED -> Value.LOAN_OFFER_UPDATED LOCKBOX_CREATED -> Value.LOCKBOX_CREATED LOCKBOX_UPDATED -> Value.LOCKBOX_UPDATED OAUTH_CONNECTION_CREATED -> Value.OAUTH_CONNECTION_CREATED @@ -1784,6 +1816,10 @@ private constructor( INTRAFI_ACCOUNT_ENROLLMENT_UPDATED -> Known.INTRAFI_ACCOUNT_ENROLLMENT_UPDATED INTRAFI_EXCLUSION_CREATED -> Known.INTRAFI_EXCLUSION_CREATED INTRAFI_EXCLUSION_UPDATED -> Known.INTRAFI_EXCLUSION_UPDATED + LOAN_APPLICATION_CREATED -> Known.LOAN_APPLICATION_CREATED + LOAN_APPLICATION_UPDATED -> Known.LOAN_APPLICATION_UPDATED + LOAN_OFFER_CREATED -> Known.LOAN_OFFER_CREATED + LOAN_OFFER_UPDATED -> Known.LOAN_OFFER_UPDATED LOCKBOX_CREATED -> Known.LOCKBOX_CREATED LOCKBOX_UPDATED -> Known.LOCKBOX_UPDATED OAUTH_CONNECTION_CREATED -> Known.OAUTH_CONNECTION_CREATED diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/eventsubscriptions/EventSubscriptionCreateParams.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/eventsubscriptions/EventSubscriptionCreateParams.kt index af8e329b8..eee375cd7 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/eventsubscriptions/EventSubscriptionCreateParams.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/eventsubscriptions/EventSubscriptionCreateParams.kt @@ -1183,6 +1183,18 @@ private constructor( /** Occurs whenever an IntraFi Exclusion is updated. */ @JvmField val INTRAFI_EXCLUSION_UPDATED = of("intrafi_exclusion.updated") + /** Occurs whenever a Loan Application is created. */ + @JvmField val LOAN_APPLICATION_CREATED = of("loan_application.created") + + /** Occurs whenever a Loan Application is updated. */ + @JvmField val LOAN_APPLICATION_UPDATED = of("loan_application.updated") + + /** Occurs whenever a Loan Offer is created. */ + @JvmField val LOAN_OFFER_CREATED = of("loan_offer.created") + + /** Occurs whenever a Loan Offer is updated. */ + @JvmField val LOAN_OFFER_UPDATED = of("loan_offer.updated") + /** Occurs whenever a Lockbox is created. */ @JvmField val LOCKBOX_CREATED = of("lockbox.created") @@ -1482,6 +1494,14 @@ private constructor( INTRAFI_EXCLUSION_CREATED, /** Occurs whenever an IntraFi Exclusion is updated. */ INTRAFI_EXCLUSION_UPDATED, + /** Occurs whenever a Loan Application is created. */ + LOAN_APPLICATION_CREATED, + /** Occurs whenever a Loan Application is updated. */ + LOAN_APPLICATION_UPDATED, + /** Occurs whenever a Loan Offer is created. */ + LOAN_OFFER_CREATED, + /** Occurs whenever a Loan Offer is updated. */ + LOAN_OFFER_UPDATED, /** Occurs whenever a Lockbox is created. */ LOCKBOX_CREATED, /** Occurs whenever a Lockbox is updated. */ @@ -1729,6 +1749,14 @@ private constructor( INTRAFI_EXCLUSION_CREATED, /** Occurs whenever an IntraFi Exclusion is updated. */ INTRAFI_EXCLUSION_UPDATED, + /** Occurs whenever a Loan Application is created. */ + LOAN_APPLICATION_CREATED, + /** Occurs whenever a Loan Application is updated. */ + LOAN_APPLICATION_UPDATED, + /** Occurs whenever a Loan Offer is created. */ + LOAN_OFFER_CREATED, + /** Occurs whenever a Loan Offer is updated. */ + LOAN_OFFER_UPDATED, /** Occurs whenever a Lockbox is created. */ LOCKBOX_CREATED, /** Occurs whenever a Lockbox is updated. */ @@ -1910,6 +1938,10 @@ private constructor( INTRAFI_ACCOUNT_ENROLLMENT_UPDATED -> Value.INTRAFI_ACCOUNT_ENROLLMENT_UPDATED INTRAFI_EXCLUSION_CREATED -> Value.INTRAFI_EXCLUSION_CREATED INTRAFI_EXCLUSION_UPDATED -> Value.INTRAFI_EXCLUSION_UPDATED + LOAN_APPLICATION_CREATED -> Value.LOAN_APPLICATION_CREATED + LOAN_APPLICATION_UPDATED -> Value.LOAN_APPLICATION_UPDATED + LOAN_OFFER_CREATED -> Value.LOAN_OFFER_CREATED + LOAN_OFFER_UPDATED -> Value.LOAN_OFFER_UPDATED LOCKBOX_CREATED -> Value.LOCKBOX_CREATED LOCKBOX_UPDATED -> Value.LOCKBOX_UPDATED OAUTH_CONNECTION_CREATED -> Value.OAUTH_CONNECTION_CREATED @@ -2044,6 +2076,10 @@ private constructor( INTRAFI_ACCOUNT_ENROLLMENT_UPDATED -> Known.INTRAFI_ACCOUNT_ENROLLMENT_UPDATED INTRAFI_EXCLUSION_CREATED -> Known.INTRAFI_EXCLUSION_CREATED INTRAFI_EXCLUSION_UPDATED -> Known.INTRAFI_EXCLUSION_UPDATED + LOAN_APPLICATION_CREATED -> Known.LOAN_APPLICATION_CREATED + LOAN_APPLICATION_UPDATED -> Known.LOAN_APPLICATION_UPDATED + LOAN_OFFER_CREATED -> Known.LOAN_OFFER_CREATED + LOAN_OFFER_UPDATED -> Known.LOAN_OFFER_UPDATED LOCKBOX_CREATED -> Known.LOCKBOX_CREATED LOCKBOX_UPDATED -> Known.LOCKBOX_UPDATED OAUTH_CONNECTION_CREATED -> Known.OAUTH_CONNECTION_CREATED 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 0eb13414c..e192c2c14 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 @@ -3918,6 +3918,8 @@ private constructor( private constructor( private val after: JsonField, private val before: JsonField, + private val onOrAfter: JsonField, + private val onOrBefore: JsonField, private val additionalProperties: MutableMap, ) { @@ -3929,7 +3931,13 @@ private constructor( @JsonProperty("before") @ExcludeMissing before: JsonField = JsonMissing.of(), - ) : this(after, before, mutableMapOf()) + @JsonProperty("on_or_after") + @ExcludeMissing + onOrAfter: JsonField = JsonMissing.of(), + @JsonProperty("on_or_before") + @ExcludeMissing + onOrBefore: JsonField = JsonMissing.of(), + ) : this(after, before, onOrAfter, onOrBefore, mutableMapOf()) /** * Filter fees created after this time. @@ -3947,6 +3955,22 @@ private constructor( */ fun before(): Optional = before.getOptional("before") + /** + * Filter fees created on or after this time. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. + * if the server responded with an unexpected value). + */ + fun onOrAfter(): Optional = onOrAfter.getOptional("on_or_after") + + /** + * Filter fees created on or before this time. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. + * if the server responded with an unexpected value). + */ + fun onOrBefore(): Optional = onOrBefore.getOptional("on_or_before") + /** * Returns the raw JSON value of [after]. * @@ -3963,6 +3987,26 @@ private constructor( @ExcludeMissing fun _before(): JsonField = before + /** + * Returns the raw JSON value of [onOrAfter]. + * + * Unlike [onOrAfter], this method doesn't throw if the JSON field has an unexpected + * type. + */ + @JsonProperty("on_or_after") + @ExcludeMissing + fun _onOrAfter(): JsonField = onOrAfter + + /** + * Returns the raw JSON value of [onOrBefore]. + * + * Unlike [onOrBefore], this method doesn't throw if the JSON field has an unexpected + * type. + */ + @JsonProperty("on_or_before") + @ExcludeMissing + fun _onOrBefore(): JsonField = onOrBefore + @JsonAnySetter private fun putAdditionalProperty(key: String, value: JsonValue) { additionalProperties.put(key, value) @@ -3984,6 +4028,8 @@ private constructor( * ```java * .after() * .before() + * .onOrAfter() + * .onOrBefore() * ``` */ @JvmStatic fun builder() = Builder() @@ -3994,12 +4040,16 @@ private constructor( private var after: JsonField? = null private var before: JsonField? = null + private var onOrAfter: JsonField? = null + private var onOrBefore: JsonField? = null private var additionalProperties: MutableMap = mutableMapOf() @JvmSynthetic internal fun from(createdAt: CreatedAt) = apply { after = createdAt.after before = createdAt.before + onOrAfter = createdAt.onOrAfter + onOrBefore = createdAt.onOrBefore additionalProperties = createdAt.additionalProperties.toMutableMap() } @@ -4033,6 +4083,44 @@ private constructor( */ fun before(before: JsonField) = apply { this.before = before } + /** Filter fees created on or after this time. */ + fun onOrAfter(onOrAfter: OffsetDateTime?) = + onOrAfter(JsonField.ofNullable(onOrAfter)) + + /** Alias for calling [Builder.onOrAfter] with `onOrAfter.orElse(null)`. */ + fun onOrAfter(onOrAfter: Optional) = + onOrAfter(onOrAfter.getOrNull()) + + /** + * Sets [Builder.onOrAfter] to an arbitrary JSON value. + * + * You should usually call [Builder.onOrAfter] with a well-typed [OffsetDateTime] + * value instead. This method is primarily for setting the field to an undocumented + * or not yet supported value. + */ + fun onOrAfter(onOrAfter: JsonField) = apply { + this.onOrAfter = onOrAfter + } + + /** Filter fees created on or before this time. */ + fun onOrBefore(onOrBefore: OffsetDateTime?) = + onOrBefore(JsonField.ofNullable(onOrBefore)) + + /** Alias for calling [Builder.onOrBefore] with `onOrBefore.orElse(null)`. */ + fun onOrBefore(onOrBefore: Optional) = + onOrBefore(onOrBefore.getOrNull()) + + /** + * Sets [Builder.onOrBefore] to an arbitrary JSON value. + * + * You should usually call [Builder.onOrBefore] with a well-typed [OffsetDateTime] + * value instead. This method is primarily for setting the field to an undocumented + * or not yet supported value. + */ + fun onOrBefore(onOrBefore: JsonField) = apply { + this.onOrBefore = onOrBefore + } + fun additionalProperties(additionalProperties: Map) = apply { this.additionalProperties.clear() putAllAdditionalProperties(additionalProperties) @@ -4064,6 +4152,8 @@ private constructor( * ```java * .after() * .before() + * .onOrAfter() + * .onOrBefore() * ``` * * @throws IllegalStateException if any required field is unset. @@ -4072,6 +4162,8 @@ private constructor( CreatedAt( checkRequired("after", after), checkRequired("before", before), + checkRequired("onOrAfter", onOrAfter), + checkRequired("onOrBefore", onOrBefore), additionalProperties.toMutableMap(), ) } @@ -4095,6 +4187,8 @@ private constructor( after() before() + onOrAfter() + onOrBefore() validated = true } @@ -4115,7 +4209,9 @@ private constructor( @JvmSynthetic internal fun validity(): Int = (if (after.asKnown().isPresent) 1 else 0) + - (if (before.asKnown().isPresent) 1 else 0) + (if (before.asKnown().isPresent) 1 else 0) + + (if (onOrAfter.asKnown().isPresent) 1 else 0) + + (if (onOrBefore.asKnown().isPresent) 1 else 0) override fun equals(other: Any?): Boolean { if (this === other) { @@ -4125,15 +4221,19 @@ private constructor( return other is CreatedAt && after == other.after && before == other.before && + onOrAfter == other.onOrAfter && + onOrBefore == other.onOrBefore && additionalProperties == other.additionalProperties } - private val hashCode: Int by lazy { Objects.hash(after, before, additionalProperties) } + private val hashCode: Int by lazy { + Objects.hash(after, before, onOrAfter, onOrBefore, additionalProperties) + } override fun hashCode(): Int = hashCode override fun toString() = - "CreatedAt{after=$after, before=$before, additionalProperties=$additionalProperties}" + "CreatedAt{after=$after, before=$before, onOrAfter=$onOrAfter, onOrBefore=$onOrBefore, additionalProperties=$additionalProperties}" } override fun equals(other: Any?): Boolean { 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 b25bf0b41..54bd99f95 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 @@ -94,6 +94,14 @@ private constructor( */ fun entityCsv(): Optional = body.entityCsv() + /** + * Options for the created export. Required if `category` is equal to `fee_csv`. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun feeCsv(): Optional = body.feeCsv() + /** * Options for the created export. Required if `category` is equal to `funding_instructions`. * @@ -183,6 +191,13 @@ private constructor( */ fun _entityCsv(): JsonField = body._entityCsv() + /** + * Returns the raw JSON value of [feeCsv]. + * + * Unlike [feeCsv], this method doesn't throw if the JSON field has an unexpected type. + */ + fun _feeCsv(): JsonField = body._feeCsv() + /** * Returns the raw JSON value of [fundingInstructions]. * @@ -384,6 +399,17 @@ private constructor( */ fun entityCsv(entityCsv: JsonField) = apply { body.entityCsv(entityCsv) } + /** Options for the created export. Required if `category` is equal to `fee_csv`. */ + fun feeCsv(feeCsv: FeeCsv) = apply { body.feeCsv(feeCsv) } + + /** + * Sets [Builder.feeCsv] to an arbitrary JSON value. + * + * You should usually call [Builder.feeCsv] with a well-typed [FeeCsv] value instead. This + * method is primarily for setting the field to an undocumented or not yet supported value. + */ + fun feeCsv(feeCsv: JsonField) = apply { body.feeCsv(feeCsv) } + /** * Options for the created export. Required if `category` is equal to * `funding_instructions`. @@ -598,6 +624,7 @@ private constructor( private val bookkeepingAccountBalanceCsv: JsonField, private val dailyAccountBalanceCsv: JsonField, private val entityCsv: JsonField, + private val feeCsv: JsonField, private val fundingInstructions: JsonField, private val transactionCsv: JsonField, private val vendorCsv: JsonField, @@ -629,6 +656,7 @@ private constructor( @JsonProperty("entity_csv") @ExcludeMissing entityCsv: JsonField = JsonMissing.of(), + @JsonProperty("fee_csv") @ExcludeMissing feeCsv: JsonField = JsonMissing.of(), @JsonProperty("funding_instructions") @ExcludeMissing fundingInstructions: JsonField = JsonMissing.of(), @@ -649,6 +677,7 @@ private constructor( bookkeepingAccountBalanceCsv, dailyAccountBalanceCsv, entityCsv, + feeCsv, fundingInstructions, transactionCsv, vendorCsv, @@ -722,6 +751,14 @@ private constructor( */ fun entityCsv(): Optional = entityCsv.getOptional("entity_csv") + /** + * Options for the created export. Required if `category` is equal to `fee_csv`. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if + * the server responded with an unexpected value). + */ + fun feeCsv(): Optional = feeCsv.getOptional("fee_csv") + /** * Options for the created export. Required if `category` is equal to * `funding_instructions`. @@ -825,6 +862,13 @@ private constructor( @ExcludeMissing fun _entityCsv(): JsonField = entityCsv + /** + * Returns the raw JSON value of [feeCsv]. + * + * Unlike [feeCsv], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("fee_csv") @ExcludeMissing fun _feeCsv(): JsonField = feeCsv + /** * Returns the raw JSON value of [fundingInstructions]. * @@ -900,6 +944,7 @@ private constructor( JsonMissing.of() private var dailyAccountBalanceCsv: JsonField = JsonMissing.of() private var entityCsv: JsonField = JsonMissing.of() + private var feeCsv: JsonField = JsonMissing.of() private var fundingInstructions: JsonField = JsonMissing.of() private var transactionCsv: JsonField = JsonMissing.of() private var vendorCsv: JsonField = JsonMissing.of() @@ -915,6 +960,7 @@ private constructor( bookkeepingAccountBalanceCsv = body.bookkeepingAccountBalanceCsv dailyAccountBalanceCsv = body.dailyAccountBalanceCsv entityCsv = body.entityCsv + feeCsv = body.feeCsv fundingInstructions = body.fundingInstructions transactionCsv = body.transactionCsv vendorCsv = body.vendorCsv @@ -1039,6 +1085,18 @@ private constructor( */ fun entityCsv(entityCsv: JsonField) = apply { this.entityCsv = entityCsv } + /** Options for the created export. Required if `category` is equal to `fee_csv`. */ + fun feeCsv(feeCsv: FeeCsv) = feeCsv(JsonField.of(feeCsv)) + + /** + * Sets [Builder.feeCsv] to an arbitrary JSON value. + * + * You should usually call [Builder.feeCsv] with a well-typed [FeeCsv] value instead. + * This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun feeCsv(feeCsv: JsonField) = apply { this.feeCsv = feeCsv } + /** * Options for the created export. Required if `category` is equal to * `funding_instructions`. @@ -1142,6 +1200,7 @@ private constructor( bookkeepingAccountBalanceCsv, dailyAccountBalanceCsv, entityCsv, + feeCsv, fundingInstructions, transactionCsv, vendorCsv, @@ -1173,6 +1232,7 @@ private constructor( bookkeepingAccountBalanceCsv().ifPresent { it.validate() } dailyAccountBalanceCsv().ifPresent { it.validate() } entityCsv().ifPresent { it.validate() } + feeCsv().ifPresent { it.validate() } fundingInstructions().ifPresent { it.validate() } transactionCsv().ifPresent { it.validate() } vendorCsv().ifPresent { it.validate() } @@ -1203,6 +1263,7 @@ private constructor( (bookkeepingAccountBalanceCsv.asKnown().getOrNull()?.validity() ?: 0) + (dailyAccountBalanceCsv.asKnown().getOrNull()?.validity() ?: 0) + (entityCsv.asKnown().getOrNull()?.validity() ?: 0) + + (feeCsv.asKnown().getOrNull()?.validity() ?: 0) + (fundingInstructions.asKnown().getOrNull()?.validity() ?: 0) + (transactionCsv.asKnown().getOrNull()?.validity() ?: 0) + (vendorCsv.asKnown().getOrNull()?.validity() ?: 0) + @@ -1221,6 +1282,7 @@ private constructor( bookkeepingAccountBalanceCsv == other.bookkeepingAccountBalanceCsv && dailyAccountBalanceCsv == other.dailyAccountBalanceCsv && entityCsv == other.entityCsv && + feeCsv == other.feeCsv && fundingInstructions == other.fundingInstructions && transactionCsv == other.transactionCsv && vendorCsv == other.vendorCsv && @@ -1237,6 +1299,7 @@ private constructor( bookkeepingAccountBalanceCsv, dailyAccountBalanceCsv, entityCsv, + feeCsv, fundingInstructions, transactionCsv, vendorCsv, @@ -1248,7 +1311,7 @@ private constructor( override fun hashCode(): Int = hashCode override fun toString() = - "Body{category=$category, accountStatementBai2=$accountStatementBai2, accountStatementOfx=$accountStatementOfx, accountVerificationLetter=$accountVerificationLetter, bookkeepingAccountBalanceCsv=$bookkeepingAccountBalanceCsv, dailyAccountBalanceCsv=$dailyAccountBalanceCsv, entityCsv=$entityCsv, fundingInstructions=$fundingInstructions, transactionCsv=$transactionCsv, vendorCsv=$vendorCsv, voidedCheck=$voidedCheck, additionalProperties=$additionalProperties}" + "Body{category=$category, accountStatementBai2=$accountStatementBai2, accountStatementOfx=$accountStatementOfx, accountVerificationLetter=$accountVerificationLetter, bookkeepingAccountBalanceCsv=$bookkeepingAccountBalanceCsv, dailyAccountBalanceCsv=$dailyAccountBalanceCsv, entityCsv=$entityCsv, feeCsv=$feeCsv, fundingInstructions=$fundingInstructions, transactionCsv=$transactionCsv, vendorCsv=$vendorCsv, voidedCheck=$voidedCheck, additionalProperties=$additionalProperties}" } /** The type of Export to create. */ @@ -1302,6 +1365,12 @@ private constructor( /** A PDF of funding instructions. */ @JvmField val FUNDING_INSTRUCTIONS = of("funding_instructions") + /** + * Export a CSV of fees. The time range must not include any fees that are part of an + * open fee statement. + */ + @JvmField val FEE_CSV = of("fee_csv") + /** A PDF of a voided check. */ @JvmField val VOIDED_CHECK = of("voided_check") @@ -1343,6 +1412,11 @@ private constructor( ACCOUNT_VERIFICATION_LETTER, /** A PDF of funding instructions. */ FUNDING_INSTRUCTIONS, + /** + * Export a CSV of fees. The time range must not include any fees that are part of an + * open fee statement. + */ + FEE_CSV, /** A PDF of a voided check. */ VOIDED_CHECK, /** @@ -1389,6 +1463,11 @@ private constructor( ACCOUNT_VERIFICATION_LETTER, /** A PDF of funding instructions. */ FUNDING_INSTRUCTIONS, + /** + * Export a CSV of fees. The time range must not include any fees that are part of an + * open fee statement. + */ + FEE_CSV, /** A PDF of a voided check. */ VOIDED_CHECK, /** @@ -1418,6 +1497,7 @@ private constructor( VENDOR_CSV -> Value.VENDOR_CSV ACCOUNT_VERIFICATION_LETTER -> Value.ACCOUNT_VERIFICATION_LETTER FUNDING_INSTRUCTIONS -> Value.FUNDING_INSTRUCTIONS + FEE_CSV -> Value.FEE_CSV VOIDED_CHECK -> Value.VOIDED_CHECK DAILY_ACCOUNT_BALANCE_CSV -> Value.DAILY_ACCOUNT_BALANCE_CSV else -> Value._UNKNOWN @@ -1443,6 +1523,7 @@ private constructor( VENDOR_CSV -> Known.VENDOR_CSV ACCOUNT_VERIFICATION_LETTER -> Known.ACCOUNT_VERIFICATION_LETTER FUNDING_INSTRUCTIONS -> Known.FUNDING_INSTRUCTIONS + FEE_CSV -> Known.FEE_CSV VOIDED_CHECK -> Known.VOIDED_CHECK DAILY_ACCOUNT_BALANCE_CSV -> Known.DAILY_ACCOUNT_BALANCE_CSV else -> throw IncreaseInvalidDataException("Unknown Category: $value") @@ -3039,6 +3120,505 @@ private constructor( override fun toString() = "EntityCsv{additionalProperties=$additionalProperties}" } + /** Options for the created export. Required if `category` is equal to `fee_csv`. */ + class FeeCsv + @JsonCreator(mode = JsonCreator.Mode.DISABLED) + private constructor( + private val createdAt: JsonField, + private val programId: JsonField, + private val additionalProperties: MutableMap, + ) { + + @JsonCreator + private constructor( + @JsonProperty("created_at") + @ExcludeMissing + createdAt: JsonField = JsonMissing.of(), + @JsonProperty("program_id") + @ExcludeMissing + programId: JsonField = JsonMissing.of(), + ) : this(createdAt, programId, mutableMapOf()) + + /** + * Filter results by time range on the `created_at` attribute. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if + * the server responded with an unexpected value). + */ + fun createdAt(): Optional = createdAt.getOptional("created_at") + + /** + * Filter exported Fees to the specified Program. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if + * the server responded with an unexpected value). + */ + fun programId(): Optional = programId.getOptional("program_id") + + /** + * Returns the raw JSON value of [createdAt]. + * + * Unlike [createdAt], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("created_at") + @ExcludeMissing + fun _createdAt(): JsonField = createdAt + + /** + * Returns the raw JSON value of [programId]. + * + * Unlike [programId], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("program_id") @ExcludeMissing fun _programId(): JsonField = programId + + @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 [FeeCsv]. */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [FeeCsv]. */ + class Builder internal constructor() { + + private var createdAt: JsonField = JsonMissing.of() + private var programId: JsonField = JsonMissing.of() + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(feeCsv: FeeCsv) = apply { + createdAt = feeCsv.createdAt + programId = feeCsv.programId + additionalProperties = feeCsv.additionalProperties.toMutableMap() + } + + /** Filter results by time range on the `created_at` attribute. */ + fun createdAt(createdAt: CreatedAt) = createdAt(JsonField.of(createdAt)) + + /** + * Sets [Builder.createdAt] to an arbitrary JSON value. + * + * You should usually call [Builder.createdAt] with a well-typed [CreatedAt] value + * instead. This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun createdAt(createdAt: JsonField) = apply { this.createdAt = createdAt } + + /** Filter exported Fees to the specified Program. */ + fun programId(programId: String) = programId(JsonField.of(programId)) + + /** + * Sets [Builder.programId] to an arbitrary JSON value. + * + * You should usually call [Builder.programId] with a well-typed [String] value instead. + * This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun programId(programId: JsonField) = apply { this.programId = programId } + + 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 [FeeCsv]. + * + * Further updates to this [Builder] will not mutate the returned instance. + */ + fun build(): FeeCsv = FeeCsv(createdAt, programId, additionalProperties.toMutableMap()) + } + + private var validated: Boolean = false + + /** + * Validates that the types of all values in this object match their expected types + * recursively. + * + * This method is _not_ forwards compatible with new types from the API for existing fields. + * + * @throws IncreaseInvalidDataException if any value type in this object doesn't match its + * expected type. + */ + fun validate(): FeeCsv = apply { + if (validated) { + return@apply + } + + createdAt().ifPresent { it.validate() } + programId() + 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 = + (createdAt.asKnown().getOrNull()?.validity() ?: 0) + + (if (programId.asKnown().isPresent) 1 else 0) + + /** Filter results by time range on the `created_at` attribute. */ + class CreatedAt + @JsonCreator(mode = JsonCreator.Mode.DISABLED) + private constructor( + private val after: JsonField, + private val before: JsonField, + private val onOrAfter: JsonField, + private val onOrBefore: JsonField, + private val additionalProperties: MutableMap, + ) { + + @JsonCreator + private constructor( + @JsonProperty("after") + @ExcludeMissing + after: JsonField = JsonMissing.of(), + @JsonProperty("before") + @ExcludeMissing + before: JsonField = JsonMissing.of(), + @JsonProperty("on_or_after") + @ExcludeMissing + onOrAfter: JsonField = JsonMissing.of(), + @JsonProperty("on_or_before") + @ExcludeMissing + onOrBefore: JsonField = JsonMissing.of(), + ) : this(after, before, onOrAfter, onOrBefore, mutableMapOf()) + + /** + * Return results after this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) + * timestamp. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. + * if the server responded with an unexpected value). + */ + fun after(): Optional = after.getOptional("after") + + /** + * Return results before this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) + * timestamp. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. + * if the server responded with an unexpected value). + */ + fun before(): Optional = before.getOptional("before") + + /** + * Return results on or after this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) + * timestamp. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. + * if the server responded with an unexpected value). + */ + fun onOrAfter(): Optional = onOrAfter.getOptional("on_or_after") + + /** + * Return results on or before this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) + * timestamp. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. + * if the server responded with an unexpected value). + */ + fun onOrBefore(): Optional = onOrBefore.getOptional("on_or_before") + + /** + * Returns the raw JSON value of [after]. + * + * Unlike [after], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("after") @ExcludeMissing fun _after(): JsonField = after + + /** + * Returns the raw JSON value of [before]. + * + * Unlike [before], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("before") + @ExcludeMissing + fun _before(): JsonField = before + + /** + * Returns the raw JSON value of [onOrAfter]. + * + * Unlike [onOrAfter], this method doesn't throw if the JSON field has an unexpected + * type. + */ + @JsonProperty("on_or_after") + @ExcludeMissing + fun _onOrAfter(): JsonField = onOrAfter + + /** + * Returns the raw JSON value of [onOrBefore]. + * + * Unlike [onOrBefore], this method doesn't throw if the JSON field has an unexpected + * type. + */ + @JsonProperty("on_or_before") + @ExcludeMissing + fun _onOrBefore(): JsonField = onOrBefore + + @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 [CreatedAt]. */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [CreatedAt]. */ + class Builder internal constructor() { + + private var after: JsonField = JsonMissing.of() + private var before: JsonField = JsonMissing.of() + private var onOrAfter: JsonField = JsonMissing.of() + private var onOrBefore: JsonField = JsonMissing.of() + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(createdAt: CreatedAt) = apply { + after = createdAt.after + before = createdAt.before + onOrAfter = createdAt.onOrAfter + onOrBefore = createdAt.onOrBefore + additionalProperties = createdAt.additionalProperties.toMutableMap() + } + + /** + * Return results after this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) + * timestamp. + */ + fun after(after: OffsetDateTime) = after(JsonField.of(after)) + + /** + * Sets [Builder.after] to an arbitrary JSON value. + * + * You should usually call [Builder.after] with a well-typed [OffsetDateTime] value + * instead. This method is primarily for setting the field to an undocumented or not + * yet supported value. + */ + fun after(after: JsonField) = apply { this.after = after } + + /** + * Return results before this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) + * timestamp. + */ + fun before(before: OffsetDateTime) = before(JsonField.of(before)) + + /** + * Sets [Builder.before] to an arbitrary JSON value. + * + * You should usually call [Builder.before] with a well-typed [OffsetDateTime] value + * instead. This method is primarily for setting the field to an undocumented or not + * yet supported value. + */ + fun before(before: JsonField) = apply { this.before = before } + + /** + * Return results on or after this + * [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) timestamp. + */ + fun onOrAfter(onOrAfter: OffsetDateTime) = onOrAfter(JsonField.of(onOrAfter)) + + /** + * Sets [Builder.onOrAfter] to an arbitrary JSON value. + * + * You should usually call [Builder.onOrAfter] with a well-typed [OffsetDateTime] + * value instead. This method is primarily for setting the field to an undocumented + * or not yet supported value. + */ + fun onOrAfter(onOrAfter: JsonField) = apply { + this.onOrAfter = onOrAfter + } + + /** + * Return results on or before this + * [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) timestamp. + */ + fun onOrBefore(onOrBefore: OffsetDateTime) = onOrBefore(JsonField.of(onOrBefore)) + + /** + * Sets [Builder.onOrBefore] to an arbitrary JSON value. + * + * You should usually call [Builder.onOrBefore] with a well-typed [OffsetDateTime] + * value instead. This method is primarily for setting the field to an undocumented + * or not yet supported value. + */ + fun onOrBefore(onOrBefore: JsonField) = apply { + this.onOrBefore = onOrBefore + } + + 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 [CreatedAt]. + * + * Further updates to this [Builder] will not mutate the returned instance. + */ + fun build(): CreatedAt = + CreatedAt( + after, + before, + onOrAfter, + onOrBefore, + additionalProperties.toMutableMap(), + ) + } + + private var validated: Boolean = false + + /** + * Validates that the types of all values in this object match their expected types + * recursively. + * + * This method is _not_ forwards compatible with new types from the API for existing + * fields. + * + * @throws IncreaseInvalidDataException if any value type in this object doesn't match + * its expected type. + */ + fun validate(): CreatedAt = apply { + if (validated) { + return@apply + } + + after() + before() + onOrAfter() + onOrBefore() + 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 (after.asKnown().isPresent) 1 else 0) + + (if (before.asKnown().isPresent) 1 else 0) + + (if (onOrAfter.asKnown().isPresent) 1 else 0) + + (if (onOrBefore.asKnown().isPresent) 1 else 0) + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is CreatedAt && + after == other.after && + before == other.before && + onOrAfter == other.onOrAfter && + onOrBefore == other.onOrBefore && + additionalProperties == other.additionalProperties + } + + private val hashCode: Int by lazy { + Objects.hash(after, before, onOrAfter, onOrBefore, additionalProperties) + } + + override fun hashCode(): Int = hashCode + + override fun toString() = + "CreatedAt{after=$after, before=$before, onOrAfter=$onOrAfter, onOrBefore=$onOrBefore, additionalProperties=$additionalProperties}" + } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is FeeCsv && + createdAt == other.createdAt && + programId == other.programId && + additionalProperties == other.additionalProperties + } + + private val hashCode: Int by lazy { + Objects.hash(createdAt, programId, additionalProperties) + } + + override fun hashCode(): Int = hashCode + + override fun toString() = + "FeeCsv{createdAt=$createdAt, programId=$programId, additionalProperties=$additionalProperties}" + } + /** * Options for the created export. Required if `category` is equal to `funding_instructions`. */ diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/fednowtransfers/FednowTransfer.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/fednowtransfers/FednowTransfer.kt index 81ee4dbfd..71042f8ec 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/fednowtransfers/FednowTransfer.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/fednowtransfers/FednowTransfer.kt @@ -36,6 +36,7 @@ private constructor( private val creditorAddress: JsonField, private val creditorName: JsonField, private val currency: JsonField, + private val debtorAddress: JsonField, private val debtorName: JsonField, private val externalAccountId: JsonField, private val idempotencyKey: JsonField, @@ -76,6 +77,9 @@ private constructor( @ExcludeMissing creditorName: JsonField = JsonMissing.of(), @JsonProperty("currency") @ExcludeMissing currency: JsonField = JsonMissing.of(), + @JsonProperty("debtor_address") + @ExcludeMissing + debtorAddress: JsonField = JsonMissing.of(), @JsonProperty("debtor_name") @ExcludeMissing debtorName: JsonField = JsonMissing.of(), @@ -122,6 +126,7 @@ private constructor( creditorAddress, creditorName, currency, + debtorAddress, debtorName, externalAccountId, idempotencyKey, @@ -223,6 +228,14 @@ private constructor( */ fun currency(): Currency = currency.getRequired("currency") + /** + * The debtor's address. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun debtorAddress(): Optional = debtorAddress.getOptional("debtor_address") + /** * The name of the transfer's sender. If not provided, defaults to the name of the account's * entity. @@ -418,6 +431,15 @@ private constructor( */ @JsonProperty("currency") @ExcludeMissing fun _currency(): JsonField = currency + /** + * Returns the raw JSON value of [debtorAddress]. + * + * Unlike [debtorAddress], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("debtor_address") + @ExcludeMissing + fun _debtorAddress(): JsonField = debtorAddress + /** * Returns the raw JSON value of [debtorName]. * @@ -562,6 +584,7 @@ private constructor( * .creditorAddress() * .creditorName() * .currency() + * .debtorAddress() * .debtorName() * .externalAccountId() * .idempotencyKey() @@ -593,6 +616,7 @@ private constructor( private var creditorAddress: JsonField? = null private var creditorName: JsonField? = null private var currency: JsonField? = null + private var debtorAddress: JsonField? = null private var debtorName: JsonField? = null private var externalAccountId: JsonField? = null private var idempotencyKey: JsonField? = null @@ -620,6 +644,7 @@ private constructor( creditorAddress = fednowTransfer.creditorAddress creditorName = fednowTransfer.creditorName currency = fednowTransfer.currency + debtorAddress = fednowTransfer.debtorAddress debtorName = fednowTransfer.debtorName externalAccountId = fednowTransfer.externalAccountId idempotencyKey = fednowTransfer.idempotencyKey @@ -787,6 +812,25 @@ private constructor( */ fun currency(currency: JsonField) = apply { this.currency = currency } + /** The debtor's address. */ + fun debtorAddress(debtorAddress: DebtorAddress?) = + debtorAddress(JsonField.ofNullable(debtorAddress)) + + /** Alias for calling [Builder.debtorAddress] with `debtorAddress.orElse(null)`. */ + fun debtorAddress(debtorAddress: Optional) = + debtorAddress(debtorAddress.getOrNull()) + + /** + * Sets [Builder.debtorAddress] to an arbitrary JSON value. + * + * You should usually call [Builder.debtorAddress] with a well-typed [DebtorAddress] value + * instead. This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun debtorAddress(debtorAddress: JsonField) = apply { + this.debtorAddress = debtorAddress + } + /** * The name of the transfer's sender. If not provided, defaults to the name of the account's * entity. @@ -1042,6 +1086,7 @@ private constructor( * .creditorAddress() * .creditorName() * .currency() + * .debtorAddress() * .debtorName() * .externalAccountId() * .idempotencyKey() @@ -1071,6 +1116,7 @@ private constructor( checkRequired("creditorAddress", creditorAddress), checkRequired("creditorName", creditorName), checkRequired("currency", currency), + checkRequired("debtorAddress", debtorAddress), checkRequired("debtorName", debtorName), checkRequired("externalAccountId", externalAccountId), checkRequired("idempotencyKey", idempotencyKey), @@ -1119,6 +1165,7 @@ private constructor( creditorAddress().ifPresent { it.validate() } creditorName() currency().validate() + debtorAddress().ifPresent { it.validate() } debtorName() externalAccountId() idempotencyKey() @@ -1160,6 +1207,7 @@ private constructor( (creditorAddress.asKnown().getOrNull()?.validity() ?: 0) + (if (creditorName.asKnown().isPresent) 1 else 0) + (currency.asKnown().getOrNull()?.validity() ?: 0) + + (debtorAddress.asKnown().getOrNull()?.validity() ?: 0) + (if (debtorName.asKnown().isPresent) 1 else 0) + (if (externalAccountId.asKnown().isPresent) 1 else 0) + (if (idempotencyKey.asKnown().isPresent) 1 else 0) + @@ -2789,6 +2837,306 @@ private constructor( override fun toString() = value.toString() } + /** The debtor's address. */ + class DebtorAddress + @JsonCreator(mode = JsonCreator.Mode.DISABLED) + private constructor( + private val city: JsonField, + private val line1: JsonField, + private val postalCode: JsonField, + private val state: JsonField, + private val additionalProperties: MutableMap, + ) { + + @JsonCreator + private constructor( + @JsonProperty("city") @ExcludeMissing city: JsonField = JsonMissing.of(), + @JsonProperty("line1") @ExcludeMissing line1: JsonField = JsonMissing.of(), + @JsonProperty("postal_code") + @ExcludeMissing + postalCode: JsonField = JsonMissing.of(), + @JsonProperty("state") @ExcludeMissing state: JsonField = JsonMissing.of(), + ) : this(city, line1, postalCode, state, mutableMapOf()) + + /** + * The city, district, town, or village of the address. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if + * the server responded with an unexpected value). + */ + fun city(): Optional = city.getOptional("city") + + /** + * The first line of the address. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if + * the server responded with an unexpected value). + */ + fun line1(): Optional = line1.getOptional("line1") + + /** + * The ZIP code of the address. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if + * the server responded with an unexpected value). + */ + fun postalCode(): Optional = postalCode.getOptional("postal_code") + + /** + * The address state. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if + * the server responded with an unexpected value). + */ + fun state(): Optional = state.getOptional("state") + + /** + * Returns the raw JSON value of [city]. + * + * Unlike [city], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("city") @ExcludeMissing fun _city(): JsonField = city + + /** + * Returns the raw JSON value of [line1]. + * + * Unlike [line1], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("line1") @ExcludeMissing fun _line1(): JsonField = line1 + + /** + * Returns the raw JSON value of [postalCode]. + * + * Unlike [postalCode], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("postal_code") + @ExcludeMissing + fun _postalCode(): JsonField = postalCode + + /** + * Returns the raw JSON value of [state]. + * + * Unlike [state], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("state") @ExcludeMissing fun _state(): JsonField = state + + @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 [DebtorAddress]. + * + * The following fields are required: + * ```java + * .city() + * .line1() + * .postalCode() + * .state() + * ``` + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [DebtorAddress]. */ + class Builder internal constructor() { + + private var city: JsonField? = null + private var line1: JsonField? = null + private var postalCode: JsonField? = null + private var state: JsonField? = null + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(debtorAddress: DebtorAddress) = apply { + city = debtorAddress.city + line1 = debtorAddress.line1 + postalCode = debtorAddress.postalCode + state = debtorAddress.state + additionalProperties = debtorAddress.additionalProperties.toMutableMap() + } + + /** The city, district, town, or village of the address. */ + fun city(city: String?) = city(JsonField.ofNullable(city)) + + /** Alias for calling [Builder.city] with `city.orElse(null)`. */ + fun city(city: Optional) = city(city.getOrNull()) + + /** + * Sets [Builder.city] to an arbitrary JSON value. + * + * You should usually call [Builder.city] with a well-typed [String] value instead. This + * method is primarily for setting the field to an undocumented or not yet supported + * value. + */ + fun city(city: JsonField) = apply { this.city = city } + + /** The first line of the address. */ + fun line1(line1: String?) = line1(JsonField.ofNullable(line1)) + + /** Alias for calling [Builder.line1] with `line1.orElse(null)`. */ + fun line1(line1: Optional) = line1(line1.getOrNull()) + + /** + * Sets [Builder.line1] to an arbitrary JSON value. + * + * You should usually call [Builder.line1] with a well-typed [String] value instead. + * This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun line1(line1: JsonField) = apply { this.line1 = line1 } + + /** The ZIP code of the address. */ + fun postalCode(postalCode: String?) = postalCode(JsonField.ofNullable(postalCode)) + + /** Alias for calling [Builder.postalCode] with `postalCode.orElse(null)`. */ + fun postalCode(postalCode: Optional) = postalCode(postalCode.getOrNull()) + + /** + * Sets [Builder.postalCode] to an arbitrary JSON value. + * + * You should usually call [Builder.postalCode] with a well-typed [String] value + * instead. This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun postalCode(postalCode: JsonField) = apply { this.postalCode = postalCode } + + /** The address state. */ + fun state(state: String?) = state(JsonField.ofNullable(state)) + + /** Alias for calling [Builder.state] with `state.orElse(null)`. */ + fun state(state: Optional) = state(state.getOrNull()) + + /** + * Sets [Builder.state] to an arbitrary JSON value. + * + * You should usually call [Builder.state] with a well-typed [String] value instead. + * This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun state(state: JsonField) = apply { this.state = state } + + 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 [DebtorAddress]. + * + * Further updates to this [Builder] will not mutate the returned instance. + * + * The following fields are required: + * ```java + * .city() + * .line1() + * .postalCode() + * .state() + * ``` + * + * @throws IllegalStateException if any required field is unset. + */ + fun build(): DebtorAddress = + DebtorAddress( + checkRequired("city", city), + checkRequired("line1", line1), + checkRequired("postalCode", postalCode), + checkRequired("state", state), + additionalProperties.toMutableMap(), + ) + } + + private var validated: Boolean = false + + /** + * Validates that the types of all values in this object match their expected types + * recursively. + * + * This method is _not_ forwards compatible with new types from the API for existing fields. + * + * @throws IncreaseInvalidDataException if any value type in this object doesn't match its + * expected type. + */ + fun validate(): DebtorAddress = apply { + if (validated) { + return@apply + } + + city() + line1() + postalCode() + state() + 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 (city.asKnown().isPresent) 1 else 0) + + (if (line1.asKnown().isPresent) 1 else 0) + + (if (postalCode.asKnown().isPresent) 1 else 0) + + (if (state.asKnown().isPresent) 1 else 0) + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is DebtorAddress && + city == other.city && + line1 == other.line1 && + postalCode == other.postalCode && + state == other.state && + additionalProperties == other.additionalProperties + } + + private val hashCode: Int by lazy { + Objects.hash(city, line1, postalCode, state, additionalProperties) + } + + override fun hashCode(): Int = hashCode + + override fun toString() = + "DebtorAddress{city=$city, line1=$line1, postalCode=$postalCode, state=$state, additionalProperties=$additionalProperties}" + } + /** * If the transfer is rejected by FedNow or the destination financial institution, this will * contain supplemental details. @@ -4083,6 +4431,7 @@ private constructor( creditorAddress == other.creditorAddress && creditorName == other.creditorName && currency == other.currency && + debtorAddress == other.debtorAddress && debtorName == other.debtorName && externalAccountId == other.externalAccountId && idempotencyKey == other.idempotencyKey && @@ -4111,6 +4460,7 @@ private constructor( creditorAddress, creditorName, currency, + debtorAddress, debtorName, externalAccountId, idempotencyKey, @@ -4131,5 +4481,5 @@ private constructor( override fun hashCode(): Int = hashCode override fun toString() = - "FednowTransfer{id=$id, accountId=$accountId, accountNumber=$accountNumber, acknowledgement=$acknowledgement, amount=$amount, createdAt=$createdAt, createdBy=$createdBy, creditorAddress=$creditorAddress, creditorName=$creditorName, currency=$currency, debtorName=$debtorName, externalAccountId=$externalAccountId, idempotencyKey=$idempotencyKey, pendingTransactionId=$pendingTransactionId, rejection=$rejection, routingNumber=$routingNumber, sourceAccountNumberId=$sourceAccountNumberId, status=$status, submission=$submission, transactionId=$transactionId, type=$type, uniqueEndToEndTransactionReference=$uniqueEndToEndTransactionReference, unstructuredRemittanceInformation=$unstructuredRemittanceInformation, additionalProperties=$additionalProperties}" + "FednowTransfer{id=$id, accountId=$accountId, accountNumber=$accountNumber, acknowledgement=$acknowledgement, amount=$amount, createdAt=$createdAt, createdBy=$createdBy, creditorAddress=$creditorAddress, creditorName=$creditorName, currency=$currency, debtorAddress=$debtorAddress, debtorName=$debtorName, externalAccountId=$externalAccountId, idempotencyKey=$idempotencyKey, pendingTransactionId=$pendingTransactionId, rejection=$rejection, routingNumber=$routingNumber, sourceAccountNumberId=$sourceAccountNumberId, status=$status, submission=$submission, transactionId=$transactionId, type=$type, uniqueEndToEndTransactionReference=$uniqueEndToEndTransactionReference, unstructuredRemittanceInformation=$unstructuredRemittanceInformation, additionalProperties=$additionalProperties}" } diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/inboundwiretransfers/InboundWireTransfer.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/inboundwiretransfers/InboundWireTransfer.kt index 65680820c..4fedfa277 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/inboundwiretransfers/InboundWireTransfer.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/inboundwiretransfers/InboundWireTransfer.kt @@ -42,6 +42,7 @@ private constructor( private val inputMessageAccountabilityData: JsonField, private val instructingAgentRoutingNumber: JsonField, private val instructionIdentification: JsonField, + private val purpose: JsonField, private val reversal: JsonField, private val status: JsonField, private val type: JsonField, @@ -104,6 +105,7 @@ private constructor( @JsonProperty("instruction_identification") @ExcludeMissing instructionIdentification: JsonField = JsonMissing.of(), + @JsonProperty("purpose") @ExcludeMissing purpose: JsonField = JsonMissing.of(), @JsonProperty("reversal") @ExcludeMissing reversal: JsonField = JsonMissing.of(), @JsonProperty("status") @ExcludeMissing status: JsonField = JsonMissing.of(), @JsonProperty("type") @ExcludeMissing type: JsonField = JsonMissing.of(), @@ -136,6 +138,7 @@ private constructor( inputMessageAccountabilityData, instructingAgentRoutingNumber, instructionIdentification, + purpose, reversal, status, type, @@ -310,6 +313,14 @@ private constructor( fun instructionIdentification(): Optional = instructionIdentification.getOptional("instruction_identification") + /** + * The reason for the wire transfer, as set by the sender. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun purpose(): Optional = purpose.getOptional("purpose") + /** * If the transfer is reversed, this will contain details of the reversal. * @@ -535,6 +546,13 @@ private constructor( @ExcludeMissing fun _instructionIdentification(): JsonField = instructionIdentification + /** + * Returns the raw JSON value of [purpose]. + * + * Unlike [purpose], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("purpose") @ExcludeMissing fun _purpose(): JsonField = purpose + /** * Returns the raw JSON value of [reversal]. * @@ -625,6 +643,7 @@ private constructor( * .inputMessageAccountabilityData() * .instructingAgentRoutingNumber() * .instructionIdentification() + * .purpose() * .reversal() * .status() * .type() @@ -658,6 +677,7 @@ private constructor( private var inputMessageAccountabilityData: JsonField? = null private var instructingAgentRoutingNumber: JsonField? = null private var instructionIdentification: JsonField? = null + private var purpose: JsonField? = null private var reversal: JsonField? = null private var status: JsonField? = null private var type: JsonField? = null @@ -687,6 +707,7 @@ private constructor( inputMessageAccountabilityData = inboundWireTransfer.inputMessageAccountabilityData instructingAgentRoutingNumber = inboundWireTransfer.instructingAgentRoutingNumber instructionIdentification = inboundWireTransfer.instructionIdentification + purpose = inboundWireTransfer.purpose reversal = inboundWireTransfer.reversal status = inboundWireTransfer.status type = inboundWireTransfer.type @@ -1044,6 +1065,20 @@ private constructor( this.instructionIdentification = instructionIdentification } + /** The reason for the wire transfer, as set by the sender. */ + fun purpose(purpose: String?) = purpose(JsonField.ofNullable(purpose)) + + /** Alias for calling [Builder.purpose] with `purpose.orElse(null)`. */ + fun purpose(purpose: Optional) = purpose(purpose.getOrNull()) + + /** + * Sets [Builder.purpose] to an arbitrary JSON value. + * + * You should usually call [Builder.purpose] with a well-typed [String] value instead. This + * method is primarily for setting the field to an undocumented or not yet supported value. + */ + fun purpose(purpose: JsonField) = apply { this.purpose = purpose } + /** If the transfer is reversed, this will contain details of the reversal. */ fun reversal(reversal: Reversal?) = reversal(JsonField.ofNullable(reversal)) @@ -1204,6 +1239,7 @@ private constructor( * .inputMessageAccountabilityData() * .instructingAgentRoutingNumber() * .instructionIdentification() + * .purpose() * .reversal() * .status() * .type() @@ -1235,6 +1271,7 @@ private constructor( checkRequired("inputMessageAccountabilityData", inputMessageAccountabilityData), checkRequired("instructingAgentRoutingNumber", instructingAgentRoutingNumber), checkRequired("instructionIdentification", instructionIdentification), + checkRequired("purpose", purpose), checkRequired("reversal", reversal), checkRequired("status", status), checkRequired("type", type), @@ -1285,6 +1322,7 @@ private constructor( inputMessageAccountabilityData() instructingAgentRoutingNumber() instructionIdentification() + purpose() reversal().ifPresent { it.validate() } status().validate() type().validate() @@ -1328,6 +1366,7 @@ private constructor( (if (inputMessageAccountabilityData.asKnown().isPresent) 1 else 0) + (if (instructingAgentRoutingNumber.asKnown().isPresent) 1 else 0) + (if (instructionIdentification.asKnown().isPresent) 1 else 0) + + (if (purpose.asKnown().isPresent) 1 else 0) + (reversal.asKnown().getOrNull()?.validity() ?: 0) + (status.asKnown().getOrNull()?.validity() ?: 0) + (type.asKnown().getOrNull()?.validity() ?: 0) + @@ -2270,6 +2309,7 @@ private constructor( inputMessageAccountabilityData == other.inputMessageAccountabilityData && instructingAgentRoutingNumber == other.instructingAgentRoutingNumber && instructionIdentification == other.instructionIdentification && + purpose == other.purpose && reversal == other.reversal && status == other.status && type == other.type && @@ -2300,6 +2340,7 @@ private constructor( inputMessageAccountabilityData, instructingAgentRoutingNumber, instructionIdentification, + purpose, reversal, status, type, @@ -2313,5 +2354,5 @@ private constructor( override fun hashCode(): Int = hashCode override fun toString() = - "InboundWireTransfer{id=$id, acceptance=$acceptance, accountId=$accountId, accountNumberId=$accountNumberId, amount=$amount, createdAt=$createdAt, creditorAddressLine1=$creditorAddressLine1, creditorAddressLine2=$creditorAddressLine2, creditorAddressLine3=$creditorAddressLine3, creditorName=$creditorName, debtorAddressLine1=$debtorAddressLine1, debtorAddressLine2=$debtorAddressLine2, debtorAddressLine3=$debtorAddressLine3, debtorName=$debtorName, description=$description, endToEndIdentification=$endToEndIdentification, inputMessageAccountabilityData=$inputMessageAccountabilityData, instructingAgentRoutingNumber=$instructingAgentRoutingNumber, instructionIdentification=$instructionIdentification, reversal=$reversal, status=$status, type=$type, uniqueEndToEndTransactionReference=$uniqueEndToEndTransactionReference, unstructuredRemittanceInformation=$unstructuredRemittanceInformation, wireDrawdownRequestId=$wireDrawdownRequestId, additionalProperties=$additionalProperties}" + "InboundWireTransfer{id=$id, acceptance=$acceptance, accountId=$accountId, accountNumberId=$accountNumberId, amount=$amount, createdAt=$createdAt, creditorAddressLine1=$creditorAddressLine1, creditorAddressLine2=$creditorAddressLine2, creditorAddressLine3=$creditorAddressLine3, creditorName=$creditorName, debtorAddressLine1=$debtorAddressLine1, debtorAddressLine2=$debtorAddressLine2, debtorAddressLine3=$debtorAddressLine3, debtorName=$debtorName, description=$description, endToEndIdentification=$endToEndIdentification, inputMessageAccountabilityData=$inputMessageAccountabilityData, instructingAgentRoutingNumber=$instructingAgentRoutingNumber, instructionIdentification=$instructionIdentification, purpose=$purpose, reversal=$reversal, status=$status, type=$type, uniqueEndToEndTransactionReference=$uniqueEndToEndTransactionReference, unstructuredRemittanceInformation=$unstructuredRemittanceInformation, wireDrawdownRequestId=$wireDrawdownRequestId, additionalProperties=$additionalProperties}" } diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/pendingtransactions/PendingTransaction.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/pendingtransactions/PendingTransaction.kt index 49430630f..0501c63ca 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/pendingtransactions/PendingTransaction.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/pendingtransactions/PendingTransaction.kt @@ -4452,6 +4452,7 @@ private constructor( private val digitalWalletTokenId: JsonField, private val direction: JsonField, private val expiresAt: JsonField, + private val healthcare: JsonField, private val merchantAcceptorId: JsonField, private val merchantCategoryCode: JsonField, private val merchantCity: JsonField, @@ -4500,6 +4501,9 @@ private constructor( @JsonProperty("expires_at") @ExcludeMissing expiresAt: JsonField = JsonMissing.of(), + @JsonProperty("healthcare") + @ExcludeMissing + healthcare: JsonField = JsonMissing.of(), @JsonProperty("merchant_acceptor_id") @ExcludeMissing merchantAcceptorId: JsonField = JsonMissing.of(), @@ -4568,6 +4572,7 @@ private constructor( digitalWalletTokenId, direction, expiresAt, + healthcare, merchantAcceptorId, merchantCategoryCode, merchantCity, @@ -4681,6 +4686,15 @@ private constructor( */ fun expiresAt(): OffsetDateTime = expiresAt.getRequired("expires_at") + /** + * The healthcare-related fields for this authorization. Only present for specific + * programs. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. + * if the server responded with an unexpected value). + */ + fun healthcare(): Optional = healthcare.getOptional("healthcare") + /** * The merchant identifier (commonly abbreviated as MID) of the merchant the card is * transacting with. @@ -4956,6 +4970,16 @@ private constructor( @ExcludeMissing fun _expiresAt(): JsonField = expiresAt + /** + * Returns the raw JSON value of [healthcare]. + * + * Unlike [healthcare], this method doesn't throw if the JSON field has an unexpected + * type. + */ + @JsonProperty("healthcare") + @ExcludeMissing + fun _healthcare(): JsonField = healthcare + /** * Returns the raw JSON value of [merchantAcceptorId]. * @@ -5181,6 +5205,7 @@ private constructor( * .digitalWalletTokenId() * .direction() * .expiresAt() + * .healthcare() * .merchantAcceptorId() * .merchantCategoryCode() * .merchantCity() @@ -5218,6 +5243,7 @@ private constructor( private var digitalWalletTokenId: JsonField? = null private var direction: JsonField? = null private var expiresAt: JsonField? = null + private var healthcare: JsonField? = null private var merchantAcceptorId: JsonField? = null private var merchantCategoryCode: JsonField? = null private var merchantCity: JsonField? = null @@ -5251,6 +5277,7 @@ private constructor( digitalWalletTokenId = cardAuthorization.digitalWalletTokenId direction = cardAuthorization.direction expiresAt = cardAuthorization.expiresAt + healthcare = cardAuthorization.healthcare merchantAcceptorId = cardAuthorization.merchantAcceptorId merchantCategoryCode = cardAuthorization.merchantCategoryCode merchantCity = cardAuthorization.merchantCity @@ -5424,6 +5451,28 @@ private constructor( this.expiresAt = expiresAt } + /** + * The healthcare-related fields for this authorization. Only present for specific + * programs. + */ + fun healthcare(healthcare: Healthcare?) = + healthcare(JsonField.ofNullable(healthcare)) + + /** Alias for calling [Builder.healthcare] with `healthcare.orElse(null)`. */ + fun healthcare(healthcare: Optional) = + healthcare(healthcare.getOrNull()) + + /** + * Sets [Builder.healthcare] to an arbitrary JSON value. + * + * You should usually call [Builder.healthcare] with a well-typed [Healthcare] value + * instead. This method is primarily for setting the field to an undocumented or not + * yet supported value. + */ + fun healthcare(healthcare: JsonField) = apply { + this.healthcare = healthcare + } + /** * The merchant identifier (commonly abbreviated as MID) of the merchant the card is * transacting with. @@ -5855,6 +5904,7 @@ private constructor( * .digitalWalletTokenId() * .direction() * .expiresAt() + * .healthcare() * .merchantAcceptorId() * .merchantCategoryCode() * .merchantCity() @@ -5890,6 +5940,7 @@ private constructor( checkRequired("digitalWalletTokenId", digitalWalletTokenId), checkRequired("direction", direction), checkRequired("expiresAt", expiresAt), + checkRequired("healthcare", healthcare), checkRequired("merchantAcceptorId", merchantAcceptorId), checkRequired("merchantCategoryCode", merchantCategoryCode), checkRequired("merchantCity", merchantCity), @@ -5940,6 +5991,7 @@ private constructor( digitalWalletTokenId() direction().validate() expiresAt() + healthcare().ifPresent { it.validate() } merchantAcceptorId() merchantCategoryCode() merchantCity() @@ -5988,6 +6040,7 @@ private constructor( (if (digitalWalletTokenId.asKnown().isPresent) 1 else 0) + (direction.asKnown().getOrNull()?.validity() ?: 0) + (if (expiresAt.asKnown().isPresent) 1 else 0) + + (healthcare.asKnown().getOrNull()?.validity() ?: 0) + (if (merchantAcceptorId.asKnown().isPresent) 1 else 0) + (if (merchantCategoryCode.asKnown().isPresent) 1 else 0) + (if (merchantCity.asKnown().isPresent) 1 else 0) + @@ -9493,6 +9546,387 @@ private constructor( override fun toString() = value.toString() } + /** + * The healthcare-related fields for this authorization. Only present for specific + * programs. + */ + class Healthcare + @JsonCreator(mode = JsonCreator.Mode.DISABLED) + private constructor( + private val merchantNinetyPercentEligibility: + JsonField, + private val additionalProperties: MutableMap, + ) { + + @JsonCreator + private constructor( + @JsonProperty("merchant_ninety_percent_eligibility") + @ExcludeMissing + merchantNinetyPercentEligibility: JsonField = + JsonMissing.of() + ) : this(merchantNinetyPercentEligibility, mutableMapOf()) + + /** + * The merchant's eligibility under the Internal Revenue Service's 90% Rule for + * Flexible Spending Account (FSA) and Health Savings Account (HSA) eligible + * products. The eligibility is determined based on the list of merchants maintained + * by the Special Interest Group for IIAS Standards (SIGIS). + * + * @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 merchantNinetyPercentEligibility(): MerchantNinetyPercentEligibility = + merchantNinetyPercentEligibility.getRequired( + "merchant_ninety_percent_eligibility" + ) + + /** + * Returns the raw JSON value of [merchantNinetyPercentEligibility]. + * + * Unlike [merchantNinetyPercentEligibility], this method doesn't throw if the JSON + * field has an unexpected type. + */ + @JsonProperty("merchant_ninety_percent_eligibility") + @ExcludeMissing + fun _merchantNinetyPercentEligibility(): + JsonField = merchantNinetyPercentEligibility + + @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 [Healthcare]. + * + * The following fields are required: + * ```java + * .merchantNinetyPercentEligibility() + * ``` + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [Healthcare]. */ + class Builder internal constructor() { + + private var merchantNinetyPercentEligibility: + JsonField? = + null + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(healthcare: Healthcare) = apply { + merchantNinetyPercentEligibility = + healthcare.merchantNinetyPercentEligibility + additionalProperties = healthcare.additionalProperties.toMutableMap() + } + + /** + * The merchant's eligibility under the Internal Revenue Service's 90% Rule for + * Flexible Spending Account (FSA) and Health Savings Account (HSA) eligible + * products. The eligibility is determined based on the list of merchants + * maintained by the Special Interest Group for IIAS Standards (SIGIS). + */ + fun merchantNinetyPercentEligibility( + merchantNinetyPercentEligibility: MerchantNinetyPercentEligibility + ) = + merchantNinetyPercentEligibility( + JsonField.of(merchantNinetyPercentEligibility) + ) + + /** + * Sets [Builder.merchantNinetyPercentEligibility] to an arbitrary JSON value. + * + * You should usually call [Builder.merchantNinetyPercentEligibility] with a + * well-typed [MerchantNinetyPercentEligibility] value instead. This method is + * primarily for setting the field to an undocumented or not yet supported + * value. + */ + fun merchantNinetyPercentEligibility( + merchantNinetyPercentEligibility: + JsonField + ) = apply { + this.merchantNinetyPercentEligibility = merchantNinetyPercentEligibility + } + + 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 [Healthcare]. + * + * Further updates to this [Builder] will not mutate the returned instance. + * + * The following fields are required: + * ```java + * .merchantNinetyPercentEligibility() + * ``` + * + * @throws IllegalStateException if any required field is unset. + */ + fun build(): Healthcare = + Healthcare( + checkRequired( + "merchantNinetyPercentEligibility", + merchantNinetyPercentEligibility, + ), + additionalProperties.toMutableMap(), + ) + } + + private var validated: Boolean = false + + /** + * Validates that the types of all values in this object match their expected types + * recursively. + * + * This method is _not_ forwards compatible with new types from the API for existing + * fields. + * + * @throws IncreaseInvalidDataException if any value type in this object doesn't + * match its expected type. + */ + fun validate(): Healthcare = apply { + if (validated) { + return@apply + } + + merchantNinetyPercentEligibility().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 = + (merchantNinetyPercentEligibility.asKnown().getOrNull()?.validity() ?: 0) + + /** + * The merchant's eligibility under the Internal Revenue Service's 90% Rule for + * Flexible Spending Account (FSA) and Health Savings Account (HSA) eligible + * products. The eligibility is determined based on the list of merchants maintained + * by the Special Interest Group for IIAS Standards (SIGIS). + */ + class MerchantNinetyPercentEligibility + @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 merchant is eligible for treatment under the 90% rule. */ + @JvmField val ELIGIBLE = of("eligible") + + /** The merchant is not eligible for treatment under the 90% rule. */ + @JvmField val NOT_ELIGIBLE = of("not_eligible") + + @JvmStatic + fun of(value: String) = + MerchantNinetyPercentEligibility(JsonField.of(value)) + } + + /** An enum containing [MerchantNinetyPercentEligibility]'s known values. */ + enum class Known { + /** The merchant is eligible for treatment under the 90% rule. */ + ELIGIBLE, + /** The merchant is not eligible for treatment under the 90% rule. */ + NOT_ELIGIBLE, + } + + /** + * An enum containing [MerchantNinetyPercentEligibility]'s known values, as well + * as an [_UNKNOWN] member. + * + * An instance of [MerchantNinetyPercentEligibility] 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 merchant is eligible for treatment under the 90% rule. */ + ELIGIBLE, + /** The merchant is not eligible for treatment under the 90% rule. */ + NOT_ELIGIBLE, + /** + * An enum member indicating that [MerchantNinetyPercentEligibility] 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) { + ELIGIBLE -> Value.ELIGIBLE + NOT_ELIGIBLE -> Value.NOT_ELIGIBLE + 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) { + ELIGIBLE -> Known.ELIGIBLE + NOT_ELIGIBLE -> Known.NOT_ELIGIBLE + else -> + throw IncreaseInvalidDataException( + "Unknown MerchantNinetyPercentEligibility: $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 + + /** + * Validates that the types of all values in this object match their expected + * types recursively. + * + * This method is _not_ forwards compatible with new types from the API for + * existing fields. + * + * @throws IncreaseInvalidDataException if any value type in this object doesn't + * match its expected type. + */ + fun validate(): MerchantNinetyPercentEligibility = 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 MerchantNinetyPercentEligibility && 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 Healthcare && + merchantNinetyPercentEligibility == + other.merchantNinetyPercentEligibility && + additionalProperties == other.additionalProperties + } + + private val hashCode: Int by lazy { + Objects.hash(merchantNinetyPercentEligibility, additionalProperties) + } + + override fun hashCode(): Int = hashCode + + override fun toString() = + "Healthcare{merchantNinetyPercentEligibility=$merchantNinetyPercentEligibility, additionalProperties=$additionalProperties}" + } + /** Fields specific to the `network`. */ class NetworkDetails @JsonCreator(mode = JsonCreator.Mode.DISABLED) @@ -15360,6 +15794,7 @@ private constructor( digitalWalletTokenId == other.digitalWalletTokenId && direction == other.direction && expiresAt == other.expiresAt && + healthcare == other.healthcare && merchantAcceptorId == other.merchantAcceptorId && merchantCategoryCode == other.merchantCategoryCode && merchantCity == other.merchantCity && @@ -15394,6 +15829,7 @@ private constructor( digitalWalletTokenId, direction, expiresAt, + healthcare, merchantAcceptorId, merchantCategoryCode, merchantCity, @@ -15421,7 +15857,7 @@ private constructor( override fun hashCode(): Int = hashCode override fun toString() = - "CardAuthorization{id=$id, actioner=$actioner, additionalAmounts=$additionalAmounts, amount=$amount, cardPaymentId=$cardPaymentId, currency=$currency, digitalWalletTokenId=$digitalWalletTokenId, direction=$direction, expiresAt=$expiresAt, merchantAcceptorId=$merchantAcceptorId, merchantCategoryCode=$merchantCategoryCode, merchantCity=$merchantCity, merchantCountry=$merchantCountry, merchantDescriptor=$merchantDescriptor, merchantPostalCode=$merchantPostalCode, merchantState=$merchantState, networkDetails=$networkDetails, networkIdentifiers=$networkIdentifiers, networkRiskScore=$networkRiskScore, pendingTransactionId=$pendingTransactionId, physicalCardId=$physicalCardId, presentmentAmount=$presentmentAmount, presentmentCurrency=$presentmentCurrency, processingCategory=$processingCategory, realTimeDecisionId=$realTimeDecisionId, schemeFees=$schemeFees, terminalId=$terminalId, type=$type, verification=$verification, additionalProperties=$additionalProperties}" + "CardAuthorization{id=$id, actioner=$actioner, additionalAmounts=$additionalAmounts, amount=$amount, cardPaymentId=$cardPaymentId, currency=$currency, digitalWalletTokenId=$digitalWalletTokenId, direction=$direction, expiresAt=$expiresAt, healthcare=$healthcare, merchantAcceptorId=$merchantAcceptorId, merchantCategoryCode=$merchantCategoryCode, merchantCity=$merchantCity, merchantCountry=$merchantCountry, merchantDescriptor=$merchantDescriptor, merchantPostalCode=$merchantPostalCode, merchantState=$merchantState, networkDetails=$networkDetails, networkIdentifiers=$networkIdentifiers, networkRiskScore=$networkRiskScore, pendingTransactionId=$pendingTransactionId, physicalCardId=$physicalCardId, presentmentAmount=$presentmentAmount, presentmentCurrency=$presentmentCurrency, processingCategory=$processingCategory, realTimeDecisionId=$realTimeDecisionId, schemeFees=$schemeFees, terminalId=$terminalId, type=$type, verification=$verification, additionalProperties=$additionalProperties}" } /** diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/physicalcardprofiles/PhysicalCardProfile.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/physicalcardprofiles/PhysicalCardProfile.kt index 7f6286873..7f45a0950 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/physicalcardprofiles/PhysicalCardProfile.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/physicalcardprofiles/PhysicalCardProfile.kt @@ -35,6 +35,7 @@ private constructor( private val creator: JsonField, private val description: JsonField, private val frontImageFileId: JsonField, + private val frontText: JsonField, private val idempotencyKey: JsonField, private val isDefault: JsonField, private val programId: JsonField, @@ -65,6 +66,9 @@ private constructor( @JsonProperty("front_image_file_id") @ExcludeMissing frontImageFileId: JsonField = JsonMissing.of(), + @JsonProperty("front_text") + @ExcludeMissing + frontText: JsonField = JsonMissing.of(), @JsonProperty("idempotency_key") @ExcludeMissing idempotencyKey: JsonField = JsonMissing.of(), @@ -83,6 +87,7 @@ private constructor( creator, description, frontImageFileId, + frontText, idempotencyKey, isDefault, programId, @@ -160,6 +165,15 @@ private constructor( */ fun frontImageFileId(): Optional = frontImageFileId.getOptional("front_image_file_id") + /** + * Text printed on the front of the card. Reach out to + * [support@increase.com](mailto:support@increase.com) for more information. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun frontText(): Optional = frontText.getOptional("front_text") + /** * The idempotency key you chose for this object. This value is unique across Increase and is * used to ensure that a request is only processed once. Learn more about @@ -271,6 +285,13 @@ private constructor( @ExcludeMissing fun _frontImageFileId(): JsonField = frontImageFileId + /** + * Returns the raw JSON value of [frontText]. + * + * Unlike [frontText], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("front_text") @ExcludeMissing fun _frontText(): JsonField = frontText + /** * Returns the raw JSON value of [idempotencyKey]. * @@ -335,6 +356,7 @@ private constructor( * .creator() * .description() * .frontImageFileId() + * .frontText() * .idempotencyKey() * .isDefault() * .programId() @@ -356,6 +378,7 @@ private constructor( private var creator: JsonField? = null private var description: JsonField? = null private var frontImageFileId: JsonField? = null + private var frontText: JsonField? = null private var idempotencyKey: JsonField? = null private var isDefault: JsonField? = null private var programId: JsonField? = null @@ -373,6 +396,7 @@ private constructor( creator = physicalCardProfile.creator description = physicalCardProfile.description frontImageFileId = physicalCardProfile.frontImageFileId + frontText = physicalCardProfile.frontText idempotencyKey = physicalCardProfile.idempotencyKey isDefault = physicalCardProfile.isDefault programId = physicalCardProfile.programId @@ -515,6 +539,24 @@ private constructor( this.frontImageFileId = frontImageFileId } + /** + * Text printed on the front of the card. Reach out to + * [support@increase.com](mailto:support@increase.com) for more information. + */ + fun frontText(frontText: FrontText?) = frontText(JsonField.ofNullable(frontText)) + + /** Alias for calling [Builder.frontText] with `frontText.orElse(null)`. */ + fun frontText(frontText: Optional) = frontText(frontText.getOrNull()) + + /** + * Sets [Builder.frontText] to an arbitrary JSON value. + * + * You should usually call [Builder.frontText] with a well-typed [FrontText] value instead. + * This method is primarily for setting the field to an undocumented or not yet supported + * value. + */ + fun frontText(frontText: JsonField) = apply { this.frontText = frontText } + /** * The idempotency key you chose for this object. This value is unique across Increase and * is used to ensure that a request is only processed once. Learn more about @@ -623,6 +665,7 @@ private constructor( * .creator() * .description() * .frontImageFileId() + * .frontText() * .idempotencyKey() * .isDefault() * .programId() @@ -642,6 +685,7 @@ private constructor( checkRequired("creator", creator), checkRequired("description", description), checkRequired("frontImageFileId", frontImageFileId), + checkRequired("frontText", frontText), checkRequired("idempotencyKey", idempotencyKey), checkRequired("isDefault", isDefault), checkRequired("programId", programId), @@ -674,6 +718,7 @@ private constructor( creator().validate() description() frontImageFileId() + frontText().ifPresent { it.validate() } idempotencyKey() isDefault() programId() @@ -705,6 +750,7 @@ private constructor( (creator.asKnown().getOrNull()?.validity() ?: 0) + (if (description.asKnown().isPresent) 1 else 0) + (if (frontImageFileId.asKnown().isPresent) 1 else 0) + + (frontText.asKnown().getOrNull()?.validity() ?: 0) + (if (idempotencyKey.asKnown().isPresent) 1 else 0) + (if (isDefault.asKnown().isPresent) 1 else 0) + (if (programId.asKnown().isPresent) 1 else 0) + @@ -854,6 +900,225 @@ private constructor( override fun toString() = value.toString() } + /** + * Text printed on the front of the card. Reach out to + * [support@increase.com](mailto:support@increase.com) for more information. + */ + class FrontText + @JsonCreator(mode = JsonCreator.Mode.DISABLED) + private constructor( + private val line1: JsonField, + private val line2: JsonField, + private val additionalProperties: MutableMap, + ) { + + @JsonCreator + private constructor( + @JsonProperty("line1") @ExcludeMissing line1: JsonField = JsonMissing.of(), + @JsonProperty("line2") @ExcludeMissing line2: JsonField = JsonMissing.of(), + ) : this(line1, line2, mutableMapOf()) + + /** + * The first line of text on the front of the card. + * + * @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 line1(): String = line1.getRequired("line1") + + /** + * The second line of text on the front of the card. Providing a second line moves the first + * line slightly higher and prints the second line in the spot where the first line would + * have otherwise been printed. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if + * the server responded with an unexpected value). + */ + fun line2(): Optional = line2.getOptional("line2") + + /** + * Returns the raw JSON value of [line1]. + * + * Unlike [line1], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("line1") @ExcludeMissing fun _line1(): JsonField = line1 + + /** + * Returns the raw JSON value of [line2]. + * + * Unlike [line2], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("line2") @ExcludeMissing fun _line2(): JsonField = line2 + + @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 [FrontText]. + * + * The following fields are required: + * ```java + * .line1() + * .line2() + * ``` + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [FrontText]. */ + class Builder internal constructor() { + + private var line1: JsonField? = null + private var line2: JsonField? = null + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(frontText: FrontText) = apply { + line1 = frontText.line1 + line2 = frontText.line2 + additionalProperties = frontText.additionalProperties.toMutableMap() + } + + /** The first line of text on the front of the card. */ + fun line1(line1: String) = line1(JsonField.of(line1)) + + /** + * Sets [Builder.line1] to an arbitrary JSON value. + * + * You should usually call [Builder.line1] with a well-typed [String] value instead. + * This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun line1(line1: JsonField) = apply { this.line1 = line1 } + + /** + * The second line of text on the front of the card. Providing a second line moves the + * first line slightly higher and prints the second line in the spot where the first + * line would have otherwise been printed. + */ + fun line2(line2: String?) = line2(JsonField.ofNullable(line2)) + + /** Alias for calling [Builder.line2] with `line2.orElse(null)`. */ + fun line2(line2: Optional) = line2(line2.getOrNull()) + + /** + * Sets [Builder.line2] to an arbitrary JSON value. + * + * You should usually call [Builder.line2] with a well-typed [String] value instead. + * This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun line2(line2: JsonField) = apply { this.line2 = line2 } + + 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 [FrontText]. + * + * Further updates to this [Builder] will not mutate the returned instance. + * + * The following fields are required: + * ```java + * .line1() + * .line2() + * ``` + * + * @throws IllegalStateException if any required field is unset. + */ + fun build(): FrontText = + FrontText( + checkRequired("line1", line1), + checkRequired("line2", line2), + additionalProperties.toMutableMap(), + ) + } + + private var validated: Boolean = false + + /** + * Validates that the types of all values in this object match their expected types + * recursively. + * + * This method is _not_ forwards compatible with new types from the API for existing fields. + * + * @throws IncreaseInvalidDataException if any value type in this object doesn't match its + * expected type. + */ + fun validate(): FrontText = apply { + if (validated) { + return@apply + } + + line1() + line2() + 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 (line1.asKnown().isPresent) 1 else 0) + (if (line2.asKnown().isPresent) 1 else 0) + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is FrontText && + line1 == other.line1 && + line2 == other.line2 && + additionalProperties == other.additionalProperties + } + + private val hashCode: Int by lazy { Objects.hash(line1, line2, additionalProperties) } + + override fun hashCode(): Int = hashCode + + override fun toString() = + "FrontText{line1=$line1, line2=$line2, additionalProperties=$additionalProperties}" + } + /** The status of the Physical Card Profile. */ class Status @JsonCreator private constructor(private val value: JsonField) : Enum { @@ -1190,6 +1455,7 @@ private constructor( creator == other.creator && description == other.description && frontImageFileId == other.frontImageFileId && + frontText == other.frontText && idempotencyKey == other.idempotencyKey && isDefault == other.isDefault && programId == other.programId && @@ -1208,6 +1474,7 @@ private constructor( creator, description, frontImageFileId, + frontText, idempotencyKey, isDefault, programId, @@ -1220,5 +1487,5 @@ private constructor( override fun hashCode(): Int = hashCode override fun toString() = - "PhysicalCardProfile{id=$id, backImageFileId=$backImageFileId, carrierImageFileId=$carrierImageFileId, contactPhone=$contactPhone, createdAt=$createdAt, creator=$creator, description=$description, frontImageFileId=$frontImageFileId, idempotencyKey=$idempotencyKey, isDefault=$isDefault, programId=$programId, status=$status, type=$type, additionalProperties=$additionalProperties}" + "PhysicalCardProfile{id=$id, backImageFileId=$backImageFileId, carrierImageFileId=$carrierImageFileId, contactPhone=$contactPhone, createdAt=$createdAt, creator=$creator, description=$description, frontImageFileId=$frontImageFileId, frontText=$frontText, idempotencyKey=$idempotencyKey, isDefault=$isDefault, programId=$programId, status=$status, type=$type, additionalProperties=$additionalProperties}" } diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/physicalcards/PhysicalCard.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/physicalcards/PhysicalCard.kt index f25cbfe30..86de95cdb 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/physicalcards/PhysicalCard.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/physicalcards/PhysicalCard.kt @@ -2879,7 +2879,12 @@ private constructor( /** The physical card has been processed for delivery. */ @JvmField val PROCESSED_FOR_DELIVERY = of("processed_for_delivery") - /** The physical card has been delivered. */ + /** + * The physical card has been delivered. Note that some couriers track + * delivery status based on driver location data rather than an explicit + * scan. While uncommon, a single physical card may have more than one + * delivered event. + */ @JvmField val DELIVERED = of("delivered") /** @@ -2901,7 +2906,12 @@ private constructor( IN_TRANSIT, /** The physical card has been processed for delivery. */ PROCESSED_FOR_DELIVERY, - /** The physical card has been delivered. */ + /** + * The physical card has been delivered. Note that some couriers track + * delivery status based on driver location data rather than an explicit + * scan. While uncommon, a single physical card may have more than one + * delivered event. + */ DELIVERED, /** * There is an issue preventing delivery. The delivery will be attempted @@ -2928,7 +2938,12 @@ private constructor( IN_TRANSIT, /** The physical card has been processed for delivery. */ PROCESSED_FOR_DELIVERY, - /** The physical card has been delivered. */ + /** + * The physical card has been delivered. Note that some couriers track + * delivery status based on driver location data rather than an explicit + * scan. While uncommon, a single physical card may have more than one + * delivered event. + */ DELIVERED, /** * There is an issue preventing delivery. The delivery will be attempted diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/realtimedecisions/RealTimeDecision.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/realtimedecisions/RealTimeDecision.kt index 09d5b181a..2d7ff50f2 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/realtimedecisions/RealTimeDecision.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/realtimedecisions/RealTimeDecision.kt @@ -6413,6 +6413,7 @@ private constructor( private val decline: JsonField, private val digitalWalletTokenId: JsonField, private val direction: JsonField, + private val healthcare: JsonField, private val merchantAcceptorId: JsonField, private val merchantCategoryCode: JsonField, private val merchantCity: JsonField, @@ -6459,6 +6460,9 @@ private constructor( @JsonProperty("direction") @ExcludeMissing direction: JsonField = JsonMissing.of(), + @JsonProperty("healthcare") + @ExcludeMissing + healthcare: JsonField = JsonMissing.of(), @JsonProperty("merchant_acceptor_id") @ExcludeMissing merchantAcceptorId: JsonField = JsonMissing.of(), @@ -6531,6 +6535,7 @@ private constructor( decline, digitalWalletTokenId, direction, + healthcare, merchantAcceptorId, merchantCategoryCode, merchantCity, @@ -6627,6 +6632,14 @@ private constructor( */ fun direction(): Direction = direction.getRequired("direction") + /** + * The healthcare-related fields for this authorization. Only present for specific programs. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if + * the server responded with an unexpected value). + */ + fun healthcare(): Optional = healthcare.getOptional("healthcare") + /** * The merchant identifier (commonly abbreviated as MID) of the merchant the card is * transacting with. @@ -6878,6 +6891,15 @@ private constructor( @ExcludeMissing fun _direction(): JsonField = direction + /** + * Returns the raw JSON value of [healthcare]. + * + * Unlike [healthcare], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("healthcare") + @ExcludeMissing + fun _healthcare(): JsonField = healthcare + /** * Returns the raw JSON value of [merchantAcceptorId]. * @@ -7115,6 +7137,7 @@ private constructor( * .decline() * .digitalWalletTokenId() * .direction() + * .healthcare() * .merchantAcceptorId() * .merchantCategoryCode() * .merchantCity() @@ -7152,6 +7175,7 @@ private constructor( private var decline: JsonField? = null private var digitalWalletTokenId: JsonField? = null private var direction: JsonField? = null + private var healthcare: JsonField? = null private var merchantAcceptorId: JsonField? = null private var merchantCategoryCode: JsonField? = null private var merchantCity: JsonField? = null @@ -7185,6 +7209,7 @@ private constructor( decline = cardAuthorization.decline digitalWalletTokenId = cardAuthorization.digitalWalletTokenId direction = cardAuthorization.direction + healthcare = cardAuthorization.healthcare merchantAcceptorId = cardAuthorization.merchantAcceptorId merchantCategoryCode = cardAuthorization.merchantCategoryCode merchantCity = cardAuthorization.merchantCity @@ -7343,6 +7368,26 @@ private constructor( */ fun direction(direction: JsonField) = apply { this.direction = direction } + /** + * The healthcare-related fields for this authorization. Only present for specific + * programs. + */ + fun healthcare(healthcare: Healthcare?) = healthcare(JsonField.ofNullable(healthcare)) + + /** Alias for calling [Builder.healthcare] with `healthcare.orElse(null)`. */ + fun healthcare(healthcare: Optional) = healthcare(healthcare.getOrNull()) + + /** + * Sets [Builder.healthcare] to an arbitrary JSON value. + * + * You should usually call [Builder.healthcare] with a well-typed [Healthcare] value + * instead. This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun healthcare(healthcare: JsonField) = apply { + this.healthcare = healthcare + } + /** * The merchant identifier (commonly abbreviated as MID) of the merchant the card is * transacting with. @@ -7762,6 +7807,7 @@ private constructor( * .decline() * .digitalWalletTokenId() * .direction() + * .healthcare() * .merchantAcceptorId() * .merchantCategoryCode() * .merchantCity() @@ -7797,6 +7843,7 @@ private constructor( checkRequired("decline", decline), checkRequired("digitalWalletTokenId", digitalWalletTokenId), checkRequired("direction", direction), + checkRequired("healthcare", healthcare), checkRequired("merchantAcceptorId", merchantAcceptorId), checkRequired("merchantCategoryCode", merchantCategoryCode), checkRequired("merchantCity", merchantCity), @@ -7846,6 +7893,7 @@ private constructor( decline().ifPresent { it.validate() } digitalWalletTokenId() direction().validate() + healthcare().ifPresent { it.validate() } merchantAcceptorId() merchantCategoryCode() merchantCity() @@ -7894,6 +7942,7 @@ private constructor( (decline.asKnown().getOrNull()?.validity() ?: 0) + (if (digitalWalletTokenId.asKnown().isPresent) 1 else 0) + (direction.asKnown().getOrNull()?.validity() ?: 0) + + (healthcare.asKnown().getOrNull()?.validity() ?: 0) + (if (merchantAcceptorId.asKnown().isPresent) 1 else 0) + (if (merchantCategoryCode.asKnown().isPresent) 1 else 0) + (if (merchantCity.asKnown().isPresent) 1 else 0) + @@ -11799,6 +11848,374 @@ private constructor( override fun toString() = value.toString() } + /** + * The healthcare-related fields for this authorization. Only present for specific programs. + */ + class Healthcare + @JsonCreator(mode = JsonCreator.Mode.DISABLED) + private constructor( + private val merchantNinetyPercentEligibility: + JsonField, + private val additionalProperties: MutableMap, + ) { + + @JsonCreator + private constructor( + @JsonProperty("merchant_ninety_percent_eligibility") + @ExcludeMissing + merchantNinetyPercentEligibility: JsonField = + JsonMissing.of() + ) : this(merchantNinetyPercentEligibility, mutableMapOf()) + + /** + * The merchant's eligibility under the Internal Revenue Service's 90% Rule for Flexible + * Spending Account (FSA) and Health Savings Account (HSA) eligible products. The + * eligibility is determined based on the list of merchants maintained by the Special + * Interest Group for IIAS Standards (SIGIS). + * + * @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 merchantNinetyPercentEligibility(): MerchantNinetyPercentEligibility = + merchantNinetyPercentEligibility.getRequired("merchant_ninety_percent_eligibility") + + /** + * Returns the raw JSON value of [merchantNinetyPercentEligibility]. + * + * Unlike [merchantNinetyPercentEligibility], this method doesn't throw if the JSON + * field has an unexpected type. + */ + @JsonProperty("merchant_ninety_percent_eligibility") + @ExcludeMissing + fun _merchantNinetyPercentEligibility(): JsonField = + merchantNinetyPercentEligibility + + @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 [Healthcare]. + * + * The following fields are required: + * ```java + * .merchantNinetyPercentEligibility() + * ``` + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [Healthcare]. */ + class Builder internal constructor() { + + private var merchantNinetyPercentEligibility: + JsonField? = + null + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(healthcare: Healthcare) = apply { + merchantNinetyPercentEligibility = healthcare.merchantNinetyPercentEligibility + additionalProperties = healthcare.additionalProperties.toMutableMap() + } + + /** + * The merchant's eligibility under the Internal Revenue Service's 90% Rule for + * Flexible Spending Account (FSA) and Health Savings Account (HSA) eligible + * products. The eligibility is determined based on the list of merchants maintained + * by the Special Interest Group for IIAS Standards (SIGIS). + */ + fun merchantNinetyPercentEligibility( + merchantNinetyPercentEligibility: MerchantNinetyPercentEligibility + ) = merchantNinetyPercentEligibility(JsonField.of(merchantNinetyPercentEligibility)) + + /** + * Sets [Builder.merchantNinetyPercentEligibility] to an arbitrary JSON value. + * + * You should usually call [Builder.merchantNinetyPercentEligibility] with a + * well-typed [MerchantNinetyPercentEligibility] value instead. This method is + * primarily for setting the field to an undocumented or not yet supported value. + */ + fun merchantNinetyPercentEligibility( + merchantNinetyPercentEligibility: JsonField + ) = apply { + this.merchantNinetyPercentEligibility = merchantNinetyPercentEligibility + } + + 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 [Healthcare]. + * + * Further updates to this [Builder] will not mutate the returned instance. + * + * The following fields are required: + * ```java + * .merchantNinetyPercentEligibility() + * ``` + * + * @throws IllegalStateException if any required field is unset. + */ + fun build(): Healthcare = + Healthcare( + checkRequired( + "merchantNinetyPercentEligibility", + merchantNinetyPercentEligibility, + ), + additionalProperties.toMutableMap(), + ) + } + + private var validated: Boolean = false + + /** + * Validates that the types of all values in this object match their expected types + * recursively. + * + * This method is _not_ forwards compatible with new types from the API for existing + * fields. + * + * @throws IncreaseInvalidDataException if any value type in this object doesn't match + * its expected type. + */ + fun validate(): Healthcare = apply { + if (validated) { + return@apply + } + + merchantNinetyPercentEligibility().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 = + (merchantNinetyPercentEligibility.asKnown().getOrNull()?.validity() ?: 0) + + /** + * The merchant's eligibility under the Internal Revenue Service's 90% Rule for Flexible + * Spending Account (FSA) and Health Savings Account (HSA) eligible products. The + * eligibility is determined based on the list of merchants maintained by the Special + * Interest Group for IIAS Standards (SIGIS). + */ + class MerchantNinetyPercentEligibility + @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 merchant is eligible for treatment under the 90% rule. */ + @JvmField val ELIGIBLE = of("eligible") + + /** The merchant is not eligible for treatment under the 90% rule. */ + @JvmField val NOT_ELIGIBLE = of("not_eligible") + + @JvmStatic + fun of(value: String) = MerchantNinetyPercentEligibility(JsonField.of(value)) + } + + /** An enum containing [MerchantNinetyPercentEligibility]'s known values. */ + enum class Known { + /** The merchant is eligible for treatment under the 90% rule. */ + ELIGIBLE, + /** The merchant is not eligible for treatment under the 90% rule. */ + NOT_ELIGIBLE, + } + + /** + * An enum containing [MerchantNinetyPercentEligibility]'s known values, as well as + * an [_UNKNOWN] member. + * + * An instance of [MerchantNinetyPercentEligibility] 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 merchant is eligible for treatment under the 90% rule. */ + ELIGIBLE, + /** The merchant is not eligible for treatment under the 90% rule. */ + NOT_ELIGIBLE, + /** + * An enum member indicating that [MerchantNinetyPercentEligibility] 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) { + ELIGIBLE -> Value.ELIGIBLE + NOT_ELIGIBLE -> Value.NOT_ELIGIBLE + 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) { + ELIGIBLE -> Known.ELIGIBLE + NOT_ELIGIBLE -> Known.NOT_ELIGIBLE + else -> + throw IncreaseInvalidDataException( + "Unknown MerchantNinetyPercentEligibility: $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 + + /** + * Validates that the types of all values in this object match their expected types + * recursively. + * + * This method is _not_ forwards compatible with new types from the API for existing + * fields. + * + * @throws IncreaseInvalidDataException if any value type in this object doesn't + * match its expected type. + */ + fun validate(): MerchantNinetyPercentEligibility = 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 MerchantNinetyPercentEligibility && 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 Healthcare && + merchantNinetyPercentEligibility == other.merchantNinetyPercentEligibility && + additionalProperties == other.additionalProperties + } + + private val hashCode: Int by lazy { + Objects.hash(merchantNinetyPercentEligibility, additionalProperties) + } + + override fun hashCode(): Int = hashCode + + override fun toString() = + "Healthcare{merchantNinetyPercentEligibility=$merchantNinetyPercentEligibility, additionalProperties=$additionalProperties}" + } + /** Fields specific to the `network`. */ class NetworkDetails @JsonCreator(mode = JsonCreator.Mode.DISABLED) @@ -17068,6 +17485,7 @@ private constructor( decline == other.decline && digitalWalletTokenId == other.digitalWalletTokenId && direction == other.direction && + healthcare == other.healthcare && merchantAcceptorId == other.merchantAcceptorId && merchantCategoryCode == other.merchantCategoryCode && merchantCity == other.merchantCity && @@ -17102,6 +17520,7 @@ private constructor( decline, digitalWalletTokenId, direction, + healthcare, merchantAcceptorId, merchantCategoryCode, merchantCity, @@ -17130,7 +17549,7 @@ private constructor( override fun hashCode(): Int = hashCode override fun toString() = - "CardAuthorization{accountId=$accountId, additionalAmounts=$additionalAmounts, approval=$approval, cardId=$cardId, decision=$decision, decline=$decline, digitalWalletTokenId=$digitalWalletTokenId, direction=$direction, merchantAcceptorId=$merchantAcceptorId, merchantCategoryCode=$merchantCategoryCode, merchantCity=$merchantCity, merchantCountry=$merchantCountry, merchantDescriptor=$merchantDescriptor, merchantPostalCode=$merchantPostalCode, merchantState=$merchantState, networkDetails=$networkDetails, networkIdentifiers=$networkIdentifiers, networkRiskScore=$networkRiskScore, partialApprovalCapability=$partialApprovalCapability, physicalCardId=$physicalCardId, presentmentAmount=$presentmentAmount, presentmentCurrency=$presentmentCurrency, processingCategory=$processingCategory, requestDetails=$requestDetails, settlementAmount=$settlementAmount, settlementCurrency=$settlementCurrency, terminalId=$terminalId, upcomingCardPaymentId=$upcomingCardPaymentId, verification=$verification, additionalProperties=$additionalProperties}" + "CardAuthorization{accountId=$accountId, additionalAmounts=$additionalAmounts, approval=$approval, cardId=$cardId, decision=$decision, decline=$decline, digitalWalletTokenId=$digitalWalletTokenId, direction=$direction, healthcare=$healthcare, merchantAcceptorId=$merchantAcceptorId, merchantCategoryCode=$merchantCategoryCode, merchantCity=$merchantCity, merchantCountry=$merchantCountry, merchantDescriptor=$merchantDescriptor, merchantPostalCode=$merchantPostalCode, merchantState=$merchantState, networkDetails=$networkDetails, networkIdentifiers=$networkIdentifiers, networkRiskScore=$networkRiskScore, partialApprovalCapability=$partialApprovalCapability, physicalCardId=$physicalCardId, presentmentAmount=$presentmentAmount, presentmentCurrency=$presentmentCurrency, processingCategory=$processingCategory, requestDetails=$requestDetails, settlementAmount=$settlementAmount, settlementCurrency=$settlementCurrency, terminalId=$terminalId, upcomingCardPaymentId=$upcomingCardPaymentId, verification=$verification, additionalProperties=$additionalProperties}" } /** Fields related to a card balance inquiry. */ diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/achtransfers/AchTransferCreateNotificationOfChangeParams.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/achtransfers/AchTransferCreateNotificationOfChangeParams.kt index b68c57330..882b356e1 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/achtransfers/AchTransferCreateNotificationOfChangeParams.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/achtransfers/AchTransferCreateNotificationOfChangeParams.kt @@ -701,6 +701,9 @@ private constructor( /** A savings account. */ @JvmField val SAVINGS = of("savings") + /** A loan account used in a lender-borrower relationship. Uncommon. */ + @JvmField val LOAN = of("loan") + /** A bank's general ledger. Uncommon. */ @JvmField val GENERAL_LEDGER = of("general_ledger") @@ -713,6 +716,8 @@ private constructor( CHECKING, /** A savings account. */ SAVINGS, + /** A loan account used in a lender-borrower relationship. Uncommon. */ + LOAN, /** A bank's general ledger. Uncommon. */ GENERAL_LEDGER, } @@ -733,6 +738,8 @@ private constructor( CHECKING, /** A savings account. */ SAVINGS, + /** A loan account used in a lender-borrower relationship. Uncommon. */ + LOAN, /** A bank's general ledger. Uncommon. */ GENERAL_LEDGER, /** @@ -753,6 +760,7 @@ private constructor( when (this) { CHECKING -> Value.CHECKING SAVINGS -> Value.SAVINGS + LOAN -> Value.LOAN GENERAL_LEDGER -> Value.GENERAL_LEDGER else -> Value._UNKNOWN } @@ -770,6 +778,7 @@ private constructor( when (this) { CHECKING -> Known.CHECKING SAVINGS -> Known.SAVINGS + LOAN -> Known.LOAN GENERAL_LEDGER -> Known.GENERAL_LEDGER else -> throw IncreaseInvalidDataException("Unknown CorrectedAccountFunding: $value") diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/cardauthorizations/CardAuthorizationCreateParams.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/cardauthorizations/CardAuthorizationCreateParams.kt index 0e0daf1da..df398ec72 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/cardauthorizations/CardAuthorizationCreateParams.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/cardauthorizations/CardAuthorizationCreateParams.kt @@ -1754,7 +1754,7 @@ private constructor( /** The attempted card transaction is not allowed per Increase's terms. */ @JvmField val TRANSACTION_NOT_ALLOWED = of("transaction_not_allowed") - /** The transaction was blocked by a Limit. */ + /** The transaction was blocked by a limit or an authorization control. */ @JvmField val BREACHES_LIMIT = of("breaches_limit") /** Your application declined the transaction via webhook. */ @@ -1825,7 +1825,7 @@ private constructor( CARD_EXPIRATION_MISMATCH, /** The attempted card transaction is not allowed per Increase's terms. */ TRANSACTION_NOT_ALLOWED, - /** The transaction was blocked by a Limit. */ + /** The transaction was blocked by a limit or an authorization control. */ BREACHES_LIMIT, /** Your application declined the transaction via webhook. */ WEBHOOK_DECLINED, @@ -1893,7 +1893,7 @@ private constructor( CARD_EXPIRATION_MISMATCH, /** The attempted card transaction is not allowed per Increase's terms. */ TRANSACTION_NOT_ALLOWED, - /** The transaction was blocked by a Limit. */ + /** The transaction was blocked by a limit or an authorization control. */ BREACHES_LIMIT, /** Your application declined the transaction via webhook. */ WEBHOOK_DECLINED, diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/cardbalanceinquiries/CardBalanceInquiryCreateParams.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/cardbalanceinquiries/CardBalanceInquiryCreateParams.kt index 8a9e06bd7..96b93b06f 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/cardbalanceinquiries/CardBalanceInquiryCreateParams.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/cardbalanceinquiries/CardBalanceInquiryCreateParams.kt @@ -1551,7 +1551,7 @@ private constructor( /** The attempted card transaction is not allowed per Increase's terms. */ @JvmField val TRANSACTION_NOT_ALLOWED = of("transaction_not_allowed") - /** The transaction was blocked by a Limit. */ + /** The transaction was blocked by a limit or an authorization control. */ @JvmField val BREACHES_LIMIT = of("breaches_limit") /** Your application declined the transaction via webhook. */ @@ -1622,7 +1622,7 @@ private constructor( CARD_EXPIRATION_MISMATCH, /** The attempted card transaction is not allowed per Increase's terms. */ TRANSACTION_NOT_ALLOWED, - /** The transaction was blocked by a Limit. */ + /** The transaction was blocked by a limit or an authorization control. */ BREACHES_LIMIT, /** Your application declined the transaction via webhook. */ WEBHOOK_DECLINED, @@ -1690,7 +1690,7 @@ private constructor( CARD_EXPIRATION_MISMATCH, /** The attempted card transaction is not allowed per Increase's terms. */ TRANSACTION_NOT_ALLOWED, - /** The transaction was blocked by a Limit. */ + /** The transaction was blocked by a limit or an authorization control. */ BREACHES_LIMIT, /** Your application declined the transaction via webhook. */ WEBHOOK_DECLINED, diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/checkdeposits/CheckDepositSubmitParams.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/checkdeposits/CheckDepositSubmitParams.kt index cfe05bf3a..f0cf6bf16 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/checkdeposits/CheckDepositSubmitParams.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/checkdeposits/CheckDepositSubmitParams.kt @@ -36,7 +36,8 @@ private constructor( fun checkDepositId(): Optional = Optional.ofNullable(checkDepositId) /** - * If set, the simulation will use these values for the check's scanned MICR data. + * If set, the simulation will use these values for the check's scanned MICR data. If not set, + * the simulation will use random values. * * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the * server responded with an unexpected value). @@ -100,7 +101,10 @@ private constructor( */ fun body(body: Body) = apply { this.body = body.toBuilder() } - /** If set, the simulation will use these values for the check's scanned MICR data. */ + /** + * If set, the simulation will use these values for the check's scanned MICR data. If not + * set, the simulation will use random values. + */ fun scan(scan: Scan) = apply { body.scan(scan) } /** @@ -267,7 +271,8 @@ private constructor( ) : this(scan, mutableMapOf()) /** - * If set, the simulation will use these values for the check's scanned MICR data. + * If set, the simulation will use these values for the check's scanned MICR data. If not + * set, the simulation will use random values. * * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if * the server responded with an unexpected value). @@ -311,7 +316,10 @@ private constructor( additionalProperties = body.additionalProperties.toMutableMap() } - /** If set, the simulation will use these values for the check's scanned MICR data. */ + /** + * If set, the simulation will use these values for the check's scanned MICR data. If + * not set, the simulation will use random values. + */ fun scan(scan: Scan) = scan(JsonField.of(scan)) /** @@ -403,13 +411,17 @@ private constructor( override fun toString() = "Body{scan=$scan, additionalProperties=$additionalProperties}" } - /** If set, the simulation will use these values for the check's scanned MICR data. */ + /** + * If set, the simulation will use these values for the check's scanned MICR data. If not set, + * the simulation will use random values. + */ class Scan @JsonCreator(mode = JsonCreator.Mode.DISABLED) private constructor( private val accountNumber: JsonField, private val routingNumber: JsonField, private val auxiliaryOnUs: JsonField, + private val serialNumber: JsonField, private val additionalProperties: MutableMap, ) { @@ -424,7 +436,10 @@ private constructor( @JsonProperty("auxiliary_on_us") @ExcludeMissing auxiliaryOnUs: JsonField = JsonMissing.of(), - ) : this(accountNumber, routingNumber, auxiliaryOnUs, mutableMapOf()) + @JsonProperty("serial_number") + @ExcludeMissing + serialNumber: JsonField = JsonMissing.of(), + ) : this(accountNumber, routingNumber, auxiliaryOnUs, serialNumber, mutableMapOf()) /** * The account number to be returned in the check deposit's scan data. @@ -443,13 +458,23 @@ private constructor( fun routingNumber(): String = routingNumber.getRequired("routing_number") /** - * The auxiliary on-us data to be returned in the check deposit's scan data. + * The auxiliary on-us data to be returned in the check deposit's scan data. Auxiliary on-us + * is typically the check number for business checks. * * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if * the server responded with an unexpected value). */ fun auxiliaryOnUs(): Optional = auxiliaryOnUs.getOptional("auxiliary_on_us") + /** + * The serial number to be returned in the check deposit's scan data. Serial number is + * typically the check number for consumer checks. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if + * the server responded with an unexpected value). + */ + fun serialNumber(): Optional = serialNumber.getOptional("serial_number") + /** * Returns the raw JSON value of [accountNumber]. * @@ -480,6 +505,16 @@ private constructor( @ExcludeMissing fun _auxiliaryOnUs(): JsonField = auxiliaryOnUs + /** + * Returns the raw JSON value of [serialNumber]. + * + * Unlike [serialNumber], this method doesn't throw if the JSON field has an unexpected + * type. + */ + @JsonProperty("serial_number") + @ExcludeMissing + fun _serialNumber(): JsonField = serialNumber + @JsonAnySetter private fun putAdditionalProperty(key: String, value: JsonValue) { additionalProperties.put(key, value) @@ -512,6 +547,7 @@ private constructor( private var accountNumber: JsonField? = null private var routingNumber: JsonField? = null private var auxiliaryOnUs: JsonField = JsonMissing.of() + private var serialNumber: JsonField = JsonMissing.of() private var additionalProperties: MutableMap = mutableMapOf() @JvmSynthetic @@ -519,6 +555,7 @@ private constructor( accountNumber = scan.accountNumber routingNumber = scan.routingNumber auxiliaryOnUs = scan.auxiliaryOnUs + serialNumber = scan.serialNumber additionalProperties = scan.additionalProperties.toMutableMap() } @@ -550,7 +587,10 @@ private constructor( this.routingNumber = routingNumber } - /** The auxiliary on-us data to be returned in the check deposit's scan data. */ + /** + * The auxiliary on-us data to be returned in the check deposit's scan data. Auxiliary + * on-us is typically the check number for business checks. + */ fun auxiliaryOnUs(auxiliaryOnUs: String) = auxiliaryOnUs(JsonField.of(auxiliaryOnUs)) /** @@ -564,6 +604,23 @@ private constructor( this.auxiliaryOnUs = auxiliaryOnUs } + /** + * The serial number to be returned in the check deposit's scan data. Serial number is + * typically the check number for consumer checks. + */ + fun serialNumber(serialNumber: String) = serialNumber(JsonField.of(serialNumber)) + + /** + * Sets [Builder.serialNumber] to an arbitrary JSON value. + * + * You should usually call [Builder.serialNumber] with a well-typed [String] value + * instead. This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun serialNumber(serialNumber: JsonField) = apply { + this.serialNumber = serialNumber + } + fun additionalProperties(additionalProperties: Map) = apply { this.additionalProperties.clear() putAllAdditionalProperties(additionalProperties) @@ -601,6 +658,7 @@ private constructor( checkRequired("accountNumber", accountNumber), checkRequired("routingNumber", routingNumber), auxiliaryOnUs, + serialNumber, additionalProperties.toMutableMap(), ) } @@ -624,6 +682,7 @@ private constructor( accountNumber() routingNumber() auxiliaryOnUs() + serialNumber() validated = true } @@ -645,7 +704,8 @@ private constructor( internal fun validity(): Int = (if (accountNumber.asKnown().isPresent) 1 else 0) + (if (routingNumber.asKnown().isPresent) 1 else 0) + - (if (auxiliaryOnUs.asKnown().isPresent) 1 else 0) + (if (auxiliaryOnUs.asKnown().isPresent) 1 else 0) + + (if (serialNumber.asKnown().isPresent) 1 else 0) override fun equals(other: Any?): Boolean { if (this === other) { @@ -656,17 +716,24 @@ private constructor( accountNumber == other.accountNumber && routingNumber == other.routingNumber && auxiliaryOnUs == other.auxiliaryOnUs && + serialNumber == other.serialNumber && additionalProperties == other.additionalProperties } private val hashCode: Int by lazy { - Objects.hash(accountNumber, routingNumber, auxiliaryOnUs, additionalProperties) + Objects.hash( + accountNumber, + routingNumber, + auxiliaryOnUs, + serialNumber, + additionalProperties, + ) } override fun hashCode(): Int = hashCode override fun toString() = - "Scan{accountNumber=$accountNumber, routingNumber=$routingNumber, auxiliaryOnUs=$auxiliaryOnUs, additionalProperties=$additionalProperties}" + "Scan{accountNumber=$accountNumber, routingNumber=$routingNumber, auxiliaryOnUs=$auxiliaryOnUs, serialNumber=$serialNumber, additionalProperties=$additionalProperties}" } override fun equals(other: Any?): Boolean { diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/digitalwallettokenrequests/DigitalWalletTokenRequestCreateResponse.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/digitalwallettokenrequests/DigitalWalletTokenRequestCreateResponse.kt index 1fde6bfdf..791a8c0f6 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/digitalwallettokenrequests/DigitalWalletTokenRequestCreateResponse.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/digitalwallettokenrequests/DigitalWalletTokenRequestCreateResponse.kt @@ -312,6 +312,15 @@ private constructor( /** Your webhook declined the token provisioning attempt. */ @JvmField val WEBHOOK_DECLINED = of("webhook_declined") + /** + * The tokenization attempt failed because the Card Verification Code (CVC) was + * incorrect. + */ + @JvmField val INCORRECT_CARD_VERIFICATION_CODE = of("incorrect_card_verification_code") + + /** The tokenization attempt was declined by the token requestor. */ + @JvmField val DECLINED_BY_TOKEN_REQUESTOR = of("declined_by_token_requestor") + @JvmStatic fun of(value: String) = DeclineReason(JsonField.of(value)) } @@ -325,6 +334,13 @@ private constructor( WEBHOOK_TIMED_OUT, /** Your webhook declined the token provisioning attempt. */ WEBHOOK_DECLINED, + /** + * The tokenization attempt failed because the Card Verification Code (CVC) was + * incorrect. + */ + INCORRECT_CARD_VERIFICATION_CODE, + /** The tokenization attempt was declined by the token requestor. */ + DECLINED_BY_TOKEN_REQUESTOR, } /** @@ -345,6 +361,13 @@ private constructor( WEBHOOK_TIMED_OUT, /** Your webhook declined the token provisioning attempt. */ WEBHOOK_DECLINED, + /** + * The tokenization attempt failed because the Card Verification Code (CVC) was + * incorrect. + */ + INCORRECT_CARD_VERIFICATION_CODE, + /** The tokenization attempt was declined by the token requestor. */ + DECLINED_BY_TOKEN_REQUESTOR, /** * An enum member indicating that [DeclineReason] was instantiated with an unknown * value. @@ -365,6 +388,8 @@ private constructor( NO_VERIFICATION_METHOD -> Value.NO_VERIFICATION_METHOD WEBHOOK_TIMED_OUT -> Value.WEBHOOK_TIMED_OUT WEBHOOK_DECLINED -> Value.WEBHOOK_DECLINED + INCORRECT_CARD_VERIFICATION_CODE -> Value.INCORRECT_CARD_VERIFICATION_CODE + DECLINED_BY_TOKEN_REQUESTOR -> Value.DECLINED_BY_TOKEN_REQUESTOR else -> Value._UNKNOWN } @@ -383,6 +408,8 @@ private constructor( NO_VERIFICATION_METHOD -> Known.NO_VERIFICATION_METHOD WEBHOOK_TIMED_OUT -> Known.WEBHOOK_TIMED_OUT WEBHOOK_DECLINED -> Known.WEBHOOK_DECLINED + INCORRECT_CARD_VERIFICATION_CODE -> Known.INCORRECT_CARD_VERIFICATION_CODE + DECLINED_BY_TOKEN_REQUESTOR -> Known.DECLINED_BY_TOKEN_REQUESTOR else -> throw IncreaseInvalidDataException("Unknown DeclineReason: $value") } diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/entities/EntityUpdateValidationParams.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/entities/EntityUpdateValidationParams.kt index 5f35856a7..97b70b7e6 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/entities/EntityUpdateValidationParams.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/entities/EntityUpdateValidationParams.kt @@ -639,7 +639,7 @@ private constructor( companion object { /** - * The entity's tax identifier could not be validated. Update the tax ID with the + * The entity's tax identifier could not be verified. Update the tax ID with the * [update an entity API](/documentation/api/entities#update-an-entity.corporation.legal_identifier). */ @JvmField val ENTITY_TAX_IDENTIFIER = of("entity_tax_identifier") @@ -669,7 +669,7 @@ private constructor( /** An enum containing [Category]'s known values. */ enum class Known { /** - * The entity's tax identifier could not be validated. Update the tax ID with the + * The entity's tax identifier could not be verified. Update the tax ID with the * [update an entity API](/documentation/api/entities#update-an-entity.corporation.legal_identifier). */ ENTITY_TAX_IDENTIFIER, @@ -702,7 +702,7 @@ private constructor( */ enum class Value { /** - * The entity's tax identifier could not be validated. Update the tax ID with the + * The entity's tax identifier could not be verified. Update the tax ID with the * [update an entity API](/documentation/api/entities#update-an-entity.corporation.legal_identifier). */ ENTITY_TAX_IDENTIFIER, diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/inboundwiretransfers/InboundWireTransferCreateParams.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/inboundwiretransfers/InboundWireTransferCreateParams.kt index bd43a2708..cf554dce6 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/inboundwiretransfers/InboundWireTransferCreateParams.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/inboundwiretransfers/InboundWireTransferCreateParams.kt @@ -140,6 +140,14 @@ private constructor( */ fun instructionIdentification(): Optional = body.instructionIdentification() + /** + * The sending bank will set purpose in production. You can simulate any value here. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun purpose(): Optional = body.purpose() + /** * The sending bank will set unique_end_to_end_transaction_reference in production. You can * simulate any value here. @@ -268,6 +276,13 @@ private constructor( */ fun _instructionIdentification(): JsonField = body._instructionIdentification() + /** + * Returns the raw JSON value of [purpose]. + * + * Unlike [purpose], this method doesn't throw if the JSON field has an unexpected type. + */ + fun _purpose(): JsonField = body._purpose() + /** * Returns the raw JSON value of [uniqueEndToEndTransactionReference]. * @@ -576,6 +591,17 @@ private constructor( body.instructionIdentification(instructionIdentification) } + /** The sending bank will set purpose in production. You can simulate any value here. */ + fun purpose(purpose: String) = apply { body.purpose(purpose) } + + /** + * Sets [Builder.purpose] to an arbitrary JSON value. + * + * You should usually call [Builder.purpose] with a well-typed [String] value instead. This + * method is primarily for setting the field to an undocumented or not yet supported value. + */ + fun purpose(purpose: JsonField) = apply { body.purpose(purpose) } + /** * The sending bank will set unique_end_to_end_transaction_reference in production. You can * simulate any value here. @@ -790,6 +816,7 @@ private constructor( private val endToEndIdentification: JsonField, private val instructingAgentRoutingNumber: JsonField, private val instructionIdentification: JsonField, + private val purpose: JsonField, private val uniqueEndToEndTransactionReference: JsonField, private val unstructuredRemittanceInformation: JsonField, private val wireDrawdownRequestId: JsonField, @@ -835,6 +862,7 @@ private constructor( @JsonProperty("instruction_identification") @ExcludeMissing instructionIdentification: JsonField = JsonMissing.of(), + @JsonProperty("purpose") @ExcludeMissing purpose: JsonField = JsonMissing.of(), @JsonProperty("unique_end_to_end_transaction_reference") @ExcludeMissing uniqueEndToEndTransactionReference: JsonField = JsonMissing.of(), @@ -858,6 +886,7 @@ private constructor( endToEndIdentification, instructingAgentRoutingNumber, instructionIdentification, + purpose, uniqueEndToEndTransactionReference, unstructuredRemittanceInformation, wireDrawdownRequestId, @@ -986,6 +1015,14 @@ private constructor( fun instructionIdentification(): Optional = instructionIdentification.getOptional("instruction_identification") + /** + * The sending bank will set purpose in production. You can simulate any value here. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if + * the server responded with an unexpected value). + */ + fun purpose(): Optional = purpose.getOptional("purpose") + /** * The sending bank will set unique_end_to_end_transaction_reference in production. You can * simulate any value here. @@ -1143,6 +1180,13 @@ private constructor( @ExcludeMissing fun _instructionIdentification(): JsonField = instructionIdentification + /** + * Returns the raw JSON value of [purpose]. + * + * Unlike [purpose], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("purpose") @ExcludeMissing fun _purpose(): JsonField = purpose + /** * Returns the raw JSON value of [uniqueEndToEndTransactionReference]. * @@ -1217,6 +1261,7 @@ private constructor( private var endToEndIdentification: JsonField = JsonMissing.of() private var instructingAgentRoutingNumber: JsonField = JsonMissing.of() private var instructionIdentification: JsonField = JsonMissing.of() + private var purpose: JsonField = JsonMissing.of() private var uniqueEndToEndTransactionReference: JsonField = JsonMissing.of() private var unstructuredRemittanceInformation: JsonField = JsonMissing.of() private var wireDrawdownRequestId: JsonField = JsonMissing.of() @@ -1237,6 +1282,7 @@ private constructor( endToEndIdentification = body.endToEndIdentification instructingAgentRoutingNumber = body.instructingAgentRoutingNumber instructionIdentification = body.instructionIdentification + purpose = body.purpose uniqueEndToEndTransactionReference = body.uniqueEndToEndTransactionReference unstructuredRemittanceInformation = body.unstructuredRemittanceInformation wireDrawdownRequestId = body.wireDrawdownRequestId @@ -1464,6 +1510,18 @@ private constructor( this.instructionIdentification = instructionIdentification } + /** The sending bank will set purpose in production. You can simulate any value here. */ + fun purpose(purpose: String) = purpose(JsonField.of(purpose)) + + /** + * Sets [Builder.purpose] to an arbitrary JSON value. + * + * You should usually call [Builder.purpose] with a well-typed [String] value instead. + * This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun purpose(purpose: JsonField) = apply { this.purpose = purpose } + /** * The sending bank will set unique_end_to_end_transaction_reference in production. You * can simulate any value here. @@ -1566,6 +1624,7 @@ private constructor( endToEndIdentification, instructingAgentRoutingNumber, instructionIdentification, + purpose, uniqueEndToEndTransactionReference, unstructuredRemittanceInformation, wireDrawdownRequestId, @@ -1602,6 +1661,7 @@ private constructor( endToEndIdentification() instructingAgentRoutingNumber() instructionIdentification() + purpose() uniqueEndToEndTransactionReference() unstructuredRemittanceInformation() wireDrawdownRequestId() @@ -1637,6 +1697,7 @@ private constructor( (if (endToEndIdentification.asKnown().isPresent) 1 else 0) + (if (instructingAgentRoutingNumber.asKnown().isPresent) 1 else 0) + (if (instructionIdentification.asKnown().isPresent) 1 else 0) + + (if (purpose.asKnown().isPresent) 1 else 0) + (if (uniqueEndToEndTransactionReference.asKnown().isPresent) 1 else 0) + (if (unstructuredRemittanceInformation.asKnown().isPresent) 1 else 0) + (if (wireDrawdownRequestId.asKnown().isPresent) 1 else 0) @@ -1660,6 +1721,7 @@ private constructor( endToEndIdentification == other.endToEndIdentification && instructingAgentRoutingNumber == other.instructingAgentRoutingNumber && instructionIdentification == other.instructionIdentification && + purpose == other.purpose && uniqueEndToEndTransactionReference == other.uniqueEndToEndTransactionReference && unstructuredRemittanceInformation == other.unstructuredRemittanceInformation && wireDrawdownRequestId == other.wireDrawdownRequestId && @@ -1681,6 +1743,7 @@ private constructor( endToEndIdentification, instructingAgentRoutingNumber, instructionIdentification, + purpose, uniqueEndToEndTransactionReference, unstructuredRemittanceInformation, wireDrawdownRequestId, @@ -1691,7 +1754,7 @@ private constructor( override fun hashCode(): Int = hashCode override fun toString() = - "Body{accountNumberId=$accountNumberId, amount=$amount, creditorAddressLine1=$creditorAddressLine1, creditorAddressLine2=$creditorAddressLine2, creditorAddressLine3=$creditorAddressLine3, creditorName=$creditorName, debtorAddressLine1=$debtorAddressLine1, debtorAddressLine2=$debtorAddressLine2, debtorAddressLine3=$debtorAddressLine3, debtorName=$debtorName, endToEndIdentification=$endToEndIdentification, instructingAgentRoutingNumber=$instructingAgentRoutingNumber, instructionIdentification=$instructionIdentification, uniqueEndToEndTransactionReference=$uniqueEndToEndTransactionReference, unstructuredRemittanceInformation=$unstructuredRemittanceInformation, wireDrawdownRequestId=$wireDrawdownRequestId, additionalProperties=$additionalProperties}" + "Body{accountNumberId=$accountNumberId, amount=$amount, creditorAddressLine1=$creditorAddressLine1, creditorAddressLine2=$creditorAddressLine2, creditorAddressLine3=$creditorAddressLine3, creditorName=$creditorName, debtorAddressLine1=$debtorAddressLine1, debtorAddressLine2=$debtorAddressLine2, debtorAddressLine3=$debtorAddressLine3, debtorName=$debtorName, endToEndIdentification=$endToEndIdentification, instructingAgentRoutingNumber=$instructingAgentRoutingNumber, instructionIdentification=$instructionIdentification, purpose=$purpose, uniqueEndToEndTransactionReference=$uniqueEndToEndTransactionReference, unstructuredRemittanceInformation=$unstructuredRemittanceInformation, wireDrawdownRequestId=$wireDrawdownRequestId, additionalProperties=$additionalProperties}" } override fun equals(other: Any?): Boolean { diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/physicalcards/PhysicalCardCreateParams.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/physicalcards/PhysicalCardCreateParams.kt index be8d6dc0b..beb150a68 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/physicalcards/PhysicalCardCreateParams.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/physicalcards/PhysicalCardCreateParams.kt @@ -751,7 +751,11 @@ private constructor( /** The physical card has been processed for delivery. */ @JvmField val PROCESSED_FOR_DELIVERY = of("processed_for_delivery") - /** The physical card has been delivered. */ + /** + * The physical card has been delivered. Note that some couriers track delivery status + * based on driver location data rather than an explicit scan. While uncommon, a single + * physical card may have more than one delivered event. + */ @JvmField val DELIVERED = of("delivered") /** @@ -773,7 +777,11 @@ private constructor( IN_TRANSIT, /** The physical card has been processed for delivery. */ PROCESSED_FOR_DELIVERY, - /** The physical card has been delivered. */ + /** + * The physical card has been delivered. Note that some couriers track delivery status + * based on driver location data rather than an explicit scan. While uncommon, a single + * physical card may have more than one delivered event. + */ DELIVERED, /** * There is an issue preventing delivery. The delivery will be attempted again if @@ -799,7 +807,11 @@ private constructor( IN_TRANSIT, /** The physical card has been processed for delivery. */ PROCESSED_FOR_DELIVERY, - /** The physical card has been delivered. */ + /** + * The physical card has been delivered. Note that some couriers track delivery status + * based on driver location data rather than an explicit scan. While uncommon, a single + * physical card may have more than one delivered event. + */ DELIVERED, /** * There is an issue preventing delivery. The delivery will be attempted again if diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/transactions/Transaction.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/transactions/Transaction.kt index fcd80307b..d39bbdddf 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/transactions/Transaction.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/transactions/Transaction.kt @@ -1194,8 +1194,9 @@ private constructor( /** * A Card Financial object. This field will be present in the JSON response if and only if - * `category` is equal to `card_financial`. Card Financials are temporary holds placed on a - * customer's funds with the intent to later clear a transaction. + * `category` is equal to `card_financial`. Card Financials are card transactions that have + * cleared and settled. Unlike a Card Settlement, which clears a previous authorization, a + * Card Financial is authorized and cleared in a single message. * * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if * the server responded with an unexpected value). @@ -2346,8 +2347,9 @@ private constructor( /** * A Card Financial object. This field will be present in the JSON response if and only - * if `category` is equal to `card_financial`. Card Financials are temporary holds - * placed on a customer's funds with the intent to later clear a transaction. + * if `category` is equal to `card_financial`. Card Financials are card transactions + * that have cleared and settled. Unlike a Card Settlement, which clears a previous + * authorization, a Card Financial is authorized and cleared in a single message. */ fun cardFinancial(cardFinancial: CardFinancial?) = cardFinancial(JsonField.ofNullable(cardFinancial)) @@ -9139,8 +9141,9 @@ private constructor( /** * A Card Financial object. This field will be present in the JSON response if and only if - * `category` is equal to `card_financial`. Card Financials are temporary holds placed on a - * customer's funds with the intent to later clear a transaction. + * `category` is equal to `card_financial`. Card Financials are card transactions that have + * cleared and settled. Unlike a Card Settlement, which clears a previous authorization, a + * Card Financial is authorized and cleared in a single message. */ class CardFinancial @JsonCreator(mode = JsonCreator.Mode.DISABLED) @@ -51545,6 +51548,7 @@ private constructor( private val inputMessageAccountabilityData: JsonField, private val instructingAgentRoutingNumber: JsonField, private val instructionIdentification: JsonField, + private val purpose: JsonField, private val transferId: JsonField, private val uniqueEndToEndTransactionReference: JsonField, private val unstructuredRemittanceInformation: JsonField, @@ -51593,6 +51597,9 @@ private constructor( @JsonProperty("instruction_identification") @ExcludeMissing instructionIdentification: JsonField = JsonMissing.of(), + @JsonProperty("purpose") + @ExcludeMissing + purpose: JsonField = JsonMissing.of(), @JsonProperty("transfer_id") @ExcludeMissing transferId: JsonField = JsonMissing.of(), @@ -51617,6 +51624,7 @@ private constructor( inputMessageAccountabilityData, instructingAgentRoutingNumber, instructionIdentification, + purpose, transferId, uniqueEndToEndTransactionReference, unstructuredRemittanceInformation, @@ -51749,6 +51757,14 @@ private constructor( fun instructionIdentification(): Optional = instructionIdentification.getOptional("instruction_identification") + /** + * The reason for the wire transfer, as set by the sender. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. + * if the server responded with an unexpected value). + */ + fun purpose(): Optional = purpose.getOptional("purpose") + /** * The ID of the Inbound Wire Transfer object that resulted in this Transaction. * @@ -51918,6 +51934,13 @@ private constructor( @ExcludeMissing fun _instructionIdentification(): JsonField = instructionIdentification + /** + * Returns the raw JSON value of [purpose]. + * + * Unlike [purpose], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("purpose") @ExcludeMissing fun _purpose(): JsonField = purpose + /** * Returns the raw JSON value of [transferId]. * @@ -51983,6 +52006,7 @@ private constructor( * .inputMessageAccountabilityData() * .instructingAgentRoutingNumber() * .instructionIdentification() + * .purpose() * .transferId() * .uniqueEndToEndTransactionReference() * .unstructuredRemittanceInformation() @@ -52008,6 +52032,7 @@ private constructor( private var inputMessageAccountabilityData: JsonField? = null private var instructingAgentRoutingNumber: JsonField? = null private var instructionIdentification: JsonField? = null + private var purpose: JsonField? = null private var transferId: JsonField? = null private var uniqueEndToEndTransactionReference: JsonField? = null private var unstructuredRemittanceInformation: JsonField? = null @@ -52031,6 +52056,7 @@ private constructor( instructingAgentRoutingNumber = inboundWireTransfer.instructingAgentRoutingNumber instructionIdentification = inboundWireTransfer.instructionIdentification + purpose = inboundWireTransfer.purpose transferId = inboundWireTransfer.transferId uniqueEndToEndTransactionReference = inboundWireTransfer.uniqueEndToEndTransactionReference @@ -52336,6 +52362,21 @@ private constructor( this.instructionIdentification = instructionIdentification } + /** The reason for the wire transfer, as set by the sender. */ + fun purpose(purpose: String?) = purpose(JsonField.ofNullable(purpose)) + + /** Alias for calling [Builder.purpose] with `purpose.orElse(null)`. */ + fun purpose(purpose: Optional) = purpose(purpose.getOrNull()) + + /** + * Sets [Builder.purpose] to an arbitrary JSON value. + * + * You should usually call [Builder.purpose] with a well-typed [String] value + * instead. This method is primarily for setting the field to an undocumented or not + * yet supported value. + */ + fun purpose(purpose: JsonField) = apply { this.purpose = purpose } + /** The ID of the Inbound Wire Transfer object that resulted in this Transaction. */ fun transferId(transferId: String) = transferId(JsonField.of(transferId)) @@ -52456,6 +52497,7 @@ private constructor( * .inputMessageAccountabilityData() * .instructingAgentRoutingNumber() * .instructionIdentification() + * .purpose() * .transferId() * .uniqueEndToEndTransactionReference() * .unstructuredRemittanceInformation() @@ -52485,6 +52527,7 @@ private constructor( instructingAgentRoutingNumber, ), checkRequired("instructionIdentification", instructionIdentification), + checkRequired("purpose", purpose), checkRequired("transferId", transferId), checkRequired( "uniqueEndToEndTransactionReference", @@ -52529,6 +52572,7 @@ private constructor( inputMessageAccountabilityData() instructingAgentRoutingNumber() instructionIdentification() + purpose() transferId() uniqueEndToEndTransactionReference() unstructuredRemittanceInformation() @@ -52565,6 +52609,7 @@ private constructor( (if (inputMessageAccountabilityData.asKnown().isPresent) 1 else 0) + (if (instructingAgentRoutingNumber.asKnown().isPresent) 1 else 0) + (if (instructionIdentification.asKnown().isPresent) 1 else 0) + + (if (purpose.asKnown().isPresent) 1 else 0) + (if (transferId.asKnown().isPresent) 1 else 0) + (if (uniqueEndToEndTransactionReference.asKnown().isPresent) 1 else 0) + (if (unstructuredRemittanceInformation.asKnown().isPresent) 1 else 0) @@ -52589,6 +52634,7 @@ private constructor( inputMessageAccountabilityData == other.inputMessageAccountabilityData && instructingAgentRoutingNumber == other.instructingAgentRoutingNumber && instructionIdentification == other.instructionIdentification && + purpose == other.purpose && transferId == other.transferId && uniqueEndToEndTransactionReference == other.uniqueEndToEndTransactionReference && @@ -52612,6 +52658,7 @@ private constructor( inputMessageAccountabilityData, instructingAgentRoutingNumber, instructionIdentification, + purpose, transferId, uniqueEndToEndTransactionReference, unstructuredRemittanceInformation, @@ -52622,7 +52669,7 @@ private constructor( override fun hashCode(): Int = hashCode override fun toString() = - "InboundWireTransfer{amount=$amount, creditorAddressLine1=$creditorAddressLine1, creditorAddressLine2=$creditorAddressLine2, creditorAddressLine3=$creditorAddressLine3, creditorName=$creditorName, debtorAddressLine1=$debtorAddressLine1, debtorAddressLine2=$debtorAddressLine2, debtorAddressLine3=$debtorAddressLine3, debtorName=$debtorName, description=$description, endToEndIdentification=$endToEndIdentification, inputMessageAccountabilityData=$inputMessageAccountabilityData, instructingAgentRoutingNumber=$instructingAgentRoutingNumber, instructionIdentification=$instructionIdentification, transferId=$transferId, uniqueEndToEndTransactionReference=$uniqueEndToEndTransactionReference, unstructuredRemittanceInformation=$unstructuredRemittanceInformation, additionalProperties=$additionalProperties}" + "InboundWireTransfer{amount=$amount, creditorAddressLine1=$creditorAddressLine1, creditorAddressLine2=$creditorAddressLine2, creditorAddressLine3=$creditorAddressLine3, creditorName=$creditorName, debtorAddressLine1=$debtorAddressLine1, debtorAddressLine2=$debtorAddressLine2, debtorAddressLine3=$debtorAddressLine3, debtorName=$debtorName, description=$description, endToEndIdentification=$endToEndIdentification, inputMessageAccountabilityData=$inputMessageAccountabilityData, instructingAgentRoutingNumber=$instructingAgentRoutingNumber, instructionIdentification=$instructionIdentification, purpose=$purpose, transferId=$transferId, uniqueEndToEndTransactionReference=$uniqueEndToEndTransactionReference, unstructuredRemittanceInformation=$unstructuredRemittanceInformation, additionalProperties=$additionalProperties}" } /** diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/wiredrawdownrequests/WireDrawdownRequest.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/wiredrawdownrequests/WireDrawdownRequest.kt index 64a34d349..d88fd7029 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/models/wiredrawdownrequests/WireDrawdownRequest.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/wiredrawdownrequests/WireDrawdownRequest.kt @@ -41,11 +41,13 @@ private constructor( private val debtorExternalAccountId: JsonField, private val debtorName: JsonField, private val debtorRoutingNumber: JsonField, + private val endToEndIdentification: JsonField, private val fulfillmentInboundWireTransferId: JsonField, private val idempotencyKey: JsonField, private val status: JsonField, private val submission: JsonField, private val type: JsonField, + private val uniqueEndToEndTransactionReference: JsonField, private val unstructuredRemittanceInformation: JsonField, private val additionalProperties: MutableMap, ) { @@ -82,6 +84,9 @@ private constructor( @JsonProperty("debtor_routing_number") @ExcludeMissing debtorRoutingNumber: JsonField = JsonMissing.of(), + @JsonProperty("end_to_end_identification") + @ExcludeMissing + endToEndIdentification: JsonField = JsonMissing.of(), @JsonProperty("fulfillment_inbound_wire_transfer_id") @ExcludeMissing fulfillmentInboundWireTransferId: JsonField = JsonMissing.of(), @@ -93,6 +98,9 @@ private constructor( @ExcludeMissing submission: JsonField = JsonMissing.of(), @JsonProperty("type") @ExcludeMissing type: JsonField = JsonMissing.of(), + @JsonProperty("unique_end_to_end_transaction_reference") + @ExcludeMissing + uniqueEndToEndTransactionReference: JsonField = JsonMissing.of(), @JsonProperty("unstructured_remittance_information") @ExcludeMissing unstructuredRemittanceInformation: JsonField = JsonMissing.of(), @@ -109,11 +117,13 @@ private constructor( debtorExternalAccountId, debtorName, debtorRoutingNumber, + endToEndIdentification, fulfillmentInboundWireTransferId, idempotencyKey, status, submission, type, + uniqueEndToEndTransactionReference, unstructuredRemittanceInformation, mutableMapOf(), ) @@ -218,6 +228,16 @@ private constructor( */ fun debtorRoutingNumber(): String = debtorRoutingNumber.getRequired("debtor_routing_number") + /** + * A free-form reference string set by the sender, to be mirrored back in the subsequent wire + * transfer. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun endToEndIdentification(): Optional = + endToEndIdentification.getOptional("end_to_end_identification") + /** * If the recipient fulfills the drawdown request by sending funds, then this will be the * identifier of the corresponding Transaction. @@ -263,6 +283,17 @@ private constructor( */ fun type(): Type = type.getRequired("type") + /** + * The unique end-to-end transaction reference + * ([UETR](https://www.swift.com/payments/what-unique-end-end-transaction-reference-uetr)) of + * the drawdown request. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun uniqueEndToEndTransactionReference(): Optional = + uniqueEndToEndTransactionReference.getOptional("unique_end_to_end_transaction_reference") + /** * Remittance information the debtor will see as part of the drawdown request. * @@ -375,6 +406,16 @@ private constructor( @ExcludeMissing fun _debtorRoutingNumber(): JsonField = debtorRoutingNumber + /** + * Returns the raw JSON value of [endToEndIdentification]. + * + * Unlike [endToEndIdentification], this method doesn't throw if the JSON field has an + * unexpected type. + */ + @JsonProperty("end_to_end_identification") + @ExcludeMissing + fun _endToEndIdentification(): JsonField = endToEndIdentification + /** * Returns the raw JSON value of [fulfillmentInboundWireTransferId]. * @@ -417,6 +458,17 @@ private constructor( */ @JsonProperty("type") @ExcludeMissing fun _type(): JsonField = type + /** + * Returns the raw JSON value of [uniqueEndToEndTransactionReference]. + * + * Unlike [uniqueEndToEndTransactionReference], this method doesn't throw if the JSON field has + * an unexpected type. + */ + @JsonProperty("unique_end_to_end_transaction_reference") + @ExcludeMissing + fun _uniqueEndToEndTransactionReference(): JsonField = + uniqueEndToEndTransactionReference + /** * Returns the raw JSON value of [unstructuredRemittanceInformation]. * @@ -458,11 +510,13 @@ private constructor( * .debtorExternalAccountId() * .debtorName() * .debtorRoutingNumber() + * .endToEndIdentification() * .fulfillmentInboundWireTransferId() * .idempotencyKey() * .status() * .submission() * .type() + * .uniqueEndToEndTransactionReference() * .unstructuredRemittanceInformation() * ``` */ @@ -484,11 +538,13 @@ private constructor( private var debtorExternalAccountId: JsonField? = null private var debtorName: JsonField? = null private var debtorRoutingNumber: JsonField? = null + private var endToEndIdentification: JsonField? = null private var fulfillmentInboundWireTransferId: JsonField? = null private var idempotencyKey: JsonField? = null private var status: JsonField? = null private var submission: JsonField? = null private var type: JsonField? = null + private var uniqueEndToEndTransactionReference: JsonField? = null private var unstructuredRemittanceInformation: JsonField? = null private var additionalProperties: MutableMap = mutableMapOf() @@ -506,11 +562,14 @@ private constructor( debtorExternalAccountId = wireDrawdownRequest.debtorExternalAccountId debtorName = wireDrawdownRequest.debtorName debtorRoutingNumber = wireDrawdownRequest.debtorRoutingNumber + endToEndIdentification = wireDrawdownRequest.endToEndIdentification fulfillmentInboundWireTransferId = wireDrawdownRequest.fulfillmentInboundWireTransferId idempotencyKey = wireDrawdownRequest.idempotencyKey status = wireDrawdownRequest.status submission = wireDrawdownRequest.submission type = wireDrawdownRequest.type + uniqueEndToEndTransactionReference = + wireDrawdownRequest.uniqueEndToEndTransactionReference unstructuredRemittanceInformation = wireDrawdownRequest.unstructuredRemittanceInformation additionalProperties = wireDrawdownRequest.additionalProperties.toMutableMap() @@ -692,6 +751,31 @@ private constructor( this.debtorRoutingNumber = debtorRoutingNumber } + /** + * A free-form reference string set by the sender, to be mirrored back in the subsequent + * wire transfer. + */ + fun endToEndIdentification(endToEndIdentification: String?) = + endToEndIdentification(JsonField.ofNullable(endToEndIdentification)) + + /** + * Alias for calling [Builder.endToEndIdentification] with + * `endToEndIdentification.orElse(null)`. + */ + fun endToEndIdentification(endToEndIdentification: Optional) = + endToEndIdentification(endToEndIdentification.getOrNull()) + + /** + * Sets [Builder.endToEndIdentification] to an arbitrary JSON value. + * + * You should usually call [Builder.endToEndIdentification] with a well-typed [String] value + * instead. This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun endToEndIdentification(endToEndIdentification: JsonField) = apply { + this.endToEndIdentification = endToEndIdentification + } + /** * If the recipient fulfills the drawdown request by sending funds, then this will be the * identifier of the corresponding Transaction. @@ -784,6 +868,35 @@ private constructor( */ fun type(type: JsonField) = apply { this.type = type } + /** + * The unique end-to-end transaction reference + * ([UETR](https://www.swift.com/payments/what-unique-end-end-transaction-reference-uetr)) + * of the drawdown request. + */ + fun uniqueEndToEndTransactionReference(uniqueEndToEndTransactionReference: String?) = + uniqueEndToEndTransactionReference( + JsonField.ofNullable(uniqueEndToEndTransactionReference) + ) + + /** + * Alias for calling [Builder.uniqueEndToEndTransactionReference] with + * `uniqueEndToEndTransactionReference.orElse(null)`. + */ + fun uniqueEndToEndTransactionReference( + uniqueEndToEndTransactionReference: Optional + ) = uniqueEndToEndTransactionReference(uniqueEndToEndTransactionReference.getOrNull()) + + /** + * Sets [Builder.uniqueEndToEndTransactionReference] to an arbitrary JSON value. + * + * You should usually call [Builder.uniqueEndToEndTransactionReference] with a well-typed + * [String] value instead. This method is primarily for setting the field to an undocumented + * or not yet supported value. + */ + fun uniqueEndToEndTransactionReference( + uniqueEndToEndTransactionReference: JsonField + ) = apply { this.uniqueEndToEndTransactionReference = uniqueEndToEndTransactionReference } + /** Remittance information the debtor will see as part of the drawdown request. */ fun unstructuredRemittanceInformation(unstructuredRemittanceInformation: String) = unstructuredRemittanceInformation(JsonField.of(unstructuredRemittanceInformation)) @@ -837,11 +950,13 @@ private constructor( * .debtorExternalAccountId() * .debtorName() * .debtorRoutingNumber() + * .endToEndIdentification() * .fulfillmentInboundWireTransferId() * .idempotencyKey() * .status() * .submission() * .type() + * .uniqueEndToEndTransactionReference() * .unstructuredRemittanceInformation() * ``` * @@ -861,11 +976,16 @@ private constructor( checkRequired("debtorExternalAccountId", debtorExternalAccountId), checkRequired("debtorName", debtorName), checkRequired("debtorRoutingNumber", debtorRoutingNumber), + checkRequired("endToEndIdentification", endToEndIdentification), checkRequired("fulfillmentInboundWireTransferId", fulfillmentInboundWireTransferId), checkRequired("idempotencyKey", idempotencyKey), checkRequired("status", status), checkRequired("submission", submission), checkRequired("type", type), + checkRequired( + "uniqueEndToEndTransactionReference", + uniqueEndToEndTransactionReference, + ), checkRequired( "unstructuredRemittanceInformation", unstructuredRemittanceInformation, @@ -901,11 +1021,13 @@ private constructor( debtorExternalAccountId() debtorName() debtorRoutingNumber() + endToEndIdentification() fulfillmentInboundWireTransferId() idempotencyKey() status().validate() submission().ifPresent { it.validate() } type().validate() + uniqueEndToEndTransactionReference() unstructuredRemittanceInformation() validated = true } @@ -937,11 +1059,13 @@ private constructor( (if (debtorExternalAccountId.asKnown().isPresent) 1 else 0) + (if (debtorName.asKnown().isPresent) 1 else 0) + (if (debtorRoutingNumber.asKnown().isPresent) 1 else 0) + + (if (endToEndIdentification.asKnown().isPresent) 1 else 0) + (if (fulfillmentInboundWireTransferId.asKnown().isPresent) 1 else 0) + (if (idempotencyKey.asKnown().isPresent) 1 else 0) + (status.asKnown().getOrNull()?.validity() ?: 0) + (submission.asKnown().getOrNull()?.validity() ?: 0) + (type.asKnown().getOrNull()?.validity() ?: 0) + + (if (uniqueEndToEndTransactionReference.asKnown().isPresent) 1 else 0) + (if (unstructuredRemittanceInformation.asKnown().isPresent) 1 else 0) /** The creditor's address. */ @@ -2196,11 +2320,13 @@ private constructor( debtorExternalAccountId == other.debtorExternalAccountId && debtorName == other.debtorName && debtorRoutingNumber == other.debtorRoutingNumber && + endToEndIdentification == other.endToEndIdentification && fulfillmentInboundWireTransferId == other.fulfillmentInboundWireTransferId && idempotencyKey == other.idempotencyKey && status == other.status && submission == other.submission && type == other.type && + uniqueEndToEndTransactionReference == other.uniqueEndToEndTransactionReference && unstructuredRemittanceInformation == other.unstructuredRemittanceInformation && additionalProperties == other.additionalProperties } @@ -2219,11 +2345,13 @@ private constructor( debtorExternalAccountId, debtorName, debtorRoutingNumber, + endToEndIdentification, fulfillmentInboundWireTransferId, idempotencyKey, status, submission, type, + uniqueEndToEndTransactionReference, unstructuredRemittanceInformation, additionalProperties, ) @@ -2232,5 +2360,5 @@ private constructor( override fun hashCode(): Int = hashCode override fun toString() = - "WireDrawdownRequest{id=$id, accountNumberId=$accountNumberId, amount=$amount, createdAt=$createdAt, creditorAddress=$creditorAddress, creditorName=$creditorName, currency=$currency, debtorAccountNumber=$debtorAccountNumber, debtorAddress=$debtorAddress, debtorExternalAccountId=$debtorExternalAccountId, debtorName=$debtorName, debtorRoutingNumber=$debtorRoutingNumber, fulfillmentInboundWireTransferId=$fulfillmentInboundWireTransferId, idempotencyKey=$idempotencyKey, status=$status, submission=$submission, type=$type, unstructuredRemittanceInformation=$unstructuredRemittanceInformation, additionalProperties=$additionalProperties}" + "WireDrawdownRequest{id=$id, accountNumberId=$accountNumberId, amount=$amount, createdAt=$createdAt, creditorAddress=$creditorAddress, creditorName=$creditorName, currency=$currency, debtorAccountNumber=$debtorAccountNumber, debtorAddress=$debtorAddress, debtorExternalAccountId=$debtorExternalAccountId, debtorName=$debtorName, debtorRoutingNumber=$debtorRoutingNumber, endToEndIdentification=$endToEndIdentification, fulfillmentInboundWireTransferId=$fulfillmentInboundWireTransferId, idempotencyKey=$idempotencyKey, status=$status, submission=$submission, type=$type, uniqueEndToEndTransactionReference=$uniqueEndToEndTransactionReference, unstructuredRemittanceInformation=$unstructuredRemittanceInformation, additionalProperties=$additionalProperties}" } diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/carddisputes/CardDisputeListPageResponseTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/carddisputes/CardDisputeListPageResponseTest.kt index 9d9a6b5d9..e3c189660 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/carddisputes/CardDisputeListPageResponseTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/carddisputes/CardDisputeListPageResponseTest.kt @@ -30,6 +30,12 @@ internal class CardDisputeListPageResponseTest { .build() ) .network(CardDispute.Network.VISA) + .rejection( + CardDispute.Rejection.builder() + .explanation("Card Dispute is not allowed per network rules.") + .rejectedAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .build() + ) .status(CardDispute.Status.PENDING_RESPONSE) .type(CardDispute.Type.CARD_DISPUTE) .userSubmissionRequiredBy(null) @@ -1422,6 +1428,12 @@ internal class CardDisputeListPageResponseTest { .build() ) .network(CardDispute.Network.VISA) + .rejection( + CardDispute.Rejection.builder() + .explanation("Card Dispute is not allowed per network rules.") + .rejectedAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .build() + ) .status(CardDispute.Status.PENDING_RESPONSE) .type(CardDispute.Type.CARD_DISPUTE) .userSubmissionRequiredBy(null) @@ -2723,6 +2735,12 @@ internal class CardDisputeListPageResponseTest { .build() ) .network(CardDispute.Network.VISA) + .rejection( + CardDispute.Rejection.builder() + .explanation("Card Dispute is not allowed per network rules.") + .rejectedAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .build() + ) .status(CardDispute.Status.PENDING_RESPONSE) .type(CardDispute.Type.CARD_DISPUTE) .userSubmissionRequiredBy(null) diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/carddisputes/CardDisputeTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/carddisputes/CardDisputeTest.kt index 9fa0bef3e..cdffa3701 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/carddisputes/CardDisputeTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/carddisputes/CardDisputeTest.kt @@ -28,6 +28,12 @@ internal class CardDisputeTest { .build() ) .network(CardDispute.Network.VISA) + .rejection( + CardDispute.Rejection.builder() + .explanation("Card Dispute is not allowed per network rules.") + .rejectedAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .build() + ) .status(CardDispute.Status.PENDING_RESPONSE) .type(CardDispute.Type.CARD_DISPUTE) .userSubmissionRequiredBy(null) @@ -1235,6 +1241,13 @@ internal class CardDisputeTest { .build() ) assertThat(cardDispute.network()).isEqualTo(CardDispute.Network.VISA) + assertThat(cardDispute.rejection()) + .contains( + CardDispute.Rejection.builder() + .explanation("Card Dispute is not allowed per network rules.") + .rejectedAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .build() + ) assertThat(cardDispute.status()).isEqualTo(CardDispute.Status.PENDING_RESPONSE) assertThat(cardDispute.type()).isEqualTo(CardDispute.Type.CARD_DISPUTE) assertThat(cardDispute.userSubmissionRequiredBy()).isEmpty @@ -2398,6 +2411,12 @@ internal class CardDisputeTest { .build() ) .network(CardDispute.Network.VISA) + .rejection( + CardDispute.Rejection.builder() + .explanation("Card Dispute is not allowed per network rules.") + .rejectedAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .build() + ) .status(CardDispute.Status.PENDING_RESPONSE) .type(CardDispute.Type.CARD_DISPUTE) .userSubmissionRequiredBy(null) diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/cardpayments/CardPaymentListPageResponseTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/cardpayments/CardPaymentListPageResponseTest.kt index ff2eba4fa..957718c14 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/cardpayments/CardPaymentListPageResponseTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/cardpayments/CardPaymentListPageResponseTest.kt @@ -324,6 +324,17 @@ internal class CardPaymentListPageResponseTest { .SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare + .builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization + .Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -2716,6 +2727,17 @@ internal class CardPaymentListPageResponseTest { .SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare + .builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization + .Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -5108,6 +5130,17 @@ internal class CardPaymentListPageResponseTest { .SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare + .builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization + .Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -7500,6 +7533,17 @@ internal class CardPaymentListPageResponseTest { .SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare + .builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization + .Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -9911,6 +9955,16 @@ internal class CardPaymentListPageResponseTest { .SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare + .builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization.Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -12171,6 +12225,16 @@ internal class CardPaymentListPageResponseTest { .SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare + .builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization.Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -14431,6 +14495,16 @@ internal class CardPaymentListPageResponseTest { .SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare + .builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization.Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -16691,6 +16765,16 @@ internal class CardPaymentListPageResponseTest { .SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare + .builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization.Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -18996,6 +19080,17 @@ internal class CardPaymentListPageResponseTest { .SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare + .builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization + .Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -21388,6 +21483,17 @@ internal class CardPaymentListPageResponseTest { .SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare + .builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization + .Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -23780,6 +23886,17 @@ internal class CardPaymentListPageResponseTest { .SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare + .builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization + .Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -26172,6 +26289,17 @@ internal class CardPaymentListPageResponseTest { .SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare + .builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization + .Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/cardpayments/CardPaymentTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/cardpayments/CardPaymentTest.kt index a16742672..597f47d76 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/cardpayments/CardPaymentTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/cardpayments/CardPaymentTest.kt @@ -300,6 +300,15 @@ internal class CardPaymentTest { CardPayment.Element.CardAuthorization.Direction.SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare.builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization.Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -2401,6 +2410,15 @@ internal class CardPaymentTest { CardPayment.Element.CardAuthorization.Direction.SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare.builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization.Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -4502,6 +4520,15 @@ internal class CardPaymentTest { CardPayment.Element.CardAuthorization.Direction.SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare.builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization.Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -6603,6 +6630,15 @@ internal class CardPaymentTest { CardPayment.Element.CardAuthorization.Direction.SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare.builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization.Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -8694,6 +8730,15 @@ internal class CardPaymentTest { .digitalWalletTokenId(null) .direction(CardPayment.Element.CardAuthorization.Direction.SETTLEMENT) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare.builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization.Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -10579,6 +10624,15 @@ internal class CardPaymentTest { .digitalWalletTokenId(null) .direction(CardPayment.Element.CardAuthorization.Direction.SETTLEMENT) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare.builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization.Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -12464,6 +12518,15 @@ internal class CardPaymentTest { .digitalWalletTokenId(null) .direction(CardPayment.Element.CardAuthorization.Direction.SETTLEMENT) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare.builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization.Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -14349,6 +14412,15 @@ internal class CardPaymentTest { .digitalWalletTokenId(null) .direction(CardPayment.Element.CardAuthorization.Direction.SETTLEMENT) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare.builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization.Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -16297,6 +16369,15 @@ internal class CardPaymentTest { CardPayment.Element.CardAuthorization.Direction.SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare.builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization.Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -18398,6 +18479,15 @@ internal class CardPaymentTest { CardPayment.Element.CardAuthorization.Direction.SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare.builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization.Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -20499,6 +20589,15 @@ internal class CardPaymentTest { CardPayment.Element.CardAuthorization.Direction.SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare.builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization.Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -22600,6 +22699,15 @@ internal class CardPaymentTest { CardPayment.Element.CardAuthorization.Direction.SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + CardPayment.Element.CardAuthorization.Healthcare.builder() + .merchantNinetyPercentEligibility( + CardPayment.Element.CardAuthorization.Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/cardpushtransfers/CardPushTransferListPageResponseTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/cardpushtransfers/CardPushTransferListPageResponseTest.kt index e96fcb92c..90ef547f3 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/cardpushtransfers/CardPushTransferListPageResponseTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/cardpushtransfers/CardPushTransferListPageResponseTest.kt @@ -77,16 +77,22 @@ internal class CardPushTransferListPageResponseTest { .idempotencyKey(null) .merchantCategoryCode("1234") .merchantCityName("New York") + .merchantLegalBusinessName(null) .merchantName("Acme Corp") .merchantNamePrefix("Acme") .merchantPostalCode("10045") .merchantState("NY") + .merchantStreetAddress(null) .presentmentAmount( CardPushTransfer.PresentmentAmount.builder() .currency(CardPushTransfer.PresentmentAmount.Currency.USD) .value("12.34") .build() ) + .recipientAddressCity(null) + .recipientAddressLine1(null) + .recipientAddressPostalCode(null) + .recipientAddressState(null) .recipientName("Ian Crease") .route(CardPushTransfer.Route.VISA) .senderAddressCity("New York") @@ -174,16 +180,22 @@ internal class CardPushTransferListPageResponseTest { .idempotencyKey(null) .merchantCategoryCode("1234") .merchantCityName("New York") + .merchantLegalBusinessName(null) .merchantName("Acme Corp") .merchantNamePrefix("Acme") .merchantPostalCode("10045") .merchantState("NY") + .merchantStreetAddress(null) .presentmentAmount( CardPushTransfer.PresentmentAmount.builder() .currency(CardPushTransfer.PresentmentAmount.Currency.USD) .value("12.34") .build() ) + .recipientAddressCity(null) + .recipientAddressLine1(null) + .recipientAddressPostalCode(null) + .recipientAddressState(null) .recipientName("Ian Crease") .route(CardPushTransfer.Route.VISA) .senderAddressCity("New York") @@ -275,16 +287,22 @@ internal class CardPushTransferListPageResponseTest { .idempotencyKey(null) .merchantCategoryCode("1234") .merchantCityName("New York") + .merchantLegalBusinessName(null) .merchantName("Acme Corp") .merchantNamePrefix("Acme") .merchantPostalCode("10045") .merchantState("NY") + .merchantStreetAddress(null) .presentmentAmount( CardPushTransfer.PresentmentAmount.builder() .currency(CardPushTransfer.PresentmentAmount.Currency.USD) .value("12.34") .build() ) + .recipientAddressCity(null) + .recipientAddressLine1(null) + .recipientAddressPostalCode(null) + .recipientAddressState(null) .recipientName("Ian Crease") .route(CardPushTransfer.Route.VISA) .senderAddressCity("New York") diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/cardpushtransfers/CardPushTransferTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/cardpushtransfers/CardPushTransferTest.kt index 91e8dc4b1..b5020aef4 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/cardpushtransfers/CardPushTransferTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/cardpushtransfers/CardPushTransferTest.kt @@ -74,16 +74,22 @@ internal class CardPushTransferTest { .idempotencyKey(null) .merchantCategoryCode("1234") .merchantCityName("New York") + .merchantLegalBusinessName(null) .merchantName("Acme Corp") .merchantNamePrefix("Acme") .merchantPostalCode("10045") .merchantState("NY") + .merchantStreetAddress(null) .presentmentAmount( CardPushTransfer.PresentmentAmount.builder() .currency(CardPushTransfer.PresentmentAmount.Currency.USD) .value("12.34") .build() ) + .recipientAddressCity(null) + .recipientAddressLine1(null) + .recipientAddressPostalCode(null) + .recipientAddressState(null) .recipientName("Ian Crease") .route(CardPushTransfer.Route.VISA) .senderAddressCity("New York") @@ -165,10 +171,12 @@ internal class CardPushTransferTest { assertThat(cardPushTransfer.idempotencyKey()).isEmpty assertThat(cardPushTransfer.merchantCategoryCode()).isEqualTo("1234") assertThat(cardPushTransfer.merchantCityName()).isEqualTo("New York") + assertThat(cardPushTransfer.merchantLegalBusinessName()).isEmpty assertThat(cardPushTransfer.merchantName()).isEqualTo("Acme Corp") assertThat(cardPushTransfer.merchantNamePrefix()).isEqualTo("Acme") assertThat(cardPushTransfer.merchantPostalCode()).isEqualTo("10045") assertThat(cardPushTransfer.merchantState()).isEqualTo("NY") + assertThat(cardPushTransfer.merchantStreetAddress()).isEmpty assertThat(cardPushTransfer.presentmentAmount()) .isEqualTo( CardPushTransfer.PresentmentAmount.builder() @@ -176,6 +184,10 @@ internal class CardPushTransferTest { .value("12.34") .build() ) + assertThat(cardPushTransfer.recipientAddressCity()).isEmpty + assertThat(cardPushTransfer.recipientAddressLine1()).isEmpty + assertThat(cardPushTransfer.recipientAddressPostalCode()).isEmpty + assertThat(cardPushTransfer.recipientAddressState()).isEmpty assertThat(cardPushTransfer.recipientName()).isEqualTo("Ian Crease") assertThat(cardPushTransfer.route()).isEqualTo(CardPushTransfer.Route.VISA) assertThat(cardPushTransfer.senderAddressCity()).isEqualTo("New York") @@ -263,16 +275,22 @@ internal class CardPushTransferTest { .idempotencyKey(null) .merchantCategoryCode("1234") .merchantCityName("New York") + .merchantLegalBusinessName(null) .merchantName("Acme Corp") .merchantNamePrefix("Acme") .merchantPostalCode("10045") .merchantState("NY") + .merchantStreetAddress(null) .presentmentAmount( CardPushTransfer.PresentmentAmount.builder() .currency(CardPushTransfer.PresentmentAmount.Currency.USD) .value("12.34") .build() ) + .recipientAddressCity(null) + .recipientAddressLine1(null) + .recipientAddressPostalCode(null) + .recipientAddressState(null) .recipientName("Ian Crease") .route(CardPushTransfer.Route.VISA) .senderAddressCity("New York") diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/cards/CardListPageResponseTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/cards/CardListPageResponseTest.kt index fc86918b5..93819533b 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/cards/CardListPageResponseTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/cards/CardListPageResponseTest.kt @@ -133,6 +133,7 @@ internal class CardListPageResponseTest { .state("NY") .build() ) + .bin("42424242") .createdAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) .description("Office Expenses") .digitalWallet( @@ -267,6 +268,7 @@ internal class CardListPageResponseTest { .state("NY") .build() ) + .bin("42424242") .createdAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) .description("Office Expenses") .digitalWallet( @@ -412,6 +414,7 @@ internal class CardListPageResponseTest { .state("NY") .build() ) + .bin("42424242") .createdAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) .description("Office Expenses") .digitalWallet( diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/cards/CardTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/cards/CardTest.kt index 09633573b..03724e3c1 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/cards/CardTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/cards/CardTest.kt @@ -121,6 +121,7 @@ internal class CardTest { .state("NY") .build() ) + .bin("42424242") .createdAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) .description("Office Expenses") .digitalWallet( @@ -245,6 +246,7 @@ internal class CardTest { .state("NY") .build() ) + assertThat(card.bin()).isEqualTo("42424242") assertThat(card.createdAt()).isEqualTo(OffsetDateTime.parse("2020-01-31T23:59:59Z")) assertThat(card.description()).contains("Office Expenses") assertThat(card.digitalWallet()) @@ -376,6 +378,7 @@ internal class CardTest { .state("NY") .build() ) + .bin("42424242") .createdAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) .description("Office Expenses") .digitalWallet( diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/checktransfers/CheckTransferListPageResponseTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/checktransfers/CheckTransferListPageResponseTest.kt index fe65078a6..654187458 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/checktransfers/CheckTransferListPageResponseTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/checktransfers/CheckTransferListPageResponseTest.kt @@ -107,7 +107,9 @@ internal class CheckTransferListPageResponseTest { .state("NY") .build() ) - .shippingMethod(null) + .shippingMethod( + CheckTransfer.PhysicalCheck.ShippingMethod.USPS_FIRST_CLASS + ) .signature( CheckTransfer.PhysicalCheck.Signature.builder() .imageFileId(null) @@ -266,7 +268,9 @@ internal class CheckTransferListPageResponseTest { .state("NY") .build() ) - .shippingMethod(null) + .shippingMethod( + CheckTransfer.PhysicalCheck.ShippingMethod.USPS_FIRST_CLASS + ) .signature( CheckTransfer.PhysicalCheck.Signature.builder() .imageFileId(null) @@ -425,7 +429,9 @@ internal class CheckTransferListPageResponseTest { .state("NY") .build() ) - .shippingMethod(null) + .shippingMethod( + CheckTransfer.PhysicalCheck.ShippingMethod.USPS_FIRST_CLASS + ) .signature( CheckTransfer.PhysicalCheck.Signature.builder() .imageFileId(null) diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/checktransfers/CheckTransferTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/checktransfers/CheckTransferTest.kt index 1728f5b26..c0e220313 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/checktransfers/CheckTransferTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/checktransfers/CheckTransferTest.kt @@ -101,7 +101,7 @@ internal class CheckTransferTest { .state("NY") .build() ) - .shippingMethod(null) + .shippingMethod(CheckTransfer.PhysicalCheck.ShippingMethod.USPS_FIRST_CLASS) .signature( CheckTransfer.PhysicalCheck.Signature.builder() .imageFileId(null) @@ -250,7 +250,7 @@ internal class CheckTransferTest { .state("NY") .build() ) - .shippingMethod(null) + .shippingMethod(CheckTransfer.PhysicalCheck.ShippingMethod.USPS_FIRST_CLASS) .signature( CheckTransfer.PhysicalCheck.Signature.builder() .imageFileId(null) @@ -398,7 +398,7 @@ internal class CheckTransferTest { .state("NY") .build() ) - .shippingMethod(null) + .shippingMethod(CheckTransfer.PhysicalCheck.ShippingMethod.USPS_FIRST_CLASS) .signature( CheckTransfer.PhysicalCheck.Signature.builder() .imageFileId(null) diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/digitalwallettokens/DigitalWalletTokenListPageResponseTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/digitalwallettokens/DigitalWalletTokenListPageResponseTest.kt index 5248556e3..8e2a71a5d 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/digitalwallettokens/DigitalWalletTokenListPageResponseTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/digitalwallettokens/DigitalWalletTokenListPageResponseTest.kt @@ -22,6 +22,11 @@ internal class DigitalWalletTokenListPageResponseTest { DigitalWalletToken.Cardholder.builder().name("John Smith").build() ) .createdAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .decline( + DigitalWalletToken.Decline.builder() + .reason(DigitalWalletToken.Decline.Reason.CARD_NOT_ACTIVE) + .build() + ) .device( DigitalWalletToken.Device.builder() .deviceType(DigitalWalletToken.Device.DeviceType.MOBILE_PHONE) @@ -57,6 +62,11 @@ internal class DigitalWalletTokenListPageResponseTest { .cardId("card_oubs0hwk5rn6knuecxg2") .cardholder(DigitalWalletToken.Cardholder.builder().name("John Smith").build()) .createdAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .decline( + DigitalWalletToken.Decline.builder() + .reason(DigitalWalletToken.Decline.Reason.CARD_NOT_ACTIVE) + .build() + ) .device( DigitalWalletToken.Device.builder() .deviceType(DigitalWalletToken.Device.DeviceType.MOBILE_PHONE) @@ -98,6 +108,11 @@ internal class DigitalWalletTokenListPageResponseTest { DigitalWalletToken.Cardholder.builder().name("John Smith").build() ) .createdAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .decline( + DigitalWalletToken.Decline.builder() + .reason(DigitalWalletToken.Decline.Reason.CARD_NOT_ACTIVE) + .build() + ) .device( DigitalWalletToken.Device.builder() .deviceType(DigitalWalletToken.Device.DeviceType.MOBILE_PHONE) diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/digitalwallettokens/DigitalWalletTokenTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/digitalwallettokens/DigitalWalletTokenTest.kt index 24f428d18..1c81e31be 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/digitalwallettokens/DigitalWalletTokenTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/digitalwallettokens/DigitalWalletTokenTest.kt @@ -18,6 +18,11 @@ internal class DigitalWalletTokenTest { .cardId("card_oubs0hwk5rn6knuecxg2") .cardholder(DigitalWalletToken.Cardholder.builder().name("John Smith").build()) .createdAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .decline( + DigitalWalletToken.Decline.builder() + .reason(DigitalWalletToken.Decline.Reason.CARD_NOT_ACTIVE) + .build() + ) .device( DigitalWalletToken.Device.builder() .deviceType(DigitalWalletToken.Device.DeviceType.MOBILE_PHONE) @@ -49,6 +54,12 @@ internal class DigitalWalletTokenTest { .isEqualTo(DigitalWalletToken.Cardholder.builder().name("John Smith").build()) assertThat(digitalWalletToken.createdAt()) .isEqualTo(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + assertThat(digitalWalletToken.decline()) + .contains( + DigitalWalletToken.Decline.builder() + .reason(DigitalWalletToken.Decline.Reason.CARD_NOT_ACTIVE) + .build() + ) assertThat(digitalWalletToken.device()) .isEqualTo( DigitalWalletToken.Device.builder() @@ -88,6 +99,11 @@ internal class DigitalWalletTokenTest { .cardId("card_oubs0hwk5rn6knuecxg2") .cardholder(DigitalWalletToken.Cardholder.builder().name("John Smith").build()) .createdAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .decline( + DigitalWalletToken.Decline.builder() + .reason(DigitalWalletToken.Decline.Reason.CARD_NOT_ACTIVE) + .build() + ) .device( DigitalWalletToken.Device.builder() .deviceType(DigitalWalletToken.Device.DeviceType.MOBILE_PHONE) diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/entities/EntityCreateParamsTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/entities/EntityCreateParamsTest.kt index 24f353d2d..8b6986ddf 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/entities/EntityCreateParamsTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/entities/EntityCreateParamsTest.kt @@ -260,9 +260,7 @@ internal class EntityCreateParamsTest { .build() ) .addSupplementalDocument( - EntityCreateParams.SupplementalDocument.builder() - .fileId("file_makxrc67oh9l6sg7w9yc") - .build() + EntityCreateParams.SupplementalDocument.builder().fileId("file_id").build() ) .addTermsAgreement( EntityCreateParams.TermsAgreement.builder() @@ -685,9 +683,7 @@ internal class EntityCreateParamsTest { .build() ) .addSupplementalDocument( - EntityCreateParams.SupplementalDocument.builder() - .fileId("file_makxrc67oh9l6sg7w9yc") - .build() + EntityCreateParams.SupplementalDocument.builder().fileId("file_id").build() ) .addTermsAgreement( EntityCreateParams.TermsAgreement.builder() @@ -1106,9 +1102,7 @@ internal class EntityCreateParamsTest { ) assertThat(body.supplementalDocuments().getOrNull()) .containsExactly( - EntityCreateParams.SupplementalDocument.builder() - .fileId("file_makxrc67oh9l6sg7w9yc") - .build() + EntityCreateParams.SupplementalDocument.builder().fileId("file_id").build() ) assertThat(body.termsAgreements().getOrNull()) .containsExactly( diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/entities/EntityListPageResponseTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/entities/EntityListPageResponseTest.kt index 96f518508..f31db870a 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/entities/EntityListPageResponseTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/entities/EntityListPageResponseTest.kt @@ -193,9 +193,9 @@ internal class EntityListPageResponseTest { ) .addTermsAgreement( Entity.TermsAgreement.builder() - .agreedAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) - .ipAddress("128.32.0.1") - .termsUrl("https://increase.com/example_terms") + .agreedAt(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .ipAddress("ip_address") + .termsUrl("terms_url") .build() ) .thirdPartyVerification( @@ -504,9 +504,9 @@ internal class EntityListPageResponseTest { ) .addTermsAgreement( Entity.TermsAgreement.builder() - .agreedAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) - .ipAddress("128.32.0.1") - .termsUrl("https://increase.com/example_terms") + .agreedAt(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .ipAddress("ip_address") + .termsUrl("terms_url") .build() ) .thirdPartyVerification( @@ -819,9 +819,9 @@ internal class EntityListPageResponseTest { ) .addTermsAgreement( Entity.TermsAgreement.builder() - .agreedAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) - .ipAddress("128.32.0.1") - .termsUrl("https://increase.com/example_terms") + .agreedAt(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .ipAddress("ip_address") + .termsUrl("terms_url") .build() ) .thirdPartyVerification( diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/entities/EntityTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/entities/EntityTest.kt index 5126c65e6..0b67effad 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/entities/EntityTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/entities/EntityTest.kt @@ -187,9 +187,9 @@ internal class EntityTest { ) .addTermsAgreement( Entity.TermsAgreement.builder() - .agreedAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) - .ipAddress("128.32.0.1") - .termsUrl("https://increase.com/example_terms") + .agreedAt(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .ipAddress("ip_address") + .termsUrl("terms_url") .build() ) .thirdPartyVerification( @@ -487,9 +487,9 @@ internal class EntityTest { assertThat(entity.termsAgreements()) .containsExactly( Entity.TermsAgreement.builder() - .agreedAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) - .ipAddress("128.32.0.1") - .termsUrl("https://increase.com/example_terms") + .agreedAt(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .ipAddress("ip_address") + .termsUrl("terms_url") .build() ) assertThat(entity.thirdPartyVerification()) @@ -789,9 +789,9 @@ internal class EntityTest { ) .addTermsAgreement( Entity.TermsAgreement.builder() - .agreedAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) - .ipAddress("128.32.0.1") - .termsUrl("https://increase.com/example_terms") + .agreedAt(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .ipAddress("ip_address") + .termsUrl("terms_url") .build() ) .thirdPartyVerification( 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 ea2c9fedf..15e5c216d 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 @@ -52,6 +52,19 @@ internal class ExportCreateParamsTest { .build() ) .entityCsv(ExportCreateParams.EntityCsv.builder().build()) + .feeCsv( + ExportCreateParams.FeeCsv.builder() + .createdAt( + ExportCreateParams.FeeCsv.CreatedAt.builder() + .after(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .before(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .onOrAfter(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .onOrBefore(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .build() + ) + .programId("program_id") + .build() + ) .fundingInstructions( ExportCreateParams.FundingInstructions.builder() .accountNumberId("account_number_id") @@ -124,6 +137,19 @@ internal class ExportCreateParamsTest { .build() ) .entityCsv(ExportCreateParams.EntityCsv.builder().build()) + .feeCsv( + ExportCreateParams.FeeCsv.builder() + .createdAt( + ExportCreateParams.FeeCsv.CreatedAt.builder() + .after(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .before(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .onOrAfter(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .onOrBefore(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .build() + ) + .programId("program_id") + .build() + ) .fundingInstructions( ExportCreateParams.FundingInstructions.builder() .accountNumberId("account_number_id") @@ -200,6 +226,20 @@ internal class ExportCreateParamsTest { .build() ) assertThat(body.entityCsv()).contains(ExportCreateParams.EntityCsv.builder().build()) + assertThat(body.feeCsv()) + .contains( + ExportCreateParams.FeeCsv.builder() + .createdAt( + ExportCreateParams.FeeCsv.CreatedAt.builder() + .after(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .before(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .onOrAfter(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .onOrBefore(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .build() + ) + .programId("program_id") + .build() + ) assertThat(body.fundingInstructions()) .contains( ExportCreateParams.FundingInstructions.builder() diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/exports/ExportListPageResponseTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/exports/ExportListPageResponseTest.kt index 88060004f..093a9dcd8 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/exports/ExportListPageResponseTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/exports/ExportListPageResponseTest.kt @@ -77,6 +77,10 @@ internal class ExportListPageResponseTest { Export.FeeCsv.CreatedAt.builder() .after(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) .before(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .onOrAfter(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .onOrBefore( + OffsetDateTime.parse("2019-12-27T18:11:19.117Z") + ) .build() ) .build() @@ -191,6 +195,8 @@ internal class ExportListPageResponseTest { Export.FeeCsv.CreatedAt.builder() .after(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) .before(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .onOrAfter(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .onOrBefore(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) .build() ) .build() @@ -309,6 +315,10 @@ internal class ExportListPageResponseTest { Export.FeeCsv.CreatedAt.builder() .after(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) .before(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .onOrAfter(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .onOrBefore( + OffsetDateTime.parse("2019-12-27T18:11:19.117Z") + ) .build() ) .build() diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/exports/ExportTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/exports/ExportTest.kt index 9ab002edb..44a8a48a0 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/exports/ExportTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/exports/ExportTest.kt @@ -75,6 +75,8 @@ internal class ExportTest { Export.FeeCsv.CreatedAt.builder() .after(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) .before(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .onOrAfter(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .onOrBefore(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) .build() ) .build() @@ -190,6 +192,8 @@ internal class ExportTest { Export.FeeCsv.CreatedAt.builder() .after(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) .before(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .onOrAfter(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .onOrBefore(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) .build() ) .build() @@ -307,6 +311,8 @@ internal class ExportTest { Export.FeeCsv.CreatedAt.builder() .after(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) .before(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .onOrAfter(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .onOrBefore(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) .build() ) .build() diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/fednowtransfers/FednowTransferListPageResponseTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/fednowtransfers/FednowTransferListPageResponseTest.kt index 365bbde56..7063f7fd0 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/fednowtransfers/FednowTransferListPageResponseTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/fednowtransfers/FednowTransferListPageResponseTest.kt @@ -56,6 +56,14 @@ internal class FednowTransferListPageResponseTest { ) .creditorName("Ian Crease") .currency(FednowTransfer.Currency.USD) + .debtorAddress( + FednowTransfer.DebtorAddress.builder() + .city("New York") + .line1("33 Liberty Street") + .postalCode("10045") + .state("NY") + .build() + ) .debtorName("National Phonograph Company") .externalAccountId(null) .idempotencyKey(null) @@ -128,6 +136,14 @@ internal class FednowTransferListPageResponseTest { ) .creditorName("Ian Crease") .currency(FednowTransfer.Currency.USD) + .debtorAddress( + FednowTransfer.DebtorAddress.builder() + .city("New York") + .line1("33 Liberty Street") + .postalCode("10045") + .state("NY") + .build() + ) .debtorName("National Phonograph Company") .externalAccountId(null) .idempotencyKey(null) @@ -204,6 +220,14 @@ internal class FednowTransferListPageResponseTest { ) .creditorName("Ian Crease") .currency(FednowTransfer.Currency.USD) + .debtorAddress( + FednowTransfer.DebtorAddress.builder() + .city("New York") + .line1("33 Liberty Street") + .postalCode("10045") + .state("NY") + .build() + ) .debtorName("National Phonograph Company") .externalAccountId(null) .idempotencyKey(null) diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/fednowtransfers/FednowTransferTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/fednowtransfers/FednowTransferTest.kt index 700e9807d..9b5d2b27d 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/fednowtransfers/FednowTransferTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/fednowtransfers/FednowTransferTest.kt @@ -52,6 +52,14 @@ internal class FednowTransferTest { ) .creditorName("Ian Crease") .currency(FednowTransfer.Currency.USD) + .debtorAddress( + FednowTransfer.DebtorAddress.builder() + .city("New York") + .line1("33 Liberty Street") + .postalCode("10045") + .state("NY") + .build() + ) .debtorName("National Phonograph Company") .externalAccountId(null) .idempotencyKey(null) @@ -114,6 +122,15 @@ internal class FednowTransferTest { ) assertThat(fednowTransfer.creditorName()).isEqualTo("Ian Crease") assertThat(fednowTransfer.currency()).isEqualTo(FednowTransfer.Currency.USD) + assertThat(fednowTransfer.debtorAddress()) + .contains( + FednowTransfer.DebtorAddress.builder() + .city("New York") + .line1("33 Liberty Street") + .postalCode("10045") + .state("NY") + .build() + ) assertThat(fednowTransfer.debtorName()).isEqualTo("National Phonograph Company") assertThat(fednowTransfer.externalAccountId()).isEmpty assertThat(fednowTransfer.idempotencyKey()).isEmpty @@ -188,6 +205,14 @@ internal class FednowTransferTest { ) .creditorName("Ian Crease") .currency(FednowTransfer.Currency.USD) + .debtorAddress( + FednowTransfer.DebtorAddress.builder() + .city("New York") + .line1("33 Liberty Street") + .postalCode("10045") + .state("NY") + .build() + ) .debtorName("National Phonograph Company") .externalAccountId(null) .idempotencyKey(null) diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/inboundwiretransfers/InboundWireTransferListPageResponseTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/inboundwiretransfers/InboundWireTransferListPageResponseTest.kt index 04d3155e0..46f959c60 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/inboundwiretransfers/InboundWireTransferListPageResponseTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/inboundwiretransfers/InboundWireTransferListPageResponseTest.kt @@ -40,6 +40,7 @@ internal class InboundWireTransferListPageResponseTest { .inputMessageAccountabilityData("20220118MMQFMP0P000001") .instructingAgentRoutingNumber("101050001") .instructionIdentification("202201180000001") + .purpose("CASH") .reversal( InboundWireTransfer.Reversal.builder() .reason(InboundWireTransfer.Reversal.Reason.DUPLICATE) @@ -83,6 +84,7 @@ internal class InboundWireTransferListPageResponseTest { .inputMessageAccountabilityData("20220118MMQFMP0P000001") .instructingAgentRoutingNumber("101050001") .instructionIdentification("202201180000001") + .purpose("CASH") .reversal( InboundWireTransfer.Reversal.builder() .reason(InboundWireTransfer.Reversal.Reason.DUPLICATE) @@ -130,6 +132,7 @@ internal class InboundWireTransferListPageResponseTest { .inputMessageAccountabilityData("20220118MMQFMP0P000001") .instructingAgentRoutingNumber("101050001") .instructionIdentification("202201180000001") + .purpose("CASH") .reversal( InboundWireTransfer.Reversal.builder() .reason(InboundWireTransfer.Reversal.Reason.DUPLICATE) diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/inboundwiretransfers/InboundWireTransferTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/inboundwiretransfers/InboundWireTransferTest.kt index dd8ce7499..e729b331b 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/inboundwiretransfers/InboundWireTransferTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/inboundwiretransfers/InboundWireTransferTest.kt @@ -38,6 +38,7 @@ internal class InboundWireTransferTest { .inputMessageAccountabilityData("20220118MMQFMP0P000001") .instructingAgentRoutingNumber("101050001") .instructionIdentification("202201180000001") + .purpose("CASH") .reversal( InboundWireTransfer.Reversal.builder() .reason(InboundWireTransfer.Reversal.Reason.DUPLICATE) @@ -79,6 +80,7 @@ internal class InboundWireTransferTest { .contains("20220118MMQFMP0P000001") assertThat(inboundWireTransfer.instructingAgentRoutingNumber()).contains("101050001") assertThat(inboundWireTransfer.instructionIdentification()).contains("202201180000001") + assertThat(inboundWireTransfer.purpose()).contains("CASH") assertThat(inboundWireTransfer.reversal()) .contains( InboundWireTransfer.Reversal.builder() @@ -124,6 +126,7 @@ internal class InboundWireTransferTest { .inputMessageAccountabilityData("20220118MMQFMP0P000001") .instructingAgentRoutingNumber("101050001") .instructionIdentification("202201180000001") + .purpose("CASH") .reversal( InboundWireTransfer.Reversal.builder() .reason(InboundWireTransfer.Reversal.Reason.DUPLICATE) diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/pendingtransactions/PendingTransactionListPageResponseTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/pendingtransactions/PendingTransactionListPageResponseTest.kt index b8edb4b39..3a17d51c9 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/pendingtransactions/PendingTransactionListPageResponseTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/pendingtransactions/PendingTransactionListPageResponseTest.kt @@ -204,6 +204,17 @@ internal class PendingTransactionListPageResponseTest { .SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + PendingTransaction.Source.CardAuthorization.Healthcare + .builder() + .merchantNinetyPercentEligibility( + PendingTransaction.Source.CardAuthorization + .Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -652,6 +663,17 @@ internal class PendingTransactionListPageResponseTest { .SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + PendingTransaction.Source.CardAuthorization.Healthcare + .builder() + .merchantNinetyPercentEligibility( + PendingTransaction.Source.CardAuthorization + .Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -1094,6 +1116,17 @@ internal class PendingTransactionListPageResponseTest { .SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + PendingTransaction.Source.CardAuthorization.Healthcare + .builder() + .merchantNinetyPercentEligibility( + PendingTransaction.Source.CardAuthorization + .Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/pendingtransactions/PendingTransactionTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/pendingtransactions/PendingTransactionTest.kt index 009d3a418..25a0b39fe 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/pendingtransactions/PendingTransactionTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/pendingtransactions/PendingTransactionTest.kt @@ -188,6 +188,15 @@ internal class PendingTransactionTest { PendingTransaction.Source.CardAuthorization.Direction.SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + PendingTransaction.Source.CardAuthorization.Healthcare.builder() + .merchantNinetyPercentEligibility( + PendingTransaction.Source.CardAuthorization.Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -583,6 +592,15 @@ internal class PendingTransactionTest { PendingTransaction.Source.CardAuthorization.Direction.SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + PendingTransaction.Source.CardAuthorization.Healthcare.builder() + .merchantNinetyPercentEligibility( + PendingTransaction.Source.CardAuthorization.Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -980,6 +998,15 @@ internal class PendingTransactionTest { PendingTransaction.Source.CardAuthorization.Direction.SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + PendingTransaction.Source.CardAuthorization.Healthcare.builder() + .merchantNinetyPercentEligibility( + PendingTransaction.Source.CardAuthorization.Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/physicalcardprofiles/PhysicalCardProfileListPageResponseTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/physicalcardprofiles/PhysicalCardProfileListPageResponseTest.kt index 9d22f9d7b..0c777b2a7 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/physicalcardprofiles/PhysicalCardProfileListPageResponseTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/physicalcardprofiles/PhysicalCardProfileListPageResponseTest.kt @@ -24,6 +24,12 @@ internal class PhysicalCardProfileListPageResponseTest { .creator(PhysicalCardProfile.Creator.USER) .description("Corporate logo card") .frontImageFileId("file_makxrc67oh9l6sg7w9yc") + .frontText( + PhysicalCardProfile.FrontText.builder() + .line1("line1") + .line2("line2") + .build() + ) .idempotencyKey(null) .isDefault(false) .programId("program_i2v2os4mwza1oetokh9i") @@ -45,6 +51,12 @@ internal class PhysicalCardProfileListPageResponseTest { .creator(PhysicalCardProfile.Creator.USER) .description("Corporate logo card") .frontImageFileId("file_makxrc67oh9l6sg7w9yc") + .frontText( + PhysicalCardProfile.FrontText.builder() + .line1("line1") + .line2("line2") + .build() + ) .idempotencyKey(null) .isDefault(false) .programId("program_i2v2os4mwza1oetokh9i") @@ -70,6 +82,12 @@ internal class PhysicalCardProfileListPageResponseTest { .creator(PhysicalCardProfile.Creator.USER) .description("Corporate logo card") .frontImageFileId("file_makxrc67oh9l6sg7w9yc") + .frontText( + PhysicalCardProfile.FrontText.builder() + .line1("line1") + .line2("line2") + .build() + ) .idempotencyKey(null) .isDefault(false) .programId("program_i2v2os4mwza1oetokh9i") diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/physicalcardprofiles/PhysicalCardProfileTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/physicalcardprofiles/PhysicalCardProfileTest.kt index 7ab72b681..ef33b3be9 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/physicalcardprofiles/PhysicalCardProfileTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/physicalcardprofiles/PhysicalCardProfileTest.kt @@ -22,6 +22,9 @@ internal class PhysicalCardProfileTest { .creator(PhysicalCardProfile.Creator.USER) .description("Corporate logo card") .frontImageFileId("file_makxrc67oh9l6sg7w9yc") + .frontText( + PhysicalCardProfile.FrontText.builder().line1("line1").line2("line2").build() + ) .idempotencyKey(null) .isDefault(false) .programId("program_i2v2os4mwza1oetokh9i") @@ -38,6 +41,8 @@ internal class PhysicalCardProfileTest { assertThat(physicalCardProfile.creator()).isEqualTo(PhysicalCardProfile.Creator.USER) assertThat(physicalCardProfile.description()).isEqualTo("Corporate logo card") assertThat(physicalCardProfile.frontImageFileId()).contains("file_makxrc67oh9l6sg7w9yc") + assertThat(physicalCardProfile.frontText()) + .contains(PhysicalCardProfile.FrontText.builder().line1("line1").line2("line2").build()) assertThat(physicalCardProfile.idempotencyKey()).isEmpty assertThat(physicalCardProfile.isDefault()).isEqualTo(false) assertThat(physicalCardProfile.programId()).isEqualTo("program_i2v2os4mwza1oetokh9i") @@ -59,6 +64,9 @@ internal class PhysicalCardProfileTest { .creator(PhysicalCardProfile.Creator.USER) .description("Corporate logo card") .frontImageFileId("file_makxrc67oh9l6sg7w9yc") + .frontText( + PhysicalCardProfile.FrontText.builder().line1("line1").line2("line2").build() + ) .idempotencyKey(null) .isDefault(false) .programId("program_i2v2os4mwza1oetokh9i") diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/realtimedecisions/RealTimeDecisionTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/realtimedecisions/RealTimeDecisionTest.kt index 5384c2cd7..cd0a7c0aa 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/realtimedecisions/RealTimeDecisionTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/realtimedecisions/RealTimeDecisionTest.kt @@ -230,6 +230,15 @@ internal class RealTimeDecisionTest { ) .digitalWalletTokenId(null) .direction(RealTimeDecision.CardAuthorization.Direction.SETTLEMENT) + .healthcare( + RealTimeDecision.CardAuthorization.Healthcare.builder() + .merchantNinetyPercentEligibility( + RealTimeDecision.CardAuthorization.Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -785,6 +794,15 @@ internal class RealTimeDecisionTest { ) .digitalWalletTokenId(null) .direction(RealTimeDecision.CardAuthorization.Direction.SETTLEMENT) + .healthcare( + RealTimeDecision.CardAuthorization.Healthcare.builder() + .merchantNinetyPercentEligibility( + RealTimeDecision.CardAuthorization.Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -1346,6 +1364,15 @@ internal class RealTimeDecisionTest { ) .digitalWalletTokenId(null) .direction(RealTimeDecision.CardAuthorization.Direction.SETTLEMENT) + .healthcare( + RealTimeDecision.CardAuthorization.Healthcare.builder() + .merchantNinetyPercentEligibility( + RealTimeDecision.CardAuthorization.Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/cardauthorizations/CardAuthorizationCreateResponseTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/cardauthorizations/CardAuthorizationCreateResponseTest.kt index 3a9db3df5..377e1a4eb 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/cardauthorizations/CardAuthorizationCreateResponseTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/cardauthorizations/CardAuthorizationCreateResponseTest.kt @@ -598,6 +598,17 @@ internal class CardAuthorizationCreateResponseTest { .SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + PendingTransaction.Source.CardAuthorization.Healthcare + .builder() + .merchantNinetyPercentEligibility( + PendingTransaction.Source.CardAuthorization + .Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -1428,6 +1439,17 @@ internal class CardAuthorizationCreateResponseTest { .SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + PendingTransaction.Source.CardAuthorization.Healthcare + .builder() + .merchantNinetyPercentEligibility( + PendingTransaction.Source.CardAuthorization + .Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") @@ -2265,6 +2287,17 @@ internal class CardAuthorizationCreateResponseTest { .SETTLEMENT ) .expiresAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .healthcare( + PendingTransaction.Source.CardAuthorization.Healthcare + .builder() + .merchantNinetyPercentEligibility( + PendingTransaction.Source.CardAuthorization + .Healthcare + .MerchantNinetyPercentEligibility + .ELIGIBLE + ) + .build() + ) .merchantAcceptorId("5665270011000168") .merchantCategoryCode("5734") .merchantCity("New York") diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/checkdeposits/CheckDepositSubmitParamsTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/checkdeposits/CheckDepositSubmitParamsTest.kt index 1bcbe6c00..26dc651cd 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/checkdeposits/CheckDepositSubmitParamsTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/checkdeposits/CheckDepositSubmitParamsTest.kt @@ -16,6 +16,7 @@ internal class CheckDepositSubmitParamsTest { .accountNumber("x") .routingNumber("x") .auxiliaryOnUs("x") + .serialNumber("x") .build() ) .build() @@ -43,6 +44,7 @@ internal class CheckDepositSubmitParamsTest { .accountNumber("x") .routingNumber("x") .auxiliaryOnUs("x") + .serialNumber("x") .build() ) .build() @@ -55,6 +57,7 @@ internal class CheckDepositSubmitParamsTest { .accountNumber("x") .routingNumber("x") .auxiliaryOnUs("x") + .serialNumber("x") .build() ) } diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/inboundwiretransfers/InboundWireTransferCreateParamsTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/inboundwiretransfers/InboundWireTransferCreateParamsTest.kt index 35d382446..6c994e6f9 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/inboundwiretransfers/InboundWireTransferCreateParamsTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/inboundwiretransfers/InboundWireTransferCreateParamsTest.kt @@ -23,6 +23,7 @@ internal class InboundWireTransferCreateParamsTest { .endToEndIdentification("x") .instructingAgentRoutingNumber("x") .instructionIdentification("x") + .purpose("x") .uniqueEndToEndTransactionReference("x") .unstructuredRemittanceInformation("x") .wireDrawdownRequestId("wire_drawdown_request_id") @@ -46,6 +47,7 @@ internal class InboundWireTransferCreateParamsTest { .endToEndIdentification("x") .instructingAgentRoutingNumber("x") .instructionIdentification("x") + .purpose("x") .uniqueEndToEndTransactionReference("x") .unstructuredRemittanceInformation("x") .wireDrawdownRequestId("wire_drawdown_request_id") @@ -66,6 +68,7 @@ internal class InboundWireTransferCreateParamsTest { assertThat(body.endToEndIdentification()).contains("x") assertThat(body.instructingAgentRoutingNumber()).contains("x") assertThat(body.instructionIdentification()).contains("x") + assertThat(body.purpose()).contains("x") assertThat(body.uniqueEndToEndTransactionReference()).contains("x") assertThat(body.unstructuredRemittanceInformation()).contains("x") assertThat(body.wireDrawdownRequestId()).contains("wire_drawdown_request_id") diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/swifttransfers/SwiftTransferCreateParamsTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/swifttransfers/SwiftTransferCreateParamsTest.kt index 97da613f6..e098fe297 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/swifttransfers/SwiftTransferCreateParamsTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/swifttransfers/SwiftTransferCreateParamsTest.kt @@ -12,7 +12,7 @@ internal class SwiftTransferCreateParamsTest { SwiftTransferCreateParams.builder() .accountId("account_in71c4amph0vgo2qllky") .accountNumber("987654321") - .bankIdentificationCode("ECBFDEFFTPP") + .bankIdentificationCode("FRNYUS33XXX") .creditorAddress( SwiftTransferCreateParams.CreditorAddress.builder() .city("Frankfurt") @@ -50,7 +50,7 @@ internal class SwiftTransferCreateParamsTest { SwiftTransferCreateParams.builder() .accountId("account_in71c4amph0vgo2qllky") .accountNumber("987654321") - .bankIdentificationCode("ECBFDEFFTPP") + .bankIdentificationCode("FRNYUS33XXX") .creditorAddress( SwiftTransferCreateParams.CreditorAddress.builder() .city("Frankfurt") @@ -85,7 +85,7 @@ internal class SwiftTransferCreateParamsTest { assertThat(body.accountId()).isEqualTo("account_in71c4amph0vgo2qllky") assertThat(body.accountNumber()).isEqualTo("987654321") - assertThat(body.bankIdentificationCode()).isEqualTo("ECBFDEFFTPP") + assertThat(body.bankIdentificationCode()).isEqualTo("FRNYUS33XXX") assertThat(body.creditorAddress()) .isEqualTo( SwiftTransferCreateParams.CreditorAddress.builder() @@ -125,7 +125,7 @@ internal class SwiftTransferCreateParamsTest { SwiftTransferCreateParams.builder() .accountId("account_in71c4amph0vgo2qllky") .accountNumber("987654321") - .bankIdentificationCode("ECBFDEFFTPP") + .bankIdentificationCode("FRNYUS33XXX") .creditorAddress( SwiftTransferCreateParams.CreditorAddress.builder() .city("Frankfurt") @@ -152,7 +152,7 @@ internal class SwiftTransferCreateParamsTest { assertThat(body.accountId()).isEqualTo("account_in71c4amph0vgo2qllky") assertThat(body.accountNumber()).isEqualTo("987654321") - assertThat(body.bankIdentificationCode()).isEqualTo("ECBFDEFFTPP") + assertThat(body.bankIdentificationCode()).isEqualTo("FRNYUS33XXX") assertThat(body.creditorAddress()) .isEqualTo( SwiftTransferCreateParams.CreditorAddress.builder() diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/swifttransfers/SwiftTransferListPageResponseTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/swifttransfers/SwiftTransferListPageResponseTest.kt index b598271f0..6cb55eb8c 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/swifttransfers/SwiftTransferListPageResponseTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/swifttransfers/SwiftTransferListPageResponseTest.kt @@ -20,7 +20,7 @@ internal class SwiftTransferListPageResponseTest { .accountId("account_in71c4amph0vgo2qllky") .accountNumber("987654321") .amount(100L) - .bankIdentificationCode("ECBFDEFFTPP") + .bankIdentificationCode("FRNYUS33XXX") .createdAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) .createdBy( SwiftTransfer.CreatedBy.builder() @@ -87,7 +87,7 @@ internal class SwiftTransferListPageResponseTest { .accountId("account_in71c4amph0vgo2qllky") .accountNumber("987654321") .amount(100L) - .bankIdentificationCode("ECBFDEFFTPP") + .bankIdentificationCode("FRNYUS33XXX") .createdAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) .createdBy( SwiftTransfer.CreatedBy.builder() @@ -158,7 +158,7 @@ internal class SwiftTransferListPageResponseTest { .accountId("account_in71c4amph0vgo2qllky") .accountNumber("987654321") .amount(100L) - .bankIdentificationCode("ECBFDEFFTPP") + .bankIdentificationCode("FRNYUS33XXX") .createdAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) .createdBy( SwiftTransfer.CreatedBy.builder() diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/swifttransfers/SwiftTransferTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/swifttransfers/SwiftTransferTest.kt index 20bd4a647..a115e3840 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/swifttransfers/SwiftTransferTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/swifttransfers/SwiftTransferTest.kt @@ -18,7 +18,7 @@ internal class SwiftTransferTest { .accountId("account_in71c4amph0vgo2qllky") .accountNumber("987654321") .amount(100L) - .bankIdentificationCode("ECBFDEFFTPP") + .bankIdentificationCode("FRNYUS33XXX") .createdAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) .createdBy( SwiftTransfer.CreatedBy.builder() @@ -75,7 +75,7 @@ internal class SwiftTransferTest { assertThat(swiftTransfer.accountId()).isEqualTo("account_in71c4amph0vgo2qllky") assertThat(swiftTransfer.accountNumber()).isEqualTo("987654321") assertThat(swiftTransfer.amount()).isEqualTo(100L) - assertThat(swiftTransfer.bankIdentificationCode()).isEqualTo("ECBFDEFFTPP") + assertThat(swiftTransfer.bankIdentificationCode()).isEqualTo("FRNYUS33XXX") assertThat(swiftTransfer.createdAt()) .isEqualTo(OffsetDateTime.parse("2020-01-31T23:59:59Z")) assertThat(swiftTransfer.createdBy()) @@ -142,7 +142,7 @@ internal class SwiftTransferTest { .accountId("account_in71c4amph0vgo2qllky") .accountNumber("987654321") .amount(100L) - .bankIdentificationCode("ECBFDEFFTPP") + .bankIdentificationCode("FRNYUS33XXX") .createdAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) .createdBy( SwiftTransfer.CreatedBy.builder() diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/transactions/TransactionListPageResponseTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/transactions/TransactionListPageResponseTest.kt index fab809208..4c0745135 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/transactions/TransactionListPageResponseTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/transactions/TransactionListPageResponseTest.kt @@ -1149,6 +1149,7 @@ internal class TransactionListPageResponseTest { .inputMessageAccountabilityData(null) .instructingAgentRoutingNumber(null) .instructionIdentification(null) + .purpose(null) .transferId("inbound_wire_transfer_f228m6bmhtcxjco9pwp0") .uniqueEndToEndTransactionReference(null) .unstructuredRemittanceInformation(null) @@ -2288,6 +2289,7 @@ internal class TransactionListPageResponseTest { .inputMessageAccountabilityData(null) .instructingAgentRoutingNumber(null) .instructionIdentification(null) + .purpose(null) .transferId("inbound_wire_transfer_f228m6bmhtcxjco9pwp0") .uniqueEndToEndTransactionReference(null) .unstructuredRemittanceInformation(null) @@ -3497,6 +3499,7 @@ internal class TransactionListPageResponseTest { .inputMessageAccountabilityData(null) .instructingAgentRoutingNumber(null) .instructionIdentification(null) + .purpose(null) .transferId("inbound_wire_transfer_f228m6bmhtcxjco9pwp0") .uniqueEndToEndTransactionReference(null) .unstructuredRemittanceInformation(null) diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/transactions/TransactionTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/transactions/TransactionTest.kt index 218a1bde2..a84183afc 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/transactions/TransactionTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/transactions/TransactionTest.kt @@ -1025,6 +1025,7 @@ internal class TransactionTest { .inputMessageAccountabilityData(null) .instructingAgentRoutingNumber(null) .instructionIdentification(null) + .purpose(null) .transferId("inbound_wire_transfer_f228m6bmhtcxjco9pwp0") .uniqueEndToEndTransactionReference(null) .unstructuredRemittanceInformation(null) @@ -2043,6 +2044,7 @@ internal class TransactionTest { .inputMessageAccountabilityData(null) .instructingAgentRoutingNumber(null) .instructionIdentification(null) + .purpose(null) .transferId("inbound_wire_transfer_f228m6bmhtcxjco9pwp0") .uniqueEndToEndTransactionReference(null) .unstructuredRemittanceInformation(null) @@ -3121,6 +3123,7 @@ internal class TransactionTest { .inputMessageAccountabilityData(null) .instructingAgentRoutingNumber(null) .instructionIdentification(null) + .purpose(null) .transferId("inbound_wire_transfer_f228m6bmhtcxjco9pwp0") .uniqueEndToEndTransactionReference(null) .unstructuredRemittanceInformation(null) diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/wiredrawdownrequests/WireDrawdownRequestListPageResponseTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/wiredrawdownrequests/WireDrawdownRequestListPageResponseTest.kt index 3d542a228..108c64ca3 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/wiredrawdownrequests/WireDrawdownRequestListPageResponseTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/wiredrawdownrequests/WireDrawdownRequestListPageResponseTest.kt @@ -46,6 +46,7 @@ internal class WireDrawdownRequestListPageResponseTest { .debtorExternalAccountId(null) .debtorName("Ian Crease") .debtorRoutingNumber("101050001") + .endToEndIdentification("Invoice 29582") .fulfillmentInboundWireTransferId( "inbound_wire_transfer_f228m6bmhtcxjco9pwp0" ) @@ -57,6 +58,7 @@ internal class WireDrawdownRequestListPageResponseTest { .build() ) .type(WireDrawdownRequest.Type.WIRE_DRAWDOWN_REQUEST) + .uniqueEndToEndTransactionReference("9a21e10a-7600-4a24-8ff3-2cbc5943c27a") .unstructuredRemittanceInformation("Invoice 29582") .build() ) @@ -96,6 +98,7 @@ internal class WireDrawdownRequestListPageResponseTest { .debtorExternalAccountId(null) .debtorName("Ian Crease") .debtorRoutingNumber("101050001") + .endToEndIdentification("Invoice 29582") .fulfillmentInboundWireTransferId("inbound_wire_transfer_f228m6bmhtcxjco9pwp0") .idempotencyKey(null) .status(WireDrawdownRequest.Status.FULFILLED) @@ -105,6 +108,7 @@ internal class WireDrawdownRequestListPageResponseTest { .build() ) .type(WireDrawdownRequest.Type.WIRE_DRAWDOWN_REQUEST) + .uniqueEndToEndTransactionReference("9a21e10a-7600-4a24-8ff3-2cbc5943c27a") .unstructuredRemittanceInformation("Invoice 29582") .build() ) @@ -148,6 +152,7 @@ internal class WireDrawdownRequestListPageResponseTest { .debtorExternalAccountId(null) .debtorName("Ian Crease") .debtorRoutingNumber("101050001") + .endToEndIdentification("Invoice 29582") .fulfillmentInboundWireTransferId( "inbound_wire_transfer_f228m6bmhtcxjco9pwp0" ) @@ -159,6 +164,7 @@ internal class WireDrawdownRequestListPageResponseTest { .build() ) .type(WireDrawdownRequest.Type.WIRE_DRAWDOWN_REQUEST) + .uniqueEndToEndTransactionReference("9a21e10a-7600-4a24-8ff3-2cbc5943c27a") .unstructuredRemittanceInformation("Invoice 29582") .build() ) diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/wiredrawdownrequests/WireDrawdownRequestTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/wiredrawdownrequests/WireDrawdownRequestTest.kt index f87523a00..396af1788 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/models/wiredrawdownrequests/WireDrawdownRequestTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/wiredrawdownrequests/WireDrawdownRequestTest.kt @@ -44,6 +44,7 @@ internal class WireDrawdownRequestTest { .debtorExternalAccountId(null) .debtorName("Ian Crease") .debtorRoutingNumber("101050001") + .endToEndIdentification("Invoice 29582") .fulfillmentInboundWireTransferId("inbound_wire_transfer_f228m6bmhtcxjco9pwp0") .idempotencyKey(null) .status(WireDrawdownRequest.Status.FULFILLED) @@ -53,6 +54,7 @@ internal class WireDrawdownRequestTest { .build() ) .type(WireDrawdownRequest.Type.WIRE_DRAWDOWN_REQUEST) + .uniqueEndToEndTransactionReference("9a21e10a-7600-4a24-8ff3-2cbc5943c27a") .unstructuredRemittanceInformation("Invoice 29582") .build() @@ -90,6 +92,7 @@ internal class WireDrawdownRequestTest { assertThat(wireDrawdownRequest.debtorExternalAccountId()).isEmpty assertThat(wireDrawdownRequest.debtorName()).isEqualTo("Ian Crease") assertThat(wireDrawdownRequest.debtorRoutingNumber()).isEqualTo("101050001") + assertThat(wireDrawdownRequest.endToEndIdentification()).contains("Invoice 29582") assertThat(wireDrawdownRequest.fulfillmentInboundWireTransferId()) .contains("inbound_wire_transfer_f228m6bmhtcxjco9pwp0") assertThat(wireDrawdownRequest.idempotencyKey()).isEmpty @@ -102,6 +105,8 @@ internal class WireDrawdownRequestTest { ) assertThat(wireDrawdownRequest.type()) .isEqualTo(WireDrawdownRequest.Type.WIRE_DRAWDOWN_REQUEST) + assertThat(wireDrawdownRequest.uniqueEndToEndTransactionReference()) + .contains("9a21e10a-7600-4a24-8ff3-2cbc5943c27a") assertThat(wireDrawdownRequest.unstructuredRemittanceInformation()) .isEqualTo("Invoice 29582") } @@ -141,6 +146,7 @@ internal class WireDrawdownRequestTest { .debtorExternalAccountId(null) .debtorName("Ian Crease") .debtorRoutingNumber("101050001") + .endToEndIdentification("Invoice 29582") .fulfillmentInboundWireTransferId("inbound_wire_transfer_f228m6bmhtcxjco9pwp0") .idempotencyKey(null) .status(WireDrawdownRequest.Status.FULFILLED) @@ -150,6 +156,7 @@ internal class WireDrawdownRequestTest { .build() ) .type(WireDrawdownRequest.Type.WIRE_DRAWDOWN_REQUEST) + .uniqueEndToEndTransactionReference("9a21e10a-7600-4a24-8ff3-2cbc5943c27a") .unstructuredRemittanceInformation("Invoice 29582") .build() diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/async/EntityServiceAsyncTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/async/EntityServiceAsyncTest.kt index ed7f3ce90..f28125050 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/services/async/EntityServiceAsyncTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/async/EntityServiceAsyncTest.kt @@ -294,9 +294,7 @@ internal class EntityServiceAsyncTest { .build() ) .addSupplementalDocument( - EntityCreateParams.SupplementalDocument.builder() - .fileId("file_makxrc67oh9l6sg7w9yc") - .build() + EntityCreateParams.SupplementalDocument.builder().fileId("file_id").build() ) .addTermsAgreement( EntityCreateParams.TermsAgreement.builder() 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 3f05c8be3..9770e921d 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 @@ -65,6 +65,19 @@ internal class ExportServiceAsyncTest { .build() ) .entityCsv(ExportCreateParams.EntityCsv.builder().build()) + .feeCsv( + ExportCreateParams.FeeCsv.builder() + .createdAt( + ExportCreateParams.FeeCsv.CreatedAt.builder() + .after(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .before(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .onOrAfter(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .onOrBefore(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .build() + ) + .programId("program_id") + .build() + ) .fundingInstructions( ExportCreateParams.FundingInstructions.builder() .accountNumberId("account_number_id") diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/async/SwiftTransferServiceAsyncTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/async/SwiftTransferServiceAsyncTest.kt index ecc7dfd13..f0de46440 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/services/async/SwiftTransferServiceAsyncTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/async/SwiftTransferServiceAsyncTest.kt @@ -25,7 +25,7 @@ internal class SwiftTransferServiceAsyncTest { SwiftTransferCreateParams.builder() .accountId("account_in71c4amph0vgo2qllky") .accountNumber("987654321") - .bankIdentificationCode("ECBFDEFFTPP") + .bankIdentificationCode("FRNYUS33XXX") .creditorAddress( SwiftTransferCreateParams.CreditorAddress.builder() .city("Frankfurt") diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/CheckDepositServiceAsyncTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/CheckDepositServiceAsyncTest.kt index 190d80a19..2040d617d 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/CheckDepositServiceAsyncTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/CheckDepositServiceAsyncTest.kt @@ -84,6 +84,7 @@ internal class CheckDepositServiceAsyncTest { .accountNumber("x") .routingNumber("x") .auxiliaryOnUs("x") + .serialNumber("x") .build() ) .build() diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/InboundWireTransferServiceAsyncTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/InboundWireTransferServiceAsyncTest.kt index 1897ebda7..ee9b7e7bb 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/InboundWireTransferServiceAsyncTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/InboundWireTransferServiceAsyncTest.kt @@ -36,6 +36,7 @@ internal class InboundWireTransferServiceAsyncTest { .endToEndIdentification("x") .instructingAgentRoutingNumber("x") .instructionIdentification("x") + .purpose("x") .uniqueEndToEndTransactionReference("x") .unstructuredRemittanceInformation("x") .wireDrawdownRequestId("wire_drawdown_request_id") diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/EntityServiceTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/EntityServiceTest.kt index 81659d081..2e2a4843f 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/EntityServiceTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/EntityServiceTest.kt @@ -294,9 +294,7 @@ internal class EntityServiceTest { .build() ) .addSupplementalDocument( - EntityCreateParams.SupplementalDocument.builder() - .fileId("file_makxrc67oh9l6sg7w9yc") - .build() + EntityCreateParams.SupplementalDocument.builder().fileId("file_id").build() ) .addTermsAgreement( EntityCreateParams.TermsAgreement.builder() 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 e40fe4a8d..6bebc56d7 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 @@ -65,6 +65,19 @@ internal class ExportServiceTest { .build() ) .entityCsv(ExportCreateParams.EntityCsv.builder().build()) + .feeCsv( + ExportCreateParams.FeeCsv.builder() + .createdAt( + ExportCreateParams.FeeCsv.CreatedAt.builder() + .after(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .before(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .onOrAfter(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .onOrBefore(OffsetDateTime.parse("2019-12-27T18:11:19.117Z")) + .build() + ) + .programId("program_id") + .build() + ) .fundingInstructions( ExportCreateParams.FundingInstructions.builder() .accountNumberId("account_number_id") diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/SwiftTransferServiceTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/SwiftTransferServiceTest.kt index 3cb958457..c545e0cc3 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/SwiftTransferServiceTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/SwiftTransferServiceTest.kt @@ -25,7 +25,7 @@ internal class SwiftTransferServiceTest { SwiftTransferCreateParams.builder() .accountId("account_in71c4amph0vgo2qllky") .accountNumber("987654321") - .bankIdentificationCode("ECBFDEFFTPP") + .bankIdentificationCode("FRNYUS33XXX") .creditorAddress( SwiftTransferCreateParams.CreditorAddress.builder() .city("Frankfurt") diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/CheckDepositServiceTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/CheckDepositServiceTest.kt index d8710f5bd..b7fdc917c 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/CheckDepositServiceTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/CheckDepositServiceTest.kt @@ -79,6 +79,7 @@ internal class CheckDepositServiceTest { .accountNumber("x") .routingNumber("x") .auxiliaryOnUs("x") + .serialNumber("x") .build() ) .build() diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/InboundWireTransferServiceTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/InboundWireTransferServiceTest.kt index d7a1a62b5..a4f035289 100644 --- a/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/InboundWireTransferServiceTest.kt +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/InboundWireTransferServiceTest.kt @@ -36,6 +36,7 @@ internal class InboundWireTransferServiceTest { .endToEndIdentification("x") .instructingAgentRoutingNumber("x") .instructionIdentification("x") + .purpose("x") .uniqueEndToEndTransactionReference("x") .unstructuredRemittanceInformation("x") .wireDrawdownRequestId("wire_drawdown_request_id") diff --git a/release-please-config.json b/release-please-config.json index b525eb2fe..5550ca0f5 100644 --- a/release-please-config.json +++ b/release-please-config.json @@ -2,13 +2,14 @@ "packages": { ".": {} }, - "$schema": "https://raw.githubusercontent.com/Increase/release-please/main/schemas/config.json", + "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json", "include-v-in-tag": true, "include-component-in-tag": false, "versioning": "prerelease", "prerelease": true, "bump-minor-pre-major": true, "bump-patch-for-minor-pre-major": false, + "pull-request-header": "Automated Release PR", "pull-request-title-pattern": "release: ${version}", "changelog-sections": [ { diff --git a/scripts/mock b/scripts/mock index 7ee8d158b..036ffd0f0 100755 --- a/scripts/mock +++ b/scripts/mock @@ -7,14 +7,15 @@ cd "$(dirname "$0")/.." if [[ -n "$1" && "$1" != '--'* ]]; then URL="$1" shift +elif [ -n "$STAINLESS_OPENAPI_SPEC_URL" ]; then + URL="$STAINLESS_OPENAPI_SPEC_URL" else - URL="$(grep 'openapi_spec_url' .stats.yml | cut -d' ' -f2)" -fi - -# Check if the URL is empty -if [ -z "$URL" ]; then - echo "Error: No OpenAPI spec path/url provided or found in .stats.yml" - exit 1 + # Embedded OpenAPI spec (base64-encoded, gzipped) + EMBEDDED_SPEC="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" + SPEC_TMPFILE="$(mktemp)" + trap 'rm -f "$SPEC_TMPFILE"' EXIT + echo "$EMBEDDED_SPEC" | base64 --decode | gunzip > "$SPEC_TMPFILE" + URL="$SPEC_TMPFILE" fi echo "==> Starting mock server with URL ${URL}"