@tinkerlandai/indiana-react-native 0.9.2 → 0.10.1

package/native-sdk/ios/BillingAuthorizationTerms.swift

@@ -0,0 +1,57 @@
+import Foundation
+
+/// Current immutable Stripe authorization terms. They contain no payment credential.
+internal enum IndianaBillingAuthorizationTerms {
+    static func validate(_ terms: [String: IndianaJSON]) throws {
+        func text(_ object: [String: IndianaJSON], _ key: String) throws -> String {
+            guard let value = object[key]?.string else { throw IndianaFunnelError.invalidResponse }; return value
+        }
+        func quantity(_ value: IndianaJSON?, positive: Bool = false) throws -> Decimal {
+            guard let raw = value?.string, raw.range(of: "^(0|[1-9][0-9]{0,11})(\\.[0-9]{1,6})?$", options: .regularExpression) != nil,
+                  let amount = Decimal(string: raw, locale: Locale(identifier: "en_US_POSIX")), !positive || amount > 0 else { throw IndianaFunnelError.invalidResponse }; return amount
+        }
+        func amount(_ key: String) throws {
+            let raw = try text(terms, key)
+            guard raw.range(of: "^[1-9][0-9]{0,14}$", options: .regularExpression) != nil else { throw IndianaFunnelError.invalidResponse }
+        }
+        let kind = try text(terms, "kind"), currency = try text(terms, "currency")
+        guard ["auto_topup", "postpaid"].contains(kind), currency.range(of: "^[A-Z]{3}$", options: .regularExpression) != nil else { throw IndianaFunnelError.invalidResponse }
+        for key in ["productVersionId", "internal_feature_id"] { guard UUID(uuidString: try text(terms, key)) != nil else { throw IndianaFunnelError.invalidResponse } }
+        let base: Set<String> = ["kind", "productVersionId", "internal_feature_id", "currency"]
+        if kind == "auto_topup" {
+            guard Set(terms.keys) == base.union(["threshold", "quantity", "purchaseAmountMinor", "purchaseUnits"]).union(terms["purchaseLimit"] == nil ? [] : ["purchaseLimit"]),
+                  let threshold=terms["threshold"]?.string,threshold.range(of:"^-?(0|[1-9][0-9]{0,11})(\\.[0-9]{1,6})?$",options:.regularExpression) != nil else {throw IndianaFunnelError.invalidResponse}
+            if let value=terms["purchaseLimit"] {
+                guard let limit=value.object,Set(limit.keys)==Set(["interval","intervalCount","limit"]),["hour","day","week","month"].contains(try text(limit,"interval")),
+                  case .number(let count)?=limit["intervalCount"],count>=1,count<=12,count.rounded()==count,
+                  case .number(let cap)?=limit["limit"],cap>=1,cap<=1000000,cap.rounded()==cap else {throw IndianaFunnelError.invalidResponse}
+            }
+            guard try quantity(terms["quantity"],positive:true)>=1 else {throw IndianaFunnelError.invalidResponse}
+            _=try quantity(terms["purchaseUnits"],positive:true);try amount("purchaseAmountMinor");return
+        }
+        try amount("maxAmountMinorPerPeriod")
+        guard Set(terms.keys) == base.union(["maxAmountMinorPerPeriod","maxOutstandingMinor", "cashPrice"]),
+              let price = terms["cashPrice"]?.object, Set(price.keys) == Set(["currency", "pricing"]).union(price["billingCycle"] == nil ? [] : ["billingCycle"]), try text(price, "currency") == currency,
+              let pricing = price["pricing"]?.object else { throw IndianaFunnelError.invalidResponse }
+        if let value = price["billingCycle"] {
+            guard let cycle=value.object, Set(cycle.keys) == Set(["interval","count","anchor"]),
+                  ["month","year"].contains(try text(cycle,"interval")), ["membership","calendar"].contains(try text(cycle,"anchor")),
+                  case .number(let count)?=cycle["count"], count >= 1, count <= 12, count.rounded() == count else { throw IndianaFunnelError.invalidResponse }
+        }
+        try amount("maxOutstandingMinor"); _ = try quantity(pricing["units"], positive: true)
+        let pricingKind = try text(pricing, "kind")
+        if pricingKind == "flat" {
+            guard Set(pricing.keys) == Set(["kind", "units", "unitAmountMinor"]) else { throw IndianaFunnelError.invalidResponse }
+            _ = try quantity(pricing["unitAmountMinor"]); return
+        }
+        guard ["graduated", "volume"].contains(pricingKind), Set(pricing.keys) == Set(["kind", "units", "tiers"]),
+              case .array(let tiers)? = pricing["tiers"], (1...12).contains(tiers.count) else { throw IndianaFunnelError.invalidResponse }
+        var previous: Decimal = 0
+        for (index, row) in tiers.enumerated() {
+            guard let tier = row.object, Set(tier.keys) == Set(["upTo", "unitAmountMinor"]) else { throw IndianaFunnelError.invalidResponse }
+            _ = try quantity(tier["unitAmountMinor"])
+            if index == tiers.count - 1 { guard tier["upTo"] == .null else { throw IndianaFunnelError.invalidResponse } }
+            else { let ceiling = try quantity(tier["upTo"], positive: true); guard ceiling > previous else { throw IndianaFunnelError.invalidResponse }; previous = ceiling }
+        }
+    }
+}

