@tinkerlandai/indiana-react-native 0.9.2 → 0.9.5

package/native-sdk/android/java/ai/tinkerland/indiana/BillingAuthorizationTerms.kt

@@ -0,0 +1,55 @@
+package ai.tinkerland.indiana
+
+import org.json.JSONObject
+import java.math.BigDecimal
+import java.util.UUID
+
+/** Current immutable Stripe authorization terms contain no payment credential. */
+internal object BillingAuthorizationTerms {
+    fun validate(terms: JSONObject) {
+        fun invalid(): Nothing = throw IndianaClientException("invalid_response")
+        fun text(value: JSONObject, key: String): String = value.opt(key) as? String ?: invalid()
+        fun keys(value: JSONObject, expected: Set<String>) { if (value.keys().asSequence().toSet() != expected) invalid() }
+        fun quantity(value: Any?, positive: Boolean = false): BigDecimal {
+            val raw = value as? String ?: invalid()
+            if (!raw.matches(Regex("(0|[1-9][0-9]{0,11})(\\.[0-9]{1,6})?"))) invalid()
+            val amount = raw.toBigDecimal(); if (positive && amount <= BigDecimal.ZERO) invalid(); return amount
+        }
+        fun amount(key: String) { if (!text(terms, key).matches(Regex("[1-9][0-9]{0,14}"))) invalid() }
+        val kind = text(terms, "kind"); val currency = text(terms, "currency")
+        if (kind !in setOf("auto_topup", "postpaid") || !currency.matches(Regex("[A-Z]{3}"))) invalid()
+        listOf("productVersionId", "internal_feature_id").forEach { UUID.fromString(text(terms, it)) }
+        val base=setOf("kind","productVersionId","internal_feature_id","currency")
+        if(kind=="auto_topup") {
+            keys(terms,base+setOf("threshold","quantity","purchaseAmountMinor","purchaseUnits")+if(terms.has("purchaseLimit"))setOf("purchaseLimit")else emptySet())
+            if(!text(terms,"threshold").matches(Regex("^-?(0|[1-9][0-9]{0,11})(\\.[0-9]{1,6})?$")))invalid()
+            if(terms.has("purchaseLimit")) {
+                val limit=terms.optJSONObject("purchaseLimit")?:invalid();keys(limit,setOf("interval","intervalCount","limit"))
+                val count=limit.opt("intervalCount")as?Number?:invalid();val cap=limit.opt("limit")as?Number?:invalid()
+                if(text(limit,"interval") !in setOf("hour","day","week","month") || count.toDouble() !in 1.0..12.0 || count.toDouble()!=count.toInt().toDouble() || cap.toDouble() !in 1.0..1000000.0 || cap.toDouble()!=cap.toInt().toDouble())invalid()
+            }
+            if(quantity(terms.opt("quantity"),true)<BigDecimal.ONE)invalid()
+            quantity(terms.opt("purchaseUnits"),true);amount("purchaseAmountMinor");return
+        }
+        amount("maxAmountMinorPerPeriod")
+        keys(terms, base + setOf("maxAmountMinorPerPeriod","maxOutstandingMinor", "cashPrice")); amount("maxOutstandingMinor")
+        val price = terms.optJSONObject("cashPrice") ?: invalid(); keys(price, setOf("currency", "pricing") + if(price.has("billingCycle")) setOf("billingCycle") else emptySet())
+        if (text(price, "currency") != currency) invalid()
+        if(price.has("billingCycle")) {
+            val cycle=price.optJSONObject("billingCycle") ?: invalid();keys(cycle,setOf("interval","count","anchor"))
+            val count=cycle.opt("count") as? Number ?: invalid()
+            if(text(cycle,"interval") !in setOf("month","year") || text(cycle,"anchor") !in setOf("membership","calendar") || count.toDouble() !in 1.0..12.0 || count.toDouble() != count.toInt().toDouble()) invalid()
+        }
+        val pricing = price.optJSONObject("pricing") ?: invalid(); quantity(pricing.opt("units"), true)
+        val pricingKind = text(pricing, "kind")
+        if (pricingKind == "flat") { keys(pricing, setOf("kind", "units", "unitAmountMinor")); quantity(pricing.opt("unitAmountMinor")); return }
+        if (pricingKind !in setOf("graduated", "volume")) invalid(); keys(pricing, setOf("kind", "units", "tiers"))
+        val tiers = pricing.optJSONArray("tiers") ?: invalid(); if (tiers.length() !in 1..12) invalid()
+        var previous = BigDecimal.ZERO
+        for (index in 0 until tiers.length()) {
+            val tier = tiers.getJSONObject(index); keys(tier, setOf("upTo", "unitAmountMinor")); quantity(tier.opt("unitAmountMinor"))
+            if (index == tiers.length() - 1) { if (!tier.isNull("upTo")) invalid() }
+            else { val ceiling = quantity(tier.opt("upTo"), true); if (ceiling <= previous) invalid(); previous = ceiling }
+        }
+    }
+}

package/native-sdk/android/java/ai/tinkerland/indiana/BundledWebView.kt

