RegulaView Operator Reporting API

const BASE = "https://api.regulaview.io";

async function getToken(clientId, clientSecret) {
  const res = await fetch(`${BASE}/v1/auth/token`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ clientId, clientSecret, grantType: "client_credentials" })
  });
  if (!res.ok) throw new Error(`token ${res.status}`);
  return (await res.json()).accessToken; // cache until close to expiresIn
}

using System;
using System.Net.Http;
using System.Net.Http.Json;

var http = new HttpClient { BaseAddress = new Uri("https://api.regulaview.io") };

async Task<string> GetTokenAsync(string clientId, string clientSecret)
{
    var res = await http.PostAsJsonAsync("/v1/auth/token",
        new { clientId, clientSecret, grantType = "client_credentials" });
    res.EnsureSuccessStatusCode();
    var body = await res.Content.ReadFromJsonAsync<TokenResponse>();
    return body!.AccessToken; // cache until close to ExpiresIn
}

record TokenResponse(string AccessToken, string TokenType, int ExpiresIn, string Scope);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

static final HttpClient HTTP = HttpClient.newHttpClient();

static String getToken(String clientId, String clientSecret) throws Exception {
    String body = "{\"clientId\":\"" + clientId + "\",\"clientSecret\":\"" + clientSecret
        + "\",\"grantType\":\"client_credentials\"}";
    HttpResponse<String> res = HTTP.send(
        HttpRequest.newBuilder(URI.create("https://api.regulaview.io/v1/auth/token"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body)).build(),
        HttpResponse.BodyHandlers.ofString());
    return readAccessToken(res.body()); // parse with your JSON library; cache until expiry
}

package client

import (
    "bytes"
    "encoding/json"
    "net/http"
)

const base = "https://api.regulaview.io"

func getToken(clientID, clientSecret string) (string, error) {
    body, _ := json.Marshal(map[string]string{
        "clientId":     clientID,
        "clientSecret": clientSecret,
        "grantType":    "client_credentials",
    })
    res, err := http.Post(base+"/v1/auth/token", "application/json", bytes.NewReader(body))
    if err != nil {
        return "", err
    }
    defer res.Body.Close()
    var out struct {
        AccessToken string `json:"accessToken"`
    }
    if err := json.NewDecoder(res.Body).Decode(&out); err != nil {
        return "", err
    }
    return out.AccessToken, nil // cache until expiresIn
}

const day = "2026-04-30"; // UTC day of the transactions you are about to sign
const res = await fetch(`https://api.regulaview.io/v1/integrity/manifests/${day}/signing-key`, {
  headers: { Authorization: `Bearer ${token}` }
});
const key = await res.json(); // { keyId, secretBase64, algorithm, ... }

var day = "2026-04-30"; // UTC day of the transactions you are about to sign
using var http = new HttpClient();
using var req = new HttpRequestMessage(HttpMethod.Get,
    $"https://api.regulaview.io/v1/integrity/manifests/{day}/signing-key");
req.Headers.Authorization = new("Bearer", token);
var res = await http.SendAsync(req);
res.EnsureSuccessStatusCode();
var key = await res.Content.ReadFromJsonAsync<SigningKey>();

String day = "2026-04-30"; // UTC day of the transactions you are about to sign
HttpResponse<String> res = HttpClient.newHttpClient().send(
    HttpRequest.newBuilder(URI.create(
        "https://api.regulaview.io/v1/integrity/manifests/" + day + "/signing-key"))
        .header("Authorization", "Bearer " + token).GET().build(),
    HttpResponse.BodyHandlers.ofString());
// res.body() holds the signing-key JSON: { "keyId": ..., "secretBase64": ..., ... }

day := "2026-04-30" // UTC day of the transactions you are about to sign
req, _ := http.NewRequest("GET",
    "https://api.regulaview.io/v1/integrity/manifests/"+day+"/signing-key", nil)
req.Header.Set("Authorization", "Bearer "+token)
res, err := http.DefaultClient.Do(req)
// decode res.Body into your SigningKey struct

const crypto = require("crypto");