package/native-sdk/ios/BundledWebView.swift

@@ -0,0 +1,87 @@
+import Foundation
+
+enum IndianaBundledWebViewResources {
+    static let origin = URL(string: "https://indiana-sdk.invalid/")!
+    static func rendererURL() throws -> String {
+        guard let file = IndianaResources.bundle.url(forResource: "renderer-data-url", withExtension: "txt", subdirectory: "WebView") else { throw IndianaClientError.invalidResponse }
+        return try String(contentsOf: file, encoding: .utf8)
+    }
+    static func html() throws -> String {
+        guard let file = IndianaResources.bundle.url(forResource: "index", withExtension: "html", subdirectory: "WebView") else { throw IndianaClientError.invalidResponse }
+        return try String(contentsOf: file, encoding: .utf8)
+    }
+}
+
+#if canImport(UIKit)
+import UIKit
+@preconcurrency import WebKit
+
+/// Shared local renderer transport for Funnel and independent Paywall. No network code loading.
+@MainActor final class IndianaBundledWebView: NSObject, @preconcurrency WKNavigationDelegate, @preconcurrency WKScriptMessageHandler {
+    let webView: WKWebView
+    private let dispatch: @MainActor (String, IndianaJSON) async throws -> IndianaJSON
+    private let onError: @MainActor (Error) -> Void
+    private var requests = Set<UUID>()
+    private var stopped = false
+    init(label: String, dispatch: @escaping @MainActor (String, IndianaJSON) async throws -> IndianaJSON, onError: @escaping @MainActor (Error) -> Void) {
+        self.dispatch = dispatch; self.onError = onError
+        let config = WKWebViewConfiguration()
+        config.websiteDataStore = .nonPersistent()
+        config.defaultWebpagePreferences.allowsContentJavaScript = true
+        webView = WKWebView(frame: .zero, configuration: config)
+        super.init()
+        config.userContentController.add(WeakBundledHandler(self), name: "indianaFunnel")
+        webView.navigationDelegate = self; webView.isOpaque = false; webView.backgroundColor = .clear
+        webView.scrollView.backgroundColor = .clear; webView.accessibilityLabel = label
+    }
+    func start() {
+        guard !stopped else { return }
+        do { webView.loadHTMLString(try IndianaBundledWebViewResources.html(), baseURL: IndianaBundledWebViewResources.origin) }
+        catch { onError(error) }
+    }
+    func send(_ value: IndianaJSON) {
+        guard !stopped, let data=try? JSONEncoder().encode(value), let text=String(data:data,encoding:.utf8) else { return }
+        webView.evaluateJavaScript("window.__indianaFunnelReceive(\(text))", completionHandler: nil)
+    }
+    func event(_ name: String) { send(.object(["event":.string(name)])) }
+    func destroy() {
+        guard !stopped else { return }; event("invalidated"); stopped = true; requests.removeAll()
+        webView.stopLoading(); webView.configuration.userContentController.removeScriptMessageHandler(forName:"indianaFunnel")
+        webView.isHidden = true; webView.loadHTMLString("", baseURL:nil)
+    }
+    func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage) {
+        guard !stopped, message.webView === webView, message.frameInfo.isMainFrame,
+              message.frameInfo.securityOrigin.protocol == "https", message.frameInfo.securityOrigin.host == "indiana-sdk.invalid",
+              [0,443].contains(message.frameInfo.securityOrigin.port),
+              let data=try? JSONSerialization.data(withJSONObject:message.body), data.count <= 262144,
+              let value=try? JSONDecoder().decode(IndianaJSON.self,from:data).object,
+              Set(value.keys) == Set(["id","method","payload"]), let id=value["id"]?.string.flatMap(UUID.init(uuidString:)),
+              let method=value["method"]?.string, requests.count < 8, requests.insert(id).inserted else { return }
+        Task {
+            defer { requests.remove(id) }
+            do {
+                let result=try await dispatch(method,value["payload"] ?? .object([:]))
+                guard !stopped else { return }; send(.object(["id":.string(id.uuidString.lowercased()),"result":result]))
+            } catch {
+                guard !stopped else { return }
+                var detail:[String:IndianaJSON] = ["code":.string("NATIVE_OPERATION_FAILED")]
+                if let e=error as? IndianaClientError, case .requestFailed(let status)=e { detail["status"] = .number(Double(status)) }
+                if let e=error as? IndianaFunnelError, case .commandPending=e { detail["code"] = .string("COMMAND_PENDING") }
+                send(.object(["id":.string(id.uuidString.lowercased()),"error":.object(detail)])); onError(error)
+            }
+        }
+    }
+    func webView(_ webView: WKWebView, decidePolicyFor action: WKNavigationAction, decisionHandler: @escaping (WKNavigationActionPolicy) -> Void) {
+        guard !stopped, let url=action.request.url else { decisionHandler(.cancel); return }
+        if action.targetFrame?.isMainFrame == true {
+            decisionHandler(url == IndianaBundledWebViewResources.origin || url.absoluteString == "about:blank" ? .allow : .cancel)
+        } else { decisionHandler(indianaAllowsFunnelRendererNavigation(url,baseURL:IndianaBundledWebViewResources.origin) ? .allow : .cancel) }
+    }
+    func webView(_ webView: WKWebView, didFailProvisionalNavigation navigation: WKNavigation!, withError error: Error) { if !stopped { onError(error) } }
+}
+@MainActor private final class WeakBundledHandler: NSObject, @preconcurrency WKScriptMessageHandler {
+    weak var owner: IndianaBundledWebView?
+    init(_ owner:IndianaBundledWebView) { self.owner=owner }
+    func userContentController(_ controller:WKUserContentController,didReceive message:WKScriptMessage) { owner?.userContentController(controller,didReceive:message) }
+}
+#endif

