diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 1eb441221..000901257 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.505.0" + ".": "0.506.0" } \ No newline at end of file diff --git a/.stats.yml b/.stats.yml index 8e99a7e66..cc2badb61 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 236 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/increase%2Fincrease-07202bc3c027c441ab8829ab0e32c1547952d4cae1691fe00497ee3b056127d0.yml -openapi_spec_hash: 3c21b26cf5803678876c00c40e88c781 -config_hash: 4945e03affdf289484733306e4797f81 +configured_endpoints: 241 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/increase%2Fincrease-8bbf0093efa65975131da3735f2adc0ec05432cde8c05e9c9796bc7d553103ae.yml +openapi_spec_hash: 5080ba849a5b100ace3bec9da24d4dc7 +config_hash: d48e9f65bcf642f92610034d6c43f07a diff --git a/CHANGELOG.md b/CHANGELOG.md index cd0f1999d..5f8a78a4b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog +## 0.506.0 (2026-04-09) + +Full Changelog: [v0.505.0...v0.506.0](https://github.com/Increase/increase-java/compare/v0.505.0...v0.506.0) + +### Features + +* **api:** api update ([2c87ea8](https://github.com/Increase/increase-java/commit/2c87ea8437e7121a883cf59fa87da7fc2ebeed7d)) + ## 0.505.0 (2026-04-07) Full Changelog: [v0.504.0...v0.505.0](https://github.com/Increase/increase-java/compare/v0.504.0...v0.505.0) diff --git a/README.md b/README.md index 20c037e96..bbbc72259 100644 --- a/README.md +++ b/README.md @@ -2,8 +2,8 @@ -[![Maven Central](https://img.shields.io/maven-central/v/com.increase.api/increase-java)](https://central.sonatype.com/artifact/com.increase.api/increase-java/0.505.0) -[![javadoc](https://javadoc.io/badge2/com.increase.api/increase-java/0.505.0/javadoc.svg)](https://javadoc.io/doc/com.increase.api/increase-java/0.505.0) +[![Maven Central](https://img.shields.io/maven-central/v/com.increase.api/increase-java)](https://central.sonatype.com/artifact/com.increase.api/increase-java/0.506.0) +[![javadoc](https://javadoc.io/badge2/com.increase.api/increase-java/0.506.0/javadoc.svg)](https://javadoc.io/doc/com.increase.api/increase-java/0.506.0) @@ -13,7 +13,7 @@ The Increase Java SDK is similar to the Increase Kotlin SDK but with minor diffe -The REST API documentation can be found on [increase.com](https://increase.com/documentation). Javadocs are available on [javadoc.io](https://javadoc.io/doc/com.increase.api/increase-java/0.505.0). +The REST API documentation can be found on [increase.com](https://increase.com/documentation). Javadocs are available on [javadoc.io](https://javadoc.io/doc/com.increase.api/increase-java/0.506.0). @@ -24,7 +24,7 @@ The REST API documentation can be found on [increase.com](https://increase.com/d ### Gradle ```kotlin -implementation("com.increase.api:increase-java:0.505.0") +implementation("com.increase.api:increase-java:0.506.0") ``` ### Maven @@ -33,7 +33,7 @@ implementation("com.increase.api:increase-java:0.505.0") com.increase.api increase-java - 0.505.0 + 0.506.0 ``` diff --git a/build.gradle.kts b/build.gradle.kts index da7837d72..fca776d63 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -8,7 +8,7 @@ repositories { allprojects { group = "com.increase.api" - version = "0.505.0" // x-release-please-version + version = "0.506.0" // x-release-please-version } subprojects { diff --git a/increase-java-core/src/main/kotlin/com/increase/api/client/IncreaseClient.kt b/increase-java-core/src/main/kotlin/com/increase/api/client/IncreaseClient.kt index c9f7ae440..afd764ab5 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/client/IncreaseClient.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/client/IncreaseClient.kt @@ -25,6 +25,7 @@ import com.increase.api.services.blocking.CheckTransferService import com.increase.api.services.blocking.DeclinedTransactionService import com.increase.api.services.blocking.DigitalCardProfileService import com.increase.api.services.blocking.DigitalWalletTokenService +import com.increase.api.services.blocking.EntityOnboardingSessionService import com.increase.api.services.blocking.EntityService import com.increase.api.services.blocking.EventService import com.increase.api.services.blocking.EventSubscriptionService @@ -171,6 +172,8 @@ interface IncreaseClient { fun supplementalDocuments(): SupplementalDocumentService + fun entityOnboardingSessions(): EntityOnboardingSessionService + fun programs(): ProgramService fun accountStatements(): AccountStatementService @@ -311,6 +314,8 @@ interface IncreaseClient { fun supplementalDocuments(): SupplementalDocumentService.WithRawResponse + fun entityOnboardingSessions(): EntityOnboardingSessionService.WithRawResponse + fun programs(): ProgramService.WithRawResponse fun accountStatements(): AccountStatementService.WithRawResponse diff --git a/increase-java-core/src/main/kotlin/com/increase/api/client/IncreaseClientAsync.kt b/increase-java-core/src/main/kotlin/com/increase/api/client/IncreaseClientAsync.kt index d414e0d64..0f74f0f91 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/client/IncreaseClientAsync.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/client/IncreaseClientAsync.kt @@ -25,6 +25,7 @@ import com.increase.api.services.async.CheckTransferServiceAsync import com.increase.api.services.async.DeclinedTransactionServiceAsync import com.increase.api.services.async.DigitalCardProfileServiceAsync import com.increase.api.services.async.DigitalWalletTokenServiceAsync +import com.increase.api.services.async.EntityOnboardingSessionServiceAsync import com.increase.api.services.async.EntityServiceAsync import com.increase.api.services.async.EventServiceAsync import com.increase.api.services.async.EventSubscriptionServiceAsync @@ -171,6 +172,8 @@ interface IncreaseClientAsync { fun supplementalDocuments(): SupplementalDocumentServiceAsync + fun entityOnboardingSessions(): EntityOnboardingSessionServiceAsync + fun programs(): ProgramServiceAsync fun accountStatements(): AccountStatementServiceAsync @@ -315,6 +318,8 @@ interface IncreaseClientAsync { fun supplementalDocuments(): SupplementalDocumentServiceAsync.WithRawResponse + fun entityOnboardingSessions(): EntityOnboardingSessionServiceAsync.WithRawResponse + fun programs(): ProgramServiceAsync.WithRawResponse fun accountStatements(): AccountStatementServiceAsync.WithRawResponse diff --git a/increase-java-core/src/main/kotlin/com/increase/api/client/IncreaseClientAsyncImpl.kt b/increase-java-core/src/main/kotlin/com/increase/api/client/IncreaseClientAsyncImpl.kt index e7352caae..19629f4e2 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/client/IncreaseClientAsyncImpl.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/client/IncreaseClientAsyncImpl.kt @@ -48,6 +48,8 @@ import com.increase.api.services.async.DigitalCardProfileServiceAsync import com.increase.api.services.async.DigitalCardProfileServiceAsyncImpl import com.increase.api.services.async.DigitalWalletTokenServiceAsync import com.increase.api.services.async.DigitalWalletTokenServiceAsyncImpl +import com.increase.api.services.async.EntityOnboardingSessionServiceAsync +import com.increase.api.services.async.EntityOnboardingSessionServiceAsyncImpl import com.increase.api.services.async.EntityServiceAsync import com.increase.api.services.async.EntityServiceAsyncImpl import com.increase.api.services.async.EventServiceAsync @@ -282,6 +284,10 @@ class IncreaseClientAsyncImpl(private val clientOptions: ClientOptions) : Increa SupplementalDocumentServiceAsyncImpl(clientOptionsWithUserAgent) } + private val entityOnboardingSessions: EntityOnboardingSessionServiceAsync by lazy { + EntityOnboardingSessionServiceAsyncImpl(clientOptionsWithUserAgent) + } + private val programs: ProgramServiceAsync by lazy { ProgramServiceAsyncImpl(clientOptionsWithUserAgent) } @@ -452,6 +458,9 @@ class IncreaseClientAsyncImpl(private val clientOptions: ClientOptions) : Increa override fun supplementalDocuments(): SupplementalDocumentServiceAsync = supplementalDocuments + override fun entityOnboardingSessions(): EntityOnboardingSessionServiceAsync = + entityOnboardingSessions + override fun programs(): ProgramServiceAsync = programs override fun accountStatements(): AccountStatementServiceAsync = accountStatements @@ -652,6 +661,11 @@ class IncreaseClientAsyncImpl(private val clientOptions: ClientOptions) : Increa SupplementalDocumentServiceAsyncImpl.WithRawResponseImpl(clientOptions) } + private val entityOnboardingSessions: + EntityOnboardingSessionServiceAsync.WithRawResponse by lazy { + EntityOnboardingSessionServiceAsyncImpl.WithRawResponseImpl(clientOptions) + } + private val programs: ProgramServiceAsync.WithRawResponse by lazy { ProgramServiceAsyncImpl.WithRawResponseImpl(clientOptions) } @@ -841,6 +855,9 @@ class IncreaseClientAsyncImpl(private val clientOptions: ClientOptions) : Increa override fun supplementalDocuments(): SupplementalDocumentServiceAsync.WithRawResponse = supplementalDocuments + override fun entityOnboardingSessions(): + EntityOnboardingSessionServiceAsync.WithRawResponse = entityOnboardingSessions + override fun programs(): ProgramServiceAsync.WithRawResponse = programs override fun accountStatements(): AccountStatementServiceAsync.WithRawResponse = diff --git a/increase-java-core/src/main/kotlin/com/increase/api/client/IncreaseClientImpl.kt b/increase-java-core/src/main/kotlin/com/increase/api/client/IncreaseClientImpl.kt index a2aca3a2e..306af6c3b 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/client/IncreaseClientImpl.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/client/IncreaseClientImpl.kt @@ -48,6 +48,8 @@ import com.increase.api.services.blocking.DigitalCardProfileService import com.increase.api.services.blocking.DigitalCardProfileServiceImpl import com.increase.api.services.blocking.DigitalWalletTokenService import com.increase.api.services.blocking.DigitalWalletTokenServiceImpl +import com.increase.api.services.blocking.EntityOnboardingSessionService +import com.increase.api.services.blocking.EntityOnboardingSessionServiceImpl import com.increase.api.services.blocking.EntityService import com.increase.api.services.blocking.EntityServiceImpl import com.increase.api.services.blocking.EventService @@ -275,6 +277,10 @@ class IncreaseClientImpl(private val clientOptions: ClientOptions) : IncreaseCli SupplementalDocumentServiceImpl(clientOptionsWithUserAgent) } + private val entityOnboardingSessions: EntityOnboardingSessionService by lazy { + EntityOnboardingSessionServiceImpl(clientOptionsWithUserAgent) + } + private val programs: ProgramService by lazy { ProgramServiceImpl(clientOptionsWithUserAgent) } private val accountStatements: AccountStatementService by lazy { @@ -435,6 +441,9 @@ class IncreaseClientImpl(private val clientOptions: ClientOptions) : IncreaseCli override fun supplementalDocuments(): SupplementalDocumentService = supplementalDocuments + override fun entityOnboardingSessions(): EntityOnboardingSessionService = + entityOnboardingSessions + override fun programs(): ProgramService = programs override fun accountStatements(): AccountStatementService = accountStatements @@ -632,6 +641,11 @@ class IncreaseClientImpl(private val clientOptions: ClientOptions) : IncreaseCli SupplementalDocumentServiceImpl.WithRawResponseImpl(clientOptions) } + private val entityOnboardingSessions: + EntityOnboardingSessionService.WithRawResponse by lazy { + EntityOnboardingSessionServiceImpl.WithRawResponseImpl(clientOptions) + } + private val programs: ProgramService.WithRawResponse by lazy { ProgramServiceImpl.WithRawResponseImpl(clientOptions) } @@ -817,6 +831,9 @@ class IncreaseClientImpl(private val clientOptions: ClientOptions) : IncreaseCli override fun supplementalDocuments(): SupplementalDocumentService.WithRawResponse = supplementalDocuments + override fun entityOnboardingSessions(): EntityOnboardingSessionService.WithRawResponse = + entityOnboardingSessions + override fun programs(): ProgramService.WithRawResponse = programs override fun accountStatements(): AccountStatementService.WithRawResponse = diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSession.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSession.kt new file mode 100644 index 000000000..5051e42b3 --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSession.kt @@ -0,0 +1,861 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.entityonboardingsessions + +import com.fasterxml.jackson.annotation.JsonAnyGetter +import com.fasterxml.jackson.annotation.JsonAnySetter +import com.fasterxml.jackson.annotation.JsonCreator +import com.fasterxml.jackson.annotation.JsonProperty +import com.increase.api.core.Enum +import com.increase.api.core.ExcludeMissing +import com.increase.api.core.JsonField +import com.increase.api.core.JsonMissing +import com.increase.api.core.JsonValue +import com.increase.api.core.checkRequired +import com.increase.api.errors.IncreaseInvalidDataException +import java.time.OffsetDateTime +import java.util.Collections +import java.util.Objects +import java.util.Optional +import kotlin.jvm.optionals.getOrNull + +/** + * Entity Onboarding Sessions let your customers onboard themselves by completing Increase-hosted + * forms. Create a session and redirect your customer to the returned URL. When they're done, + * they'll be redirected back to your site. This API is used for + * [hosted onboarding](/documentation/hosted-onboarding). + */ +class EntityOnboardingSession +@JsonCreator(mode = JsonCreator.Mode.DISABLED) +private constructor( + private val id: JsonField, + private val createdAt: JsonField, + private val entityId: JsonField, + private val expiresAt: JsonField, + private val idempotencyKey: JsonField, + private val programId: JsonField, + private val redirectUrl: JsonField, + private val sessionUrl: JsonField, + private val status: JsonField, + private val type: JsonField, + private val additionalProperties: MutableMap, +) { + + @JsonCreator + private constructor( + @JsonProperty("id") @ExcludeMissing id: JsonField = JsonMissing.of(), + @JsonProperty("created_at") + @ExcludeMissing + createdAt: JsonField = JsonMissing.of(), + @JsonProperty("entity_id") @ExcludeMissing entityId: JsonField = JsonMissing.of(), + @JsonProperty("expires_at") + @ExcludeMissing + expiresAt: JsonField = JsonMissing.of(), + @JsonProperty("idempotency_key") + @ExcludeMissing + idempotencyKey: JsonField = JsonMissing.of(), + @JsonProperty("program_id") @ExcludeMissing programId: JsonField = JsonMissing.of(), + @JsonProperty("redirect_url") + @ExcludeMissing + redirectUrl: JsonField = JsonMissing.of(), + @JsonProperty("session_url") + @ExcludeMissing + sessionUrl: JsonField = JsonMissing.of(), + @JsonProperty("status") @ExcludeMissing status: JsonField = JsonMissing.of(), + @JsonProperty("type") @ExcludeMissing type: JsonField = JsonMissing.of(), + ) : this( + id, + createdAt, + entityId, + expiresAt, + idempotencyKey, + programId, + redirectUrl, + sessionUrl, + status, + type, + mutableMapOf(), + ) + + /** + * The Entity Onboarding Session's identifier. + * + * @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 id(): String = id.getRequired("id") + + /** + * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date and time at which the Entity + * Onboarding Session was created. + * + * @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 createdAt(): OffsetDateTime = createdAt.getRequired("created_at") + + /** + * The identifier of the Entity associated with this session, if one has been created or was + * provided when creating the session. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun entityId(): Optional = entityId.getOptional("entity_id") + + /** + * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date and time at which the Entity + * Onboarding Session will expire. + * + * @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 expiresAt(): OffsetDateTime = expiresAt.getRequired("expires_at") + + /** + * 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 + * [idempotency](https://increase.com/documentation/idempotency-keys). + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun idempotencyKey(): Optional = idempotencyKey.getOptional("idempotency_key") + + /** + * The identifier of the Program the Entity will be onboarded to. + * + * @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 programId(): String = programId.getRequired("program_id") + + /** + * The URL to redirect to after the onboarding session is complete. Increase will include the + * query parameters `entity_onboarding_session_id` and `entity_id` when redirecting. + * + * @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 redirectUrl(): String = redirectUrl.getRequired("redirect_url") + + /** + * The URL containing the onboarding form. You should share this link with your customer. Only + * present when the session is active. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun sessionUrl(): Optional = sessionUrl.getOptional("session_url") + + /** + * The status of the onboarding session. + * + * @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 status(): Status = status.getRequired("status") + + /** + * A constant representing the object's type. For this resource it will always be + * `entity_onboarding_session`. + * + * @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 type(): Type = type.getRequired("type") + + /** + * Returns the raw JSON value of [id]. + * + * Unlike [id], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("id") @ExcludeMissing fun _id(): JsonField = 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 [entityId]. + * + * Unlike [entityId], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("entity_id") @ExcludeMissing fun _entityId(): JsonField = entityId + + /** + * Returns the raw JSON value of [expiresAt]. + * + * Unlike [expiresAt], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("expires_at") + @ExcludeMissing + fun _expiresAt(): JsonField = expiresAt + + /** + * Returns the raw JSON value of [idempotencyKey]. + * + * Unlike [idempotencyKey], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("idempotency_key") + @ExcludeMissing + fun _idempotencyKey(): JsonField = idempotencyKey + + /** + * 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 + + /** + * Returns the raw JSON value of [redirectUrl]. + * + * Unlike [redirectUrl], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("redirect_url") + @ExcludeMissing + fun _redirectUrl(): JsonField = redirectUrl + + /** + * Returns the raw JSON value of [sessionUrl]. + * + * Unlike [sessionUrl], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("session_url") @ExcludeMissing fun _sessionUrl(): JsonField = sessionUrl + + /** + * Returns the raw JSON value of [status]. + * + * Unlike [status], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("status") @ExcludeMissing fun _status(): JsonField = status + + /** + * Returns the raw JSON value of [type]. + * + * Unlike [type], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("type") @ExcludeMissing fun _type(): JsonField = type + + @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 [EntityOnboardingSession]. + * + * The following fields are required: + * ```java + * .id() + * .createdAt() + * .entityId() + * .expiresAt() + * .idempotencyKey() + * .programId() + * .redirectUrl() + * .sessionUrl() + * .status() + * .type() + * ``` + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [EntityOnboardingSession]. */ + class Builder internal constructor() { + + private var id: JsonField? = null + private var createdAt: JsonField? = null + private var entityId: JsonField? = null + private var expiresAt: JsonField? = null + private var idempotencyKey: JsonField? = null + private var programId: JsonField? = null + private var redirectUrl: JsonField? = null + private var sessionUrl: JsonField? = null + private var status: JsonField? = null + private var type: JsonField? = null + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(entityOnboardingSession: EntityOnboardingSession) = apply { + id = entityOnboardingSession.id + createdAt = entityOnboardingSession.createdAt + entityId = entityOnboardingSession.entityId + expiresAt = entityOnboardingSession.expiresAt + idempotencyKey = entityOnboardingSession.idempotencyKey + programId = entityOnboardingSession.programId + redirectUrl = entityOnboardingSession.redirectUrl + sessionUrl = entityOnboardingSession.sessionUrl + status = entityOnboardingSession.status + type = entityOnboardingSession.type + additionalProperties = entityOnboardingSession.additionalProperties.toMutableMap() + } + + /** The Entity Onboarding Session's identifier. */ + fun id(id: String) = id(JsonField.of(id)) + + /** + * Sets [Builder.id] to an arbitrary JSON value. + * + * You should usually call [Builder.id] with a well-typed [String] value instead. This + * method is primarily for setting the field to an undocumented or not yet supported value. + */ + fun id(id: JsonField) = apply { this.id = id } + + /** + * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date and time at which the Entity + * Onboarding Session was created. + */ + fun createdAt(createdAt: OffsetDateTime) = createdAt(JsonField.of(createdAt)) + + /** + * Sets [Builder.createdAt] to an arbitrary JSON value. + * + * You should usually call [Builder.createdAt] with a well-typed [OffsetDateTime] 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 } + + /** + * The identifier of the Entity associated with this session, if one has been created or was + * provided when creating the session. + */ + fun entityId(entityId: String?) = entityId(JsonField.ofNullable(entityId)) + + /** Alias for calling [Builder.entityId] with `entityId.orElse(null)`. */ + fun entityId(entityId: Optional) = entityId(entityId.getOrNull()) + + /** + * Sets [Builder.entityId] to an arbitrary JSON value. + * + * You should usually call [Builder.entityId] with a well-typed [String] value instead. This + * method is primarily for setting the field to an undocumented or not yet supported value. + */ + fun entityId(entityId: JsonField) = apply { this.entityId = entityId } + + /** + * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date and time at which the Entity + * Onboarding Session will expire. + */ + fun expiresAt(expiresAt: OffsetDateTime) = expiresAt(JsonField.of(expiresAt)) + + /** + * Sets [Builder.expiresAt] to an arbitrary JSON value. + * + * You should usually call [Builder.expiresAt] with a well-typed [OffsetDateTime] value + * instead. This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun expiresAt(expiresAt: JsonField) = apply { this.expiresAt = expiresAt } + + /** + * 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 + * [idempotency](https://increase.com/documentation/idempotency-keys). + */ + fun idempotencyKey(idempotencyKey: String?) = + idempotencyKey(JsonField.ofNullable(idempotencyKey)) + + /** Alias for calling [Builder.idempotencyKey] with `idempotencyKey.orElse(null)`. */ + fun idempotencyKey(idempotencyKey: Optional) = + idempotencyKey(idempotencyKey.getOrNull()) + + /** + * Sets [Builder.idempotencyKey] to an arbitrary JSON value. + * + * You should usually call [Builder.idempotencyKey] with a well-typed [String] value + * instead. This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun idempotencyKey(idempotencyKey: JsonField) = apply { + this.idempotencyKey = idempotencyKey + } + + /** The identifier of the Program the Entity will be onboarded to. */ + 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 } + + /** + * The URL to redirect to after the onboarding session is complete. Increase will include + * the query parameters `entity_onboarding_session_id` and `entity_id` when redirecting. + */ + fun redirectUrl(redirectUrl: String) = redirectUrl(JsonField.of(redirectUrl)) + + /** + * Sets [Builder.redirectUrl] to an arbitrary JSON value. + * + * You should usually call [Builder.redirectUrl] with a well-typed [String] value instead. + * This method is primarily for setting the field to an undocumented or not yet supported + * value. + */ + fun redirectUrl(redirectUrl: JsonField) = apply { this.redirectUrl = redirectUrl } + + /** + * The URL containing the onboarding form. You should share this link with your customer. + * Only present when the session is active. + */ + fun sessionUrl(sessionUrl: String?) = sessionUrl(JsonField.ofNullable(sessionUrl)) + + /** Alias for calling [Builder.sessionUrl] with `sessionUrl.orElse(null)`. */ + fun sessionUrl(sessionUrl: Optional) = sessionUrl(sessionUrl.getOrNull()) + + /** + * Sets [Builder.sessionUrl] to an arbitrary JSON value. + * + * You should usually call [Builder.sessionUrl] with a well-typed [String] value instead. + * This method is primarily for setting the field to an undocumented or not yet supported + * value. + */ + fun sessionUrl(sessionUrl: JsonField) = apply { this.sessionUrl = sessionUrl } + + /** The status of the onboarding session. */ + fun status(status: Status) = status(JsonField.of(status)) + + /** + * Sets [Builder.status] to an arbitrary JSON value. + * + * You should usually call [Builder.status] with a well-typed [Status] value instead. This + * method is primarily for setting the field to an undocumented or not yet supported value. + */ + fun status(status: JsonField) = apply { this.status = status } + + /** + * A constant representing the object's type. For this resource it will always be + * `entity_onboarding_session`. + */ + fun type(type: Type) = type(JsonField.of(type)) + + /** + * Sets [Builder.type] to an arbitrary JSON value. + * + * You should usually call [Builder.type] with a well-typed [Type] value instead. This + * method is primarily for setting the field to an undocumented or not yet supported value. + */ + fun type(type: JsonField) = apply { this.type = type } + + 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 [EntityOnboardingSession]. + * + * Further updates to this [Builder] will not mutate the returned instance. + * + * The following fields are required: + * ```java + * .id() + * .createdAt() + * .entityId() + * .expiresAt() + * .idempotencyKey() + * .programId() + * .redirectUrl() + * .sessionUrl() + * .status() + * .type() + * ``` + * + * @throws IllegalStateException if any required field is unset. + */ + fun build(): EntityOnboardingSession = + EntityOnboardingSession( + checkRequired("id", id), + checkRequired("createdAt", createdAt), + checkRequired("entityId", entityId), + checkRequired("expiresAt", expiresAt), + checkRequired("idempotencyKey", idempotencyKey), + checkRequired("programId", programId), + checkRequired("redirectUrl", redirectUrl), + checkRequired("sessionUrl", sessionUrl), + checkRequired("status", status), + checkRequired("type", type), + additionalProperties.toMutableMap(), + ) + } + + private var validated: Boolean = false + + fun validate(): EntityOnboardingSession = apply { + if (validated) { + return@apply + } + + id() + createdAt() + entityId() + expiresAt() + idempotencyKey() + programId() + redirectUrl() + sessionUrl() + status().validate() + type().validate() + validated = true + } + + fun isValid(): Boolean = + try { + validate() + true + } catch (e: IncreaseInvalidDataException) { + false + } + + /** + * Returns a score indicating how many valid values are contained in this object recursively. + * + * Used for best match union deserialization. + */ + @JvmSynthetic + internal fun validity(): Int = + (if (id.asKnown().isPresent) 1 else 0) + + (if (createdAt.asKnown().isPresent) 1 else 0) + + (if (entityId.asKnown().isPresent) 1 else 0) + + (if (expiresAt.asKnown().isPresent) 1 else 0) + + (if (idempotencyKey.asKnown().isPresent) 1 else 0) + + (if (programId.asKnown().isPresent) 1 else 0) + + (if (redirectUrl.asKnown().isPresent) 1 else 0) + + (if (sessionUrl.asKnown().isPresent) 1 else 0) + + (status.asKnown().getOrNull()?.validity() ?: 0) + + (type.asKnown().getOrNull()?.validity() ?: 0) + + /** The status of the onboarding session. */ + class Status @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 Entity Onboarding Session is active. */ + @JvmField val ACTIVE = of("active") + + /** The Entity Onboarding Session has expired. */ + @JvmField val EXPIRED = of("expired") + + @JvmStatic fun of(value: String) = Status(JsonField.of(value)) + } + + /** An enum containing [Status]'s known values. */ + enum class Known { + /** The Entity Onboarding Session is active. */ + ACTIVE, + /** The Entity Onboarding Session has expired. */ + EXPIRED, + } + + /** + * An enum containing [Status]'s known values, as well as an [_UNKNOWN] member. + * + * An instance of [Status] 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 Entity Onboarding Session is active. */ + ACTIVE, + /** The Entity Onboarding Session has expired. */ + EXPIRED, + /** An enum member indicating that [Status] 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) { + ACTIVE -> Value.ACTIVE + EXPIRED -> Value.EXPIRED + 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) { + ACTIVE -> Known.ACTIVE + EXPIRED -> Known.EXPIRED + else -> throw IncreaseInvalidDataException("Unknown Status: $value") + } + + /** + * Returns this class instance's primitive wire representation. + * + * This differs from the [toString] method because that method is primarily for debugging + * and generally doesn't throw. + * + * @throws IncreaseInvalidDataException if this class instance's value does not have the + * expected primitive type. + */ + fun asString(): String = + _value().asString().orElseThrow { + IncreaseInvalidDataException("Value is not a String") + } + + private var validated: Boolean = false + + fun validate(): Status = 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 Status && value == other.value + } + + override fun hashCode() = value.hashCode() + + override fun toString() = value.toString() + } + + /** + * A constant representing the object's type. For this resource it will always be + * `entity_onboarding_session`. + */ + class Type @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 { + + @JvmField val ENTITY_ONBOARDING_SESSION = of("entity_onboarding_session") + + @JvmStatic fun of(value: String) = Type(JsonField.of(value)) + } + + /** An enum containing [Type]'s known values. */ + enum class Known { + ENTITY_ONBOARDING_SESSION + } + + /** + * An enum containing [Type]'s known values, as well as an [_UNKNOWN] member. + * + * An instance of [Type] 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 { + ENTITY_ONBOARDING_SESSION, + /** An enum member indicating that [Type] 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) { + ENTITY_ONBOARDING_SESSION -> Value.ENTITY_ONBOARDING_SESSION + 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) { + ENTITY_ONBOARDING_SESSION -> Known.ENTITY_ONBOARDING_SESSION + else -> throw IncreaseInvalidDataException("Unknown Type: $value") + } + + /** + * Returns this class instance's primitive wire representation. + * + * This differs from the [toString] method because that method is primarily for debugging + * and generally doesn't throw. + * + * @throws IncreaseInvalidDataException if this class instance's value does not have the + * expected primitive type. + */ + fun asString(): String = + _value().asString().orElseThrow { + IncreaseInvalidDataException("Value is not a String") + } + + private var validated: Boolean = false + + fun validate(): Type = 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 Type && 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 EntityOnboardingSession && + id == other.id && + createdAt == other.createdAt && + entityId == other.entityId && + expiresAt == other.expiresAt && + idempotencyKey == other.idempotencyKey && + programId == other.programId && + redirectUrl == other.redirectUrl && + sessionUrl == other.sessionUrl && + status == other.status && + type == other.type && + additionalProperties == other.additionalProperties + } + + private val hashCode: Int by lazy { + Objects.hash( + id, + createdAt, + entityId, + expiresAt, + idempotencyKey, + programId, + redirectUrl, + sessionUrl, + status, + type, + additionalProperties, + ) + } + + override fun hashCode(): Int = hashCode + + override fun toString() = + "EntityOnboardingSession{id=$id, createdAt=$createdAt, entityId=$entityId, expiresAt=$expiresAt, idempotencyKey=$idempotencyKey, programId=$programId, redirectUrl=$redirectUrl, sessionUrl=$sessionUrl, status=$status, type=$type, additionalProperties=$additionalProperties}" +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionCreateParams.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionCreateParams.kt new file mode 100644 index 000000000..4c752ee2c --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionCreateParams.kt @@ -0,0 +1,588 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.entityonboardingsessions + +import com.fasterxml.jackson.annotation.JsonAnyGetter +import com.fasterxml.jackson.annotation.JsonAnySetter +import com.fasterxml.jackson.annotation.JsonCreator +import com.fasterxml.jackson.annotation.JsonProperty +import com.increase.api.core.ExcludeMissing +import com.increase.api.core.JsonField +import com.increase.api.core.JsonMissing +import com.increase.api.core.JsonValue +import com.increase.api.core.Params +import com.increase.api.core.checkRequired +import com.increase.api.core.http.Headers +import com.increase.api.core.http.QueryParams +import com.increase.api.errors.IncreaseInvalidDataException +import java.util.Collections +import java.util.Objects +import java.util.Optional + +/** Create an Entity Onboarding Session */ +class EntityOnboardingSessionCreateParams +private constructor( + private val body: Body, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, +) : Params { + + /** + * The identifier of the Program the Entity will be onboarded to. + * + * @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 programId(): String = body.programId() + + /** + * The URL to redirect the customer to after they complete the onboarding form. The redirect + * will include `entity_onboarding_session_id` and `entity_id` query parameters. + * + * @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 redirectUrl(): String = body.redirectUrl() + + /** + * The identifier of an existing Entity to associate with the onboarding session. If provided, + * the onboarding form will display any outstanding tasks required to complete the Entity's + * onboarding. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun entityId(): Optional = body.entityId() + + /** + * Returns the raw JSON value of [programId]. + * + * Unlike [programId], this method doesn't throw if the JSON field has an unexpected type. + */ + fun _programId(): JsonField = body._programId() + + /** + * Returns the raw JSON value of [redirectUrl]. + * + * Unlike [redirectUrl], this method doesn't throw if the JSON field has an unexpected type. + */ + fun _redirectUrl(): JsonField = body._redirectUrl() + + /** + * Returns the raw JSON value of [entityId]. + * + * Unlike [entityId], this method doesn't throw if the JSON field has an unexpected type. + */ + fun _entityId(): JsonField = body._entityId() + + fun _additionalBodyProperties(): Map = body._additionalProperties() + + /** Additional headers to send with the request. */ + fun _additionalHeaders(): Headers = additionalHeaders + + /** Additional query param to send with the request. */ + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun toBuilder() = Builder().from(this) + + companion object { + + /** + * Returns a mutable builder for constructing an instance of + * [EntityOnboardingSessionCreateParams]. + * + * The following fields are required: + * ```java + * .programId() + * .redirectUrl() + * ``` + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [EntityOnboardingSessionCreateParams]. */ + class Builder internal constructor() { + + private var body: Body.Builder = Body.builder() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() + + @JvmSynthetic + internal fun from( + entityOnboardingSessionCreateParams: EntityOnboardingSessionCreateParams + ) = apply { + body = entityOnboardingSessionCreateParams.body.toBuilder() + additionalHeaders = entityOnboardingSessionCreateParams.additionalHeaders.toBuilder() + additionalQueryParams = + entityOnboardingSessionCreateParams.additionalQueryParams.toBuilder() + } + + /** + * Sets the entire request body. + * + * This is generally only useful if you are already constructing the body separately. + * Otherwise, it's more convenient to use the top-level setters instead: + * - [programId] + * - [redirectUrl] + * - [entityId] + */ + fun body(body: Body) = apply { this.body = body.toBuilder() } + + /** The identifier of the Program the Entity will be onboarded to. */ + fun programId(programId: String) = apply { body.programId(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 { body.programId(programId) } + + /** + * The URL to redirect the customer to after they complete the onboarding form. The redirect + * will include `entity_onboarding_session_id` and `entity_id` query parameters. + */ + fun redirectUrl(redirectUrl: String) = apply { body.redirectUrl(redirectUrl) } + + /** + * Sets [Builder.redirectUrl] to an arbitrary JSON value. + * + * You should usually call [Builder.redirectUrl] with a well-typed [String] value instead. + * This method is primarily for setting the field to an undocumented or not yet supported + * value. + */ + fun redirectUrl(redirectUrl: JsonField) = apply { body.redirectUrl(redirectUrl) } + + /** + * The identifier of an existing Entity to associate with the onboarding session. If + * provided, the onboarding form will display any outstanding tasks required to complete the + * Entity's onboarding. + */ + fun entityId(entityId: String) = apply { body.entityId(entityId) } + + /** + * Sets [Builder.entityId] to an arbitrary JSON value. + * + * You should usually call [Builder.entityId] with a well-typed [String] value instead. This + * method is primarily for setting the field to an undocumented or not yet supported value. + */ + fun entityId(entityId: JsonField) = apply { body.entityId(entityId) } + + fun additionalBodyProperties(additionalBodyProperties: Map) = apply { + body.additionalProperties(additionalBodyProperties) + } + + fun putAdditionalBodyProperty(key: String, value: JsonValue) = apply { + body.putAdditionalProperty(key, value) + } + + fun putAllAdditionalBodyProperties(additionalBodyProperties: Map) = + apply { + body.putAllAdditionalProperties(additionalBodyProperties) + } + + fun removeAdditionalBodyProperty(key: String) = apply { body.removeAdditionalProperty(key) } + + fun removeAllAdditionalBodyProperties(keys: Set) = apply { + body.removeAllAdditionalProperties(keys) + } + + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) + } + + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) + } + + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.putAll(additionalHeaders) + } + + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replace(name, value) + } + + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + this.additionalQueryParams.putAll(additionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replace(key, value) + } + + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } + + fun removeAllAdditionalQueryParams(keys: Set) = apply { + additionalQueryParams.removeAll(keys) + } + + /** + * Returns an immutable instance of [EntityOnboardingSessionCreateParams]. + * + * Further updates to this [Builder] will not mutate the returned instance. + * + * The following fields are required: + * ```java + * .programId() + * .redirectUrl() + * ``` + * + * @throws IllegalStateException if any required field is unset. + */ + fun build(): EntityOnboardingSessionCreateParams = + EntityOnboardingSessionCreateParams( + body.build(), + additionalHeaders.build(), + additionalQueryParams.build(), + ) + } + + fun _body(): Body = body + + override fun _headers(): Headers = additionalHeaders + + override fun _queryParams(): QueryParams = additionalQueryParams + + class Body + @JsonCreator(mode = JsonCreator.Mode.DISABLED) + private constructor( + private val programId: JsonField, + private val redirectUrl: JsonField, + private val entityId: JsonField, + private val additionalProperties: MutableMap, + ) { + + @JsonCreator + private constructor( + @JsonProperty("program_id") + @ExcludeMissing + programId: JsonField = JsonMissing.of(), + @JsonProperty("redirect_url") + @ExcludeMissing + redirectUrl: JsonField = JsonMissing.of(), + @JsonProperty("entity_id") + @ExcludeMissing + entityId: JsonField = JsonMissing.of(), + ) : this(programId, redirectUrl, entityId, mutableMapOf()) + + /** + * The identifier of the Program the Entity will be onboarded to. + * + * @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 programId(): String = programId.getRequired("program_id") + + /** + * The URL to redirect the customer to after they complete the onboarding form. The redirect + * will include `entity_onboarding_session_id` and `entity_id` query parameters. + * + * @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 redirectUrl(): String = redirectUrl.getRequired("redirect_url") + + /** + * The identifier of an existing Entity to associate with the onboarding session. If + * provided, the onboarding form will display any outstanding tasks required to complete the + * Entity's onboarding. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if + * the server responded with an unexpected value). + */ + fun entityId(): Optional = entityId.getOptional("entity_id") + + /** + * 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 + + /** + * Returns the raw JSON value of [redirectUrl]. + * + * Unlike [redirectUrl], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("redirect_url") + @ExcludeMissing + fun _redirectUrl(): JsonField = redirectUrl + + /** + * Returns the raw JSON value of [entityId]. + * + * Unlike [entityId], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("entity_id") @ExcludeMissing fun _entityId(): JsonField = entityId + + @JsonAnySetter + private fun putAdditionalProperty(key: String, value: JsonValue) { + additionalProperties.put(key, value) + } + + @JsonAnyGetter + @ExcludeMissing + fun _additionalProperties(): Map = + Collections.unmodifiableMap(additionalProperties) + + fun toBuilder() = Builder().from(this) + + companion object { + + /** + * Returns a mutable builder for constructing an instance of [Body]. + * + * The following fields are required: + * ```java + * .programId() + * .redirectUrl() + * ``` + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [Body]. */ + class Builder internal constructor() { + + private var programId: JsonField? = null + private var redirectUrl: JsonField? = null + private var entityId: JsonField = JsonMissing.of() + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(body: Body) = apply { + programId = body.programId + redirectUrl = body.redirectUrl + entityId = body.entityId + additionalProperties = body.additionalProperties.toMutableMap() + } + + /** The identifier of the Program the Entity will be onboarded to. */ + 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 } + + /** + * The URL to redirect the customer to after they complete the onboarding form. The + * redirect will include `entity_onboarding_session_id` and `entity_id` query + * parameters. + */ + fun redirectUrl(redirectUrl: String) = redirectUrl(JsonField.of(redirectUrl)) + + /** + * Sets [Builder.redirectUrl] to an arbitrary JSON value. + * + * You should usually call [Builder.redirectUrl] with a well-typed [String] value + * instead. This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun redirectUrl(redirectUrl: JsonField) = apply { + this.redirectUrl = redirectUrl + } + + /** + * The identifier of an existing Entity to associate with the onboarding session. If + * provided, the onboarding form will display any outstanding tasks required to complete + * the Entity's onboarding. + */ + fun entityId(entityId: String) = entityId(JsonField.of(entityId)) + + /** + * Sets [Builder.entityId] to an arbitrary JSON value. + * + * You should usually call [Builder.entityId] with a well-typed [String] value instead. + * This method is primarily for setting the field to an undocumented or not yet + * supported value. + */ + fun entityId(entityId: JsonField) = apply { this.entityId = entityId } + + fun additionalProperties(additionalProperties: Map) = apply { + this.additionalProperties.clear() + putAllAdditionalProperties(additionalProperties) + } + + fun putAdditionalProperty(key: String, value: JsonValue) = apply { + additionalProperties.put(key, value) + } + + fun putAllAdditionalProperties(additionalProperties: Map) = apply { + this.additionalProperties.putAll(additionalProperties) + } + + fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) } + + fun removeAllAdditionalProperties(keys: Set) = apply { + keys.forEach(::removeAdditionalProperty) + } + + /** + * Returns an immutable instance of [Body]. + * + * Further updates to this [Builder] will not mutate the returned instance. + * + * The following fields are required: + * ```java + * .programId() + * .redirectUrl() + * ``` + * + * @throws IllegalStateException if any required field is unset. + */ + fun build(): Body = + Body( + checkRequired("programId", programId), + checkRequired("redirectUrl", redirectUrl), + entityId, + additionalProperties.toMutableMap(), + ) + } + + private var validated: Boolean = false + + fun validate(): Body = apply { + if (validated) { + return@apply + } + + programId() + redirectUrl() + entityId() + 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 (programId.asKnown().isPresent) 1 else 0) + + (if (redirectUrl.asKnown().isPresent) 1 else 0) + + (if (entityId.asKnown().isPresent) 1 else 0) + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is Body && + programId == other.programId && + redirectUrl == other.redirectUrl && + entityId == other.entityId && + additionalProperties == other.additionalProperties + } + + private val hashCode: Int by lazy { + Objects.hash(programId, redirectUrl, entityId, additionalProperties) + } + + override fun hashCode(): Int = hashCode + + override fun toString() = + "Body{programId=$programId, redirectUrl=$redirectUrl, entityId=$entityId, additionalProperties=$additionalProperties}" + } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is EntityOnboardingSessionCreateParams && + body == other.body && + additionalHeaders == other.additionalHeaders && + additionalQueryParams == other.additionalQueryParams + } + + override fun hashCode(): Int = Objects.hash(body, additionalHeaders, additionalQueryParams) + + override fun toString() = + "EntityOnboardingSessionCreateParams{body=$body, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionExpireParams.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionExpireParams.kt new file mode 100644 index 000000000..aa8cd3909 --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionExpireParams.kt @@ -0,0 +1,251 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.entityonboardingsessions + +import com.increase.api.core.JsonValue +import com.increase.api.core.Params +import com.increase.api.core.http.Headers +import com.increase.api.core.http.QueryParams +import com.increase.api.core.toImmutable +import java.util.Objects +import java.util.Optional +import kotlin.jvm.optionals.getOrNull + +/** Expire an Entity Onboarding Session */ +class EntityOnboardingSessionExpireParams +private constructor( + private val entityOnboardingSessionId: String?, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, + private val additionalBodyProperties: Map, +) : Params { + + /** The identifier of the Entity Onboarding Session to expire. */ + fun entityOnboardingSessionId(): Optional = + Optional.ofNullable(entityOnboardingSessionId) + + /** Additional body properties to send with the request. */ + fun _additionalBodyProperties(): Map = additionalBodyProperties + + /** Additional headers to send with the request. */ + fun _additionalHeaders(): Headers = additionalHeaders + + /** Additional query param to send with the request. */ + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun toBuilder() = Builder().from(this) + + companion object { + + @JvmStatic fun none(): EntityOnboardingSessionExpireParams = builder().build() + + /** + * Returns a mutable builder for constructing an instance of + * [EntityOnboardingSessionExpireParams]. + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [EntityOnboardingSessionExpireParams]. */ + class Builder internal constructor() { + + private var entityOnboardingSessionId: String? = null + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() + private var additionalBodyProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from( + entityOnboardingSessionExpireParams: EntityOnboardingSessionExpireParams + ) = apply { + entityOnboardingSessionId = + entityOnboardingSessionExpireParams.entityOnboardingSessionId + additionalHeaders = entityOnboardingSessionExpireParams.additionalHeaders.toBuilder() + additionalQueryParams = + entityOnboardingSessionExpireParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + entityOnboardingSessionExpireParams.additionalBodyProperties.toMutableMap() + } + + /** The identifier of the Entity Onboarding Session to expire. */ + fun entityOnboardingSessionId(entityOnboardingSessionId: String?) = apply { + this.entityOnboardingSessionId = entityOnboardingSessionId + } + + /** + * Alias for calling [Builder.entityOnboardingSessionId] with + * `entityOnboardingSessionId.orElse(null)`. + */ + fun entityOnboardingSessionId(entityOnboardingSessionId: Optional) = + entityOnboardingSessionId(entityOnboardingSessionId.getOrNull()) + + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) + } + + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) + } + + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.putAll(additionalHeaders) + } + + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replace(name, value) + } + + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + this.additionalQueryParams.putAll(additionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replace(key, value) + } + + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } + + fun removeAllAdditionalQueryParams(keys: Set) = apply { + additionalQueryParams.removeAll(keys) + } + + fun additionalBodyProperties(additionalBodyProperties: Map) = apply { + this.additionalBodyProperties.clear() + putAllAdditionalBodyProperties(additionalBodyProperties) + } + + fun putAdditionalBodyProperty(key: String, value: JsonValue) = apply { + additionalBodyProperties.put(key, value) + } + + fun putAllAdditionalBodyProperties(additionalBodyProperties: Map) = + apply { + this.additionalBodyProperties.putAll(additionalBodyProperties) + } + + fun removeAdditionalBodyProperty(key: String) = apply { + additionalBodyProperties.remove(key) + } + + fun removeAllAdditionalBodyProperties(keys: Set) = apply { + keys.forEach(::removeAdditionalBodyProperty) + } + + /** + * Returns an immutable instance of [EntityOnboardingSessionExpireParams]. + * + * Further updates to this [Builder] will not mutate the returned instance. + */ + fun build(): EntityOnboardingSessionExpireParams = + EntityOnboardingSessionExpireParams( + entityOnboardingSessionId, + additionalHeaders.build(), + additionalQueryParams.build(), + additionalBodyProperties.toImmutable(), + ) + } + + fun _body(): Optional> = + Optional.ofNullable(additionalBodyProperties.ifEmpty { null }) + + fun _pathParam(index: Int): String = + when (index) { + 0 -> entityOnboardingSessionId ?: "" + else -> "" + } + + override fun _headers(): Headers = additionalHeaders + + override fun _queryParams(): QueryParams = additionalQueryParams + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is EntityOnboardingSessionExpireParams && + entityOnboardingSessionId == other.entityOnboardingSessionId && + additionalHeaders == other.additionalHeaders && + additionalQueryParams == other.additionalQueryParams && + additionalBodyProperties == other.additionalBodyProperties + } + + override fun hashCode(): Int = + Objects.hash( + entityOnboardingSessionId, + additionalHeaders, + additionalQueryParams, + additionalBodyProperties, + ) + + override fun toString() = + "EntityOnboardingSessionExpireParams{entityOnboardingSessionId=$entityOnboardingSessionId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionListPage.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionListPage.kt new file mode 100644 index 000000000..33ad746fa --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionListPage.kt @@ -0,0 +1,137 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.entityonboardingsessions + +import com.increase.api.core.AutoPager +import com.increase.api.core.Page +import com.increase.api.core.checkRequired +import com.increase.api.services.blocking.EntityOnboardingSessionService +import java.util.Objects +import java.util.Optional +import kotlin.jvm.optionals.getOrNull + +/** @see EntityOnboardingSessionService.list */ +class EntityOnboardingSessionListPage +private constructor( + private val service: EntityOnboardingSessionService, + private val params: EntityOnboardingSessionListParams, + private val response: EntityOnboardingSessionListPageResponse, +) : Page { + + /** + * Delegates to [EntityOnboardingSessionListPageResponse], but gracefully handles missing data. + * + * @see EntityOnboardingSessionListPageResponse.data + */ + fun data(): List = + response._data().getOptional("data").getOrNull() ?: emptyList() + + /** + * Delegates to [EntityOnboardingSessionListPageResponse], but gracefully handles missing data. + * + * @see EntityOnboardingSessionListPageResponse.nextCursor + */ + fun nextCursor(): Optional = response._nextCursor().getOptional("next_cursor") + + override fun items(): List = data() + + override fun hasNextPage(): Boolean = items().isNotEmpty() && nextCursor().isPresent + + fun nextPageParams(): EntityOnboardingSessionListParams { + val nextCursor = + nextCursor().getOrNull() + ?: throw IllegalStateException("Cannot construct next page params") + return params.toBuilder().cursor(nextCursor).build() + } + + override fun nextPage(): EntityOnboardingSessionListPage = service.list(nextPageParams()) + + fun autoPager(): AutoPager = AutoPager.from(this) + + /** The parameters that were used to request this page. */ + fun params(): EntityOnboardingSessionListParams = params + + /** The response that this page was parsed from. */ + fun response(): EntityOnboardingSessionListPageResponse = response + + fun toBuilder() = Builder().from(this) + + companion object { + + /** + * Returns a mutable builder for constructing an instance of + * [EntityOnboardingSessionListPage]. + * + * The following fields are required: + * ```java + * .service() + * .params() + * .response() + * ``` + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [EntityOnboardingSessionListPage]. */ + class Builder internal constructor() { + + private var service: EntityOnboardingSessionService? = null + private var params: EntityOnboardingSessionListParams? = null + private var response: EntityOnboardingSessionListPageResponse? = null + + @JvmSynthetic + internal fun from(entityOnboardingSessionListPage: EntityOnboardingSessionListPage) = + apply { + service = entityOnboardingSessionListPage.service + params = entityOnboardingSessionListPage.params + response = entityOnboardingSessionListPage.response + } + + fun service(service: EntityOnboardingSessionService) = apply { this.service = service } + + /** The parameters that were used to request this page. */ + fun params(params: EntityOnboardingSessionListParams) = apply { this.params = params } + + /** The response that this page was parsed from. */ + fun response(response: EntityOnboardingSessionListPageResponse) = apply { + this.response = response + } + + /** + * Returns an immutable instance of [EntityOnboardingSessionListPage]. + * + * Further updates to this [Builder] will not mutate the returned instance. + * + * The following fields are required: + * ```java + * .service() + * .params() + * .response() + * ``` + * + * @throws IllegalStateException if any required field is unset. + */ + fun build(): EntityOnboardingSessionListPage = + EntityOnboardingSessionListPage( + checkRequired("service", service), + checkRequired("params", params), + checkRequired("response", response), + ) + } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is EntityOnboardingSessionListPage && + service == other.service && + params == other.params && + response == other.response + } + + override fun hashCode(): Int = Objects.hash(service, params, response) + + override fun toString() = + "EntityOnboardingSessionListPage{service=$service, params=$params, response=$response}" +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionListPageAsync.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionListPageAsync.kt new file mode 100644 index 000000000..2b4ac8837 --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionListPageAsync.kt @@ -0,0 +1,153 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.entityonboardingsessions + +import com.increase.api.core.AutoPagerAsync +import com.increase.api.core.PageAsync +import com.increase.api.core.checkRequired +import com.increase.api.services.async.EntityOnboardingSessionServiceAsync +import java.util.Objects +import java.util.Optional +import java.util.concurrent.CompletableFuture +import java.util.concurrent.Executor +import kotlin.jvm.optionals.getOrNull + +/** @see EntityOnboardingSessionServiceAsync.list */ +class EntityOnboardingSessionListPageAsync +private constructor( + private val service: EntityOnboardingSessionServiceAsync, + private val streamHandlerExecutor: Executor, + private val params: EntityOnboardingSessionListParams, + private val response: EntityOnboardingSessionListPageResponse, +) : PageAsync { + + /** + * Delegates to [EntityOnboardingSessionListPageResponse], but gracefully handles missing data. + * + * @see EntityOnboardingSessionListPageResponse.data + */ + fun data(): List = + response._data().getOptional("data").getOrNull() ?: emptyList() + + /** + * Delegates to [EntityOnboardingSessionListPageResponse], but gracefully handles missing data. + * + * @see EntityOnboardingSessionListPageResponse.nextCursor + */ + fun nextCursor(): Optional = response._nextCursor().getOptional("next_cursor") + + override fun items(): List = data() + + override fun hasNextPage(): Boolean = items().isNotEmpty() && nextCursor().isPresent + + fun nextPageParams(): EntityOnboardingSessionListParams { + val nextCursor = + nextCursor().getOrNull() + ?: throw IllegalStateException("Cannot construct next page params") + return params.toBuilder().cursor(nextCursor).build() + } + + override fun nextPage(): CompletableFuture = + service.list(nextPageParams()) + + fun autoPager(): AutoPagerAsync = + AutoPagerAsync.from(this, streamHandlerExecutor) + + /** The parameters that were used to request this page. */ + fun params(): EntityOnboardingSessionListParams = params + + /** The response that this page was parsed from. */ + fun response(): EntityOnboardingSessionListPageResponse = response + + fun toBuilder() = Builder().from(this) + + companion object { + + /** + * Returns a mutable builder for constructing an instance of + * [EntityOnboardingSessionListPageAsync]. + * + * The following fields are required: + * ```java + * .service() + * .streamHandlerExecutor() + * .params() + * .response() + * ``` + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [EntityOnboardingSessionListPageAsync]. */ + class Builder internal constructor() { + + private var service: EntityOnboardingSessionServiceAsync? = null + private var streamHandlerExecutor: Executor? = null + private var params: EntityOnboardingSessionListParams? = null + private var response: EntityOnboardingSessionListPageResponse? = null + + @JvmSynthetic + internal fun from( + entityOnboardingSessionListPageAsync: EntityOnboardingSessionListPageAsync + ) = apply { + service = entityOnboardingSessionListPageAsync.service + streamHandlerExecutor = entityOnboardingSessionListPageAsync.streamHandlerExecutor + params = entityOnboardingSessionListPageAsync.params + response = entityOnboardingSessionListPageAsync.response + } + + fun service(service: EntityOnboardingSessionServiceAsync) = apply { this.service = service } + + fun streamHandlerExecutor(streamHandlerExecutor: Executor) = apply { + this.streamHandlerExecutor = streamHandlerExecutor + } + + /** The parameters that were used to request this page. */ + fun params(params: EntityOnboardingSessionListParams) = apply { this.params = params } + + /** The response that this page was parsed from. */ + fun response(response: EntityOnboardingSessionListPageResponse) = apply { + this.response = response + } + + /** + * Returns an immutable instance of [EntityOnboardingSessionListPageAsync]. + * + * Further updates to this [Builder] will not mutate the returned instance. + * + * The following fields are required: + * ```java + * .service() + * .streamHandlerExecutor() + * .params() + * .response() + * ``` + * + * @throws IllegalStateException if any required field is unset. + */ + fun build(): EntityOnboardingSessionListPageAsync = + EntityOnboardingSessionListPageAsync( + checkRequired("service", service), + checkRequired("streamHandlerExecutor", streamHandlerExecutor), + checkRequired("params", params), + checkRequired("response", response), + ) + } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is EntityOnboardingSessionListPageAsync && + service == other.service && + streamHandlerExecutor == other.streamHandlerExecutor && + params == other.params && + response == other.response + } + + override fun hashCode(): Int = Objects.hash(service, streamHandlerExecutor, params, response) + + override fun toString() = + "EntityOnboardingSessionListPageAsync{service=$service, streamHandlerExecutor=$streamHandlerExecutor, params=$params, response=$response}" +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionListPageResponse.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionListPageResponse.kt new file mode 100644 index 000000000..f3a9d3f21 --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionListPageResponse.kt @@ -0,0 +1,245 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.entityonboardingsessions + +import com.fasterxml.jackson.annotation.JsonAnyGetter +import com.fasterxml.jackson.annotation.JsonAnySetter +import com.fasterxml.jackson.annotation.JsonCreator +import com.fasterxml.jackson.annotation.JsonProperty +import com.increase.api.core.ExcludeMissing +import com.increase.api.core.JsonField +import com.increase.api.core.JsonMissing +import com.increase.api.core.JsonValue +import com.increase.api.core.checkKnown +import com.increase.api.core.checkRequired +import com.increase.api.core.toImmutable +import com.increase.api.errors.IncreaseInvalidDataException +import java.util.Collections +import java.util.Objects +import java.util.Optional +import kotlin.jvm.optionals.getOrNull + +/** A list of Entity Onboarding Session objects. */ +class EntityOnboardingSessionListPageResponse +@JsonCreator(mode = JsonCreator.Mode.DISABLED) +private constructor( + private val data: JsonField>, + private val nextCursor: JsonField, + private val additionalProperties: MutableMap, +) { + + @JsonCreator + private constructor( + @JsonProperty("data") + @ExcludeMissing + data: JsonField> = JsonMissing.of(), + @JsonProperty("next_cursor") + @ExcludeMissing + nextCursor: JsonField = JsonMissing.of(), + ) : this(data, nextCursor, mutableMapOf()) + + /** + * The contents of the list. + * + * @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 data(): List = data.getRequired("data") + + /** + * A pointer to a place in the list. + * + * @throws IncreaseInvalidDataException if the JSON field has an unexpected type (e.g. if the + * server responded with an unexpected value). + */ + fun nextCursor(): Optional = nextCursor.getOptional("next_cursor") + + /** + * Returns the raw JSON value of [data]. + * + * Unlike [data], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("data") + @ExcludeMissing + fun _data(): JsonField> = data + + /** + * Returns the raw JSON value of [nextCursor]. + * + * Unlike [nextCursor], this method doesn't throw if the JSON field has an unexpected type. + */ + @JsonProperty("next_cursor") @ExcludeMissing fun _nextCursor(): JsonField = nextCursor + + @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 + * [EntityOnboardingSessionListPageResponse]. + * + * The following fields are required: + * ```java + * .data() + * .nextCursor() + * ``` + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [EntityOnboardingSessionListPageResponse]. */ + class Builder internal constructor() { + + private var data: JsonField>? = null + private var nextCursor: JsonField? = null + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from( + entityOnboardingSessionListPageResponse: EntityOnboardingSessionListPageResponse + ) = apply { + data = entityOnboardingSessionListPageResponse.data.map { it.toMutableList() } + nextCursor = entityOnboardingSessionListPageResponse.nextCursor + additionalProperties = + entityOnboardingSessionListPageResponse.additionalProperties.toMutableMap() + } + + /** The contents of the list. */ + fun data(data: List) = data(JsonField.of(data)) + + /** + * Sets [Builder.data] to an arbitrary JSON value. + * + * You should usually call [Builder.data] with a well-typed `List` + * value instead. This method is primarily for setting the field to an undocumented or not + * yet supported value. + */ + fun data(data: JsonField>) = apply { + this.data = data.map { it.toMutableList() } + } + + /** + * Adds a single [EntityOnboardingSession] to [Builder.data]. + * + * @throws IllegalStateException if the field was previously set to a non-list. + */ + fun addData(data: EntityOnboardingSession) = apply { + this.data = + (this.data ?: JsonField.of(mutableListOf())).also { + checkKnown("data", it).add(data) + } + } + + /** A pointer to a place in the list. */ + fun nextCursor(nextCursor: String?) = nextCursor(JsonField.ofNullable(nextCursor)) + + /** Alias for calling [Builder.nextCursor] with `nextCursor.orElse(null)`. */ + fun nextCursor(nextCursor: Optional) = nextCursor(nextCursor.getOrNull()) + + /** + * Sets [Builder.nextCursor] to an arbitrary JSON value. + * + * You should usually call [Builder.nextCursor] with a well-typed [String] value instead. + * This method is primarily for setting the field to an undocumented or not yet supported + * value. + */ + fun nextCursor(nextCursor: JsonField) = apply { this.nextCursor = nextCursor } + + 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 [EntityOnboardingSessionListPageResponse]. + * + * Further updates to this [Builder] will not mutate the returned instance. + * + * The following fields are required: + * ```java + * .data() + * .nextCursor() + * ``` + * + * @throws IllegalStateException if any required field is unset. + */ + fun build(): EntityOnboardingSessionListPageResponse = + EntityOnboardingSessionListPageResponse( + checkRequired("data", data).map { it.toImmutable() }, + checkRequired("nextCursor", nextCursor), + additionalProperties.toMutableMap(), + ) + } + + private var validated: Boolean = false + + fun validate(): EntityOnboardingSessionListPageResponse = apply { + if (validated) { + return@apply + } + + data().forEach { it.validate() } + nextCursor() + 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 = + (data.asKnown().getOrNull()?.sumOf { it.validity().toInt() } ?: 0) + + (if (nextCursor.asKnown().isPresent) 1 else 0) + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is EntityOnboardingSessionListPageResponse && + data == other.data && + nextCursor == other.nextCursor && + additionalProperties == other.additionalProperties + } + + private val hashCode: Int by lazy { Objects.hash(data, nextCursor, additionalProperties) } + + override fun hashCode(): Int = hashCode + + override fun toString() = + "EntityOnboardingSessionListPageResponse{data=$data, nextCursor=$nextCursor, additionalProperties=$additionalProperties}" +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionListParams.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionListParams.kt new file mode 100644 index 000000000..81bc03ec2 --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionListParams.kt @@ -0,0 +1,541 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.entityonboardingsessions + +import com.fasterxml.jackson.annotation.JsonCreator +import com.increase.api.core.Enum +import com.increase.api.core.JsonField +import com.increase.api.core.Params +import com.increase.api.core.http.Headers +import com.increase.api.core.http.QueryParams +import com.increase.api.core.toImmutable +import com.increase.api.errors.IncreaseInvalidDataException +import java.util.Objects +import java.util.Optional +import kotlin.jvm.optionals.getOrNull + +/** List Entity Onboarding Session */ +class EntityOnboardingSessionListParams +private constructor( + private val cursor: String?, + private val idempotencyKey: String?, + private val limit: Long?, + private val status: Status?, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, +) : Params { + + /** Return the page of entries after this one. */ + fun cursor(): Optional = Optional.ofNullable(cursor) + + /** + * Filter records to the one with the specified `idempotency_key` you chose for that object. + * This value is unique across Increase and is used to ensure that a request is only processed + * once. Learn more about [idempotency](https://increase.com/documentation/idempotency-keys). + */ + fun idempotencyKey(): Optional = Optional.ofNullable(idempotencyKey) + + /** Limit the size of the list that is returned. The default (and maximum) is 100 objects. */ + fun limit(): Optional = Optional.ofNullable(limit) + + fun status(): Optional = Optional.ofNullable(status) + + /** Additional headers to send with the request. */ + fun _additionalHeaders(): Headers = additionalHeaders + + /** Additional query param to send with the request. */ + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun toBuilder() = Builder().from(this) + + companion object { + + @JvmStatic fun none(): EntityOnboardingSessionListParams = builder().build() + + /** + * Returns a mutable builder for constructing an instance of + * [EntityOnboardingSessionListParams]. + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [EntityOnboardingSessionListParams]. */ + class Builder internal constructor() { + + private var cursor: String? = null + private var idempotencyKey: String? = null + private var limit: Long? = null + private var status: Status? = null + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() + + @JvmSynthetic + internal fun from(entityOnboardingSessionListParams: EntityOnboardingSessionListParams) = + apply { + cursor = entityOnboardingSessionListParams.cursor + idempotencyKey = entityOnboardingSessionListParams.idempotencyKey + limit = entityOnboardingSessionListParams.limit + status = entityOnboardingSessionListParams.status + additionalHeaders = entityOnboardingSessionListParams.additionalHeaders.toBuilder() + additionalQueryParams = + entityOnboardingSessionListParams.additionalQueryParams.toBuilder() + } + + /** Return the page of entries after this one. */ + fun cursor(cursor: String?) = apply { this.cursor = cursor } + + /** Alias for calling [Builder.cursor] with `cursor.orElse(null)`. */ + fun cursor(cursor: Optional) = cursor(cursor.getOrNull()) + + /** + * Filter records to the one with the specified `idempotency_key` you chose for that object. + * This value is unique across Increase and is used to ensure that a request is only + * processed once. Learn more about + * [idempotency](https://increase.com/documentation/idempotency-keys). + */ + fun idempotencyKey(idempotencyKey: String?) = apply { this.idempotencyKey = idempotencyKey } + + /** Alias for calling [Builder.idempotencyKey] with `idempotencyKey.orElse(null)`. */ + fun idempotencyKey(idempotencyKey: Optional) = + idempotencyKey(idempotencyKey.getOrNull()) + + /** + * Limit the size of the list that is returned. The default (and maximum) is 100 objects. + */ + fun limit(limit: Long?) = apply { this.limit = limit } + + /** + * Alias for [Builder.limit]. + * + * This unboxed primitive overload exists for backwards compatibility. + */ + fun limit(limit: Long) = limit(limit as Long?) + + /** Alias for calling [Builder.limit] with `limit.orElse(null)`. */ + fun limit(limit: Optional) = limit(limit.getOrNull()) + + fun status(status: Status?) = apply { this.status = status } + + /** Alias for calling [Builder.status] with `status.orElse(null)`. */ + fun status(status: Optional) = status(status.getOrNull()) + + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) + } + + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) + } + + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.putAll(additionalHeaders) + } + + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replace(name, value) + } + + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + this.additionalQueryParams.putAll(additionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replace(key, value) + } + + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } + + fun removeAllAdditionalQueryParams(keys: Set) = apply { + additionalQueryParams.removeAll(keys) + } + + /** + * Returns an immutable instance of [EntityOnboardingSessionListParams]. + * + * Further updates to this [Builder] will not mutate the returned instance. + */ + fun build(): EntityOnboardingSessionListParams = + EntityOnboardingSessionListParams( + cursor, + idempotencyKey, + limit, + status, + additionalHeaders.build(), + additionalQueryParams.build(), + ) + } + + override fun _headers(): Headers = additionalHeaders + + override fun _queryParams(): QueryParams = + QueryParams.builder() + .apply { + cursor?.let { put("cursor", it) } + idempotencyKey?.let { put("idempotency_key", it) } + limit?.let { put("limit", it.toString()) } + status?.let { + it.in_().ifPresent { put("status.in", it.joinToString(",") { it.toString() }) } + it._additionalProperties().keys().forEach { key -> + it._additionalProperties().values(key).forEach { value -> + put("status.$key", value) + } + } + } + putAll(additionalQueryParams) + } + .build() + + class Status + private constructor(private val in_: List?, private val additionalProperties: QueryParams) { + + /** + * Filter Entity Onboarding Session for those with the specified status or statuses. For GET + * requests, this should be encoded as a comma-delimited string, such as + * `?in=one,two,three`. + */ + fun in_(): Optional> = Optional.ofNullable(in_) + + /** Query params to send with the request. */ + fun _additionalProperties(): QueryParams = additionalProperties + + fun toBuilder() = Builder().from(this) + + companion object { + + /** Returns a mutable builder for constructing an instance of [Status]. */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [Status]. */ + class Builder internal constructor() { + + private var in_: MutableList? = null + private var additionalProperties: QueryParams.Builder = QueryParams.builder() + + @JvmSynthetic + internal fun from(status: Status) = apply { + in_ = status.in_?.toMutableList() + additionalProperties = status.additionalProperties.toBuilder() + } + + /** + * Filter Entity Onboarding Session for those with the specified status or statuses. For + * GET requests, this should be encoded as a comma-delimited string, such as + * `?in=one,two,three`. + */ + fun in_(in_: List?) = apply { this.in_ = in_?.toMutableList() } + + /** Alias for calling [Builder.in_] with `in_.orElse(null)`. */ + fun in_(in_: Optional>) = in_(in_.getOrNull()) + + /** + * Adds a single [In] to [Builder.in_]. + * + * @throws IllegalStateException if the field was previously set to a non-list. + */ + fun addIn(in_: In) = apply { + this.in_ = (this.in_ ?: mutableListOf()).apply { add(in_) } + } + + fun additionalProperties(additionalProperties: QueryParams) = apply { + this.additionalProperties.clear() + putAllAdditionalProperties(additionalProperties) + } + + fun additionalProperties(additionalProperties: Map>) = apply { + this.additionalProperties.clear() + putAllAdditionalProperties(additionalProperties) + } + + fun putAdditionalProperty(key: String, value: String) = apply { + additionalProperties.put(key, value) + } + + fun putAdditionalProperties(key: String, values: Iterable) = apply { + additionalProperties.put(key, values) + } + + fun putAllAdditionalProperties(additionalProperties: QueryParams) = apply { + this.additionalProperties.putAll(additionalProperties) + } + + fun putAllAdditionalProperties(additionalProperties: Map>) = + apply { + this.additionalProperties.putAll(additionalProperties) + } + + fun replaceAdditionalProperties(key: String, value: String) = apply { + additionalProperties.replace(key, value) + } + + fun replaceAdditionalProperties(key: String, values: Iterable) = apply { + additionalProperties.replace(key, values) + } + + fun replaceAllAdditionalProperties(additionalProperties: QueryParams) = apply { + this.additionalProperties.replaceAll(additionalProperties) + } + + fun replaceAllAdditionalProperties( + additionalProperties: Map> + ) = apply { this.additionalProperties.replaceAll(additionalProperties) } + + fun removeAdditionalProperties(key: String) = apply { additionalProperties.remove(key) } + + fun removeAllAdditionalProperties(keys: Set) = apply { + additionalProperties.removeAll(keys) + } + + /** + * Returns an immutable instance of [Status]. + * + * Further updates to this [Builder] will not mutate the returned instance. + */ + fun build(): Status = Status(in_?.toImmutable(), additionalProperties.build()) + } + + class In @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 Entity Onboarding Session is active. */ + @JvmField val ACTIVE = of("active") + + /** The Entity Onboarding Session has expired. */ + @JvmField val EXPIRED = of("expired") + + @JvmStatic fun of(value: String) = In(JsonField.of(value)) + } + + /** An enum containing [In]'s known values. */ + enum class Known { + /** The Entity Onboarding Session is active. */ + ACTIVE, + /** The Entity Onboarding Session has expired. */ + EXPIRED, + } + + /** + * An enum containing [In]'s known values, as well as an [_UNKNOWN] member. + * + * An instance of [In] 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 Entity Onboarding Session is active. */ + ACTIVE, + /** The Entity Onboarding Session has expired. */ + EXPIRED, + /** An enum member indicating that [In] 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) { + ACTIVE -> Value.ACTIVE + EXPIRED -> Value.EXPIRED + 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) { + ACTIVE -> Known.ACTIVE + EXPIRED -> Known.EXPIRED + else -> throw IncreaseInvalidDataException("Unknown In: $value") + } + + /** + * Returns this class instance's primitive wire representation. + * + * This differs from the [toString] method because that method is primarily for + * debugging and generally doesn't throw. + * + * @throws IncreaseInvalidDataException if this class instance's value does not have the + * expected primitive type. + */ + fun asString(): String = + _value().asString().orElseThrow { + IncreaseInvalidDataException("Value is not a String") + } + + private var validated: Boolean = false + + fun validate(): In = 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 In && 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 Status && + in_ == other.in_ && + additionalProperties == other.additionalProperties + } + + private val hashCode: Int by lazy { Objects.hash(in_, additionalProperties) } + + override fun hashCode(): Int = hashCode + + override fun toString() = "Status{in_=$in_, additionalProperties=$additionalProperties}" + } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is EntityOnboardingSessionListParams && + cursor == other.cursor && + idempotencyKey == other.idempotencyKey && + limit == other.limit && + status == other.status && + additionalHeaders == other.additionalHeaders && + additionalQueryParams == other.additionalQueryParams + } + + override fun hashCode(): Int = + Objects.hash( + cursor, + idempotencyKey, + limit, + status, + additionalHeaders, + additionalQueryParams, + ) + + override fun toString() = + "EntityOnboardingSessionListParams{cursor=$cursor, idempotencyKey=$idempotencyKey, limit=$limit, status=$status, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionRetrieveParams.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionRetrieveParams.kt new file mode 100644 index 000000000..3a33c615f --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionRetrieveParams.kt @@ -0,0 +1,210 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.entityonboardingsessions + +import com.increase.api.core.Params +import com.increase.api.core.http.Headers +import com.increase.api.core.http.QueryParams +import java.util.Objects +import java.util.Optional +import kotlin.jvm.optionals.getOrNull + +/** Retrieve an Entity Onboarding Session */ +class EntityOnboardingSessionRetrieveParams +private constructor( + private val entityOnboardingSessionId: String?, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, +) : Params { + + /** The identifier of the Entity Onboarding Session. */ + fun entityOnboardingSessionId(): Optional = + Optional.ofNullable(entityOnboardingSessionId) + + /** Additional headers to send with the request. */ + fun _additionalHeaders(): Headers = additionalHeaders + + /** Additional query param to send with the request. */ + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun toBuilder() = Builder().from(this) + + companion object { + + @JvmStatic fun none(): EntityOnboardingSessionRetrieveParams = builder().build() + + /** + * Returns a mutable builder for constructing an instance of + * [EntityOnboardingSessionRetrieveParams]. + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [EntityOnboardingSessionRetrieveParams]. */ + class Builder internal constructor() { + + private var entityOnboardingSessionId: String? = null + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() + + @JvmSynthetic + internal fun from( + entityOnboardingSessionRetrieveParams: EntityOnboardingSessionRetrieveParams + ) = apply { + entityOnboardingSessionId = + entityOnboardingSessionRetrieveParams.entityOnboardingSessionId + additionalHeaders = entityOnboardingSessionRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = + entityOnboardingSessionRetrieveParams.additionalQueryParams.toBuilder() + } + + /** The identifier of the Entity Onboarding Session. */ + fun entityOnboardingSessionId(entityOnboardingSessionId: String?) = apply { + this.entityOnboardingSessionId = entityOnboardingSessionId + } + + /** + * Alias for calling [Builder.entityOnboardingSessionId] with + * `entityOnboardingSessionId.orElse(null)`. + */ + fun entityOnboardingSessionId(entityOnboardingSessionId: Optional) = + entityOnboardingSessionId(entityOnboardingSessionId.getOrNull()) + + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) + } + + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) + } + + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.putAll(additionalHeaders) + } + + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replace(name, value) + } + + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + this.additionalQueryParams.putAll(additionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replace(key, value) + } + + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } + + fun removeAllAdditionalQueryParams(keys: Set) = apply { + additionalQueryParams.removeAll(keys) + } + + /** + * Returns an immutable instance of [EntityOnboardingSessionRetrieveParams]. + * + * Further updates to this [Builder] will not mutate the returned instance. + */ + fun build(): EntityOnboardingSessionRetrieveParams = + EntityOnboardingSessionRetrieveParams( + entityOnboardingSessionId, + additionalHeaders.build(), + additionalQueryParams.build(), + ) + } + + fun _pathParam(index: Int): String = + when (index) { + 0 -> entityOnboardingSessionId ?: "" + else -> "" + } + + override fun _headers(): Headers = additionalHeaders + + override fun _queryParams(): QueryParams = additionalQueryParams + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is EntityOnboardingSessionRetrieveParams && + entityOnboardingSessionId == other.entityOnboardingSessionId && + additionalHeaders == other.additionalHeaders && + additionalQueryParams == other.additionalQueryParams + } + + override fun hashCode(): Int = + Objects.hash(entityOnboardingSessionId, additionalHeaders, additionalQueryParams) + + override fun toString() = + "EntityOnboardingSessionRetrieveParams{entityOnboardingSessionId=$entityOnboardingSessionId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/entityonboardingsessions/EntityOnboardingSessionSubmitParams.kt b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/entityonboardingsessions/EntityOnboardingSessionSubmitParams.kt new file mode 100644 index 000000000..a6961d681 --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/models/simulations/entityonboardingsessions/EntityOnboardingSessionSubmitParams.kt @@ -0,0 +1,255 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.simulations.entityonboardingsessions + +import com.increase.api.core.JsonValue +import com.increase.api.core.Params +import com.increase.api.core.http.Headers +import com.increase.api.core.http.QueryParams +import com.increase.api.core.toImmutable +import java.util.Objects +import java.util.Optional +import kotlin.jvm.optionals.getOrNull + +/** + * Simulates the submission of an [Entity Onboarding Session](#entity-onboarding-sessions). This + * session must have a `status` of `active`. After submission, the session will transition to + * `expired` and a new Entity will be created. + */ +class EntityOnboardingSessionSubmitParams +private constructor( + private val entityOnboardingSessionId: String?, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, + private val additionalBodyProperties: Map, +) : Params { + + /** The identifier of the Entity Onboarding Session you wish to submit. */ + fun entityOnboardingSessionId(): Optional = + Optional.ofNullable(entityOnboardingSessionId) + + /** Additional body properties to send with the request. */ + fun _additionalBodyProperties(): Map = additionalBodyProperties + + /** Additional headers to send with the request. */ + fun _additionalHeaders(): Headers = additionalHeaders + + /** Additional query param to send with the request. */ + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun toBuilder() = Builder().from(this) + + companion object { + + @JvmStatic fun none(): EntityOnboardingSessionSubmitParams = builder().build() + + /** + * Returns a mutable builder for constructing an instance of + * [EntityOnboardingSessionSubmitParams]. + */ + @JvmStatic fun builder() = Builder() + } + + /** A builder for [EntityOnboardingSessionSubmitParams]. */ + class Builder internal constructor() { + + private var entityOnboardingSessionId: String? = null + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() + private var additionalBodyProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from( + entityOnboardingSessionSubmitParams: EntityOnboardingSessionSubmitParams + ) = apply { + entityOnboardingSessionId = + entityOnboardingSessionSubmitParams.entityOnboardingSessionId + additionalHeaders = entityOnboardingSessionSubmitParams.additionalHeaders.toBuilder() + additionalQueryParams = + entityOnboardingSessionSubmitParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + entityOnboardingSessionSubmitParams.additionalBodyProperties.toMutableMap() + } + + /** The identifier of the Entity Onboarding Session you wish to submit. */ + fun entityOnboardingSessionId(entityOnboardingSessionId: String?) = apply { + this.entityOnboardingSessionId = entityOnboardingSessionId + } + + /** + * Alias for calling [Builder.entityOnboardingSessionId] with + * `entityOnboardingSessionId.orElse(null)`. + */ + fun entityOnboardingSessionId(entityOnboardingSessionId: Optional) = + entityOnboardingSessionId(entityOnboardingSessionId.getOrNull()) + + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) + } + + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) + } + + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.putAll(additionalHeaders) + } + + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replace(name, value) + } + + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + this.additionalQueryParams.putAll(additionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replace(key, value) + } + + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } + + fun removeAllAdditionalQueryParams(keys: Set) = apply { + additionalQueryParams.removeAll(keys) + } + + fun additionalBodyProperties(additionalBodyProperties: Map) = apply { + this.additionalBodyProperties.clear() + putAllAdditionalBodyProperties(additionalBodyProperties) + } + + fun putAdditionalBodyProperty(key: String, value: JsonValue) = apply { + additionalBodyProperties.put(key, value) + } + + fun putAllAdditionalBodyProperties(additionalBodyProperties: Map) = + apply { + this.additionalBodyProperties.putAll(additionalBodyProperties) + } + + fun removeAdditionalBodyProperty(key: String) = apply { + additionalBodyProperties.remove(key) + } + + fun removeAllAdditionalBodyProperties(keys: Set) = apply { + keys.forEach(::removeAdditionalBodyProperty) + } + + /** + * Returns an immutable instance of [EntityOnboardingSessionSubmitParams]. + * + * Further updates to this [Builder] will not mutate the returned instance. + */ + fun build(): EntityOnboardingSessionSubmitParams = + EntityOnboardingSessionSubmitParams( + entityOnboardingSessionId, + additionalHeaders.build(), + additionalQueryParams.build(), + additionalBodyProperties.toImmutable(), + ) + } + + fun _body(): Optional> = + Optional.ofNullable(additionalBodyProperties.ifEmpty { null }) + + fun _pathParam(index: Int): String = + when (index) { + 0 -> entityOnboardingSessionId ?: "" + else -> "" + } + + override fun _headers(): Headers = additionalHeaders + + override fun _queryParams(): QueryParams = additionalQueryParams + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is EntityOnboardingSessionSubmitParams && + entityOnboardingSessionId == other.entityOnboardingSessionId && + additionalHeaders == other.additionalHeaders && + additionalQueryParams == other.additionalQueryParams && + additionalBodyProperties == other.additionalBodyProperties + } + + override fun hashCode(): Int = + Objects.hash( + entityOnboardingSessionId, + additionalHeaders, + additionalQueryParams, + additionalBodyProperties, + ) + + override fun toString() = + "EntityOnboardingSessionSubmitParams{entityOnboardingSessionId=$entityOnboardingSessionId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/async/EntityOnboardingSessionServiceAsync.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/async/EntityOnboardingSessionServiceAsync.kt new file mode 100644 index 000000000..1d0ea6590 --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/async/EntityOnboardingSessionServiceAsync.kt @@ -0,0 +1,312 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.services.async + +import com.increase.api.core.ClientOptions +import com.increase.api.core.RequestOptions +import com.increase.api.core.http.HttpResponseFor +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSession +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionCreateParams +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionExpireParams +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionListPageAsync +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionListParams +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionRetrieveParams +import java.util.concurrent.CompletableFuture +import java.util.function.Consumer + +interface EntityOnboardingSessionServiceAsync { + + /** + * Returns a view of this service that provides access to raw HTTP responses for each method. + */ + fun withRawResponse(): WithRawResponse + + /** + * Returns a view of this service with the given option modifications applied. + * + * The original service is not modified. + */ + fun withOptions(modifier: Consumer): EntityOnboardingSessionServiceAsync + + /** Create an Entity Onboarding Session */ + fun create( + params: EntityOnboardingSessionCreateParams + ): CompletableFuture = create(params, RequestOptions.none()) + + /** @see create */ + fun create( + params: EntityOnboardingSessionCreateParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture + + /** Retrieve an Entity Onboarding Session */ + fun retrieve(entityOnboardingSessionId: String): CompletableFuture = + retrieve(entityOnboardingSessionId, EntityOnboardingSessionRetrieveParams.none()) + + /** @see retrieve */ + fun retrieve( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionRetrieveParams = + EntityOnboardingSessionRetrieveParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture = + retrieve( + params.toBuilder().entityOnboardingSessionId(entityOnboardingSessionId).build(), + requestOptions, + ) + + /** @see retrieve */ + fun retrieve( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionRetrieveParams = EntityOnboardingSessionRetrieveParams.none(), + ): CompletableFuture = + retrieve(entityOnboardingSessionId, params, RequestOptions.none()) + + /** @see retrieve */ + fun retrieve( + params: EntityOnboardingSessionRetrieveParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture + + /** @see retrieve */ + fun retrieve( + params: EntityOnboardingSessionRetrieveParams + ): CompletableFuture = retrieve(params, RequestOptions.none()) + + /** @see retrieve */ + fun retrieve( + entityOnboardingSessionId: String, + requestOptions: RequestOptions, + ): CompletableFuture = + retrieve( + entityOnboardingSessionId, + EntityOnboardingSessionRetrieveParams.none(), + requestOptions, + ) + + /** List Entity Onboarding Session */ + fun list(): CompletableFuture = + list(EntityOnboardingSessionListParams.none()) + + /** @see list */ + fun list( + params: EntityOnboardingSessionListParams = EntityOnboardingSessionListParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture + + /** @see list */ + fun list( + params: EntityOnboardingSessionListParams = EntityOnboardingSessionListParams.none() + ): CompletableFuture = list(params, RequestOptions.none()) + + /** @see list */ + fun list( + requestOptions: RequestOptions + ): CompletableFuture = + list(EntityOnboardingSessionListParams.none(), requestOptions) + + /** Expire an Entity Onboarding Session */ + fun expire(entityOnboardingSessionId: String): CompletableFuture = + expire(entityOnboardingSessionId, EntityOnboardingSessionExpireParams.none()) + + /** @see expire */ + fun expire( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionExpireParams = EntityOnboardingSessionExpireParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture = + expire( + params.toBuilder().entityOnboardingSessionId(entityOnboardingSessionId).build(), + requestOptions, + ) + + /** @see expire */ + fun expire( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionExpireParams = EntityOnboardingSessionExpireParams.none(), + ): CompletableFuture = + expire(entityOnboardingSessionId, params, RequestOptions.none()) + + /** @see expire */ + fun expire( + params: EntityOnboardingSessionExpireParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture + + /** @see expire */ + fun expire( + params: EntityOnboardingSessionExpireParams + ): CompletableFuture = expire(params, RequestOptions.none()) + + /** @see expire */ + fun expire( + entityOnboardingSessionId: String, + requestOptions: RequestOptions, + ): CompletableFuture = + expire( + entityOnboardingSessionId, + EntityOnboardingSessionExpireParams.none(), + requestOptions, + ) + + /** + * A view of [EntityOnboardingSessionServiceAsync] that provides access to raw HTTP responses + * for each method. + */ + interface WithRawResponse { + + /** + * Returns a view of this service with the given option modifications applied. + * + * The original service is not modified. + */ + fun withOptions( + modifier: Consumer + ): EntityOnboardingSessionServiceAsync.WithRawResponse + + /** + * Returns a raw HTTP response for `post /entity_onboarding_sessions`, but is otherwise the + * same as [EntityOnboardingSessionServiceAsync.create]. + */ + fun create( + params: EntityOnboardingSessionCreateParams + ): CompletableFuture> = + create(params, RequestOptions.none()) + + /** @see create */ + fun create( + params: EntityOnboardingSessionCreateParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture> + + /** + * Returns a raw HTTP response for `get + * /entity_onboarding_sessions/{entity_onboarding_session_id}`, but is otherwise the same as + * [EntityOnboardingSessionServiceAsync.retrieve]. + */ + fun retrieve( + entityOnboardingSessionId: String + ): CompletableFuture> = + retrieve(entityOnboardingSessionId, EntityOnboardingSessionRetrieveParams.none()) + + /** @see retrieve */ + fun retrieve( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionRetrieveParams = + EntityOnboardingSessionRetrieveParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture> = + retrieve( + params.toBuilder().entityOnboardingSessionId(entityOnboardingSessionId).build(), + requestOptions, + ) + + /** @see retrieve */ + fun retrieve( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionRetrieveParams = + EntityOnboardingSessionRetrieveParams.none(), + ): CompletableFuture> = + retrieve(entityOnboardingSessionId, params, RequestOptions.none()) + + /** @see retrieve */ + fun retrieve( + params: EntityOnboardingSessionRetrieveParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture> + + /** @see retrieve */ + fun retrieve( + params: EntityOnboardingSessionRetrieveParams + ): CompletableFuture> = + retrieve(params, RequestOptions.none()) + + /** @see retrieve */ + fun retrieve( + entityOnboardingSessionId: String, + requestOptions: RequestOptions, + ): CompletableFuture> = + retrieve( + entityOnboardingSessionId, + EntityOnboardingSessionRetrieveParams.none(), + requestOptions, + ) + + /** + * Returns a raw HTTP response for `get /entity_onboarding_sessions`, but is otherwise the + * same as [EntityOnboardingSessionServiceAsync.list]. + */ + fun list(): CompletableFuture> = + list(EntityOnboardingSessionListParams.none()) + + /** @see list */ + fun list( + params: EntityOnboardingSessionListParams = EntityOnboardingSessionListParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture> + + /** @see list */ + fun list( + params: EntityOnboardingSessionListParams = EntityOnboardingSessionListParams.none() + ): CompletableFuture> = + list(params, RequestOptions.none()) + + /** @see list */ + fun list( + requestOptions: RequestOptions + ): CompletableFuture> = + list(EntityOnboardingSessionListParams.none(), requestOptions) + + /** + * Returns a raw HTTP response for `post + * /entity_onboarding_sessions/{entity_onboarding_session_id}/expire`, but is otherwise the + * same as [EntityOnboardingSessionServiceAsync.expire]. + */ + fun expire( + entityOnboardingSessionId: String + ): CompletableFuture> = + expire(entityOnboardingSessionId, EntityOnboardingSessionExpireParams.none()) + + /** @see expire */ + fun expire( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionExpireParams = + EntityOnboardingSessionExpireParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture> = + expire( + params.toBuilder().entityOnboardingSessionId(entityOnboardingSessionId).build(), + requestOptions, + ) + + /** @see expire */ + fun expire( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionExpireParams = EntityOnboardingSessionExpireParams.none(), + ): CompletableFuture> = + expire(entityOnboardingSessionId, params, RequestOptions.none()) + + /** @see expire */ + fun expire( + params: EntityOnboardingSessionExpireParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture> + + /** @see expire */ + fun expire( + params: EntityOnboardingSessionExpireParams + ): CompletableFuture> = + expire(params, RequestOptions.none()) + + /** @see expire */ + fun expire( + entityOnboardingSessionId: String, + requestOptions: RequestOptions, + ): CompletableFuture> = + expire( + entityOnboardingSessionId, + EntityOnboardingSessionExpireParams.none(), + requestOptions, + ) + } +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/async/EntityOnboardingSessionServiceAsyncImpl.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/async/EntityOnboardingSessionServiceAsyncImpl.kt new file mode 100644 index 000000000..c0366c369 --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/async/EntityOnboardingSessionServiceAsyncImpl.kt @@ -0,0 +1,231 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.services.async + +import com.increase.api.core.ClientOptions +import com.increase.api.core.RequestOptions +import com.increase.api.core.checkRequired +import com.increase.api.core.handlers.errorBodyHandler +import com.increase.api.core.handlers.errorHandler +import com.increase.api.core.handlers.jsonHandler +import com.increase.api.core.http.HttpMethod +import com.increase.api.core.http.HttpRequest +import com.increase.api.core.http.HttpResponse +import com.increase.api.core.http.HttpResponse.Handler +import com.increase.api.core.http.HttpResponseFor +import com.increase.api.core.http.json +import com.increase.api.core.http.parseable +import com.increase.api.core.prepareAsync +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSession +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionCreateParams +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionExpireParams +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionListPageAsync +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionListPageResponse +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionListParams +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionRetrieveParams +import java.util.concurrent.CompletableFuture +import java.util.function.Consumer +import kotlin.jvm.optionals.getOrNull + +class EntityOnboardingSessionServiceAsyncImpl +internal constructor(private val clientOptions: ClientOptions) : + EntityOnboardingSessionServiceAsync { + + private val withRawResponse: EntityOnboardingSessionServiceAsync.WithRawResponse by lazy { + WithRawResponseImpl(clientOptions) + } + + override fun withRawResponse(): EntityOnboardingSessionServiceAsync.WithRawResponse = + withRawResponse + + override fun withOptions( + modifier: Consumer + ): EntityOnboardingSessionServiceAsync = + EntityOnboardingSessionServiceAsyncImpl( + clientOptions.toBuilder().apply(modifier::accept).build() + ) + + override fun create( + params: EntityOnboardingSessionCreateParams, + requestOptions: RequestOptions, + ): CompletableFuture = + // post /entity_onboarding_sessions + withRawResponse().create(params, requestOptions).thenApply { it.parse() } + + override fun retrieve( + params: EntityOnboardingSessionRetrieveParams, + requestOptions: RequestOptions, + ): CompletableFuture = + // get /entity_onboarding_sessions/{entity_onboarding_session_id} + withRawResponse().retrieve(params, requestOptions).thenApply { it.parse() } + + override fun list( + params: EntityOnboardingSessionListParams, + requestOptions: RequestOptions, + ): CompletableFuture = + // get /entity_onboarding_sessions + withRawResponse().list(params, requestOptions).thenApply { it.parse() } + + override fun expire( + params: EntityOnboardingSessionExpireParams, + requestOptions: RequestOptions, + ): CompletableFuture = + // post /entity_onboarding_sessions/{entity_onboarding_session_id}/expire + withRawResponse().expire(params, requestOptions).thenApply { it.parse() } + + class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) : + EntityOnboardingSessionServiceAsync.WithRawResponse { + + private val errorHandler: Handler = + errorHandler(errorBodyHandler(clientOptions.jsonMapper)) + + override fun withOptions( + modifier: Consumer + ): EntityOnboardingSessionServiceAsync.WithRawResponse = + EntityOnboardingSessionServiceAsyncImpl.WithRawResponseImpl( + clientOptions.toBuilder().apply(modifier::accept).build() + ) + + private val createHandler: Handler = + jsonHandler(clientOptions.jsonMapper) + + override fun create( + params: EntityOnboardingSessionCreateParams, + requestOptions: RequestOptions, + ): CompletableFuture> { + val request = + HttpRequest.builder() + .method(HttpMethod.POST) + .baseUrl(clientOptions.baseUrl()) + .addPathSegments("entity_onboarding_sessions") + .body(json(clientOptions.jsonMapper, params._body())) + .build() + .prepareAsync(clientOptions, params) + val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions)) + return request + .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) } + .thenApply { response -> + errorHandler.handle(response).parseable { + response + .use { createHandler.handle(it) } + .also { + if (requestOptions.responseValidation!!) { + it.validate() + } + } + } + } + } + + private val retrieveHandler: Handler = + jsonHandler(clientOptions.jsonMapper) + + override fun retrieve( + params: EntityOnboardingSessionRetrieveParams, + requestOptions: RequestOptions, + ): CompletableFuture> { + // We check here instead of in the params builder because this can be specified + // positionally or in the params class. + checkRequired( + "entityOnboardingSessionId", + params.entityOnboardingSessionId().getOrNull(), + ) + val request = + HttpRequest.builder() + .method(HttpMethod.GET) + .baseUrl(clientOptions.baseUrl()) + .addPathSegments("entity_onboarding_sessions", params._pathParam(0)) + .build() + .prepareAsync(clientOptions, params) + val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions)) + return request + .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) } + .thenApply { response -> + errorHandler.handle(response).parseable { + response + .use { retrieveHandler.handle(it) } + .also { + if (requestOptions.responseValidation!!) { + it.validate() + } + } + } + } + } + + private val listHandler: Handler = + jsonHandler(clientOptions.jsonMapper) + + override fun list( + params: EntityOnboardingSessionListParams, + requestOptions: RequestOptions, + ): CompletableFuture> { + val request = + HttpRequest.builder() + .method(HttpMethod.GET) + .baseUrl(clientOptions.baseUrl()) + .addPathSegments("entity_onboarding_sessions") + .build() + .prepareAsync(clientOptions, params) + val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions)) + return request + .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) } + .thenApply { response -> + errorHandler.handle(response).parseable { + response + .use { listHandler.handle(it) } + .also { + if (requestOptions.responseValidation!!) { + it.validate() + } + } + .let { + EntityOnboardingSessionListPageAsync.builder() + .service(EntityOnboardingSessionServiceAsyncImpl(clientOptions)) + .streamHandlerExecutor(clientOptions.streamHandlerExecutor) + .params(params) + .response(it) + .build() + } + } + } + } + + private val expireHandler: Handler = + jsonHandler(clientOptions.jsonMapper) + + override fun expire( + params: EntityOnboardingSessionExpireParams, + requestOptions: RequestOptions, + ): CompletableFuture> { + // We check here instead of in the params builder because this can be specified + // positionally or in the params class. + checkRequired( + "entityOnboardingSessionId", + params.entityOnboardingSessionId().getOrNull(), + ) + val request = + HttpRequest.builder() + .method(HttpMethod.POST) + .baseUrl(clientOptions.baseUrl()) + .addPathSegments("entity_onboarding_sessions", params._pathParam(0), "expire") + .apply { params._body().ifPresent { body(json(clientOptions.jsonMapper, it)) } } + .build() + .prepareAsync(clientOptions, params) + val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions)) + return request + .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) } + .thenApply { response -> + errorHandler.handle(response).parseable { + response + .use { expireHandler.handle(it) } + .also { + if (requestOptions.responseValidation!!) { + it.validate() + } + } + } + } + } + } +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/async/SimulationServiceAsync.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/async/SimulationServiceAsync.kt index d8234d4d4..b1bb758a0 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/services/async/SimulationServiceAsync.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/async/SimulationServiceAsync.kt @@ -20,6 +20,7 @@ import com.increase.api.services.async.simulations.CardTokenServiceAsync import com.increase.api.services.async.simulations.CheckDepositServiceAsync import com.increase.api.services.async.simulations.CheckTransferServiceAsync import com.increase.api.services.async.simulations.DigitalWalletTokenRequestServiceAsync +import com.increase.api.services.async.simulations.EntityOnboardingSessionServiceAsync import com.increase.api.services.async.simulations.ExportServiceAsync import com.increase.api.services.async.simulations.InboundAchTransferServiceAsync import com.increase.api.services.async.simulations.InboundCheckDepositServiceAsync @@ -107,6 +108,8 @@ interface SimulationServiceAsync { fun inboundMailItems(): InboundMailItemServiceAsync + fun entityOnboardingSessions(): EntityOnboardingSessionServiceAsync + fun programs(): ProgramServiceAsync fun accountStatements(): AccountStatementServiceAsync @@ -187,6 +190,8 @@ interface SimulationServiceAsync { fun inboundMailItems(): InboundMailItemServiceAsync.WithRawResponse + fun entityOnboardingSessions(): EntityOnboardingSessionServiceAsync.WithRawResponse + fun programs(): ProgramServiceAsync.WithRawResponse fun accountStatements(): AccountStatementServiceAsync.WithRawResponse diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/async/SimulationServiceAsyncImpl.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/async/SimulationServiceAsyncImpl.kt index 35bf5ded1..aea8bdfea 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/services/async/SimulationServiceAsyncImpl.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/async/SimulationServiceAsyncImpl.kt @@ -37,6 +37,8 @@ import com.increase.api.services.async.simulations.CheckTransferServiceAsync import com.increase.api.services.async.simulations.CheckTransferServiceAsyncImpl import com.increase.api.services.async.simulations.DigitalWalletTokenRequestServiceAsync import com.increase.api.services.async.simulations.DigitalWalletTokenRequestServiceAsyncImpl +import com.increase.api.services.async.simulations.EntityOnboardingSessionServiceAsync +import com.increase.api.services.async.simulations.EntityOnboardingSessionServiceAsyncImpl import com.increase.api.services.async.simulations.ExportServiceAsync import com.increase.api.services.async.simulations.ExportServiceAsyncImpl import com.increase.api.services.async.simulations.InboundAchTransferServiceAsync @@ -189,6 +191,10 @@ class SimulationServiceAsyncImpl internal constructor(private val clientOptions: InboundMailItemServiceAsyncImpl(clientOptions) } + private val entityOnboardingSessions: EntityOnboardingSessionServiceAsync by lazy { + EntityOnboardingSessionServiceAsyncImpl(clientOptions) + } + private val programs: ProgramServiceAsync by lazy { ProgramServiceAsyncImpl(clientOptions) } private val accountStatements: AccountStatementServiceAsync by lazy { @@ -268,6 +274,9 @@ class SimulationServiceAsyncImpl internal constructor(private val clientOptions: override fun inboundMailItems(): InboundMailItemServiceAsync = inboundMailItems + override fun entityOnboardingSessions(): EntityOnboardingSessionServiceAsync = + entityOnboardingSessions + override fun programs(): ProgramServiceAsync = programs override fun accountStatements(): AccountStatementServiceAsync = accountStatements @@ -398,6 +407,11 @@ class SimulationServiceAsyncImpl internal constructor(private val clientOptions: InboundMailItemServiceAsyncImpl.WithRawResponseImpl(clientOptions) } + private val entityOnboardingSessions: + EntityOnboardingSessionServiceAsync.WithRawResponse by lazy { + EntityOnboardingSessionServiceAsyncImpl.WithRawResponseImpl(clientOptions) + } + private val programs: ProgramServiceAsync.WithRawResponse by lazy { ProgramServiceAsyncImpl.WithRawResponseImpl(clientOptions) } @@ -496,6 +510,9 @@ class SimulationServiceAsyncImpl internal constructor(private val clientOptions: override fun inboundMailItems(): InboundMailItemServiceAsync.WithRawResponse = inboundMailItems + override fun entityOnboardingSessions(): + EntityOnboardingSessionServiceAsync.WithRawResponse = entityOnboardingSessions + override fun programs(): ProgramServiceAsync.WithRawResponse = programs override fun accountStatements(): AccountStatementServiceAsync.WithRawResponse = diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/EntityOnboardingSessionServiceAsync.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/EntityOnboardingSessionServiceAsync.kt new file mode 100644 index 000000000..1ccc1744d --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/EntityOnboardingSessionServiceAsync.kt @@ -0,0 +1,142 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.services.async.simulations + +import com.increase.api.core.ClientOptions +import com.increase.api.core.RequestOptions +import com.increase.api.core.http.HttpResponseFor +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSession +import com.increase.api.models.simulations.entityonboardingsessions.EntityOnboardingSessionSubmitParams +import java.util.concurrent.CompletableFuture +import java.util.function.Consumer + +interface EntityOnboardingSessionServiceAsync { + + /** + * Returns a view of this service that provides access to raw HTTP responses for each method. + */ + fun withRawResponse(): WithRawResponse + + /** + * Returns a view of this service with the given option modifications applied. + * + * The original service is not modified. + */ + fun withOptions(modifier: Consumer): EntityOnboardingSessionServiceAsync + + /** + * Simulates the submission of an [Entity Onboarding Session](#entity-onboarding-sessions). This + * session must have a `status` of `active`. After submission, the session will transition to + * `expired` and a new Entity will be created. + */ + fun submit(entityOnboardingSessionId: String): CompletableFuture = + submit(entityOnboardingSessionId, EntityOnboardingSessionSubmitParams.none()) + + /** @see submit */ + fun submit( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionSubmitParams = EntityOnboardingSessionSubmitParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture = + submit( + params.toBuilder().entityOnboardingSessionId(entityOnboardingSessionId).build(), + requestOptions, + ) + + /** @see submit */ + fun submit( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionSubmitParams = EntityOnboardingSessionSubmitParams.none(), + ): CompletableFuture = + submit(entityOnboardingSessionId, params, RequestOptions.none()) + + /** @see submit */ + fun submit( + params: EntityOnboardingSessionSubmitParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture + + /** @see submit */ + fun submit( + params: EntityOnboardingSessionSubmitParams + ): CompletableFuture = submit(params, RequestOptions.none()) + + /** @see submit */ + fun submit( + entityOnboardingSessionId: String, + requestOptions: RequestOptions, + ): CompletableFuture = + submit( + entityOnboardingSessionId, + EntityOnboardingSessionSubmitParams.none(), + requestOptions, + ) + + /** + * A view of [EntityOnboardingSessionServiceAsync] that provides access to raw HTTP responses + * for each method. + */ + interface WithRawResponse { + + /** + * Returns a view of this service with the given option modifications applied. + * + * The original service is not modified. + */ + fun withOptions( + modifier: Consumer + ): EntityOnboardingSessionServiceAsync.WithRawResponse + + /** + * Returns a raw HTTP response for `post + * /simulations/entity_onboarding_sessions/{entity_onboarding_session_id}/submit`, but is + * otherwise the same as [EntityOnboardingSessionServiceAsync.submit]. + */ + fun submit( + entityOnboardingSessionId: String + ): CompletableFuture> = + submit(entityOnboardingSessionId, EntityOnboardingSessionSubmitParams.none()) + + /** @see submit */ + fun submit( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionSubmitParams = + EntityOnboardingSessionSubmitParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture> = + submit( + params.toBuilder().entityOnboardingSessionId(entityOnboardingSessionId).build(), + requestOptions, + ) + + /** @see submit */ + fun submit( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionSubmitParams = EntityOnboardingSessionSubmitParams.none(), + ): CompletableFuture> = + submit(entityOnboardingSessionId, params, RequestOptions.none()) + + /** @see submit */ + fun submit( + params: EntityOnboardingSessionSubmitParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): CompletableFuture> + + /** @see submit */ + fun submit( + params: EntityOnboardingSessionSubmitParams + ): CompletableFuture> = + submit(params, RequestOptions.none()) + + /** @see submit */ + fun submit( + entityOnboardingSessionId: String, + requestOptions: RequestOptions, + ): CompletableFuture> = + submit( + entityOnboardingSessionId, + EntityOnboardingSessionSubmitParams.none(), + requestOptions, + ) + } +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/EntityOnboardingSessionServiceAsyncImpl.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/EntityOnboardingSessionServiceAsyncImpl.kt new file mode 100644 index 000000000..72c033019 --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/async/simulations/EntityOnboardingSessionServiceAsyncImpl.kt @@ -0,0 +1,105 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.services.async.simulations + +import com.increase.api.core.ClientOptions +import com.increase.api.core.RequestOptions +import com.increase.api.core.checkRequired +import com.increase.api.core.handlers.errorBodyHandler +import com.increase.api.core.handlers.errorHandler +import com.increase.api.core.handlers.jsonHandler +import com.increase.api.core.http.HttpMethod +import com.increase.api.core.http.HttpRequest +import com.increase.api.core.http.HttpResponse +import com.increase.api.core.http.HttpResponse.Handler +import com.increase.api.core.http.HttpResponseFor +import com.increase.api.core.http.json +import com.increase.api.core.http.parseable +import com.increase.api.core.prepareAsync +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSession +import com.increase.api.models.simulations.entityonboardingsessions.EntityOnboardingSessionSubmitParams +import java.util.concurrent.CompletableFuture +import java.util.function.Consumer +import kotlin.jvm.optionals.getOrNull + +class EntityOnboardingSessionServiceAsyncImpl +internal constructor(private val clientOptions: ClientOptions) : + EntityOnboardingSessionServiceAsync { + + private val withRawResponse: EntityOnboardingSessionServiceAsync.WithRawResponse by lazy { + WithRawResponseImpl(clientOptions) + } + + override fun withRawResponse(): EntityOnboardingSessionServiceAsync.WithRawResponse = + withRawResponse + + override fun withOptions( + modifier: Consumer + ): EntityOnboardingSessionServiceAsync = + EntityOnboardingSessionServiceAsyncImpl( + clientOptions.toBuilder().apply(modifier::accept).build() + ) + + override fun submit( + params: EntityOnboardingSessionSubmitParams, + requestOptions: RequestOptions, + ): CompletableFuture = + // post /simulations/entity_onboarding_sessions/{entity_onboarding_session_id}/submit + withRawResponse().submit(params, requestOptions).thenApply { it.parse() } + + class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) : + EntityOnboardingSessionServiceAsync.WithRawResponse { + + private val errorHandler: Handler = + errorHandler(errorBodyHandler(clientOptions.jsonMapper)) + + override fun withOptions( + modifier: Consumer + ): EntityOnboardingSessionServiceAsync.WithRawResponse = + EntityOnboardingSessionServiceAsyncImpl.WithRawResponseImpl( + clientOptions.toBuilder().apply(modifier::accept).build() + ) + + private val submitHandler: Handler = + jsonHandler(clientOptions.jsonMapper) + + override fun submit( + params: EntityOnboardingSessionSubmitParams, + requestOptions: RequestOptions, + ): CompletableFuture> { + // We check here instead of in the params builder because this can be specified + // positionally or in the params class. + checkRequired( + "entityOnboardingSessionId", + params.entityOnboardingSessionId().getOrNull(), + ) + val request = + HttpRequest.builder() + .method(HttpMethod.POST) + .baseUrl(clientOptions.baseUrl()) + .addPathSegments( + "simulations", + "entity_onboarding_sessions", + params._pathParam(0), + "submit", + ) + .apply { params._body().ifPresent { body(json(clientOptions.jsonMapper, it)) } } + .build() + .prepareAsync(clientOptions, params) + val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions)) + return request + .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) } + .thenApply { response -> + errorHandler.handle(response).parseable { + response + .use { submitHandler.handle(it) } + .also { + if (requestOptions.responseValidation!!) { + it.validate() + } + } + } + } + } + } +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/EntityOnboardingSessionService.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/EntityOnboardingSessionService.kt new file mode 100644 index 000000000..35d433400 --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/EntityOnboardingSessionService.kt @@ -0,0 +1,312 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.services.blocking + +import com.google.errorprone.annotations.MustBeClosed +import com.increase.api.core.ClientOptions +import com.increase.api.core.RequestOptions +import com.increase.api.core.http.HttpResponseFor +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSession +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionCreateParams +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionExpireParams +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionListPage +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionListParams +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionRetrieveParams +import java.util.function.Consumer + +interface EntityOnboardingSessionService { + + /** + * Returns a view of this service that provides access to raw HTTP responses for each method. + */ + fun withRawResponse(): WithRawResponse + + /** + * Returns a view of this service with the given option modifications applied. + * + * The original service is not modified. + */ + fun withOptions(modifier: Consumer): EntityOnboardingSessionService + + /** Create an Entity Onboarding Session */ + fun create(params: EntityOnboardingSessionCreateParams): EntityOnboardingSession = + create(params, RequestOptions.none()) + + /** @see create */ + fun create( + params: EntityOnboardingSessionCreateParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): EntityOnboardingSession + + /** Retrieve an Entity Onboarding Session */ + fun retrieve(entityOnboardingSessionId: String): EntityOnboardingSession = + retrieve(entityOnboardingSessionId, EntityOnboardingSessionRetrieveParams.none()) + + /** @see retrieve */ + fun retrieve( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionRetrieveParams = + EntityOnboardingSessionRetrieveParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): EntityOnboardingSession = + retrieve( + params.toBuilder().entityOnboardingSessionId(entityOnboardingSessionId).build(), + requestOptions, + ) + + /** @see retrieve */ + fun retrieve( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionRetrieveParams = EntityOnboardingSessionRetrieveParams.none(), + ): EntityOnboardingSession = retrieve(entityOnboardingSessionId, params, RequestOptions.none()) + + /** @see retrieve */ + fun retrieve( + params: EntityOnboardingSessionRetrieveParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): EntityOnboardingSession + + /** @see retrieve */ + fun retrieve(params: EntityOnboardingSessionRetrieveParams): EntityOnboardingSession = + retrieve(params, RequestOptions.none()) + + /** @see retrieve */ + fun retrieve( + entityOnboardingSessionId: String, + requestOptions: RequestOptions, + ): EntityOnboardingSession = + retrieve( + entityOnboardingSessionId, + EntityOnboardingSessionRetrieveParams.none(), + requestOptions, + ) + + /** List Entity Onboarding Session */ + fun list(): EntityOnboardingSessionListPage = list(EntityOnboardingSessionListParams.none()) + + /** @see list */ + fun list( + params: EntityOnboardingSessionListParams = EntityOnboardingSessionListParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): EntityOnboardingSessionListPage + + /** @see list */ + fun list( + params: EntityOnboardingSessionListParams = EntityOnboardingSessionListParams.none() + ): EntityOnboardingSessionListPage = list(params, RequestOptions.none()) + + /** @see list */ + fun list(requestOptions: RequestOptions): EntityOnboardingSessionListPage = + list(EntityOnboardingSessionListParams.none(), requestOptions) + + /** Expire an Entity Onboarding Session */ + fun expire(entityOnboardingSessionId: String): EntityOnboardingSession = + expire(entityOnboardingSessionId, EntityOnboardingSessionExpireParams.none()) + + /** @see expire */ + fun expire( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionExpireParams = EntityOnboardingSessionExpireParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): EntityOnboardingSession = + expire( + params.toBuilder().entityOnboardingSessionId(entityOnboardingSessionId).build(), + requestOptions, + ) + + /** @see expire */ + fun expire( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionExpireParams = EntityOnboardingSessionExpireParams.none(), + ): EntityOnboardingSession = expire(entityOnboardingSessionId, params, RequestOptions.none()) + + /** @see expire */ + fun expire( + params: EntityOnboardingSessionExpireParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): EntityOnboardingSession + + /** @see expire */ + fun expire(params: EntityOnboardingSessionExpireParams): EntityOnboardingSession = + expire(params, RequestOptions.none()) + + /** @see expire */ + fun expire( + entityOnboardingSessionId: String, + requestOptions: RequestOptions, + ): EntityOnboardingSession = + expire( + entityOnboardingSessionId, + EntityOnboardingSessionExpireParams.none(), + requestOptions, + ) + + /** + * A view of [EntityOnboardingSessionService] that provides access to raw HTTP responses for + * each method. + */ + interface WithRawResponse { + + /** + * Returns a view of this service with the given option modifications applied. + * + * The original service is not modified. + */ + fun withOptions( + modifier: Consumer + ): EntityOnboardingSessionService.WithRawResponse + + /** + * Returns a raw HTTP response for `post /entity_onboarding_sessions`, but is otherwise the + * same as [EntityOnboardingSessionService.create]. + */ + @MustBeClosed + fun create( + params: EntityOnboardingSessionCreateParams + ): HttpResponseFor = create(params, RequestOptions.none()) + + /** @see create */ + @MustBeClosed + fun create( + params: EntityOnboardingSessionCreateParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): HttpResponseFor + + /** + * Returns a raw HTTP response for `get + * /entity_onboarding_sessions/{entity_onboarding_session_id}`, but is otherwise the same as + * [EntityOnboardingSessionService.retrieve]. + */ + @MustBeClosed + fun retrieve(entityOnboardingSessionId: String): HttpResponseFor = + retrieve(entityOnboardingSessionId, EntityOnboardingSessionRetrieveParams.none()) + + /** @see retrieve */ + @MustBeClosed + fun retrieve( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionRetrieveParams = + EntityOnboardingSessionRetrieveParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): HttpResponseFor = + retrieve( + params.toBuilder().entityOnboardingSessionId(entityOnboardingSessionId).build(), + requestOptions, + ) + + /** @see retrieve */ + @MustBeClosed + fun retrieve( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionRetrieveParams = + EntityOnboardingSessionRetrieveParams.none(), + ): HttpResponseFor = + retrieve(entityOnboardingSessionId, params, RequestOptions.none()) + + /** @see retrieve */ + @MustBeClosed + fun retrieve( + params: EntityOnboardingSessionRetrieveParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): HttpResponseFor + + /** @see retrieve */ + @MustBeClosed + fun retrieve( + params: EntityOnboardingSessionRetrieveParams + ): HttpResponseFor = retrieve(params, RequestOptions.none()) + + /** @see retrieve */ + @MustBeClosed + fun retrieve( + entityOnboardingSessionId: String, + requestOptions: RequestOptions, + ): HttpResponseFor = + retrieve( + entityOnboardingSessionId, + EntityOnboardingSessionRetrieveParams.none(), + requestOptions, + ) + + /** + * Returns a raw HTTP response for `get /entity_onboarding_sessions`, but is otherwise the + * same as [EntityOnboardingSessionService.list]. + */ + @MustBeClosed + fun list(): HttpResponseFor = + list(EntityOnboardingSessionListParams.none()) + + /** @see list */ + @MustBeClosed + fun list( + params: EntityOnboardingSessionListParams = EntityOnboardingSessionListParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): HttpResponseFor + + /** @see list */ + @MustBeClosed + fun list( + params: EntityOnboardingSessionListParams = EntityOnboardingSessionListParams.none() + ): HttpResponseFor = list(params, RequestOptions.none()) + + /** @see list */ + @MustBeClosed + fun list(requestOptions: RequestOptions): HttpResponseFor = + list(EntityOnboardingSessionListParams.none(), requestOptions) + + /** + * Returns a raw HTTP response for `post + * /entity_onboarding_sessions/{entity_onboarding_session_id}/expire`, but is otherwise the + * same as [EntityOnboardingSessionService.expire]. + */ + @MustBeClosed + fun expire(entityOnboardingSessionId: String): HttpResponseFor = + expire(entityOnboardingSessionId, EntityOnboardingSessionExpireParams.none()) + + /** @see expire */ + @MustBeClosed + fun expire( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionExpireParams = + EntityOnboardingSessionExpireParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): HttpResponseFor = + expire( + params.toBuilder().entityOnboardingSessionId(entityOnboardingSessionId).build(), + requestOptions, + ) + + /** @see expire */ + @MustBeClosed + fun expire( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionExpireParams = EntityOnboardingSessionExpireParams.none(), + ): HttpResponseFor = + expire(entityOnboardingSessionId, params, RequestOptions.none()) + + /** @see expire */ + @MustBeClosed + fun expire( + params: EntityOnboardingSessionExpireParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): HttpResponseFor + + /** @see expire */ + @MustBeClosed + fun expire( + params: EntityOnboardingSessionExpireParams + ): HttpResponseFor = expire(params, RequestOptions.none()) + + /** @see expire */ + @MustBeClosed + fun expire( + entityOnboardingSessionId: String, + requestOptions: RequestOptions, + ): HttpResponseFor = + expire( + entityOnboardingSessionId, + EntityOnboardingSessionExpireParams.none(), + requestOptions, + ) + } +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/EntityOnboardingSessionServiceImpl.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/EntityOnboardingSessionServiceImpl.kt new file mode 100644 index 000000000..80c74caae --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/EntityOnboardingSessionServiceImpl.kt @@ -0,0 +1,215 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.services.blocking + +import com.increase.api.core.ClientOptions +import com.increase.api.core.RequestOptions +import com.increase.api.core.checkRequired +import com.increase.api.core.handlers.errorBodyHandler +import com.increase.api.core.handlers.errorHandler +import com.increase.api.core.handlers.jsonHandler +import com.increase.api.core.http.HttpMethod +import com.increase.api.core.http.HttpRequest +import com.increase.api.core.http.HttpResponse +import com.increase.api.core.http.HttpResponse.Handler +import com.increase.api.core.http.HttpResponseFor +import com.increase.api.core.http.json +import com.increase.api.core.http.parseable +import com.increase.api.core.prepare +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSession +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionCreateParams +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionExpireParams +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionListPage +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionListPageResponse +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionListParams +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionRetrieveParams +import java.util.function.Consumer +import kotlin.jvm.optionals.getOrNull + +class EntityOnboardingSessionServiceImpl +internal constructor(private val clientOptions: ClientOptions) : EntityOnboardingSessionService { + + private val withRawResponse: EntityOnboardingSessionService.WithRawResponse by lazy { + WithRawResponseImpl(clientOptions) + } + + override fun withRawResponse(): EntityOnboardingSessionService.WithRawResponse = withRawResponse + + override fun withOptions( + modifier: Consumer + ): EntityOnboardingSessionService = + EntityOnboardingSessionServiceImpl( + clientOptions.toBuilder().apply(modifier::accept).build() + ) + + override fun create( + params: EntityOnboardingSessionCreateParams, + requestOptions: RequestOptions, + ): EntityOnboardingSession = + // post /entity_onboarding_sessions + withRawResponse().create(params, requestOptions).parse() + + override fun retrieve( + params: EntityOnboardingSessionRetrieveParams, + requestOptions: RequestOptions, + ): EntityOnboardingSession = + // get /entity_onboarding_sessions/{entity_onboarding_session_id} + withRawResponse().retrieve(params, requestOptions).parse() + + override fun list( + params: EntityOnboardingSessionListParams, + requestOptions: RequestOptions, + ): EntityOnboardingSessionListPage = + // get /entity_onboarding_sessions + withRawResponse().list(params, requestOptions).parse() + + override fun expire( + params: EntityOnboardingSessionExpireParams, + requestOptions: RequestOptions, + ): EntityOnboardingSession = + // post /entity_onboarding_sessions/{entity_onboarding_session_id}/expire + withRawResponse().expire(params, requestOptions).parse() + + class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) : + EntityOnboardingSessionService.WithRawResponse { + + private val errorHandler: Handler = + errorHandler(errorBodyHandler(clientOptions.jsonMapper)) + + override fun withOptions( + modifier: Consumer + ): EntityOnboardingSessionService.WithRawResponse = + EntityOnboardingSessionServiceImpl.WithRawResponseImpl( + clientOptions.toBuilder().apply(modifier::accept).build() + ) + + private val createHandler: Handler = + jsonHandler(clientOptions.jsonMapper) + + override fun create( + params: EntityOnboardingSessionCreateParams, + requestOptions: RequestOptions, + ): HttpResponseFor { + val request = + HttpRequest.builder() + .method(HttpMethod.POST) + .baseUrl(clientOptions.baseUrl()) + .addPathSegments("entity_onboarding_sessions") + .body(json(clientOptions.jsonMapper, params._body())) + .build() + .prepare(clientOptions, params) + val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions)) + val response = clientOptions.httpClient.execute(request, requestOptions) + return errorHandler.handle(response).parseable { + response + .use { createHandler.handle(it) } + .also { + if (requestOptions.responseValidation!!) { + it.validate() + } + } + } + } + + private val retrieveHandler: Handler = + jsonHandler(clientOptions.jsonMapper) + + override fun retrieve( + params: EntityOnboardingSessionRetrieveParams, + requestOptions: RequestOptions, + ): HttpResponseFor { + // We check here instead of in the params builder because this can be specified + // positionally or in the params class. + checkRequired( + "entityOnboardingSessionId", + params.entityOnboardingSessionId().getOrNull(), + ) + val request = + HttpRequest.builder() + .method(HttpMethod.GET) + .baseUrl(clientOptions.baseUrl()) + .addPathSegments("entity_onboarding_sessions", params._pathParam(0)) + .build() + .prepare(clientOptions, params) + val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions)) + val response = clientOptions.httpClient.execute(request, requestOptions) + return errorHandler.handle(response).parseable { + response + .use { retrieveHandler.handle(it) } + .also { + if (requestOptions.responseValidation!!) { + it.validate() + } + } + } + } + + private val listHandler: Handler = + jsonHandler(clientOptions.jsonMapper) + + override fun list( + params: EntityOnboardingSessionListParams, + requestOptions: RequestOptions, + ): HttpResponseFor { + val request = + HttpRequest.builder() + .method(HttpMethod.GET) + .baseUrl(clientOptions.baseUrl()) + .addPathSegments("entity_onboarding_sessions") + .build() + .prepare(clientOptions, params) + val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions)) + val response = clientOptions.httpClient.execute(request, requestOptions) + return errorHandler.handle(response).parseable { + response + .use { listHandler.handle(it) } + .also { + if (requestOptions.responseValidation!!) { + it.validate() + } + } + .let { + EntityOnboardingSessionListPage.builder() + .service(EntityOnboardingSessionServiceImpl(clientOptions)) + .params(params) + .response(it) + .build() + } + } + } + + private val expireHandler: Handler = + jsonHandler(clientOptions.jsonMapper) + + override fun expire( + params: EntityOnboardingSessionExpireParams, + requestOptions: RequestOptions, + ): HttpResponseFor { + // We check here instead of in the params builder because this can be specified + // positionally or in the params class. + checkRequired( + "entityOnboardingSessionId", + params.entityOnboardingSessionId().getOrNull(), + ) + val request = + HttpRequest.builder() + .method(HttpMethod.POST) + .baseUrl(clientOptions.baseUrl()) + .addPathSegments("entity_onboarding_sessions", params._pathParam(0), "expire") + .apply { params._body().ifPresent { body(json(clientOptions.jsonMapper, it)) } } + .build() + .prepare(clientOptions, params) + val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions)) + val response = clientOptions.httpClient.execute(request, requestOptions) + return errorHandler.handle(response).parseable { + response + .use { expireHandler.handle(it) } + .also { + if (requestOptions.responseValidation!!) { + it.validate() + } + } + } + } + } +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/SimulationService.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/SimulationService.kt index a74c3135b..c1e7349aa 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/SimulationService.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/SimulationService.kt @@ -20,6 +20,7 @@ import com.increase.api.services.blocking.simulations.CardTokenService import com.increase.api.services.blocking.simulations.CheckDepositService import com.increase.api.services.blocking.simulations.CheckTransferService import com.increase.api.services.blocking.simulations.DigitalWalletTokenRequestService +import com.increase.api.services.blocking.simulations.EntityOnboardingSessionService import com.increase.api.services.blocking.simulations.ExportService import com.increase.api.services.blocking.simulations.InboundAchTransferService import com.increase.api.services.blocking.simulations.InboundCheckDepositService @@ -107,6 +108,8 @@ interface SimulationService { fun inboundMailItems(): InboundMailItemService + fun entityOnboardingSessions(): EntityOnboardingSessionService + fun programs(): ProgramService fun accountStatements(): AccountStatementService @@ -184,6 +187,8 @@ interface SimulationService { fun inboundMailItems(): InboundMailItemService.WithRawResponse + fun entityOnboardingSessions(): EntityOnboardingSessionService.WithRawResponse + fun programs(): ProgramService.WithRawResponse fun accountStatements(): AccountStatementService.WithRawResponse diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/SimulationServiceImpl.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/SimulationServiceImpl.kt index 1b51b6fed..e304f068b 100644 --- a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/SimulationServiceImpl.kt +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/SimulationServiceImpl.kt @@ -37,6 +37,8 @@ import com.increase.api.services.blocking.simulations.CheckTransferService import com.increase.api.services.blocking.simulations.CheckTransferServiceImpl import com.increase.api.services.blocking.simulations.DigitalWalletTokenRequestService import com.increase.api.services.blocking.simulations.DigitalWalletTokenRequestServiceImpl +import com.increase.api.services.blocking.simulations.EntityOnboardingSessionService +import com.increase.api.services.blocking.simulations.EntityOnboardingSessionServiceImpl import com.increase.api.services.blocking.simulations.ExportService import com.increase.api.services.blocking.simulations.ExportServiceImpl import com.increase.api.services.blocking.simulations.InboundAchTransferService @@ -182,6 +184,10 @@ class SimulationServiceImpl internal constructor(private val clientOptions: Clie InboundMailItemServiceImpl(clientOptions) } + private val entityOnboardingSessions: EntityOnboardingSessionService by lazy { + EntityOnboardingSessionServiceImpl(clientOptions) + } + private val programs: ProgramService by lazy { ProgramServiceImpl(clientOptions) } private val accountStatements: AccountStatementService by lazy { @@ -258,6 +264,9 @@ class SimulationServiceImpl internal constructor(private val clientOptions: Clie override fun inboundMailItems(): InboundMailItemService = inboundMailItems + override fun entityOnboardingSessions(): EntityOnboardingSessionService = + entityOnboardingSessions + override fun programs(): ProgramService = programs override fun accountStatements(): AccountStatementService = accountStatements @@ -386,6 +395,11 @@ class SimulationServiceImpl internal constructor(private val clientOptions: Clie InboundMailItemServiceImpl.WithRawResponseImpl(clientOptions) } + private val entityOnboardingSessions: + EntityOnboardingSessionService.WithRawResponse by lazy { + EntityOnboardingSessionServiceImpl.WithRawResponseImpl(clientOptions) + } + private val programs: ProgramService.WithRawResponse by lazy { ProgramServiceImpl.WithRawResponseImpl(clientOptions) } @@ -481,6 +495,9 @@ class SimulationServiceImpl internal constructor(private val clientOptions: Clie override fun inboundMailItems(): InboundMailItemService.WithRawResponse = inboundMailItems + override fun entityOnboardingSessions(): EntityOnboardingSessionService.WithRawResponse = + entityOnboardingSessions + override fun programs(): ProgramService.WithRawResponse = programs override fun accountStatements(): AccountStatementService.WithRawResponse = diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/EntityOnboardingSessionService.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/EntityOnboardingSessionService.kt new file mode 100644 index 000000000..db8a1b482 --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/EntityOnboardingSessionService.kt @@ -0,0 +1,143 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.services.blocking.simulations + +import com.google.errorprone.annotations.MustBeClosed +import com.increase.api.core.ClientOptions +import com.increase.api.core.RequestOptions +import com.increase.api.core.http.HttpResponseFor +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSession +import com.increase.api.models.simulations.entityonboardingsessions.EntityOnboardingSessionSubmitParams +import java.util.function.Consumer + +interface EntityOnboardingSessionService { + + /** + * Returns a view of this service that provides access to raw HTTP responses for each method. + */ + fun withRawResponse(): WithRawResponse + + /** + * Returns a view of this service with the given option modifications applied. + * + * The original service is not modified. + */ + fun withOptions(modifier: Consumer): EntityOnboardingSessionService + + /** + * Simulates the submission of an [Entity Onboarding Session](#entity-onboarding-sessions). This + * session must have a `status` of `active`. After submission, the session will transition to + * `expired` and a new Entity will be created. + */ + fun submit(entityOnboardingSessionId: String): EntityOnboardingSession = + submit(entityOnboardingSessionId, EntityOnboardingSessionSubmitParams.none()) + + /** @see submit */ + fun submit( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionSubmitParams = EntityOnboardingSessionSubmitParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): EntityOnboardingSession = + submit( + params.toBuilder().entityOnboardingSessionId(entityOnboardingSessionId).build(), + requestOptions, + ) + + /** @see submit */ + fun submit( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionSubmitParams = EntityOnboardingSessionSubmitParams.none(), + ): EntityOnboardingSession = submit(entityOnboardingSessionId, params, RequestOptions.none()) + + /** @see submit */ + fun submit( + params: EntityOnboardingSessionSubmitParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): EntityOnboardingSession + + /** @see submit */ + fun submit(params: EntityOnboardingSessionSubmitParams): EntityOnboardingSession = + submit(params, RequestOptions.none()) + + /** @see submit */ + fun submit( + entityOnboardingSessionId: String, + requestOptions: RequestOptions, + ): EntityOnboardingSession = + submit( + entityOnboardingSessionId, + EntityOnboardingSessionSubmitParams.none(), + requestOptions, + ) + + /** + * A view of [EntityOnboardingSessionService] that provides access to raw HTTP responses for + * each method. + */ + interface WithRawResponse { + + /** + * Returns a view of this service with the given option modifications applied. + * + * The original service is not modified. + */ + fun withOptions( + modifier: Consumer + ): EntityOnboardingSessionService.WithRawResponse + + /** + * Returns a raw HTTP response for `post + * /simulations/entity_onboarding_sessions/{entity_onboarding_session_id}/submit`, but is + * otherwise the same as [EntityOnboardingSessionService.submit]. + */ + @MustBeClosed + fun submit(entityOnboardingSessionId: String): HttpResponseFor = + submit(entityOnboardingSessionId, EntityOnboardingSessionSubmitParams.none()) + + /** @see submit */ + @MustBeClosed + fun submit( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionSubmitParams = + EntityOnboardingSessionSubmitParams.none(), + requestOptions: RequestOptions = RequestOptions.none(), + ): HttpResponseFor = + submit( + params.toBuilder().entityOnboardingSessionId(entityOnboardingSessionId).build(), + requestOptions, + ) + + /** @see submit */ + @MustBeClosed + fun submit( + entityOnboardingSessionId: String, + params: EntityOnboardingSessionSubmitParams = EntityOnboardingSessionSubmitParams.none(), + ): HttpResponseFor = + submit(entityOnboardingSessionId, params, RequestOptions.none()) + + /** @see submit */ + @MustBeClosed + fun submit( + params: EntityOnboardingSessionSubmitParams, + requestOptions: RequestOptions = RequestOptions.none(), + ): HttpResponseFor + + /** @see submit */ + @MustBeClosed + fun submit( + params: EntityOnboardingSessionSubmitParams + ): HttpResponseFor = submit(params, RequestOptions.none()) + + /** @see submit */ + @MustBeClosed + fun submit( + entityOnboardingSessionId: String, + requestOptions: RequestOptions, + ): HttpResponseFor = + submit( + entityOnboardingSessionId, + EntityOnboardingSessionSubmitParams.none(), + requestOptions, + ) + } +} diff --git a/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/EntityOnboardingSessionServiceImpl.kt b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/EntityOnboardingSessionServiceImpl.kt new file mode 100644 index 000000000..91fb23d6b --- /dev/null +++ b/increase-java-core/src/main/kotlin/com/increase/api/services/blocking/simulations/EntityOnboardingSessionServiceImpl.kt @@ -0,0 +1,99 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.services.blocking.simulations + +import com.increase.api.core.ClientOptions +import com.increase.api.core.RequestOptions +import com.increase.api.core.checkRequired +import com.increase.api.core.handlers.errorBodyHandler +import com.increase.api.core.handlers.errorHandler +import com.increase.api.core.handlers.jsonHandler +import com.increase.api.core.http.HttpMethod +import com.increase.api.core.http.HttpRequest +import com.increase.api.core.http.HttpResponse +import com.increase.api.core.http.HttpResponse.Handler +import com.increase.api.core.http.HttpResponseFor +import com.increase.api.core.http.json +import com.increase.api.core.http.parseable +import com.increase.api.core.prepare +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSession +import com.increase.api.models.simulations.entityonboardingsessions.EntityOnboardingSessionSubmitParams +import java.util.function.Consumer +import kotlin.jvm.optionals.getOrNull + +class EntityOnboardingSessionServiceImpl +internal constructor(private val clientOptions: ClientOptions) : EntityOnboardingSessionService { + + private val withRawResponse: EntityOnboardingSessionService.WithRawResponse by lazy { + WithRawResponseImpl(clientOptions) + } + + override fun withRawResponse(): EntityOnboardingSessionService.WithRawResponse = withRawResponse + + override fun withOptions( + modifier: Consumer + ): EntityOnboardingSessionService = + EntityOnboardingSessionServiceImpl( + clientOptions.toBuilder().apply(modifier::accept).build() + ) + + override fun submit( + params: EntityOnboardingSessionSubmitParams, + requestOptions: RequestOptions, + ): EntityOnboardingSession = + // post /simulations/entity_onboarding_sessions/{entity_onboarding_session_id}/submit + withRawResponse().submit(params, requestOptions).parse() + + class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) : + EntityOnboardingSessionService.WithRawResponse { + + private val errorHandler: Handler = + errorHandler(errorBodyHandler(clientOptions.jsonMapper)) + + override fun withOptions( + modifier: Consumer + ): EntityOnboardingSessionService.WithRawResponse = + EntityOnboardingSessionServiceImpl.WithRawResponseImpl( + clientOptions.toBuilder().apply(modifier::accept).build() + ) + + private val submitHandler: Handler = + jsonHandler(clientOptions.jsonMapper) + + override fun submit( + params: EntityOnboardingSessionSubmitParams, + requestOptions: RequestOptions, + ): HttpResponseFor { + // We check here instead of in the params builder because this can be specified + // positionally or in the params class. + checkRequired( + "entityOnboardingSessionId", + params.entityOnboardingSessionId().getOrNull(), + ) + val request = + HttpRequest.builder() + .method(HttpMethod.POST) + .baseUrl(clientOptions.baseUrl()) + .addPathSegments( + "simulations", + "entity_onboarding_sessions", + params._pathParam(0), + "submit", + ) + .apply { params._body().ifPresent { body(json(clientOptions.jsonMapper, it)) } } + .build() + .prepare(clientOptions, params) + val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions)) + val response = clientOptions.httpClient.execute(request, requestOptions) + return errorHandler.handle(response).parseable { + response + .use { submitHandler.handle(it) } + .also { + if (requestOptions.responseValidation!!) { + it.validate() + } + } + } + } + } +} diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionCreateParamsTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionCreateParamsTest.kt new file mode 100644 index 000000000..910f5b420 --- /dev/null +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionCreateParamsTest.kt @@ -0,0 +1,48 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.entityonboardingsessions + +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Test + +internal class EntityOnboardingSessionCreateParamsTest { + + @Test + fun create() { + EntityOnboardingSessionCreateParams.builder() + .programId("program_i2v2os4mwza1oetokh9i") + .redirectUrl("https://example.com/onboarding/session") + .entityId("entity_id") + .build() + } + + @Test + fun body() { + val params = + EntityOnboardingSessionCreateParams.builder() + .programId("program_i2v2os4mwza1oetokh9i") + .redirectUrl("https://example.com/onboarding/session") + .entityId("entity_id") + .build() + + val body = params._body() + + assertThat(body.programId()).isEqualTo("program_i2v2os4mwza1oetokh9i") + assertThat(body.redirectUrl()).isEqualTo("https://example.com/onboarding/session") + assertThat(body.entityId()).contains("entity_id") + } + + @Test + fun bodyWithoutOptionalFields() { + val params = + EntityOnboardingSessionCreateParams.builder() + .programId("program_i2v2os4mwza1oetokh9i") + .redirectUrl("https://example.com/onboarding/session") + .build() + + val body = params._body() + + assertThat(body.programId()).isEqualTo("program_i2v2os4mwza1oetokh9i") + assertThat(body.redirectUrl()).isEqualTo("https://example.com/onboarding/session") + } +} diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionExpireParamsTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionExpireParamsTest.kt new file mode 100644 index 000000000..96ed7735f --- /dev/null +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionExpireParamsTest.kt @@ -0,0 +1,28 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.entityonboardingsessions + +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Test + +internal class EntityOnboardingSessionExpireParamsTest { + + @Test + fun create() { + EntityOnboardingSessionExpireParams.builder() + .entityOnboardingSessionId("entity_onboarding_session_wid2ug11fsmvh3k9hymd") + .build() + } + + @Test + fun pathParams() { + val params = + EntityOnboardingSessionExpireParams.builder() + .entityOnboardingSessionId("entity_onboarding_session_wid2ug11fsmvh3k9hymd") + .build() + + assertThat(params._pathParam(0)).isEqualTo("entity_onboarding_session_wid2ug11fsmvh3k9hymd") + // out-of-bound path param + assertThat(params._pathParam(1)).isEqualTo("") + } +} diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionListPageResponseTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionListPageResponseTest.kt new file mode 100644 index 000000000..4ecb07a04 --- /dev/null +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionListPageResponseTest.kt @@ -0,0 +1,89 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.entityonboardingsessions + +import com.fasterxml.jackson.module.kotlin.jacksonTypeRef +import com.increase.api.core.jsonMapper +import java.time.OffsetDateTime +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Test + +internal class EntityOnboardingSessionListPageResponseTest { + + @Test + fun create() { + val entityOnboardingSessionListPageResponse = + EntityOnboardingSessionListPageResponse.builder() + .addData( + EntityOnboardingSession.builder() + .id("entity_onboarding_session_wid2ug11fsmvh3k9hymd") + .createdAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .entityId("entity_n8y8tnk2p9339ti393yi") + .expiresAt(OffsetDateTime.parse("2020-02-01T05:59:59+00:00")) + .idempotencyKey(null) + .programId("program_i2v2os4mwza1oetokh9i") + .redirectUrl("https://example.com/onboarding/completed") + .sessionUrl( + "https://onboarding.increase.com/onboarding/sessions?id=HIrdj46cXyyNqT5RDcIR38dzPqzRBgTdG84XwzOz" + ) + .status(EntityOnboardingSession.Status.ACTIVE) + .type(EntityOnboardingSession.Type.ENTITY_ONBOARDING_SESSION) + .build() + ) + .nextCursor("v57w5d") + .build() + + assertThat(entityOnboardingSessionListPageResponse.data()) + .containsExactly( + EntityOnboardingSession.builder() + .id("entity_onboarding_session_wid2ug11fsmvh3k9hymd") + .createdAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .entityId("entity_n8y8tnk2p9339ti393yi") + .expiresAt(OffsetDateTime.parse("2020-02-01T05:59:59+00:00")) + .idempotencyKey(null) + .programId("program_i2v2os4mwza1oetokh9i") + .redirectUrl("https://example.com/onboarding/completed") + .sessionUrl( + "https://onboarding.increase.com/onboarding/sessions?id=HIrdj46cXyyNqT5RDcIR38dzPqzRBgTdG84XwzOz" + ) + .status(EntityOnboardingSession.Status.ACTIVE) + .type(EntityOnboardingSession.Type.ENTITY_ONBOARDING_SESSION) + .build() + ) + assertThat(entityOnboardingSessionListPageResponse.nextCursor()).contains("v57w5d") + } + + @Test + fun roundtrip() { + val jsonMapper = jsonMapper() + val entityOnboardingSessionListPageResponse = + EntityOnboardingSessionListPageResponse.builder() + .addData( + EntityOnboardingSession.builder() + .id("entity_onboarding_session_wid2ug11fsmvh3k9hymd") + .createdAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .entityId("entity_n8y8tnk2p9339ti393yi") + .expiresAt(OffsetDateTime.parse("2020-02-01T05:59:59+00:00")) + .idempotencyKey(null) + .programId("program_i2v2os4mwza1oetokh9i") + .redirectUrl("https://example.com/onboarding/completed") + .sessionUrl( + "https://onboarding.increase.com/onboarding/sessions?id=HIrdj46cXyyNqT5RDcIR38dzPqzRBgTdG84XwzOz" + ) + .status(EntityOnboardingSession.Status.ACTIVE) + .type(EntityOnboardingSession.Type.ENTITY_ONBOARDING_SESSION) + .build() + ) + .nextCursor("v57w5d") + .build() + + val roundtrippedEntityOnboardingSessionListPageResponse = + jsonMapper.readValue( + jsonMapper.writeValueAsString(entityOnboardingSessionListPageResponse), + jacksonTypeRef(), + ) + + assertThat(roundtrippedEntityOnboardingSessionListPageResponse) + .isEqualTo(entityOnboardingSessionListPageResponse) + } +} diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionListParamsTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionListParamsTest.kt new file mode 100644 index 000000000..de5a6357b --- /dev/null +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionListParamsTest.kt @@ -0,0 +1,60 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.entityonboardingsessions + +import com.increase.api.core.http.QueryParams +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Test + +internal class EntityOnboardingSessionListParamsTest { + + @Test + fun create() { + EntityOnboardingSessionListParams.builder() + .cursor("cursor") + .idempotencyKey("x") + .limit(1L) + .status( + EntityOnboardingSessionListParams.Status.builder() + .addIn(EntityOnboardingSessionListParams.Status.In.ACTIVE) + .build() + ) + .build() + } + + @Test + fun queryParams() { + val params = + EntityOnboardingSessionListParams.builder() + .cursor("cursor") + .idempotencyKey("x") + .limit(1L) + .status( + EntityOnboardingSessionListParams.Status.builder() + .addIn(EntityOnboardingSessionListParams.Status.In.ACTIVE) + .build() + ) + .build() + + val queryParams = params._queryParams() + + assertThat(queryParams) + .isEqualTo( + QueryParams.builder() + .put("cursor", "cursor") + .put("idempotency_key", "x") + .put("limit", "1") + .put("status.in", listOf("active").joinToString(",")) + .build() + ) + } + + @Test + fun queryParamsWithoutOptionalFields() { + val params = EntityOnboardingSessionListParams.builder().build() + + val queryParams = params._queryParams() + + assertThat(queryParams).isEqualTo(QueryParams.builder().build()) + } +} diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionRetrieveParamsTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionRetrieveParamsTest.kt new file mode 100644 index 000000000..7a0339487 --- /dev/null +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionRetrieveParamsTest.kt @@ -0,0 +1,28 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.entityonboardingsessions + +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Test + +internal class EntityOnboardingSessionRetrieveParamsTest { + + @Test + fun create() { + EntityOnboardingSessionRetrieveParams.builder() + .entityOnboardingSessionId("entity_onboarding_session_wid2ug11fsmvh3k9hymd") + .build() + } + + @Test + fun pathParams() { + val params = + EntityOnboardingSessionRetrieveParams.builder() + .entityOnboardingSessionId("entity_onboarding_session_wid2ug11fsmvh3k9hymd") + .build() + + assertThat(params._pathParam(0)).isEqualTo("entity_onboarding_session_wid2ug11fsmvh3k9hymd") + // out-of-bound path param + assertThat(params._pathParam(1)).isEqualTo("") + } +} diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionTest.kt new file mode 100644 index 000000000..ddf7d4877 --- /dev/null +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/entityonboardingsessions/EntityOnboardingSessionTest.kt @@ -0,0 +1,79 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.entityonboardingsessions + +import com.fasterxml.jackson.module.kotlin.jacksonTypeRef +import com.increase.api.core.jsonMapper +import java.time.OffsetDateTime +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Test + +internal class EntityOnboardingSessionTest { + + @Test + fun create() { + val entityOnboardingSession = + EntityOnboardingSession.builder() + .id("entity_onboarding_session_wid2ug11fsmvh3k9hymd") + .createdAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .entityId("entity_n8y8tnk2p9339ti393yi") + .expiresAt(OffsetDateTime.parse("2020-02-01T05:59:59+00:00")) + .idempotencyKey(null) + .programId("program_i2v2os4mwza1oetokh9i") + .redirectUrl("https://example.com/onboarding/completed") + .sessionUrl( + "https://onboarding.increase.com/onboarding/sessions?id=HIrdj46cXyyNqT5RDcIR38dzPqzRBgTdG84XwzOz" + ) + .status(EntityOnboardingSession.Status.ACTIVE) + .type(EntityOnboardingSession.Type.ENTITY_ONBOARDING_SESSION) + .build() + + assertThat(entityOnboardingSession.id()) + .isEqualTo("entity_onboarding_session_wid2ug11fsmvh3k9hymd") + assertThat(entityOnboardingSession.createdAt()) + .isEqualTo(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + assertThat(entityOnboardingSession.entityId()).contains("entity_n8y8tnk2p9339ti393yi") + assertThat(entityOnboardingSession.expiresAt()) + .isEqualTo(OffsetDateTime.parse("2020-02-01T05:59:59+00:00")) + assertThat(entityOnboardingSession.idempotencyKey()).isEmpty + assertThat(entityOnboardingSession.programId()).isEqualTo("program_i2v2os4mwza1oetokh9i") + assertThat(entityOnboardingSession.redirectUrl()) + .isEqualTo("https://example.com/onboarding/completed") + assertThat(entityOnboardingSession.sessionUrl()) + .contains( + "https://onboarding.increase.com/onboarding/sessions?id=HIrdj46cXyyNqT5RDcIR38dzPqzRBgTdG84XwzOz" + ) + assertThat(entityOnboardingSession.status()) + .isEqualTo(EntityOnboardingSession.Status.ACTIVE) + assertThat(entityOnboardingSession.type()) + .isEqualTo(EntityOnboardingSession.Type.ENTITY_ONBOARDING_SESSION) + } + + @Test + fun roundtrip() { + val jsonMapper = jsonMapper() + val entityOnboardingSession = + EntityOnboardingSession.builder() + .id("entity_onboarding_session_wid2ug11fsmvh3k9hymd") + .createdAt(OffsetDateTime.parse("2020-01-31T23:59:59Z")) + .entityId("entity_n8y8tnk2p9339ti393yi") + .expiresAt(OffsetDateTime.parse("2020-02-01T05:59:59+00:00")) + .idempotencyKey(null) + .programId("program_i2v2os4mwza1oetokh9i") + .redirectUrl("https://example.com/onboarding/completed") + .sessionUrl( + "https://onboarding.increase.com/onboarding/sessions?id=HIrdj46cXyyNqT5RDcIR38dzPqzRBgTdG84XwzOz" + ) + .status(EntityOnboardingSession.Status.ACTIVE) + .type(EntityOnboardingSession.Type.ENTITY_ONBOARDING_SESSION) + .build() + + val roundtrippedEntityOnboardingSession = + jsonMapper.readValue( + jsonMapper.writeValueAsString(entityOnboardingSession), + jacksonTypeRef(), + ) + + assertThat(roundtrippedEntityOnboardingSession).isEqualTo(entityOnboardingSession) + } +} diff --git a/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/entityonboardingsessions/EntityOnboardingSessionSubmitParamsTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/entityonboardingsessions/EntityOnboardingSessionSubmitParamsTest.kt new file mode 100644 index 000000000..80463fae0 --- /dev/null +++ b/increase-java-core/src/test/kotlin/com/increase/api/models/simulations/entityonboardingsessions/EntityOnboardingSessionSubmitParamsTest.kt @@ -0,0 +1,28 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.models.simulations.entityonboardingsessions + +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Test + +internal class EntityOnboardingSessionSubmitParamsTest { + + @Test + fun create() { + EntityOnboardingSessionSubmitParams.builder() + .entityOnboardingSessionId("entity_onboarding_session_wid2ug11fsmvh3k9hymd") + .build() + } + + @Test + fun pathParams() { + val params = + EntityOnboardingSessionSubmitParams.builder() + .entityOnboardingSessionId("entity_onboarding_session_wid2ug11fsmvh3k9hymd") + .build() + + assertThat(params._pathParam(0)).isEqualTo("entity_onboarding_session_wid2ug11fsmvh3k9hymd") + // out-of-bound path param + assertThat(params._pathParam(1)).isEqualTo("") + } +} diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/async/EntityOnboardingSessionServiceAsyncTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/async/EntityOnboardingSessionServiceAsyncTest.kt new file mode 100644 index 000000000..f695d0aab --- /dev/null +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/async/EntityOnboardingSessionServiceAsyncTest.kt @@ -0,0 +1,86 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.services.async + +import com.increase.api.TestServerExtension +import com.increase.api.client.okhttp.IncreaseOkHttpClientAsync +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionCreateParams +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +internal class EntityOnboardingSessionServiceAsyncTest { + + @Test + fun create() { + val client = + IncreaseOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val entityOnboardingSessionServiceAsync = client.entityOnboardingSessions() + + val entityOnboardingSessionFuture = + entityOnboardingSessionServiceAsync.create( + EntityOnboardingSessionCreateParams.builder() + .programId("program_i2v2os4mwza1oetokh9i") + .redirectUrl("https://example.com/onboarding/session") + .entityId("entity_id") + .build() + ) + + val entityOnboardingSession = entityOnboardingSessionFuture.get() + entityOnboardingSession.validate() + } + + @Test + fun retrieve() { + val client = + IncreaseOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val entityOnboardingSessionServiceAsync = client.entityOnboardingSessions() + + val entityOnboardingSessionFuture = + entityOnboardingSessionServiceAsync.retrieve( + "entity_onboarding_session_wid2ug11fsmvh3k9hymd" + ) + + val entityOnboardingSession = entityOnboardingSessionFuture.get() + entityOnboardingSession.validate() + } + + @Test + fun list() { + val client = + IncreaseOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val entityOnboardingSessionServiceAsync = client.entityOnboardingSessions() + + val pageFuture = entityOnboardingSessionServiceAsync.list() + + val page = pageFuture.get() + page.response().validate() + } + + @Test + fun expire() { + val client = + IncreaseOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val entityOnboardingSessionServiceAsync = client.entityOnboardingSessions() + + val entityOnboardingSessionFuture = + entityOnboardingSessionServiceAsync.expire( + "entity_onboarding_session_wid2ug11fsmvh3k9hymd" + ) + + val entityOnboardingSession = entityOnboardingSessionFuture.get() + entityOnboardingSession.validate() + } +} diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/EntityOnboardingSessionServiceAsyncTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/EntityOnboardingSessionServiceAsyncTest.kt new file mode 100644 index 000000000..6a6dc9a39 --- /dev/null +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/async/simulations/EntityOnboardingSessionServiceAsyncTest.kt @@ -0,0 +1,30 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.services.async.simulations + +import com.increase.api.TestServerExtension +import com.increase.api.client.okhttp.IncreaseOkHttpClientAsync +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +internal class EntityOnboardingSessionServiceAsyncTest { + + @Test + fun submit() { + val client = + IncreaseOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val entityOnboardingSessionServiceAsync = client.simulations().entityOnboardingSessions() + + val entityOnboardingSessionFuture = + entityOnboardingSessionServiceAsync.submit( + "entity_onboarding_session_wid2ug11fsmvh3k9hymd" + ) + + val entityOnboardingSession = entityOnboardingSessionFuture.get() + entityOnboardingSession.validate() + } +} diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/EntityOnboardingSessionServiceTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/EntityOnboardingSessionServiceTest.kt new file mode 100644 index 000000000..f32a0a0a7 --- /dev/null +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/EntityOnboardingSessionServiceTest.kt @@ -0,0 +1,80 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.services.blocking + +import com.increase.api.TestServerExtension +import com.increase.api.client.okhttp.IncreaseOkHttpClient +import com.increase.api.models.entityonboardingsessions.EntityOnboardingSessionCreateParams +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +internal class EntityOnboardingSessionServiceTest { + + @Test + fun create() { + val client = + IncreaseOkHttpClient.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val entityOnboardingSessionService = client.entityOnboardingSessions() + + val entityOnboardingSession = + entityOnboardingSessionService.create( + EntityOnboardingSessionCreateParams.builder() + .programId("program_i2v2os4mwza1oetokh9i") + .redirectUrl("https://example.com/onboarding/session") + .entityId("entity_id") + .build() + ) + + entityOnboardingSession.validate() + } + + @Test + fun retrieve() { + val client = + IncreaseOkHttpClient.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val entityOnboardingSessionService = client.entityOnboardingSessions() + + val entityOnboardingSession = + entityOnboardingSessionService.retrieve( + "entity_onboarding_session_wid2ug11fsmvh3k9hymd" + ) + + entityOnboardingSession.validate() + } + + @Test + fun list() { + val client = + IncreaseOkHttpClient.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val entityOnboardingSessionService = client.entityOnboardingSessions() + + val page = entityOnboardingSessionService.list() + + page.response().validate() + } + + @Test + fun expire() { + val client = + IncreaseOkHttpClient.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val entityOnboardingSessionService = client.entityOnboardingSessions() + + val entityOnboardingSession = + entityOnboardingSessionService.expire("entity_onboarding_session_wid2ug11fsmvh3k9hymd") + + entityOnboardingSession.validate() + } +} diff --git a/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/EntityOnboardingSessionServiceTest.kt b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/EntityOnboardingSessionServiceTest.kt new file mode 100644 index 000000000..c636386fa --- /dev/null +++ b/increase-java-core/src/test/kotlin/com/increase/api/services/blocking/simulations/EntityOnboardingSessionServiceTest.kt @@ -0,0 +1,27 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.increase.api.services.blocking.simulations + +import com.increase.api.TestServerExtension +import com.increase.api.client.okhttp.IncreaseOkHttpClient +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +internal class EntityOnboardingSessionServiceTest { + + @Test + fun submit() { + val client = + IncreaseOkHttpClient.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val entityOnboardingSessionService = client.simulations().entityOnboardingSessions() + + val entityOnboardingSession = + entityOnboardingSessionService.submit("entity_onboarding_session_wid2ug11fsmvh3k9hymd") + + entityOnboardingSession.validate() + } +} diff --git a/increase-java-proguard-test/src/test/kotlin/com/increase/api/proguard/ProGuardCompatibilityTest.kt b/increase-java-proguard-test/src/test/kotlin/com/increase/api/proguard/ProGuardCompatibilityTest.kt index bcd7c1c00..7045d5b42 100644 --- a/increase-java-proguard-test/src/test/kotlin/com/increase/api/proguard/ProGuardCompatibilityTest.kt +++ b/increase-java-proguard-test/src/test/kotlin/com/increase/api/proguard/ProGuardCompatibilityTest.kt @@ -85,6 +85,7 @@ internal class ProGuardCompatibilityTest { assertThat(client.entities()).isNotNull() assertThat(client.beneficialOwners()).isNotNull() assertThat(client.supplementalDocuments()).isNotNull() + assertThat(client.entityOnboardingSessions()).isNotNull() assertThat(client.programs()).isNotNull() assertThat(client.accountStatements()).isNotNull() assertThat(client.files()).isNotNull()