function signTransaction(key, tx) {
  const type = { Wager: 0, Payout: 1, Adjustment: 2, Void: 3, Refund: 4, Deposit: 5, Withdrawal: 6 }[tx.type];
  const product = { OnlineCasino: 0, PhysicalCasino: 1, RetailGambling: 2, SportsBetting: 3, VirtualGames: 4, Lotto: 5, InstantWin: 6, Keno: 7, Bingo: 8, GamingMachine: 9, Jackpot: 10, ParimutuelRacing: 11, MobileGambling: 12, Poker: 13, VirtualSports: 14, ScheduledGames: 15, Other: 99 }[tx.product ?? "Other"];
  const canonical = [
    key.keyId,
    tx.deviceExternalId ?? "",
    tx.externalId,
    type,
    product,
    Number(tx.amount).toFixed(4),
    tx.currency,
    new Date(tx.occurredAtUtc).getTime(),
    tx.chainReference ?? "",
    tx.correlationId ?? ""
  ].join("|");

  return crypto.createHmac("sha256", Buffer.from(key.secretBase64, "base64"))
    .update(canonical, "utf8")
    .digest("hex");
}

using System;
using System.Globalization;
using System.Security.Cryptography;
using System.Text;

// type and product use the integer codes from the signing-value table above.
static string SignTransaction(
    string keyId, string secretBase64, string deviceExternalId, string externalId,
    int type, int product, decimal amount, string currency,
    DateTimeOffset occurredAtUtc, string chainReference, string correlationId)
{
    var canonical = string.Join("|",
        keyId,
        deviceExternalId ?? "",
        externalId,
        type,
        product,
        amount.ToString("F4", CultureInfo.InvariantCulture),
        currency,
        occurredAtUtc.ToUnixTimeMilliseconds(),
        chainReference ?? "",
        correlationId ?? "");

    using var hmac = new HMACSHA256(Convert.FromBase64String(secretBase64));
    var hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(canonical));
    return Convert.ToHexString(hash).ToLowerInvariant();
}

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.nio.charset.StandardCharsets;
import java.time.Instant;
import java.util.Base64;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

// type and product use the integer codes from the signing-value table above.
static String signTransaction(
        String keyId, String secretBase64, String deviceExternalId, String externalId,
        int type, int product, BigDecimal amount, String currency,
        Instant occurredAtUtc, String chainReference, String correlationId) throws Exception {

    String canonical = String.join("|",
        keyId,
        deviceExternalId == null ? "" : deviceExternalId,
        externalId,
        Integer.toString(type),
        Integer.toString(product),
        amount.setScale(4, RoundingMode.HALF_UP).toPlainString(),
        currency,
        Long.toString(occurredAtUtc.toEpochMilli()),
        chainReference == null ? "" : chainReference,
        correlationId == null ? "" : correlationId);

    Mac mac = Mac.getInstance("HmacSHA256");
    mac.init(new SecretKeySpec(Base64.getDecoder().decode(secretBase64), "HmacSHA256"));
    byte[] hash = mac.doFinal(canonical.getBytes(StandardCharsets.UTF_8));
    StringBuilder hex = new StringBuilder(hash.length * 2);
    for (byte b : hash) hex.append(String.format("%02x", b));
    return hex.toString();
}

package signing

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/base64"
    "encoding/hex"
    "strconv"
    "strings"
    "time"
)

// typeCode and productCode use the integer codes from the signing-value table above.
func SignTransaction(
    keyID, secretBase64, deviceExternalID, externalID string,
    typeCode, productCode int, amount float64, currency string,
    occurredAtUtc time.Time, chainReference, correlationID string,
) (string, error) {
    secret, err := base64.StdEncoding.DecodeString(secretBase64)
    if err != nil {
        return "", err
    }
    canonical := strings.Join([]string{
        keyID,
        deviceExternalID,
        externalID,
        strconv.Itoa(typeCode),
        strconv.Itoa(productCode),
        strconv.FormatFloat(amount, 'f', 4, 64),
        currency,
        strconv.FormatInt(occurredAtUtc.UnixMilli(), 10),
        chainReference,
        correlationID,
    }, "|")

    mac := hmac.New(sha256.New, secret)
    mac.Write([]byte(canonical))
    return hex.EncodeToString(mac.Sum(nil)), nil
}

const day = tx.occurredAtUtc.slice(0, 10); // UTC day of the transaction
const keyRes = await fetch(`https://api.regulaview.io/v1/integrity/manifests/${day}/signing-key`, {
  headers: { Authorization: `Bearer ${token}` }
});
const key = await keyRes.json();

const res = await fetch("https://api.regulaview.io/v1/ingest/transactions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${token}`,
    "Content-Type": "application/json",
    "X-RegulaView-Signature": signTransaction(key, tx), // from Transaction signing
    "Idempotency-Key": tx.externalId
  },
  body: JSON.stringify(tx)
});
const receipt = await res.json();