@@ -0,0 +1,90 @@
+package ai.tinkerland.indiana
+
+import android.app.Activity
+import android.graphics.Color
+import android.net.Uri
+import android.os.Handler
+import android.os.Looper
+import android.webkit.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import org.json.JSONObject
+import java.net.URI
+import java.util.UUID
+
+/** One local renderer/bridge implementation for Funnel and independent Paywall. */
+internal class IndianaBundledWebView(
+    activity: Activity, label: String, private val work: CoroutineScope,
+    private val dispatch: suspend (String, Any?) -> Any?, private val onError: (Exception) -> Unit
+) {
+    val view = WebView(activity)
+    private val shell = URI("https://indiana-sdk.invalid/")
+    private var port: WebMessagePort? = null
+    private var stopped = false
+    private val requests = mutableSetOf<UUID>()
+    init {
+        view.setBackgroundColor(Color.TRANSPARENT); view.contentDescription = label; view.isSaveEnabled = false
+        view.settings.apply {
+            javaScriptEnabled = true; domStorageEnabled = false; databaseEnabled = false
+            allowFileAccess = false; allowContentAccess = false; mixedContentMode = WebSettings.MIXED_CONTENT_NEVER_ALLOW
+            cacheMode = WebSettings.LOAD_NO_CACHE; javaScriptCanOpenWindowsAutomatically = false; setSupportMultipleWindows(false)
+            mediaPlaybackRequiresUserGesture = true; saveFormData = false
+        }
+        view.webViewClient = object: WebViewClient() {
+            override fun shouldInterceptRequest(webView: WebView, request: WebResourceRequest): WebResourceResponse? {
+                if (request.url.host != "indiana-sdk.invalid") return null
+                return if (request.method == "GET" && request.url.toString() == shell.toString())
+                    WebResourceResponse("text/html", "UTF-8", activity.assets.open("indiana/index.html"))
+                else WebResourceResponse("text/plain", "UTF-8", 404, "Not Found", emptyMap(), java.io.ByteArrayInputStream(byteArrayOf()))
+            }
+            override fun shouldOverrideUrlLoading(webView: WebView, request: WebResourceRequest): Boolean {
+                val url = try { URI(request.url.toString()) } catch (_: Exception) { return true }
+                return if (request.isForMainFrame) url != shell else !allowsFunnelRendererNavigation(url, shell)
+            }
+            override fun onPageFinished(webView: WebView, url: String) {
+                if (stopped || url != shell.toString()) return
+                port?.close()
+                val channels = view.createWebMessageChannel(); port = channels[0]
+                channels[0].setWebMessageCallback(object: WebMessagePort.WebMessageCallback() {
+                    override fun onMessage(port: WebMessagePort, message: WebMessage) { receive(message.data ?: return) }
+                }, Handler(Looper.getMainLooper()))
+                val nonce = UUID.randomUUID().toString()
+                view.evaluateJavascript("window.__indianaFunnelPreparePort(" + JSONObject.quote(nonce) + ")") { accepted ->
+                    if (!stopped && view.url == shell.toString() && accepted == "true")
+                        view.postWebMessage(WebMessage(JSONObject().put("type", "indiana-native-port").put("nonce", nonce).toString(), arrayOf(channels[1])), Uri.parse(shell.toString()))
+                    else { channels[0].close(); channels[1].close() }
+                }
+            }
+            override fun onReceivedError(webView: WebView, request: WebResourceRequest, error: WebResourceError) {
+                if (!stopped && request.isForMainFrame) onError(IndianaClientException("renderer_unavailable"))
+            }
+        }
+    }
+    fun start() { if (!stopped) view.loadUrl(shell.toString()) }
+    private fun receive(raw: String) {
+        if (stopped || raw.toByteArray().size > 262144) return
+        val message = try { JSONObject(raw) } catch (_: Exception) { return }
+        if (message.keys().asSequence().toSet() != setOf("id", "method", "payload")) return
+        val id = try { UUID.fromString(message.getString("id")) } catch (_: Exception) { return }
+        if (requests.size >= 8 || !requests.add(id)) return
+        work.launch {
+            try {
+                val result = dispatch(message.getString("method"), message.opt("payload"))
+                send(JSONObject().put("id", id.toString()).put("result", result ?: JSONObject.NULL))
+            } catch (error: Exception) {
+                if (!stopped) {
+                    val detail = JSONObject().put("code", if (error is IndianaClientException) error.code else "NATIVE_OPERATION_FAILED")
+                    if (error is IndianaClientException) error.code.removePrefix("request_failed_").toIntOrNull()?.let { detail.put("status", it) }
+                    send(JSONObject().put("id", id.toString()).put("error", detail)); onError(error)
+                }
+            } finally { requests.remove(id) }
+        }
+    }
+    fun send(value: JSONObject) { if (!stopped) port?.postMessage(WebMessage(value.toString())) }
+    fun event(name: String) { send(JSONObject().put("event", name)) }
+    fun destroy() {
+        if (stopped) return
+        event("invalidated"); stopped = true; port?.close(); port = null; requests.clear()
+        view.stopLoading(); view.destroy()
+    }
+}

package/native-sdk/android/java/ai/tinkerland/indiana/ContentSession.kt

@@ -0,0 +1,45 @@
+package ai.tinkerland.indiana
+
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.UUID
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+/** Version-pinned independent Page, Popup or Banner. No Funnel is created. */
+class IndianaContentSession internal constructor(private val configuration: IndianaConfiguration, input: JSONObject, private val locale: String, inputs: JSONObject, private val send: suspend (JSONObject) -> JSONObject) {
+    private val mutex = Mutex()
+    private val input = JSONObject(input.toString())
+    private val inputs = JSONObject(inputs.toString())
+    @Volatile private var stopped = false
+    @Volatile private var value: JSONObject? = null
+    @Volatile private var invalidation: (() -> Unit)? = null
+    val current: JSONObject? get() = value?.let { JSONObject(it.toString()) }
+    init { require(locale.isNotEmpty() && locale.length <= 35 && inputs.length() <= 40) }
+    fun close() { if (stopped) return; stopped = true; value = null; invalidation?.invoke(); invalidation = null }
+    suspend fun refresh(): JSONObject = mutex.withLock {
+        if (stopped) throw IndianaClientException("identity_changed")
+        val content = send(JSONObject(input.toString())).getJSONObject("content")
+        if (stopped || content.getString("projectId") != configuration.scope.projectId.toString() || content.getString("kind") != input.getString("kind") || (value != null && value!!.getString("id") != content.getString("id"))) throw IndianaClientException("invalid_response")
+        input.put("selector", JSONObject().put("type", "version").put("id", content.getString("id")))
+        value = JSONObject(content.toString()); JSONObject(content.toString())
+    }
+    internal fun onInvalidation(callback: () -> Unit) { invalidation = callback; if (stopped) callback() }
+    internal fun hostInit(): JSONObject = JSONObject().put("event", "init").put("surface", "content").put("scope", JSONObject().put("projectId", configuration.scope.projectId.toString()).put("environment", configuration.scope.environment.value)).put("apiOrigin", configuration.apiOrigin)
+    internal suspend fun hostContent(): JSONObject {
+        if (stopped) throw IndianaClientException("identity_changed")
+        return JSONObject().put("content", current ?: refresh()).put("locale", locale).put("inputs", JSONObject(inputs.toString()))
+    }
+    internal fun trustedAction(raw: JSONObject): JSONObject = safe {
+        if (stopped || raw.keys().asSequence().toSet() != setOf("requestId", "contentVersionId", "actionId", "event", "value", "answers", "selection", "requestedClose")) throw IndianaClientException("invalid_command")
+        UUID.fromString(raw.getString("requestId"))
+        val content = value ?: throw IndianaClientException("invalid_command")
+        val document = content.getJSONObject("document")
+        val id = raw.getString("actionId")
+        val actions = document.getJSONObject("screen").getJSONArray("actions")
+        val action = (0 until actions.length()).map { actions.getJSONObject(it) }.firstOrNull { it.getString("id") == id } ?: throw IndianaClientException("invalid_command")
+        val properties = action.getJSONObject("properties")
+        if (raw.getString("contentVersionId") != content.getString("id") || !document.getJSONObject("contract").getJSONObject("outputs").has(id) || action.getString("type") != "event" || raw.getString("event") != action.getString("event") || raw.getBoolean("requestedClose") != action.getBoolean("close") || !IndianaSchema.equal(raw.opt("value"), if (properties.has("value")) properties.opt("value") else properties) || raw.optJSONObject("answers") == null || raw.optJSONObject("selection") == null) throw IndianaClientException("invalid_command")
+        JSONObject(raw.toString())
+    }
+}

