Billing and settlement

import { initialize } from "@expys/sdk";

const orgApiKey = process.env.EXPYS_ORG_API_KEY;
if (!orgApiKey) {
  throw new Error(
    "Set EXPYS_ORG_API_KEY (your secret Org-API-Key, e.g. expys_live_...). " +
      "Run this on a backend only, never in a client app.",
  );
}

const expys = initialize({
  baseUrl: process.env.EXPYS_BASE_URL,
  environment: "sandbox",
  token: orgApiKey,
});

async function main(): Promise<void> {
  const account = await expys.balance();

  console.log(`settlement mode: ${account.settlementMode}`);
  console.log(`balance: ${account.balance} points`);

  if (account.settlementMode === "ORG_POOL") {
    // Spendable headroom includes the credit limit: a postpaid org may overdraw
    // to -creditLimit before redemptions are refused with INSUFFICIENT_ORG_POINTS.
    const spendable = account.balance + account.creditLimit;
    console.log(`spendable now: ${spendable} points`);
    console.log(`lifetime spent from the pool: ${account.lifetimeSpent}`);

    if (spendable <= 0) {
      console.warn(
        "Pool exhausted - redemptions will be refused until topped up.",
      );
    }
  } else {
    // MEMBER_WALLET: this balance funds the points you credit to VIPs, and each
    // VIP's own wallet is what a redemption debits.
    console.log(
      "VIP redemptions debit each member's wallet, not this balance.",
    );
  }
}

import ExpysSDK
import Foundation

@main
struct BalanceExample {
  static func main() async throws {
    let environment = ProcessInfo.processInfo.environment
    guard let orgApiKey = environment["EXPYS_ORG_API_KEY"] else {
      fatalError(
        "Set EXPYS_ORG_API_KEY (your secret Org-API-Key, e.g. expys_live_...). "
          + "Run this on a backend only, never in a client app.")
    }
    let baseURL =
      environment["EXPYS_BASE_URL"].flatMap(URL.init(string:))
      ?? ExpysConfiguration.defaultBaseURL

    let client = ExpysClient(
      configuration: ExpysConfiguration(token: orgApiKey, environment: .sandbox, baseURL: baseURL)
    )

    let account = try await client.balance()

    print("settlement mode: \(account.settlementMode.rawValue)")
    print("balance: \(account.balance) points")

    switch account.settlementMode {
    case .orgPool:
      // Spendable headroom includes the credit limit: a postpaid org may overdraw
      // to -creditLimit before redemptions are refused with INSUFFICIENT_ORG_POINTS.
      let spendable = account.balance + account.creditLimit
      print("spendable now: \(spendable) points")
      print("lifetime spent from the pool: \(account.lifetimeSpent)")

      if spendable <= 0 {
        print("Pool exhausted - redemptions will be refused until topped up.")
      }
    case .memberWallet:
      // memberWallet: this balance funds the points you credit to VIPs, and each
      // VIP's own wallet is what a redemption debits.
      print("VIP redemptions debit each member's wallet, not this balance.")
    }
  }
}

package com.expys.sdk.examples.balance

import com.expys.sdk.ExpysClient
import com.expys.sdk.ExpysConfiguration
import com.expys.sdk.ExpysEnvironment
import com.expys.sdk.models.GetBalanceResponse
import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
  val orgApiKey = System.getenv("EXPYS_ORG_API_KEY")
    ?: error(
      "Set EXPYS_ORG_API_KEY (your secret Org-API-Key, e.g. expys_live_...). " +
        "Run this on a backend only, never in a client app.",
    )

  val client = ExpysClient.create(
    ExpysConfiguration(
      token = orgApiKey,
      environment = ExpysEnvironment.SANDBOX,
      baseUrl = System.getenv("EXPYS_BASE_URL") ?: ExpysConfiguration.DEFAULT_BASE_URL,
    ),
  )

  val account = client.balance()

  println("settlement mode: ${account.settlementMode.value}")
  println("balance: ${account.balance} points")

  when (account.settlementMode) {
    GetBalanceResponse.SettlementMode.ORG_POOL -> {
      // Spendable headroom includes the credit limit: a postpaid org may overdraw
      // to -creditLimit before redemptions are refused with INSUFFICIENT_ORG_POINTS.
      val spendable = account.balance + account.creditLimit
      println("spendable now: $spendable points")
      println("lifetime spent from the pool: ${account.lifetimeSpent}")

      if (spendable <= 0) {
        println("Pool exhausted - redemptions will be refused until topped up.")
      }
    }
    GetBalanceResponse.SettlementMode.MEMBER_WALLET -> {
      // MEMBER_WALLET: this balance funds the points you credit to VIPs, and each
      // VIP's own wallet is what a redemption debits.
      println("VIP redemptions debit each member's wallet, not this balance.")
    }
  }
}