using var http = new HttpClient();
var day = tx.OccurredAtUtc.ToString("yyyy-MM-dd"); // UTC day of the transaction

using var keyReq = new HttpRequestMessage(HttpMethod.Get,
    $"https://api.regulaview.io/v1/integrity/manifests/{day}/signing-key");
keyReq.Headers.Authorization = new("Bearer", token);
var key = await (await http.SendAsync(keyReq)).Content.ReadFromJsonAsync<SigningKey>();

using var req = new HttpRequestMessage(HttpMethod.Post, "https://api.regulaview.io/v1/ingest/transactions");
req.Headers.Authorization = new("Bearer", token);
req.Headers.Add("X-RegulaView-Signature", SignTransaction(key, tx)); // from Transaction signing
req.Headers.Add("Idempotency-Key", tx.ExternalId);
req.Content = JsonContent.Create(tx);
var res = await http.SendAsync(req);
res.EnsureSuccessStatusCode();

HttpClient http = HttpClient.newHttpClient();
ObjectMapper mapper = new ObjectMapper(); // Java has no built-in JSON; e.g. Jackson
String day = tx.occurredAtUtc.substring(0, 10); // UTC day of the transaction

HttpResponse<String> keyRes = http.send(
    HttpRequest.newBuilder(URI.create(
        "https://api.regulaview.io/v1/integrity/manifests/" + day + "/signing-key"))
        .header("Authorization", "Bearer " + token).GET().build(),
    HttpResponse.BodyHandlers.ofString());
SigningKey key = mapper.readValue(keyRes.body(), SigningKey.class);

HttpResponse<String> res = http.send(
    HttpRequest.newBuilder(URI.create("https://api.regulaview.io/v1/ingest/transactions"))
        .header("Authorization", "Bearer " + token)
        .header("Content-Type", "application/json")
        .header("X-RegulaView-Signature", signTransaction(key, tx)) // from Transaction signing
        .header("Idempotency-Key", tx.externalId)
        .POST(HttpRequest.BodyPublishers.ofString(mapper.writeValueAsString(tx))).build(),
    HttpResponse.BodyHandlers.ofString());

day := tx.OccurredAtUtc.UTC().Format("2006-01-02") // UTC day of the transaction

keyReq, _ := http.NewRequest("GET",
    "https://api.regulaview.io/v1/integrity/manifests/"+day+"/signing-key", nil)
keyReq.Header.Set("Authorization", "Bearer "+token)
keyRes, _ := http.DefaultClient.Do(keyReq)
var key SigningKey
json.NewDecoder(keyRes.Body).Decode(&key)

sig, _ := SignTransaction(key, tx) // from Transaction signing
txJSON, _ := json.Marshal(tx)
req, _ := http.NewRequest("POST", "https://api.regulaview.io/v1/ingest/transactions", bytes.NewReader(txJSON))
req.Header.Set("Authorization", "Bearer "+token)
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-RegulaView-Signature", sig)
req.Header.Set("Idempotency-Key", tx.ExternalID)
res, err := http.DefaultClient.Do(req)

// key fetched as in "Retrieve the daily signing key"; sign each item individually
const items = transactions.map(tx => ({
  ...tx,
  idempotencyKey: tx.externalId,
  signature: signTransaction(key, tx) // from Transaction signing
}));

const res = await fetch("https://api.regulaview.io/v1/ingest/transactions/batch", {
  method: "POST",
  headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
  body: JSON.stringify({ transactions: items })
});
const result = await res.json();

// key fetched as in "Retrieve the daily signing key"; sign each item individually
var items = transactions
    .Select(tx => tx with { IdempotencyKey = tx.ExternalId, Signature = SignTransaction(key, tx) })
    .ToArray();

using var http = new HttpClient();
using var req = new HttpRequestMessage(HttpMethod.Post, "https://api.regulaview.io/v1/ingest/transactions/batch");
req.Headers.Authorization = new("Bearer", token);
req.Content = JsonContent.Create(new { transactions = items });
var res = await http.SendAsync(req);
res.EnsureSuccessStatusCode();
var result = await res.Content.ReadFromJsonAsync<BatchResult>();