package/native-sdk/ios/ContentSession.swift

@@ -0,0 +1,48 @@
+import Foundation
+
+/// An independent, version-pinned Page, Popup or Banner; it creates no Funnel Run.
+public actor IndianaContentSession {
+    private let configuration: IndianaConfiguration
+    private let send: @Sendable ([String: IndianaJSON]) async throws -> IndianaJSON
+    private var input: [String: IndianaJSON]
+    private let locale: String
+    private let inputs: [String: IndianaJSON]
+    public private(set) var current: IndianaJSON?
+    private var stopped = false
+    private var invalidation: (@Sendable () -> Void)?
+    init(configuration: IndianaConfiguration, input: [String: IndianaJSON], locale: String, inputs: [String: IndianaJSON], send: @escaping @Sendable ([String: IndianaJSON]) async throws -> IndianaJSON) throws {
+        guard !locale.isEmpty, locale.count <= 35, inputs.count <= 40 else { throw IndianaClientError.invalidConfiguration }
+        self.configuration = configuration; self.input = input; self.locale = locale; self.inputs = inputs; self.send = send
+    }
+    public func close() { guard !stopped else { return }; stopped = true; current = nil; invalidation?(); invalidation = nil }
+    public func refresh() async throws -> IndianaJSON {
+        guard !stopped else { throw IndianaClientError.identityChanged }
+        let result = try await send(input)
+        guard !stopped, let content = result.object?["content"]?.object, let id = content["id"]?.string,
+              content["kind"] == input["kind"], content["projectId"]?.string == configuration.scope.projectId.uuidString.lowercased() else { throw IndianaClientError.invalidResponse }
+        if let current, current.object?["id"]?.string != id { throw IndianaClientError.invalidResponse }
+        input["selector"] = .object(["type": .string("version"), "id": .string(id)])
+        current = .object(content); return .object(content)
+    }
+    func onInvalidation(_ callback: @escaping @Sendable () -> Void) { invalidation = callback; if stopped { callback() } }
+    func hostInit() -> IndianaJSON { .object(["event": .string("init"), "surface": .string("content"), "scope": .object(["projectId": .string(configuration.scope.projectId.uuidString.lowercased()), "environment": .string(configuration.scope.environment.rawValue)]), "apiOrigin": .string(configuration.apiOrigin)]) }
+    func hostContent() async throws -> IndianaJSON {
+        guard !stopped else { throw IndianaClientError.identityChanged }
+        let content: IndianaJSON
+        if let current { content = current } else { content = try await refresh() }
+        return .object(["content": content, "locale": .string(locale), "inputs": .object(inputs)])
+    }
+    func trustedAction(_ intent: IndianaJSON) throws -> IndianaJSON {
+        guard !stopped, let value = intent.object, Set(value.keys) == Set(["requestId", "contentVersionId", "actionId", "event", "value", "answers", "selection", "requestedClose"]),
+              let request = value["requestId"]?.string, UUID(uuidString: request) != nil,
+              let current = current?.object, value["contentVersionId"] == current["id"],
+              let actionID = value["actionId"]?.string, let document = current["document"]?.object,
+              document["contract"]?.object?["outputs"]?.object?[actionID] != nil,
+              case .array(let actions)? = document["screen"]?.object?["actions"],
+              let action = actions.compactMap(\.object).first(where: { $0["id"]?.string == actionID }),
+              action["type"]?.string == "event", action["event"] == value["event"], action["close"] == value["requestedClose"],
+              let properties = action["properties"]?.object, value["value"] == (properties["value"] ?? .object(properties)),
+              value["answers"]?.object != nil, value["selection"]?.object != nil else { throw IndianaFunnelError.invalidCommand }
+        return intent
+    }
+}

