feat(api): updates (#141)

Author: stainless-bot

.stats.yml

@@ -1 +1 @@
-configured_endpoints: 105
+configured_endpoints: 106

lithic-java-core/src/main/kotlin/com/lithic/api/models/AccountHolder.kt

@@ -147,7 +147,7 @@ private constructor(
         Optional.ofNullable(statusReasons.getNullable("status_reasons"))
 
     /** Globally unique identifier for the account holder. */
-    fun token(): Optional<String> = Optional.ofNullable(token.getNullable("token"))
+    fun token(): String = token.getRequired("token")
 
     /**
      * The type of Account Holder. If the type is "INDIVIDUAL", the "individual" attribute will be

lithic-java-core/src/main/kotlin/com/lithic/api/models/AccountHolderListPage.kt

@@ -0,0 +1,205 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.lithic.api.models
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize
+import com.lithic.api.core.ExcludeMissing
+import com.lithic.api.core.JsonField
+import com.lithic.api.core.JsonMissing
+import com.lithic.api.core.JsonValue
+import com.lithic.api.core.NoAutoDetect
+import com.lithic.api.core.toUnmodifiable
+import com.lithic.api.services.blocking.AccountHolderService
+import java.util.Objects
+import java.util.Optional
+import java.util.stream.Stream
+import java.util.stream.StreamSupport
+
+class AccountHolderListPage
+private constructor(
+    private val accountHoldersService: AccountHolderService,
+    private val params: AccountHolderListParams,
+    private val response: Response,
+) {
+
+    fun response(): Response = response
+
+    fun data(): List<AccountHolder> = response().data()
+
+    fun hasMore(): Boolean = response().hasMore()
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return other is AccountHolderListPage &&
+            this.accountHoldersService == other.accountHoldersService &&
+            this.params == other.params &&
+            this.response == other.response
+    }
+
+    override fun hashCode(): Int {
+        return Objects.hash(
+            accountHoldersService,
+            params,
+            response,
+        )
+    }
+
+    override fun toString() =
+        "AccountHolderListPage{accountHoldersService=$accountHoldersService, params=$params, response=$response}"
+
+    fun hasNextPage(): Boolean {
+        return data().isEmpty()
+    }
+
+    fun getNextPageParams(): Optional<AccountHolderListParams> {
+        return Optional.empty()
+    }
+
+    fun getNextPage(): Optional<AccountHolderListPage> {
+        return getNextPageParams().map { accountHoldersService.list(it) }
+    }
+
+    fun autoPager(): AutoPager = AutoPager(this)
+
+    companion object {
+
+        @JvmStatic
+        fun of(
+            accountHoldersService: AccountHolderService,
+            params: AccountHolderListParams,
+            response: Response
+        ) =
+            AccountHolderListPage(
+                accountHoldersService,
+                params,
+                response,
+            )
+    }
+
+    @JsonDeserialize(builder = Response.Builder::class)
+    @NoAutoDetect
+    class Response
+    constructor(
+        private val data: JsonField<List<AccountHolder>>,
+        private val hasMore: JsonField<Boolean>,
+        private val additionalProperties: Map<String, JsonValue>,
+    ) {
+
+        private var validated: Boolean = false
+
+        fun data(): List<AccountHolder> = data.getNullable("data") ?: listOf()
+
+        fun hasMore(): Boolean = hasMore.getRequired("has_more")
+
+        @JsonProperty("data")
+        fun _data(): Optional<JsonField<List<AccountHolder>>> = Optional.ofNullable(data)
+
+        @JsonProperty("has_more")
+        fun _hasMore(): Optional<JsonField<Boolean>> = Optional.ofNullable(hasMore)
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> = additionalProperties
+
+        fun validate(): Response = apply {
+            if (!validated) {
+                data().map { it.validate() }
+                hasMore()
+                validated = true
+            }
+        }
+
+        fun toBuilder() = Builder().from(this)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return other is Response &&
+                this.data == other.data &&
+                this.hasMore == other.hasMore &&
+                this.additionalProperties == other.additionalProperties
+        }
+
+        override fun hashCode(): Int {
+            return Objects.hash(
+                data,
+                hasMore,
+                additionalProperties,
+            )
+        }
+
+        override fun toString() =
+            "AccountHolderListPage.Response{data=$data, hasMore=$hasMore, additionalProperties=$additionalProperties}"
+
+        companion object {
+
+            @JvmStatic fun builder() = Builder()
+        }
+
+        class Builder {
+
+            private var data: JsonField<List<AccountHolder>> = JsonMissing.of()
+            private var hasMore: JsonField<Boolean> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(page: Response) = apply {
+                this.data = page.data
+                this.hasMore = page.hasMore
+                this.additionalProperties.putAll(page.additionalProperties)
+            }
+
+            fun data(data: List<AccountHolder>) = data(JsonField.of(data))
+
+            @JsonProperty("data")
+            fun data(data: JsonField<List<AccountHolder>>) = apply { this.data = data }
+
+            fun hasMore(hasMore: Boolean) = hasMore(JsonField.of(hasMore))
+
+            @JsonProperty("has_more")
+            fun hasMore(hasMore: JsonField<Boolean>) = apply { this.hasMore = hasMore }
+
+            @JsonAnySetter
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                this.additionalProperties.put(key, value)
+            }
+
+            fun build() =
+                Response(
+                    data,
+                    hasMore,
+                    additionalProperties.toUnmodifiable(),
+                )
+        }
+    }
+
+    class AutoPager
+    constructor(
+        private val firstPage: AccountHolderListPage,
+    ) : Iterable<AccountHolder> {
+
+        override fun iterator(): Iterator<AccountHolder> = iterator {
+            var page = firstPage
+            var index = 0
+            while (true) {
+                while (index < page.data().size) {
+                    yield(page.data()[index++])
+                }
+                page = page.getNextPage().orElse(null) ?: break
+                index = 0
+            }
+        }
+
+        fun stream(): Stream<AccountHolder> {
+            return StreamSupport.stream(spliterator(), false)
+        }
+    }
+}