// key fetched as in "Retrieve the daily signing key"; sign each item individually
for (Tx tx : transactions) {
    tx.idempotencyKey = tx.externalId;
    tx.signature = signTransaction(key, tx); // from Transaction signing
}
String body = mapper.writeValueAsString(Map.of("transactions", transactions));
HttpResponse<String> res = HttpClient.newHttpClient().send(
    HttpRequest.newBuilder(URI.create("https://api.regulaview.io/v1/ingest/transactions/batch"))
        .header("Authorization", "Bearer " + token)
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString(body)).build(),
    HttpResponse.BodyHandlers.ofString());

// key fetched as in "Retrieve the daily signing key"; sign each item individually
for i := range transactions {
    transactions[i].IdempotencyKey = transactions[i].ExternalID
    transactions[i].Signature, _ = SignTransaction(key, transactions[i])
}
body, _ := json.Marshal(map[string]any{"transactions": transactions})
req, _ := http.NewRequest("POST", "https://api.regulaview.io/v1/ingest/transactions/batch", bytes.NewReader(body))
req.Header.Set("Authorization", "Bearer "+token)
req.Header.Set("Content-Type", "application/json")
res, err := http.DefaultClient.Do(req)

const res = await fetch("https://api.regulaview.io/v1/tax/declarations", {
  method: "POST",
  headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
  body: JSON.stringify({ day: "2026-04-30", grossWagers: 125000.00, payouts: 91000.00, declaredTax: 5100.00 })
});
const summary = await res.json();

using var http = new HttpClient();
using var req = new HttpRequestMessage(HttpMethod.Post, "https://api.regulaview.io/v1/tax/declarations");
req.Headers.Authorization = new("Bearer", token);
req.Content = JsonContent.Create(new { day = "2026-04-30", grossWagers = 125000.00m, payouts = 91000.00m, declaredTax = 5100.00m });
var res = await http.SendAsync(req);
res.EnsureSuccessStatusCode();
var summary = await res.Content.ReadFromJsonAsync<TaxSummary>();

String body = "{\"day\":\"2026-04-30\",\"grossWagers\":125000.00,\"payouts\":91000.00,\"declaredTax\":5100.00}";
HttpResponse<String> res = HttpClient.newHttpClient().send(
    HttpRequest.newBuilder(URI.create("https://api.regulaview.io/v1/tax/declarations"))
        .header("Authorization", "Bearer " + token)
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString(body)).build(),
    HttpResponse.BodyHandlers.ofString());

body := []byte(`{"day":"2026-04-30","grossWagers":125000.00,"payouts":91000.00,"declaredTax":5100.00}`)
req, _ := http.NewRequest("POST", "https://api.regulaview.io/v1/tax/declarations", bytes.NewReader(body))
req.Header.Set("Authorization", "Bearer "+token)
req.Header.Set("Content-Type", "application/json")
res, err := http.DefaultClient.Do(req)

const res = await fetch("https://api.regulaview.io/v1/recon/cashier-totals", {
  method: "POST",
  headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
  body: JSON.stringify({ day: "2026-04-30", cashIn: 48000.00, cashOut: 36500.00, outletReference: "SHOP-014", source: "cashier-close-v2" })
});
const stored = await res.json();

using var http = new HttpClient();
using var req = new HttpRequestMessage(HttpMethod.Post, "https://api.regulaview.io/v1/recon/cashier-totals");
req.Headers.Authorization = new("Bearer", token);
req.Content = JsonContent.Create(new { day = "2026-04-30", cashIn = 48000.00m, cashOut = 36500.00m, outletReference = "SHOP-014", source = "cashier-close-v2" });
var res = await http.SendAsync(req);
res.EnsureSuccessStatusCode();
var stored = await res.Content.ReadFromJsonAsync<CashierTotals>();

String body = "{\"day\":\"2026-04-30\",\"cashIn\":48000.00,\"cashOut\":36500.00,\"outletReference\":\"SHOP-014\",\"source\":\"cashier-close-v2\"}";
HttpResponse<String> res = HttpClient.newHttpClient().send(
    HttpRequest.newBuilder(URI.create("https://api.regulaview.io/v1/recon/cashier-totals"))
        .header("Authorization", "Bearer " + token)
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString(body)).build(),
    HttpResponse.BodyHandlers.ofString());