package/native-sdk/android/java/ai/tinkerland/indiana/ContentView.kt

@@ -0,0 +1,36 @@
+package ai.tinkerland.indiana
+
+import android.app.Activity
+import android.widget.FrameLayout
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import org.json.JSONObject
+
+/** Independent content; actions are explicit callbacks into the merchant host. */
+class IndianaContentView(activity: Activity, val session: IndianaContentSession): FrameLayout(activity) {
+    var onAction: (suspend (JSONObject) -> Unit)? = null
+    var onDismiss: (() -> Unit)? = null
+    var onError: ((Exception) -> Unit)? = null
+    private val work = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+    private val host = IndianaBundledWebView(activity, "Indiana content", work, ::dispatch) { error -> onError?.invoke(error) }
+    private var stopped = false
+    init {
+        addView(host.view, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
+        session.onInvalidation { post { destroy() } }; host.start()
+    }
+    private suspend fun dispatch(method: String, raw: Any?): Any? = when (method) {
+        "ready" -> { host.send(session.hostInit()); null }
+        "content" -> session.hostContent()
+        "contentAction" -> {
+            val trusted = session.trustedAction(raw as? JSONObject ?: throw IndianaClientException("invalid_command"))
+            (onAction ?: throw IndianaClientException("unsupported_capability"))(trusted); null
+        }
+        "dismiss" -> { close(); null }
+        "error" -> { onError?.invoke(IndianaClientException("renderer_failed")); null }
+        else -> throw IndianaClientException("invalid_command")
+    }
+    fun destroy() { if (stopped) return; stopped = true; host.destroy(); work.cancel(); removeView(host.view); session.close(); onDismiss?.invoke() }
+    fun close() = destroy()
+}

package/native-sdk/android/java/ai/tinkerland/indiana/CustomerOperations.generated.kt

@@ -0,0 +1,84 @@
+// Generated by scripts/sdk/generate-native-protocol.mjs. Do not edit.
+package ai.tinkerland.indiana
+import org.json.JSONObject
+
+enum class IndianaCustomerOperation(val wireName: String, internal val path: String, internal val method: String) {
+    bindPushInstallation("bindPushInstallation", "push/installations/bind", "POST"),
+    readPushInstallation("readPushInstallation", "push/installations/read", "POST"),
+    updatePushAddress("updatePushAddress", "push/installations/address", "POST"),
+    readMessagingPreference("readMessagingPreference", "messaging/preferences/read", "POST"),
+    setMessagingPreference("setMessagingPreference", "messaging/preferences/set", "POST"),
+    getFeatures("getFeatures", "features", "GET"),
+    evaluateFeatures("evaluateFeatures", "features/evaluate", "POST"),
+    trackEvents("trackEvents", "events", "POST"),
+    restoreNativePurchase("restoreNativePurchase", "subscriptions/native/restore", "POST"),
+    setupPayment("setupPayment", "billing/setup-payment", "POST"),
+    readPaymentSetup("readPaymentSetup", "billing/payment-setup", "POST"),
+    previewAttach("previewAttach", "subscriptions/preview-attach", "POST"),
+    attach("attach", "subscriptions/attach", "POST"),
+    readSubscriptionOperation("readSubscriptionOperation", "subscriptions/operations/read", "POST"),
+    previewUpdate("previewUpdate", "subscriptions/preview-update", "POST"),
+    update("update", "subscriptions/update", "POST"),
+    readSubscriptionUpdate("readSubscriptionUpdate", "subscriptions/updates/read", "POST"),
+    readBillingControls("readBillingControls", "billing/controls/read", "POST"),
+    prepareBillingAuthorization("prepareBillingAuthorization", "billing/authorizations/prepare", "POST"),
+    confirmBillingAuthorization("confirmBillingAuthorization", "billing/authorizations/confirm", "POST"),
+    setBillingCoupons("setBillingCoupons", "billing/coupons", "POST"),
+    revokeBillingAuthorization("revokeBillingAuthorization", "billing/authorizations/revoke", "POST"),
+    listBillingInvoices("listBillingInvoices", "billing/invoices/read", "POST"),
+    confirmBillingAdjustment("confirmBillingAdjustment", "billing/invoices/confirm-adjustment", "POST"),
+    checkEntitlement("checkEntitlement", "entitlements/check", "POST"),
+    resolveContent("resolveContent", "content/resolve", "POST"),
+    resolvePaywall("resolvePaywall", "paywalls/resolve", "POST"),
+    resolveOffering("resolveOffering", "offerings/resolve", "POST"),
+    readHoldings("readHoldings", "customer-holdings", "POST"),
+    readLedger("readLedger", "customer-ledger", "POST"),
+    readBillingInvoice("readBillingInvoice", "billing/invoices/detail", "POST"),
+    readCreditStatement("readCreditStatement", "credit-statements/read", "POST"),
+    quoteBalance("quoteBalance", "balances/quote", "POST"),
+    redeemReward("redeemReward", "rewards/redeem", "POST"),
+    createReferralCode("createReferralCode", "rewards/referral-code", "POST"),
+    claimRewardProduct("claimRewardProduct", "rewards/product/claim", "POST"),
+    redeemCoupon("redeemCoupon", "offers/redeem", "POST"),
+    listOffers("listOffers", "offers", "GET"),
+    grantOffer("grantOffer", "offers/grant", "POST");
+}
+suspend fun IndianaClient.bindPushInstallation(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.bindPushInstallation, input)
+suspend fun IndianaClient.readPushInstallation(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.readPushInstallation, input)
+suspend fun IndianaClient.updatePushAddress(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.updatePushAddress, input)
+suspend fun IndianaClient.readMessagingPreference(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.readMessagingPreference, input)
+suspend fun IndianaClient.setMessagingPreference(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.setMessagingPreference, input)
+suspend fun IndianaClient.getFeatures(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.getFeatures, input)
+suspend fun IndianaClient.evaluateFeatures(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.evaluateFeatures, input)
+suspend fun IndianaClient.trackEvents(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.trackEvents, input)
+suspend fun IndianaClient.restoreNativePurchase(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.restoreNativePurchase, input)
+suspend fun IndianaClient.setupPayment(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.setupPayment, input)
+suspend fun IndianaClient.readPaymentSetup(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.readPaymentSetup, input)
+suspend fun IndianaClient.previewAttach(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.previewAttach, input)
+suspend fun IndianaClient.attach(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.attach, input)
+suspend fun IndianaClient.readSubscriptionOperation(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.readSubscriptionOperation, input)
+suspend fun IndianaClient.previewUpdate(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.previewUpdate, input)
+suspend fun IndianaClient.update(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.update, input)
+suspend fun IndianaClient.readSubscriptionUpdate(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.readSubscriptionUpdate, input)
+suspend fun IndianaClient.readBillingControls(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.readBillingControls, input)
+suspend fun IndianaClient.prepareBillingAuthorization(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.prepareBillingAuthorization, input)
+suspend fun IndianaClient.confirmBillingAuthorization(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.confirmBillingAuthorization, input)
+suspend fun IndianaClient.setBillingCoupons(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.setBillingCoupons, input)
+suspend fun IndianaClient.revokeBillingAuthorization(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.revokeBillingAuthorization, input)
+suspend fun IndianaClient.listBillingInvoices(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.listBillingInvoices, input)
+suspend fun IndianaClient.confirmBillingAdjustment(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.confirmBillingAdjustment, input)
+suspend fun IndianaClient.checkEntitlement(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.checkEntitlement, input)
+suspend fun IndianaClient.resolveContent(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.resolveContent, input)
+suspend fun IndianaClient.resolvePaywall(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.resolvePaywall, input)
+suspend fun IndianaClient.resolveOffering(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.resolveOffering, input)
+suspend fun IndianaClient.readHoldings(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.readHoldings, input)
+suspend fun IndianaClient.readLedgerRequest(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.readLedger, input)
+suspend fun IndianaClient.readBillingInvoice(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.readBillingInvoice, input)
+suspend fun IndianaClient.readCreditStatement(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.readCreditStatement, input)
+suspend fun IndianaClient.quoteBalance(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.quoteBalance, input)
+suspend fun IndianaClient.redeemReward(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.redeemReward, input)
+suspend fun IndianaClient.createReferralCode(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.createReferralCode, input)
+suspend fun IndianaClient.claimRewardProduct(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.claimRewardProduct, input)
+suspend fun IndianaClient.redeemCoupon(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.redeemCoupon, input)
+suspend fun IndianaClient.listOffers(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.listOffers, input)
+suspend fun IndianaClient.grantOffer(input: JSONObject): JSONObject = customerOperation(IndianaCustomerOperation.grantOffer, input)

package/native-sdk/android/java/ai/tinkerland/indiana/CustomerResponseSemantics.kt

@@ -0,0 +1,193 @@
+package ai.tinkerland.indiana
+
+import org.json.JSONObject
+import org.json.JSONArray
+import java.math.BigDecimal
+import java.net.URI
+
+/** Dispatch is based on generated schema fields, never arbitrary merchant JSON shapes. */
+internal object IndianaCustomerResponseSemantics {
+    private fun require(value: Boolean) { if (!value) throw IndianaClientException("invalid_response") }
+    private fun o(value: Any?) = value as? JSONObject ?: JSONObject()
+    private fun a(value: Any?) = (value as? JSONArray)?.let { array -> (0 until array.length()).map { o(array.opt(it)) } } ?: emptyList()
+    private fun s(value: Any?) = value as? String ?: ""
+    private fun n(value: Any?) = when (value) { is String -> value.toBigDecimalOrNull() ?: BigDecimal.ZERO; is Number -> value.toString().toBigDecimal(); else -> BigDecimal.ZERO }
+    private fun nil(value: Any?) = value == null || value == JSONObject.NULL
+    private fun unique(values: List<String>) = values.distinct().size == values.size
+    private fun time(value: Any?) = utcMillis(s(value))
+    private fun strings(value: Any?) = (value as? JSONArray)?.let { array -> (0 until array.length()).map { array.getString(it) } } ?: emptyList()
+    fun rules(original: Any?, schema: JSONObject): Any? {
+        val rules = schema.optJSONArray("x-indiana-rules")?.let { strings(it).toSet() } ?: emptySet()
+        val value = if ("trim" in rules && original is String) original.trim { it in "\u0009\u000a\u000b\u000c\u000d\u0020\u00a0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000\ufeff" } else original
+        if ("positive" in rules) require(n(value) > BigDecimal.ZERO); if ("atLeastOne" in rules) require(n(value) >= BigDecimal.ONE)
+        if ("lowercase" in rules) require(s(value) == s(value).lowercase())
+        if ("https" in rules) { val url = URI(s(value)); require(url.scheme == "https" && !url.host.isNullOrEmpty()) }
+        if ("locale" in rules) { val parts = s(value).split('-'); require(parts.first() !in IndianaProtocol.nonCanonicalLocaleLanguages && parts.drop(1).none { if (it.length == 4) it in IndianaProtocol.nonCanonicalLocaleScripts else it in IndianaProtocol.nonCanonicalLocaleRegions }) }
+        if ("notNegativeZero" in rules) require(!s(value).startsWith('-') || n(value).compareTo(BigDecimal.ZERO) != 0)
+        if ("boundedAdjustment" in rules) require(s(value) != "-0" && n(value) >= BigDecimal(-200000000) && n(value) <= BigDecimal(200000000))
+        if ("orderedPair" in rules && value is JSONArray && value.length() == 2) require(n(value.opt(0)) <= n(value.opt(1)))
+        if (rules.any { it in listOf("jsonBudget", "attributes", "condition") }) { jsonBudget(value); if (rules.any { it in listOf("attributes", "condition") }) require(o(value).length() <= 128) }
+        if ("condition" in rules) condition(o(value))
+        return value
+    }
+    private fun jsonBudget(value: Any?) {
+        var count = 0
+        fun visit(value: Any?, depth: Int) {
+            require(++count <= 10000 && depth <= 20)
+            fun text(text: String) { require('\u0000' !in text && text.indices.none { Character.isHighSurrogate(text[it]) && (it + 1 >= text.length || !Character.isLowSurrogate(text[it + 1])) || Character.isLowSurrogate(text[it]) && (it == 0 || !Character.isHighSurrogate(text[it - 1])) }) }
+            when (value) { is String -> text(value); is JSONArray -> for (index in 0 until value.length()) visit(value.opt(index), depth + 1); is JSONObject -> for (key in value.keys()) { text(key); require(key !in listOf("__proto__", "constructor", "prototype")); visit(value.opt(key), depth + 1) } }
+        }
+        visit(value, 0)
+        val encoded = if (value is JSONObject || value is JSONArray) value.toString() else JSONArray().put(value).toString().drop(1).dropLast(1)
+        require(encoded.toByteArray(Charsets.UTF_8).size <= 65536)
+    }
+    private fun condition(value: JSONObject) {
+        val operators = setOf("\$in", "\$ini", "\$inGroup", "\$nin", "\$nini", "\$notInGroup", "\$gt", "\$gte", "\$lt", "\$lte", "\$regex", "\$regexi", "\$ne", "\$eq", "\$size", "\$elemMatch", "\$all", "\$alli", "\$not", "\$type", "\$exists", "\$vgt", "\$vgte", "\$vlt", "\$vlte", "\$vne", "\$veq", "\$and", "\$or", "\$nor", "\$savedGroup")
+        require(value.optString("source") !in listOf("all", "any", "group", "parameter", "answer", "attribute", "result") || !value.has("operator") && !value.has("predicates") && !value.has("groupId"))
+        fun visit(current: Any?) {
+            if (current is JSONArray) for (index in 0 until current.length()) visit(current.opt(index))
+            if (current is JSONObject) for (key in current.keys()) {
+                val child = current.opt(key)
+                if (key == "\$savedGroup") { val group = o(child); require(group.keys().asSequence().all { it in listOf("id", "attributeKey") } && group.optString("id").matches(IndianaProtocol.uuidPattern) && (!group.has("attributeKey") || group.getString("attributeKey").length in 1..128)) }
+                if (key.startsWith("$")) require(key in operators) else require(key.split('.').none { it in listOf("__proto__", "constructor", "prototype") })
+                if (key in listOf("\$regex", "\$regexi") && child is String) {
+                    require(!Regex("\\(\\?[<!=]|\\\\[0-9]|\\\\k<").containsMatchIn(child))
+                    for (match in Regex("\\{([0-9]+)(?:,([0-9]*))?\\}").findAll(child)) for (index in listOf(1, 2)) require((match.groups[index]?.value?.toIntOrNull() ?: 0) <= 255)
+                    if (key == "\$regexi") require(child.all { it.code <= 127 })
+                    val syntax = buildString { var index = 0; while (index < child.length) { if (child[index] == '\\' && index + 1 < child.length) { val next = child[index + 1]; if (next.isLetter() && next.code < 128 && next !in "bBcdDsSwWfnrtvux") append(next) else { append('\\'); append(next) }; index += 2 } else { append(child[index]); index++ } } }
+                    Regex(syntax)
+                }; visit(child)
+            }
+        }; visit(value)
+    }
+    fun objectValue(v: JSONObject, fields: Set<String>, path: List<String>) {
+        fun has(vararg keys: String) = fields.containsAll(keys.toList())
+        if (has("productKind", "seatBundle", "applePromotionalOffer", "replacement", "offerKind")) {
+            val apple = v.getString("provider") == "apple"; val member = v.getString("productKind") == "membership"; val kind = v.getString("offerKind"); val replacement = o(v.opt("replacement")); val proof = o(v.opt("applePromotionalOffer"))
+            if (replacement.length() > 0) require(member && kind == "none" && v.isNull("trialDays") && replacement.getString("policy") == if (apple) "apple_store" else "google_full_price")
+            if (!member) require(v.isNull("trialDays") && kind == "none" && !v.has("basePlanId")) else if (!apple) require(v.has("basePlanId"))
+            require(n(v.opt("discountMinor")) <= n(v.opt("catalogAmountMinor")) && unique(a(v.opt("seatBundle")).map { it.getString("key") }))
+            require(v.isNull("trialDays") || n(v.opt("discountMinor")).compareTo(BigDecimal.ZERO) == 0 && kind != "none")
+            require(kind != "none" || n(v.opt("discountMinor")).compareTo(BigDecimal.ZERO) == 0)
+            if (apple) {
+                require(!v.isNull("appAccountToken") && !v.has("obfuscatedAccountId") && !v.has("obfuscatedProfileId") && !v.has("basePlanId"))
+                require((kind == "promotional") == !v.isNull("applePromotionalOffer") && (kind == "promotional") == v.has("offerId"))
+                require(proof.length() == 0 || proof.getString("offerId") == v.optString("offerId"))
+            } else require(!v.has("appAccountToken") && v.optString("obfuscatedAccountId").isNotEmpty() && v.optString("obfuscatedProfileId").isNotEmpty() && v.isNull("applePromotionalOffer") && (kind == "none") == !v.has("offerId"))
+        }
+        if (has("kind", "tiers") && v.optString("kind") in listOf("graduated", "volume")) {
+            val rows = a(v.opt("tiers")); require(rows.isNotEmpty() && rows.last().isNull("upTo"))
+            for ((index, row) in rows.dropLast(1).withIndex()) require(!row.isNull("upTo") && (index == 0 || n(row.opt("upTo")) > n(rows[index - 1].opt("upTo"))))
+            require(rows.none { n(it.opt("flatAmountMinor")) > BigDecimal.ZERO } || v.getString("kind") == "volume" && rows.size > 1)
+        }
+        if (has("units", "prices", "minimumQuantity", "maximumQuantity")) {
+            require(n(v.opt("units")) > BigDecimal.ZERO && n(v.opt("maximumQuantity")) >= n(v.opt("minimumQuantity")))
+            val prices = a(v.opt("prices")); require(unique(prices.map { it.getString("currency") }))
+            for (price in prices) { require(!price.has("pricing") || n(price.opt("amountMinor")).compareTo(BigDecimal.ZERO) == 0); val bounds = listOf(n(v.opt("maximumQuantity"))) + a(o(price.opt("pricing")).opt("tiers")).filter { !it.isNull("upTo") }.flatMap { listOf(n(it.opt("upTo")), n(it.opt("upTo")) + BigDecimal.ONE) }; for (quantity in bounds) if (quantity <= n(v.opt("maximumQuantity"))) prepaid(price, quantity) }
+        }
+        if (has("terms", "includedAmount", "priceId", "productId", "unitAmountMinor")) {
+            val terms = v.getJSONObject("terms"); val quantity = n(v.opt("quantity"))
+            require(quantity >= n(terms.opt("minimumQuantity")) && quantity <= n(terms.opt("maximumQuantity")) && v.isNull("productId") == v.isNull("priceId"))
+            require(quantity.compareTo(BigDecimal.ZERO) == 0 || !v.has("pricing") && n(v.opt("unitAmountMinor")).compareTo(BigDecimal.ZERO) == 0 || !v.isNull("priceId"))
+            require(n(v.opt("includedAmount")) + n(terms.opt("units")) * quantity <= BigDecimal("999999999999.999999")); prepaid(v, quantity)
+        }
+        if (has("lineId", "baseAmountMinor", "catalogAmountMinor", "seats", "trial")) {
+            val seats = a(v.opt("seats")); require(unique(seats.map { it.getString("key") }))
+            require(seats.all { n(it.opt("quantity")) >= n(it.opt("includedQuantity")) && n(it.opt("quantity")) <= n(it.opt("maximumQuantity")) })
+            var total = n(v.opt("baseAmountMinor")) + seats.fold(BigDecimal.ZERO) { total, seat -> total + n(seat.opt("unitAmountMinor")) * (n(seat.opt("quantity")) - n(seat.opt("includedQuantity"))) }
+            for (row in a(v.opt("prepaid"))) total += prepaid(row, n(row.opt("quantity"))); require(total.compareTo(n(v.opt("catalogAmountMinor"))) == 0)
+        }
+        if (has("percent_off", "amount_off", "currency", "duration_in_months", "duration")) require(v.has("percent_off") != v.has("amount_off") && !v.has("amount_off") == !v.has("currency") && (v.getString("duration") == "repeating") == v.has("duration_in_months"))
+        if (has("operationId", "lines", "discount", "charge", "nativeOffer", "execution")) attachQuote(v)
+        if (has("executor", "checkoutUrl", "execution")) {
+            require(v.isNull("execution") || v.getString("executor") == "merchant")
+            if (has("quoteFinalized", "orderId")) require(v.isNull("checkoutUrl") || v.getString("executor") == "indiana")
+            if (!v.isNull("checkoutUrl")) require(URI(v.getString("checkoutUrl")).scheme == "https")
+        }
+        if (has("action", "executor", "update", "cancel", "schedule", "release")) {
+            for (action in listOf("update", "cancel", "schedule", "release")) require(!v.isNull(action) == (v.getString("action") == action))
+            require(v.getString("executor") == "indiana" || (a(o(v.opt("update")).opt("items")) + a(o(v.opt("schedule")).opt("nextItems"))).all { !it.isNull("price") })
+        }
+        if (has("offerKind", "offerId", "discountMinor", "trialDays") && fields.size == 4) require((v.getString("offerKind") != "none" || v.isNull("offerId") && n(v.opt("discountMinor")).compareTo(BigDecimal.ZERO) == 0 && v.isNull("trialDays")) && (v.isNull("trialDays") || n(v.opt("discountMinor")).compareTo(BigDecimal.ZERO) == 0))
+        if (has("lookupKey", "displayName", "items", "metadata")) offering(v)
+        if (has("tiers", "assignments")) { val tiers = a(v.opt("tiers")).map { it.getString("id") }; val assignments = a(v.opt("assignments")); require(unique(tiers) && unique(assignments.map { it.getString("productVersionId") }) && unique(assignments.map { it.getString("tierId") + ":" + it.getString("period") }) && assignments.all { it.getString("tierId") in tiers }) }
+        if (has("kind", "screen", "contract", "name")) { val screen = v.getJSONObject("screen"); val kind = v.getString("kind"); val actions = a(screen.opt("actions")); val outputs = v.getJSONObject("contract").getJSONObject("outputs"); require(screen.getString("surface") == kind && screen.getString("name") == v.getString("name") && (kind == "banner") == (o(screen.opt("presentation")).optString("type") == "inline") && actions.all { it.getString("type") in listOf("event", "navigate") }); require(actions.filter { it.getString("type") == "event" }.map { it.getString("id") }.toSet() == outputs.keys().asSequence().toSet()); require(v.toString().toByteArray(Charsets.UTF_8).size <= 300000) }
+        if (has("pages", "actions", "initialPageId", "strings", "surface")) screen(v)
+        if (has("type", "planIds", "label", "fallback") && v.optString("type") == "plan_picker") { val ids = strings(v.opt("planIds")); require(unique(ids)); if (v.has("grouping")) require(productGrouping(v.getJSONObject("grouping")) == ids.toSet()) }
+        if (has("type", "source", "expired", "granularity") && v.optString("type") == "countdown") require(v.getString("source") != "fixed" || v.has("at"))
+        if (has("minimumQuantity", "maximumQuantity", "defaultQuantity", "step")) { val quantity = v.getLong("defaultQuantity"); val minimum = v.getLong("minimumQuantity"); require(quantity >= minimum && quantity <= v.getLong("maximumQuantity") && (quantity - minimum) % v.getLong("step") == 0L) }
+        if (has("id", "event", "properties", "type", "close")) require(o(v.opt("properties")).length() <= 20)
+        if (has("transactionIds", "membership")) require(unique(strings(v.opt("transactionIds"))))
+        if (has("defaultLocale", "locales") && path.last() == "displayCopy") { val locales = v.getJSONObject("locales"); require(locales.length() in 1..20 && locales.has(v.getString("defaultLocale")) && v.toString().toByteArray(Charsets.UTF_8).size <= 50000) }
+        if (has("kind", "threshold", "quantity", "purchaseUnits")) require(n(v.opt("quantity")) >= BigDecimal.ONE && n(v.opt("purchaseUnits")) > BigDecimal.ZERO)
+        if (has("kind", "cashPrice", "currency")) require(o(v.opt("cashPrice")).optString("currency") == v.getString("currency"))
+        if (has("currency", "pricing", "billingCycle")) o(v.opt("pricing")).let { require(it.optString("kind") != "volume" || a(it.opt("tiers")).size == 1) }
+        if (has("status", "terms", "acceptedAt", "effectiveAt", "revokedAt")) { val status = v.getString("status"); require((status != "prepared" || v.isNull("acceptedAt")) && (status != "active" || !v.isNull("acceptedAt") && !v.isNull("effectiveAt")) && (status == "revoked") == !v.isNull("revokedAt")) }
+        if (has("basis", "thresholds", "limit")) for (field in listOf("thresholds", "includedThresholds", "absoluteThresholds")) v.optJSONArray(field)?.let { for (index in 1 until it.length()) require(n(it.opt(index)) > n(it.opt(index - 1))) }
+        if (has("basis", "used", "reserved") && v.optString("basis") == "usage") for (key in listOf("used", "reserved")) require(v.getString(key).matches(Regex("^(0|[1-9][0-9]{0,11})(\\.[0-9]{1,6})?$")))
+        if (has("amountMinor", "requestId", "reason") && v.opt("amountMinor") is String) require(v.getString("amountMinor") != "-0" && n(v.opt("amountMinor")) >= BigDecimal(-200000000) && n(v.opt("amountMinor")) <= BigDecimal(200000000))
+        if (has("inputs", "outputs") && path.last() == "contract") require(o(v.opt("inputs")).length() <= 40 && o(v.opt("outputs")).length() <= 40)
+        if (has("formatVersion", "kind", "sha256", "url") && "paywall" in path) require(v.getString("kind") == "paywall" && v.getInt("formatVersion") == 1)
+        if (has("changeKind", "seat", "feature", "effectiveAt")) require((v.getString("changeKind") == "seats") == !v.isNull("seat") && (v.getString("changeKind") == "quantity") == v.has("feature"))
+        if (has("usage", "capacity", "remaining", "withinLimit", "operationId")) {
+            require(v.isNull("capacity") == v.isNull("remaining")); require(if (v.isNull("capacity")) v.getBoolean("withinLimit") else n(v.opt("remaining")).compareTo(n(v.opt("capacity")) - n(v.opt("usage"))) == 0 && v.getBoolean("withinLimit") == (n(v.opt("remaining")) >= BigDecimal.ZERO))
+            require((v.getLong("revision") == 0L) == v.isNull("operationId") && v.isNull("operationId") == v.isNull("updatedAt"))
+        }
+        if (has("usageType", "accessible", "available", "held", "debt", "usage")) {
+            require((v.getString("kind") == "metered") == !v.isNull("usageType") && (v.getBoolean("accessible") || v.getString("available") == "0" && v.getString("held") == "0"))
+            val usage = o(v.opt("usage")); if (v.optString("usageType") == "non_consumable") require(usage.length() > 0 && usage.getString("internal_feature_id") == v.getString("internal_feature_id") && v.getBoolean("unlimited") == usage.isNull("capacity") && v.getString("available") == (if (usage.isNull("remaining") || usage.getString("remaining").startsWith('-')) "0" else usage.getString("remaining")) && v.getString("held") == "0" && v.getString("debt") == "0") else require(v.isNull("usage"))
+        }
+        if (has("customerId", "rows", "nextCursor") && "ledger" in path) { val rows = a(v.opt("rows")); require(unique(rows.map { it.getString("type") + it.getString("id") })); if (!v.isNull("nextCursor")) { val last = rows.lastOrNull() ?: JSONObject(); val cursor = v.getJSONObject("nextCursor"); require(last.optString("id") == cursor.getString("id") && last.optString("type") == cursor.getString("type") && last.optString("occurredAt") == cursor.getString("at")) } }
+        if (has("kind", "accepted", "charges", "reservationStatus", "quantity") && v.optString("type") == "usage") {
+            val zero = v.getString("kind") == "set_usage" || v.getString("kind") == "consume" && v.getString("quantity") == "0"; val accepted = v.getBoolean("accepted"); val charges = a(v.opt("charges"))
+            require(if (zero) accepted && v.isNull("reason") && charges.isEmpty() && v.isNull("reservationStatus") else if (accepted) v.isNull("reason") && charges.isNotEmpty() else !v.isNull("reason") && charges.isEmpty())
+            require(!v.isNull("originalId") == (v.getString("kind") in listOf("confirm", "refund", "release", "expire")) && v.isNull("expiresAt") == v.isNull("reservationStatus"))
+        }
+        if (has("purpose", "productVersionId", "productName", "invoiceId", "originalId") && v.optString("type") == "transaction") { val product = v.getString("purpose") == "product"; require(v.isNull("currency") == v.isNull("amountMinor") && product == !v.isNull("productVersionId") && product == !v.isNull("productName") && product == !v.isNull("productVersion") && product == v.isNull("invoiceId") && (v.getString("kind") == "refund") == !v.isNull("originalId") && (v.getString("kind") != "refund" || v.isNull("amountMinor") || n(v.opt("amountMinor")) > BigDecimal.ZERO)) }
+        if (has("net", "internal_feature_id") && v.optString("net").startsWith('-')) require(n(v.opt("net")).compareTo(BigDecimal.ZERO) != 0)
+        if (has("funding", "units")) { require(n(v.opt("units")) > BigDecimal.ZERO); if (v.getString("funding") == "prepaid") { val rows = a(v.opt("pricing")); require(rows.fold(BigDecimal.ZERO) { sum, row -> sum + n(row.opt("units")) }.compareTo(n(v.opt("units"))) == 0 && rows.fold(BigDecimal.ZERO) { sum, row -> sum + n(row.opt("amount")) }.compareTo(n(v.opt("amount"))) == 0 && rows.all { (n(it.opt("unitCost")) * n(it.opt("units"))).compareTo(n(it.opt("amount"))) == 0 }) } }
+        if (has("allowed", "allocations", "quantity", "internal_feature_id") && v.getBoolean("allowed")) { val rows = a(v.opt("allocations")); val delta = rows.fold(BigDecimal.ZERO) { sum, row -> sum + n(row.opt("units")) } - n(v.opt("quantity")); val tolerance = if (rows.any { it.getString("funding") == "balance" }) BigDecimal("0.0000000001") else BigDecimal.ZERO; require(delta >= -tolerance && delta <= tolerance) }
+    }
+    private fun prepaid(price: JSONObject, quantity: BigDecimal): BigDecimal {
+        if (quantity.compareTo(BigDecimal.ZERO) == 0) return BigDecimal.ZERO
+        var total = BigDecimal.ZERO; val pricing = o(price.opt("pricing"))
+        if (pricing.length() == 0) total = n(if (price.has("amountMinor")) price.opt("amountMinor") else price.opt("unitAmountMinor")) * quantity
+        else { var lower = BigDecimal.ZERO; for (row in a(pricing.opt("tiers"))) { val upper = if (row.isNull("upTo")) BigDecimal(10000) else n(row.opt("upTo")); if (pricing.getString("kind") == "volume" && quantity <= upper) { total = quantity * n(row.opt("unitAmountMinor")) + n(row.opt("flatAmountMinor")); break }; if (pricing.getString("kind") != "volume" && quantity > lower) total += (quantity.min(upper) - lower) * n(row.opt("unitAmountMinor")); lower = upper } }
+        require(total <= BigDecimal(200000000)); return total
+    }
+    private fun attachQuote(v: JSONObject) {
+        val lines = a(v.opt("lines")); val trial = o(lines.firstOrNull()?.opt("trial")); val execution = o(v.opt("execution")); val discount = o(v.opt("discount")); val provider = v.getString("provider")
+        if (provider == "stripe") {
+            if (trial.has("cardRequired") && !trial.getBoolean("cardRequired") && !o(execution.opt("invoiceMode")).optBoolean("enabled")) require(execution.length() == 0 && discount.length() == 0)
+            else {
+                require(execution.length() > 0 && o(execution.opt("metadata")).optString("grooveCheckoutId") == v.getString("operationId") && time(execution.opt("expiresAt")) <= time(v.opt("expiresAt")))
+                require(execution.getString("mode") == if (lines.any { it.getString("interval") !in listOf("one_time", "free") }) "subscription" else "payment")
+                require(execution.isNull("trialPeriodDays") == (trial.length() == 0) && (trial.length() == 0 || n(execution.opt("trialPeriodDays")).compareTo(n(trial.opt("days"))) == 0))
+                require(execution.getString("executor") == "indiana" || a(execution.opt("lineItems")).all { !it.isNull("price") })
+                val discounts = a(execution.opt("discounts")); require(discounts.size == if (discount.length() == 0) 0 else 1)
+                for (row in discounts) { val terms = o(row.opt("terms")); val coupon = row.getString("coupon"); require(coupon == terms.getString("id") && discount.length() > 0); if (coupon != discount.getString("couponId")) require(o(discount.opt("discount")).getString("type") == "amount" && coupon == discount.getString("couponId") + "_credit_" + discount.getString("offerId") + "_" + terms.get("amount_off").toString() && n(terms.opt("amount_off")).compareTo(n(o(discount.opt("discount")).opt("amountOffCents"))) == 0 && terms.optString("currency").uppercase() == v.getString("currency") && terms.getString("duration") == "once") }
+            }
+            require(!v.has("nativeOffer"))
+        } else { val selection = o(v.opt("nativeOffer")); require(execution.length() == 0 && selection.length() > 0 && lines.size == 1 && n(selection.opt("discountMinor")) <= n(v.opt("catalogAmountMinor")) && selection.isNull("trialDays") == (trial.length() == 0) && (trial.length() == 0 || n(selection.opt("trialDays")).compareTo(n(trial.opt("days"))) == 0) && (discount.length() == 0 || n(selection.opt("discountMinor")).compareTo(n(discount.opt("amountMinor"))) == 0)) }
+        if (discount.length() > 0) { val allocations = a(discount.opt("allocations")); require(v.isNull("billingSubscriptionId") && (provider == "stripe" || o(discount.opt("duration")).getString("type") == "once") && n(discount.opt("amountMinor")) <= n(v.opt("catalogAmountMinor")) && allocations.size == lines.size); for ((row, line) in allocations.zip(lines)) require(row.getString("productVersionId") == line.getString("productVersionId") && n(row.opt("amountMinor")) <= n(line.opt("catalogAmountMinor"))); require(allocations.fold(BigDecimal.ZERO) { total, row -> total + n(row.opt("amountMinor")) }.compareTo(n(discount.opt("amountMinor"))) == 0) }
+        if (!v.isNull("charge")) { val charge = v.getJSONObject("charge"); require(!v.isNull("billingSubscriptionId") && n(charge.opt("totalMinor")).compareTo(n(charge.opt("debitMinor")) - n(charge.opt("discountMinor")) + n(charge.opt("taxMinor"))) == 0 && n(charge.opt("discountMinor")) <= n(charge.opt("debitMinor")) && time(charge.opt("periodEndsAt")) > time(charge.opt("effectiveAt"))) }
+        require(unique(lines.map { it.getString("lineId") }) && lines.fold(BigDecimal.ZERO) { total, line -> total + n(line.opt("catalogAmountMinor")) }.compareTo(n(v.opt("catalogAmountMinor"))) == 0)
+    }
+    private fun offering(v: JSONObject) {
+        val products = mutableSetOf<String>(); val groups = mutableSetOf<String>(); var count = 0
+        fun visit(items: List<JSONObject>) { for (item in items) { count++; if (item.getString("type") == "product") { val id = item.getString("productId"); require(id == id.lowercase() && products.add(id)) } else { require(groups.add(item.getString("key"))); item.put("name", item.getString("name").trim()); visit(a(item.opt("items"))) } } }
+        visit(a(v.opt("items"))); require(products.size <= 20 && count <= 60)
+        val metadata = v.getJSONObject("metadata").toString(); require(metadata.codePointCount(0, metadata.length) <= 4000)
+        for (field in listOf("displayName", "lookupKey")) v.put(field, v.getString(field).trim())
+    }
+    private fun productGrouping(group: JSONObject): Set<String> = a(group.opt("assignments")).map { it.getString("productVersionId") }.toSet()
+    private fun screen(v: JSONObject) {
+        val pages = a(v.opt("pages")); val actions = a(v.opt("actions")); val strings = v.getJSONObject("strings"); val locales = strings.getJSONObject("locales").keys().asSequence().toSet(); val pageIds = pages.map { it.getString("id") }; val actionIds = actions.map { it.getString("id") }
+        require((v.getString("surface") == "paywall" || pages.size == 1) && pages.size <= 10 && actions.size <= 40 && locales.size <= 20 && strings.getString("defaultLocale") in locales && unique(pageIds) && unique(actionIds) && "next" !in pageIds && "back" !in pageIds)
+        require(v.isNull("initialPageId") || v.getString("initialPageId") in pageIds)
+        for (action in actions) if (action.getString("type") == "navigate") require(v.getString("surface") == "paywall" && action.getString("pageId") in pageIds)
+        val ids = mutableSetOf<String>(); var count = 0
+        fun visit(node: JSONObject, depth: Int) { require(depth <= 8 && ++count <= 150 && ids.add(node.getString("id"))); if (node.getString("type") == "button") require(node.getString("action") in actionIds); if (node.getString("type") == "custom_html") require(locales.containsAll(o(node.opt("html")).keys().asSequence().toSet())); if (node.getString("type") == "image") require(locales.containsAll(o(node.opt("localizedSrc")).keys().asSequence().toSet())); for (child in a(node.opt("children"))) visit(child, depth + 1) }
+        for (page in pages) visit(page.getJSONObject("root"), 1)
+    }
+}