package/native-sdk/ios/ContentView.swift

@@ -0,0 +1,51 @@
+#if canImport(UIKit)
+import UIKit
+import SwiftUI
+
+/// Independent content presented through the same isolated packaged renderer as Funnel.
+@MainActor public final class IndianaContentViewController: UIViewController {
+    public let session: IndianaContentSession
+    public var onAction: (@MainActor (IndianaJSON) async throws -> Void)?
+    public var onDismiss: (@MainActor () -> Void)?
+    public var onError: (@MainActor (Error) -> Void)?
+    private var host: IndianaBundledWebView!
+    private var stopped = false
+    public init(session: IndianaContentSession) { self.session = session; super.init(nibName: nil, bundle: nil) }
+    required init?(coder: NSCoder) { fatalError("Use init(session:)") }
+    public override func viewDidLoad() {
+        super.viewDidLoad()
+        host = IndianaBundledWebView(label: "Indiana content", dispatch: { [weak self] method, payload in
+            guard let self else { throw IndianaClientError.identityChanged }; return try await self.dispatch(method, payload)
+        }, onError: { [weak self] error in self?.onError?(error) })
+        host.webView.frame = view.bounds; host.webView.autoresizingMask = [.flexibleWidth, .flexibleHeight]; view.addSubview(host.webView)
+        Task { [weak self, session] in await session.onInvalidation { [weak self] in Task { @MainActor in self?.invalidate() } } }
+        host.start()
+    }
+    public func close() async { await session.close(); invalidate() }
+    private func invalidate() { guard !stopped else { return }; stopped = true; host?.destroy(); onDismiss?() }
+    private func dispatch(_ method: String, _ payload: IndianaJSON) async throws -> IndianaJSON {
+        switch method {
+        case "ready": host.send(await session.hostInit()); return .null
+        case "content": return try await session.hostContent()
+        case "contentAction":
+            let trusted = try await session.trustedAction(payload)
+            guard let onAction else { throw IndianaClientError.unsupportedCapability }
+            try await onAction(trusted); return .null
+        case "dismiss": await close(); return .null
+        case "error": onError?(IndianaClientError.invalidResponse); return .null
+        default: throw IndianaFunnelError.invalidCommand
+        }
+    }
+}
+
+@MainActor public struct IndianaContentView: UIViewControllerRepresentable {
+    public let session: IndianaContentSession
+    public var onAction: (@MainActor (IndianaJSON) async throws -> Void)?
+    public var onDismiss: (@MainActor () -> Void)?
+    public var onError: (@MainActor (Error) -> Void)?
+    public init(session: IndianaContentSession, onAction: (@MainActor (IndianaJSON) async throws -> Void)? = nil, onDismiss: (@MainActor () -> Void)? = nil, onError: (@MainActor (Error) -> Void)? = nil) { self.session = session; self.onAction = onAction; self.onDismiss = onDismiss; self.onError = onError }
+    public func makeUIViewController(context: Context) -> IndianaContentViewController { let view = IndianaContentViewController(session: session); updateUIViewController(view, context: context); return view }
+    public func updateUIViewController(_ view: IndianaContentViewController, context: Context) { view.onAction = onAction; view.onDismiss = onDismiss; view.onError = onError }
+    public static func dismantleUIViewController(_ view: IndianaContentViewController, coordinator: ()) { Task { await view.close() } }
+}
+#endif