body := []byte(`{"day":"2026-04-30","cashIn":48000.00,"cashOut":36500.00,"outletReference":"SHOP-014","source":"cashier-close-v2"}`)
req, _ := http.NewRequest("POST", "https://api.regulaview.io/v1/recon/cashier-totals", bytes.NewReader(body))
req.Header.Set("Authorization", "Bearer "+token)
req.Header.Set("Content-Type", "application/json")
res, err := http.DefaultClient.Do(req)

const state = await api("POST", `/v1/devices/external/${deviceExternalId}/heartbeat`,
  { configurationVersion: "2026.04.30.1", configurationHash: "b6e4f8b7266f4d2e998c7f2a0f1be75c", gameEnabled: true, health: "Healthy" });

var state = await Api<HeartbeatState>(HttpMethod.Post, $"/v1/devices/external/{deviceExternalId}/heartbeat",
    new { configurationVersion = "2026.04.30.1", configurationHash = "b6e4f8b7266f4d2e998c7f2a0f1be75c", gameEnabled = true, health = "Healthy" });

HttpResponse<String> state = api("POST", "/v1/devices/external/" + deviceExternalId + "/heartbeat", toJson(heartbeat), null);

body, _ := json.Marshal(heartbeat)
state, err := api("POST", "/v1/devices/external/"+deviceExternalID+"/heartbeat", body, nil)

const event = await api("POST", "/v1/rg/events", {
  type: "LimitBreach", severity: "High", deviceExternalId: "terminal-alpha-07",
  pseudonymousPlayerRef: "player-hash-91b2", summary: "Daily loss threshold breached",
  evidence: "loss=500;threshold=500;currency=EUR"
});

var ev = await Api<RgEventAck>(HttpMethod.Post, "/v1/rg/events", new {
    type = "LimitBreach", severity = "High", deviceExternalId = "terminal-alpha-07",
    pseudonymousPlayerRef = "player-hash-91b2", summary = "Daily loss threshold breached",
    evidence = "loss=500;threshold=500;currency=EUR"
});

HttpResponse<String> ev = api("POST", "/v1/rg/events", toJson(rgEvent), null);

body, _ := json.Marshal(rgEvent)
ev, err := api("POST", "/v1/rg/events", body, nil)

const correction = await api("POST", "/v1/corrections", {
  originalExternalId: "OP-20260430-000001",
  reason: "Operator settlement system corrected payout amount after manual review.",
  payloadDiff: [{ path: "/amount", from: 5.00, to: 4.50, reason: "Manual settlement review corrected the amount." }]
});

var correction = await Api<CorrectionAck>(HttpMethod.Post, "/v1/corrections", new {
    originalExternalId = "OP-20260430-000001",
    reason = "Operator settlement system corrected payout amount after manual review.",
    payloadDiff = new[] { new { path = "/amount", from = 5.00m, to = 4.50m, reason = "Manual settlement review corrected the amount." } }
});

HttpResponse<String> correction = api("POST", "/v1/corrections", toJson(request), null);

body, _ := json.Marshal(request)
correction, err := api("POST", "/v1/corrections", body, nil)

const crypto = require("crypto");
// key fetched as in "Retrieve the daily signing key"
const canonical = [
  key.keyId, report.day, report.currency,
  report.declaredCount, report.declaredFirstSequence, report.declaredLastSequence,
  report.declaredWageredAmount.toFixed(4), report.declaredPaidOutAmount.toFixed(4)
].join("|");
report.signature = crypto.createHmac("sha256", Buffer.from(key.secretBase64, "base64"))
  .update(canonical, "utf8").digest("hex");

const res = await fetch("https://api.regulaview.io/v1/ingest/end-of-day", {
  method: "POST",
  headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
  body: JSON.stringify(report)
});
const receipt = await res.json();

// key fetched as in "Retrieve the daily signing key"
var canonical = string.Join("|",
    key.KeyId, report.Day, report.Currency,
    report.DeclaredCount, report.DeclaredFirstSequence, report.DeclaredLastSequence,
    report.DeclaredWageredAmount.ToString("F4", CultureInfo.InvariantCulture),
    report.DeclaredPaidOutAmount.ToString("F4", CultureInfo.InvariantCulture));
using var hmac = new HMACSHA256(Convert.FromBase64String(key.SecretBase64));
report.Signature = Convert.ToHexString(hmac.ComputeHash(Encoding.UTF8.GetBytes(canonical))).ToLowerInvariant();

using var http = new HttpClient();
using var req = new HttpRequestMessage(HttpMethod.Post, "https://api.regulaview.io/v1/ingest/end-of-day");
req.Headers.Authorization = new("Bearer", token);
req.Content = JsonContent.Create(report);
var res = await http.SendAsync(req);
res.EnsureSuccessStatusCode();
var receipt = await res.Content.ReadFromJsonAsync<EodReceipt>();

// key fetched as in "Retrieve the daily signing key"
String canonical = String.join("|",
    key.keyId, report.day, report.currency,
    Long.toString(report.declaredCount),
    Long.toString(report.declaredFirstSequence),
    Long.toString(report.declaredLastSequence),
    report.declaredWageredAmount.setScale(4, RoundingMode.HALF_UP).toPlainString(),
    report.declaredPaidOutAmount.setScale(4, RoundingMode.HALF_UP).toPlainString());
Mac mac = Mac.getInstance("HmacSHA256");
mac.init(new SecretKeySpec(Base64.getDecoder().decode(key.secretBase64), "HmacSHA256"));
report.signature = HexFormat.of().formatHex(mac.doFinal(canonical.getBytes(StandardCharsets.UTF_8)));

HttpResponse<String> res = HttpClient.newHttpClient().send(
    HttpRequest.newBuilder(URI.create("https://api.regulaview.io/v1/ingest/end-of-day"))
        .header("Authorization", "Bearer " + token)
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString(mapper.writeValueAsString(report))).build(),
    HttpResponse.BodyHandlers.ofString());

// key fetched as in "Retrieve the daily signing key"
canonical := strings.Join([]string{
    key.KeyID, report.Day, report.Currency,
    strconv.FormatInt(report.DeclaredCount, 10),
    strconv.FormatInt(report.DeclaredFirstSequence, 10),
    strconv.FormatInt(report.DeclaredLastSequence, 10),
    strconv.FormatFloat(report.DeclaredWageredAmount, 'f', 4, 64),
    strconv.FormatFloat(report.DeclaredPaidOutAmount, 'f', 4, 64),
}, "|")
secret, _ := base64.StdEncoding.DecodeString(key.SecretBase64)
m := hmac.New(sha256.New, secret)
m.Write([]byte(canonical))
report.Signature = hex.EncodeToString(m.Sum(nil))

body, _ := json.Marshal(report)
req, _ := http.NewRequest("POST", "https://api.regulaview.io/v1/ingest/end-of-day", bytes.NewReader(body))
req.Header.Set("Authorization", "Bearer "+token)
req.Header.Set("Content-Type", "application/json")
res, err := http.DefaultClient.Do(req)

const outcomes = await api("GET", "/v1/reconciliation?from=2026-04-01&to=2026-04-30");

var outcomes = await Api<ReconOutcome[]>(HttpMethod.Get, "/v1/reconciliation?from=2026-04-01&to=2026-04-30");

HttpResponse<String> outcomes = api("GET", "/v1/reconciliation?from=2026-04-01&to=2026-04-30", null, null);

outcomes, err := api("GET", "/v1/reconciliation?from=2026-04-01&to=2026-04-30", nil, nil)

const manifest = await api("GET", "/v1/integrity/aggregates/manifest?day=2026-04-30");

var manifest = await Api<Manifest>(HttpMethod.Get, "/v1/integrity/aggregates/manifest?day=2026-04-30");

HttpResponse<String> manifest = api("GET", "/v1/integrity/aggregates/manifest?day=2026-04-30", null, null);

manifest, err := api("GET", "/v1/integrity/aggregates/manifest?day=2026-04-30", nil, nil)

const proof = await api("GET", `/v1/integrity/aggregates/proof?bucketId=${bucketId}`);

var proof = await Api<InclusionProof>(HttpMethod.Get, $"/v1/integrity/aggregates/proof?bucketId={bucketId}");

HttpResponse<String> proof = api("GET", "/v1/integrity/aggregates/proof?bucketId=" + bucketId, null, null);

proof, err := api("GET", "/v1/integrity/aggregates/proof?bucketId="+bucketID, nil, nil)

const result = await api("GET", "/v1/integrity/aggregates/verify-chain?day=2026-04-30");

var result = await Api<ChainVerification>(HttpMethod.Get, "/v1/integrity/aggregates/verify-chain?day=2026-04-30");

HttpResponse<String> result = api("GET", "/v1/integrity/aggregates/verify-chain?day=2026-04-30", null, null);

result, err := api("GET", "/v1/integrity/aggregates/verify-chain?day=2026-04-30", nil, nil)