package/native-sdk/ios/CustomerOperations.generated.swift

@@ -0,0 +1,166 @@
+// Generated by scripts/sdk/generate-native-protocol.mjs. Do not edit.
+import Foundation
+public enum IndianaCustomerOperation: String, CaseIterable, Sendable {
+    case bindPushInstallation
+    case readPushInstallation
+    case updatePushAddress
+    case readMessagingPreference
+    case setMessagingPreference
+    case getFeatures
+    case evaluateFeatures
+    case trackEvents
+    case restoreNativePurchase
+    case setupPayment
+    case readPaymentSetup
+    case previewAttach
+    case attach
+    case readSubscriptionOperation
+    case previewUpdate
+    case update
+    case readSubscriptionUpdate
+    case readBillingControls
+    case prepareBillingAuthorization
+    case confirmBillingAuthorization
+    case setBillingCoupons
+    case revokeBillingAuthorization
+    case listBillingInvoices
+    case confirmBillingAdjustment
+    case checkEntitlement
+    case resolveContent
+    case resolvePaywall
+    case resolveOffering
+    case readHoldings
+    case readLedger
+    case readBillingInvoice
+    case readCreditStatement
+    case quoteBalance
+    case redeemReward
+    case createReferralCode
+    case claimRewardProduct
+    case redeemCoupon
+    case listOffers
+    case grantOffer
+    var path: String { switch self {
+    case .bindPushInstallation: return "push/installations/bind"
+    case .readPushInstallation: return "push/installations/read"
+    case .updatePushAddress: return "push/installations/address"
+    case .readMessagingPreference: return "messaging/preferences/read"
+    case .setMessagingPreference: return "messaging/preferences/set"
+    case .getFeatures: return "features"
+    case .evaluateFeatures: return "features/evaluate"
+    case .trackEvents: return "events"
+    case .restoreNativePurchase: return "subscriptions/native/restore"
+    case .setupPayment: return "billing/setup-payment"
+    case .readPaymentSetup: return "billing/payment-setup"
+    case .previewAttach: return "subscriptions/preview-attach"
+    case .attach: return "subscriptions/attach"
+    case .readSubscriptionOperation: return "subscriptions/operations/read"
+    case .previewUpdate: return "subscriptions/preview-update"
+    case .update: return "subscriptions/update"
+    case .readSubscriptionUpdate: return "subscriptions/updates/read"
+    case .readBillingControls: return "billing/controls/read"
+    case .prepareBillingAuthorization: return "billing/authorizations/prepare"
+    case .confirmBillingAuthorization: return "billing/authorizations/confirm"
+    case .setBillingCoupons: return "billing/coupons"
+    case .revokeBillingAuthorization: return "billing/authorizations/revoke"
+    case .listBillingInvoices: return "billing/invoices/read"
+    case .confirmBillingAdjustment: return "billing/invoices/confirm-adjustment"
+    case .checkEntitlement: return "entitlements/check"
+    case .resolveContent: return "content/resolve"
+    case .resolvePaywall: return "paywalls/resolve"
+    case .resolveOffering: return "offerings/resolve"
+    case .readHoldings: return "customer-holdings"
+    case .readLedger: return "customer-ledger"
+    case .readBillingInvoice: return "billing/invoices/detail"
+    case .readCreditStatement: return "credit-statements/read"
+    case .quoteBalance: return "balances/quote"
+    case .redeemReward: return "rewards/redeem"
+    case .createReferralCode: return "rewards/referral-code"
+    case .claimRewardProduct: return "rewards/product/claim"
+    case .redeemCoupon: return "offers/redeem"
+    case .listOffers: return "offers"
+    case .grantOffer: return "offers/grant"
+    } }
+    var method: String { switch self {
+    case .bindPushInstallation: return "POST"
+    case .readPushInstallation: return "POST"
+    case .updatePushAddress: return "POST"
+    case .readMessagingPreference: return "POST"
+    case .setMessagingPreference: return "POST"
+    case .getFeatures: return "GET"
+    case .evaluateFeatures: return "POST"
+    case .trackEvents: return "POST"
+    case .restoreNativePurchase: return "POST"
+    case .setupPayment: return "POST"
+    case .readPaymentSetup: return "POST"
+    case .previewAttach: return "POST"
+    case .attach: return "POST"
+    case .readSubscriptionOperation: return "POST"
+    case .previewUpdate: return "POST"
+    case .update: return "POST"
+    case .readSubscriptionUpdate: return "POST"
+    case .readBillingControls: return "POST"
+    case .prepareBillingAuthorization: return "POST"
+    case .confirmBillingAuthorization: return "POST"
+    case .setBillingCoupons: return "POST"
+    case .revokeBillingAuthorization: return "POST"
+    case .listBillingInvoices: return "POST"
+    case .confirmBillingAdjustment: return "POST"
+    case .checkEntitlement: return "POST"
+    case .resolveContent: return "POST"
+    case .resolvePaywall: return "POST"
+    case .resolveOffering: return "POST"
+    case .readHoldings: return "POST"
+    case .readLedger: return "POST"
+    case .readBillingInvoice: return "POST"
+    case .readCreditStatement: return "POST"
+    case .quoteBalance: return "POST"
+    case .redeemReward: return "POST"
+    case .createReferralCode: return "POST"
+    case .claimRewardProduct: return "POST"
+    case .redeemCoupon: return "POST"
+    case .listOffers: return "GET"
+    case .grantOffer: return "POST"
+    } }
+}
+extension IndianaClient {
+    public func bindPushInstallation(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.bindPushInstallation, input: input) }
+    public func readPushInstallation(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.readPushInstallation, input: input) }
+    public func updatePushAddress(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.updatePushAddress, input: input) }
+    public func readMessagingPreference(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.readMessagingPreference, input: input) }
+    public func setMessagingPreference(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.setMessagingPreference, input: input) }
+    public func getFeatures(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.getFeatures, input: input) }
+    public func evaluateFeatures(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.evaluateFeatures, input: input) }
+    public func trackEvents(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.trackEvents, input: input) }
+    public func restoreNativePurchase(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.restoreNativePurchase, input: input) }
+    public func setupPayment(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.setupPayment, input: input) }
+    public func readPaymentSetup(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.readPaymentSetup, input: input) }
+    public func previewAttach(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.previewAttach, input: input) }
+    public func attach(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.attach, input: input) }
+    public func readSubscriptionOperation(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.readSubscriptionOperation, input: input) }
+    public func previewUpdate(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.previewUpdate, input: input) }
+    public func update(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.update, input: input) }
+    public func readSubscriptionUpdate(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.readSubscriptionUpdate, input: input) }
+    public func readBillingControls(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.readBillingControls, input: input) }
+    public func prepareBillingAuthorization(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.prepareBillingAuthorization, input: input) }
+    public func confirmBillingAuthorization(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.confirmBillingAuthorization, input: input) }
+    public func setBillingCoupons(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.setBillingCoupons, input: input) }
+    public func revokeBillingAuthorization(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.revokeBillingAuthorization, input: input) }
+    public func listBillingInvoices(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.listBillingInvoices, input: input) }
+    public func confirmBillingAdjustment(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.confirmBillingAdjustment, input: input) }
+    public func checkEntitlement(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.checkEntitlement, input: input) }
+    public func resolveContent(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.resolveContent, input: input) }
+    public func resolvePaywall(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.resolvePaywall, input: input) }
+    public func resolveOffering(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.resolveOffering, input: input) }
+    public func readHoldings(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.readHoldings, input: input) }
+    public func readLedger(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.readLedger, input: input) }
+    public func readBillingInvoice(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.readBillingInvoice, input: input) }
+    public func readCreditStatement(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.readCreditStatement, input: input) }
+    public func quoteBalance(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.quoteBalance, input: input) }
+    public func redeemReward(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.redeemReward, input: input) }
+    public func createReferralCode(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.createReferralCode, input: input) }
+    public func claimRewardProduct(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.claimRewardProduct, input: input) }
+    public func redeemCoupon(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.redeemCoupon, input: input) }
+    public func listOffers(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.listOffers, input: input) }
+    public func grantOffer(_ input: [String: IndianaJSON]) async throws -> IndianaJSON { try await customerOperation(.grantOffer, input: input) }
+}