SDKs

# Python ≥ 3.11 — a system/Homebrew Python refuses a bare `pip install`
# (PEP 668), so install into a virtualenv:
python3 -m venv .venv && source .venv/bin/activate   # Windows: .venv\Scripts\activate
pip install allus-company-data

// Node ≥ 18 — dual ESM + CommonJS, bundled .d.ts types
npm install @allus-fyi/company-data

// Go ≥ 1.26 — `go get` adds to an existing module:
go get github.com/allus-fyi/company-data-go@latest
// import companydata "github.com/allus-fyi/company-data-go/companydata"

// Starting from scratch instead of an existing module?
//   mkdir my-integration && cd my-integration
//   go mod init my-integration
//   go get github.com/allus-fyi/company-data-go@latest

// .NET 8.0+, namespace Allus.CompanyData — not on NuGet yet; reference it from the GitHub repo:
git clone https://github.com/allus-fyi/company-data-csharp.git
dotnet add reference company-data-csharp/src/Allus.CompanyData/Allus.CompanyData.csproj

// Java 21+, package fyi.allme.allus.companydata — not on Maven Central yet; build from the GitHub repo:
// git clone https://github.com/allus-fyi/company-data-java.git
// cd company-data-java && mvn -q install      // installs fyi.allme.allus:company-data:0.1.0 to your ~/.m2
// then depend on it:
//   Maven:  <dependency><groupId>fyi.allme.allus</groupId><artifactId>company-data</artifactId><version>0.1.0</version></dependency>
//   Gradle: implementation 'fyi.allme.allus:company-data:0.1.0'

// PHP ≥ 8.1 (ext-openssl, ext-json) — PSR-4 autoloaded
composer require allus/company-data

from allus_company_data import Client

client = Client.from_config("allus.json")
# or: Client.from_env()

import { Client } from '@allus-fyi/company-data';

const client = Client.fromConfig('allus.json');
// or: Client.fromEnv()

client, err := companydata.FromConfig("allus.json")
if err != nil {
    log.Fatal(err)
}
// or: companydata.FromEnv()

using Allus.CompanyData;

using var client = Client.FromConfig("allus.json");
// or: Client.FromEnv() — Client is IDisposable (holds the in-memory key)

import fyi.allme.allus.companydata.Client;

Client client = Client.fromConfig("allus.json");
// or: Client.fromEnv()

use Allus\CompanyData\Client;

$client = Client::fromConfig('allus.json');
// or: Client::fromEnv()

for conn in client.connections():
    print(conn.display_name, conn.person_id)
    for slug, val in conn.values.items():
        print(f"  {slug} = {val.value!r}  (live={val.live}, updated={val.updated_at})")

# one connection by id:
conn = client.connection("019xxxxxxxxxxxxxxxxxxxxxxxxx")
email = conn.values["work_email"].value        # "alice@acme.com"

for await (const conn of client.connections()) {
  console.log(conn.displayName, conn.personId);
  for (const [slug, val] of Object.entries(conn.values)) {
    console.log(`  ${slug} = ${JSON.stringify(val.value)} (live=${val.live}, updated=${val.updatedAt})`);
  }
}

// one connection by id:
const conn = await client.connection('019xxxxxxxxxxxxxxxxxxxxxxxxx');
const email = conn.values['work_email'].value;   // "alice@acme.com"

conns, errs := client.Connections(ctx, 100, 0)   // page size, offset — lazily auto-paged
for conn := range conns {
    fmt.Println(conn.DisplayName, conn.PersonID)
    for slug, val := range conn.Values {
        fmt.Printf("  %s = %v (live=%v, updated=%v)\n", slug, val.Value, val.Live, val.UpdatedAt)
    }
}
if err := <-errs; err != nil {
    log.Fatal(err)
}
// or eagerly: client.ConnectionsList(ctx, 100, 0)

conn, err := client.Connection(ctx, "019xxxxxxxxxxxxxxxxxxxxxxxxx")
email := conn.Values["work_email"].Value.(string)   // "alice@acme.com"

await foreach (var conn in client.ConnectionsAsync())
{
    Console.WriteLine($"{conn.DisplayName} {conn.PersonId}");
    foreach (var (slug, val) in conn.Values)
        Console.WriteLine($"  {slug} = {val.ValueObj} (live={val.Live}, updated={val.UpdatedAt})");
}

var conn = await client.ConnectionAsync("019xxxxxxxxxxxxxxxxxxxxxxxxx");
var email = (string?)conn.Values["work_email"].ValueObj;   // "alice@acme.com"

for (Connection conn : client.connections()) {
    System.out.println(conn.displayName() + " " + conn.personId());
    conn.values().forEach((slug, val) ->
        System.out.printf("  %s = %s (live=%s, updated=%s)%n",
            slug, val.value(), val.live(), val.updatedAt()));
}

Connection conn = client.connection("019xxxxxxxxxxxxxxxxxxxxxxxxx");
Object email = conn.values().get("work_email").value();   // "alice@acme.com"

foreach ($client->connections() as $conn) {
    echo $conn->displayName, ' ', $conn->personId, PHP_EOL;
    foreach ($conn->values as $slug => $val) {
        printf("  %s = %s (live=%s)\n", $slug,
            is_scalar($val->value) ? (string) $val->value : json_encode($val->value),
            $val->live ? 'true' : 'false');
    }
}

$conn  = $client->connection('019xxxxxxxxxxxxxxxxxxxxxxxxx');
$email = $conn->values['work_email']->value;   // "alice@acme.com"

# end one of your service's connections (the service side of a disconnect):
client.delete_connection("019xxxxxxxxxxxxxxxxxxxxxxxxx")

// end one of your service's connections (the service side of a disconnect):
await client.deleteConnection('019xxxxxxxxxxxxxxxxxxxxxxxxx');

// end one of your service's connections (the service side of a disconnect):
err := client.DeleteConnection(ctx, "019xxxxxxxxxxxxxxxxxxxxxxxxx")

// end one of your service's connections (the service side of a disconnect):
await client.DeleteConnectionAsync("019xxxxxxxxxxxxxxxxxxxxxxxxx");

// end one of your service's connections (the service side of a disconnect):
client.deleteConnection("019xxxxxxxxxxxxxxxxxxxxxxxxx");

// end one of your service's connections (the service side of a disconnect):
$client->deleteConnection('019xxxxxxxxxxxxxxxxxxxxxxxxx');

email = conn.values["work_email"]
if email.verified:            # cryptographically bound to this exact value
    trust_it(email.value)

const email = conn.values["work_email"];
if (email.verified) trustIt(email.value);

email := conn.Values["work_email"]
if email.Verified {                    // cryptographically bound to this exact value
    trustIt(email.Value.(string))
}

var email = conn.Values["work_email"];
if (email.Verified)                    // cryptographically bound to this exact value
    TrustIt((string?)email.ValueObj);

Value email = conn.values().get("work_email");
if (email.verified())                  // cryptographically bound to this exact value
    trustIt(email.value());

$email = $conn->values['work_email'];
if ($email->verified) {                // cryptographically bound to this exact value
    trustIt($email->value);
}

# Broadcast a plaintext doc to every connection of the service
client.create_document(name="Terms v3", payload_kind="json",
                       json_value={"url": "https://x/terms.pdf", "version": "3"})

# Per-person doc — AUTO-encrypted to the recipient (any is_private), no key arg
doc = client.create_document(
    name="Your invoice", payload_kind="json", connection_id=conn_id,
    json_value={"amount": "42.00", "due": "2026-07-01"},
    metadata={"can_be_cancelled_in_app": True},
)
# A per-person FILE doc (the bytes are encrypted automatically too):
client.create_document(name="Contract.pdf", payload_kind="file",
                       person_user_id=pid, file_bytes=pdf, file_mime="application/pdf")

# A CONTRACT — must be per-person; status is derived (ready_to_sign here)
contract = client.create_document(
    name="Service agreement", payload_kind="file", connection_id=conn_id,
    kind="agreement", requires_signature=True,
    file_bytes=pdf, file_mime="application/pdf")
# Observe the person's sign/accept/cancel via the changes pump (action field).
# Read the audit trail (each entry: action, method, content_sha256, plain_sha256,
# signer_first_name, signer_last_name, signer_name_verified, created_at):
signed = client.document(contract.id)
print(signed.signatures)
print(signed.sealed_at)  # None until the completing act seals it

client.list_documents(status="active")
client.update_document_status(doc.id, "ended")
client.update_document_metadata(doc.id, name="Invoice #1001")
client.delete_document(doc.id)

// Broadcast a plaintext doc
await client.createDocument({ name: 'Terms v3', payloadKind: 'json',
  jsonValue: { url: 'https://x/terms.pdf', version: '3' } });

// Per-person doc — AUTO-encrypted to the recipient (any isPrivate), no key arg
const doc = await client.createDocument({
  name: 'Your invoice', payloadKind: 'json', connectionId: connId,
  jsonValue: { amount: '42.00', due: '2026-07-01' },
  metadata: { can_be_cancelled_in_app: true },
});
await client.createDocument({ name: 'Contract.pdf', payloadKind: 'file',
  personUserId: pid, fileBytes: pdf, fileMime: 'application/pdf' });

// A CONTRACT — must be per-person; status is derived (ready_to_sign here)
const contract = await client.createDocument({
  name: 'Service agreement', payloadKind: 'file', connectionId: connId,
  kind: 'agreement', requiresSignature: true,
  fileBytes: pdf, fileMime: 'application/pdf' });
// Observe the person's sign/accept/cancel via the changes pump (action field).
// signatures is an untyped list of raw maps, keyed exactly as the wire sends
// them (snake_case): each entry is { action, method, content_sha256,
// plain_sha256, signer_first_name, signer_last_name, signer_name_verified,
// created_at }.
const signed = await client.document(contract.id);
console.log(signed.signatures);
console.log(signed.sealedAt);  // null until the completing act seals it

await client.listDocuments({ status: 'active' });
await client.updateDocumentStatus(doc.id, 'ended');
await client.updateDocumentMetadata(doc.id, { name: 'Invoice #1001' });
await client.deleteDocument(doc.id);

// Broadcast a plaintext doc
client.CreateDocument(ctx, companydata.CreateDocumentOptions{
    Name: "Terms v3", PayloadKind: "json",
    JSONValue: map[string]any{"url": "https://x/terms.pdf", "version": "3"}})

// Per-person doc — AUTO-encrypted to the recipient (any IsPrivate), no key arg
doc, _ := client.CreateDocument(ctx, companydata.CreateDocumentOptions{
    Name: "Your invoice", PayloadKind: "json", ConnectionID: connID,
    JSONValue: map[string]any{"amount": "42.00", "due": "2026-07-01"},
    Metadata:  map[string]any{"can_be_cancelled_in_app": true}})

// A CONTRACT — must be per-person; status is derived (ready_to_sign here)
contract, _ := client.CreateDocument(ctx, companydata.CreateDocumentOptions{
    Name: "Service agreement", PayloadKind: "file", ConnectionID: connID,
    Kind: "agreement", RequiresSignature: true,
    FileBytes: pdf, FileMime: "application/pdf"})
// Observe the person's sign/accept/cancel via the changes pump (Action field).
// Signatures is []map[string]any — the raw wire keys (snake_case), not Go
// field names: each entry is {action, method, content_sha256, plain_sha256,
// signer_first_name, signer_last_name, signer_name_verified, created_at}.
signed, _ := client.Document(ctx, contract.ID)
fmt.Println(signed.Signatures)
fmt.Println(signed.SealedAt) // nil until the completing act seals it

client.ListDocuments(ctx, companydata.ListDocumentsOptions{Status: "active"})
client.UpdateDocumentStatus(ctx, doc.ID, "ended")
client.UpdateDocumentMetadata(ctx, doc.ID, companydata.UpdateDocumentMetadataOptions{Name: "Invoice #1001"})
client.DeleteDocument(ctx, doc.ID)

// Broadcast a plaintext doc
await client.CreateDocumentAsync(new CreateDocumentOptions {
    Name = "Terms v3", PayloadKind = "json",
    JsonValue = new { url = "https://x/terms.pdf", version = "3" } });

// Per-person doc — AUTO-encrypted to the recipient (any IsPrivate), no key arg
var doc = await client.CreateDocumentAsync(new CreateDocumentOptions {
    Name = "Your invoice", PayloadKind = "json", ConnectionId = connId,
    JsonValue = new { amount = "42.00", due = "2026-07-01" },
    Metadata = new { can_be_cancelled_in_app = true } });

// A CONTRACT — must be per-person; status is derived (ready_to_sign here)
var contract = await client.CreateDocumentAsync(new CreateDocumentOptions {
    Name = "Service agreement", PayloadKind = "file", ConnectionId = connId,
    Kind = "agreement", RequiresSignature = true,
    FileBytes = pdf, FileMime = "application/pdf" });
// Observe the person's sign/accept/cancel via the changes pump (Action field).
// Signatures is an untyped list of raw maps, keyed exactly as the wire sends
// them (snake_case): each entry is { action, method, content_sha256,
// plain_sha256, signer_first_name, signer_last_name, signer_name_verified,
// created_at }.
var signed = await client.DocumentAsync(contract.Id);
Console.WriteLine(signed.Signatures);
Console.WriteLine(signed.SealedAt); // null until the completing act seals it

await client.ListDocumentsAsync(status: "active");
await client.UpdateDocumentStatusAsync(doc.Id, "ended");
await client.UpdateDocumentMetadataAsync(doc.Id, name: "Invoice #1001");
await client.DeleteDocumentAsync(doc.Id);

// Broadcast a plaintext doc
client.createDocument(CreateDocumentRequest.builder()
    .name("Terms v3").payloadKind("json")
    .jsonValue(Map.of("url", "https://x/terms.pdf", "version", "3")).build());

// Per-person doc — AUTO-encrypted to the recipient (any isPrivate), no key arg
Document doc = client.createDocument(CreateDocumentRequest.builder()
    .name("Your invoice").payloadKind("json").connectionId(connId)
    .jsonValue(Map.of("amount", "42.00", "due", "2026-07-01"))
    .metadata(Map.of("can_be_cancelled_in_app", true)).build());

// A CONTRACT — must be per-person; status is derived (ready_to_sign here)
Document contract = client.createDocument(CreateDocumentRequest.builder()
    .name("Service agreement").payloadKind("file").connectionId(connId)
    .kind("agreement").requiresSignature(true)
    .fileBytes(pdf).fileMime("application/pdf").build());
// Observe the person's sign/accept/cancel via the changes pump (action field).
// signatures() is an untyped list of raw maps, keyed exactly as the wire sends
// them (snake_case): each entry is { action, method, content_sha256,
// plain_sha256, signer_first_name, signer_last_name, signer_name_verified,
// created_at }.
Document signed = client.document(contract.id());
System.out.println(signed.signatures());
System.out.println(signed.sealedAt());  // null until the completing act seals it

client.listDocuments("active");
client.updateDocumentStatus(doc.id(), "ended");
client.updateDocumentMetadata(doc.id(), Map.of("name", "Invoice #1001"));
client.deleteDocument(doc.id());

// Broadcast a plaintext doc
$client->createDocument(['name' => 'Terms v3', 'payload_kind' => 'json',
    'json_value' => ['url' => 'https://x/terms.pdf', 'version' => '3']]);

// Per-person doc — AUTO-encrypted to the recipient (any is_private), no key arg
$doc = $client->createDocument([
    'name' => 'Your invoice', 'payload_kind' => 'json', 'connection_id' => $connId,
    'json_value' => ['amount' => '42.00', 'due' => '2026-07-01'],
    'metadata' => ['can_be_cancelled_in_app' => true],
]);

// A CONTRACT — must be per-person; status is derived (ready_to_sign here)
$contract = $client->createDocument([
    'name' => 'Service agreement', 'payload_kind' => 'file', 'connection_id' => $connId,
    'kind' => 'agreement', 'requires_signature' => true,
    'file_bytes' => $pdf, 'file_mime' => 'application/pdf',
]);
// Observe the person's sign/accept/cancel via the changes pump (action field).
// signatures is an untyped list of raw arrays, keyed exactly as the wire sends
// them (snake_case): each entry is [action, method, content_sha256,
// plain_sha256, signer_first_name, signer_last_name, signer_name_verified,
// created_at].
$signed = $client->document($contract->id);
print_r($signed->signatures);
var_dump($signed->sealedAt);  // null until the completing act seals it

$client->listDocuments(['status' => 'active']);
$client->updateDocumentStatus($doc->id, 'ended');
$client->updateDocumentMetadata($doc->id, ['name' => 'Invoice #1001']);
$client->deleteDocument($doc->id);

request_id = client.send_connect_request("ABC123")
# Outcome later on the pump:
#   change.event == "connection_request_accepted" / "connection_request_rejected"
#   change.request_id == request_id

const requestId = await client.sendConnectRequest('ABC123');
// Outcome later on the pump:
//   change.event === 'connection_request_accepted' | 'connection_request_rejected'
//   change.requestId === requestId

requestID, err := client.SendConnectRequest(ctx, "ABC123")
// Outcome later on the pump:
//   c.Event == "connection_request_accepted" / "connection_request_rejected"
//   c.RequestID == requestID

string requestId = await client.SendConnectRequestAsync("ABC123");
// Outcome later on the pump:
//   change.Event == "connection_request_accepted" / "connection_request_rejected"
//   change.RequestId == requestId

String requestId = client.sendConnectRequest("ABC123");
// Outcome later on the pump:
//   change.event().equals("connection_request_accepted") / "connection_request_rejected"
//   change.requestId().equals(requestId)

$requestId = $client->sendConnectRequest('ABC123');
// Outcome later on the pump:
//   $change->event === 'connection_request_accepted' / 'connection_request_rejected'
//   $change->requestId === $requestId

def handle(change):
    if change.event != "message_received":
        return
    print(change.person_id, change.message_body)   # already decrypted

    client.send_message(change.connection_id, "Thanks — we're on it.",
                        person_public_key=change.person_public_key)
    client.mark_messages_read(change.connection_id, change.message_id)

client.process_changes(handle)
client.broadcast_message("We're closed on Friday.")

await client.processChanges(async (change) => {
  if (change.event !== 'message_received') return;
  console.log(change.personId, change.messageBody);   // already decrypted

  await client.sendMessage(change.connectionId, "Thanks — we're on it.",
    { personPublicKey: change.personPublicKey });
  await client.markMessagesRead(change.connectionId, change.messageId);
});
await client.broadcastMessage("We're closed on Friday.");

err := client.ProcessChanges(func(c companydata.Change) error {
    if c.Event != "message_received" {
        return nil
    }
    log.Println(c.PersonID, c.MessageBody) // already decrypted

    if _, err := client.SendMessage(ctx, c.ConnectionID, "Thanks — we're on it.",
        companydata.SendMessageOptions{PersonPublicKey: c.PersonPublicKey}); err != nil {
        return err
    }
    return client.MarkMessagesRead(ctx, c.ConnectionID, c.MessageID)
}, companydata.PumpOptions{})
_, err = client.BroadcastMessage(ctx, "We're closed on Friday.")

await client.ProcessChangesAsync(async change => {
    if (change.Event != "message_received") return;
    Console.WriteLine($"{change.PersonId}: {change.MessageBody}");   // already decrypted

    await client.SendMessageAsync(change.ConnectionId!, "Thanks — we're on it.",
        personPublicKey: change.PersonPublicKey);
    await client.MarkMessagesReadAsync(change.ConnectionId!, change.MessageId!);
});
await client.BroadcastMessageAsync("We're closed on Friday.");

client.processChanges(change -> {
    if (!"message_received".equals(change.event())) return;
    log(change.personId(), change.messageBody());   // already decrypted

    client.sendMessage(change.connectionId(), "Thanks — we're on it.",
                       change.personPublicKey(), null);
    client.markMessagesRead(change.connectionId(), change.messageId());
});
client.broadcastMessage("We're closed on Friday.");

$client->processChanges(function ($change) use ($client): void {
    if ($change->event !== 'message_received') {
        return;
    }
    echo $change->personId, ': ', $change->messageBody, "\n";   // already decrypted

    $client->sendMessage($change->connectionId, "Thanks — we're on it.",
        personPublicKey: $change->personPublicKey);
    $client->markMessagesRead($change->connectionId, $change->messageId);
});
$client->broadcastMessage("We're closed on Friday.");

def handle(change):
    if already_processed(change.id):   # idempotency — dedup on the stable id
        return
    if change.event == "field_updated":
        store(change.person_id, change.slug, change.value)
    elif change.event in ("connection_deleted", "field_deleted"):
        remove(change.person_id, change.slug)
    mark_processed(change.id)

client.process_changes(handle)         # returns when the feed is empty

await client.processChanges((change) => {
  if (alreadyProcessed(change.id)) return;       // dedup on change.id
  if (change.event === 'field_updated') {
    store(change.personId, change.slug, change.value);
  } else if (change.event === 'connection_deleted' || change.event === 'field_deleted') {
    remove(change.personId, change.slug);
  }
  markProcessed(change.id);
});

err = client.ProcessChanges(func(c companydata.Change) error {
    if alreadyProcessed(c.ID) {                 // dedup on c.ID
        return nil
    }
    switch c.Event {
    case "field_updated":
        store(c.PersonID, c.Slug, c.Value)
    case "connection_deleted", "field_deleted":
        remove(c.PersonID, c.Slug)
    }
    markProcessed(c.ID)
    return nil // returning nil ACKS; an error RETRIES → then dead-letters
}, companydata.PumpOptions{})

await client.ProcessChangesAsync(async change =>
{
    if (AlreadyProcessed(change.Id)) return;     // dedup on change.Id
    if (change.Event == "field_updated")
        Store(change.PersonId, change.Slug, change.ValueObj);
    else if (change.Event is "connection_deleted" or "field_deleted")
        Remove(change.PersonId, change.Slug);
    MarkProcessed(change.Id);
    await Task.CompletedTask;
});

client.processChanges(change -> {
    if (alreadyProcessed(change.id())) return;   // dedup on change.id()
    switch (change.event()) {
        case "field_updated" -> store(change.personId(), change.slug(), change.value());
        case "connection_deleted", "field_deleted" -> remove(change.personId(), change.slug());
        default -> note(change.event(), change.personId());
    }
    markProcessed(change.id());
});

use Allus\CompanyData\Model\Change;

$client->processChanges(function (Change $change): void {
    if (alreadyProcessed($change->id)) return;   // dedup on $change->id
    if ($change->event === 'field_updated') {
        store($change->personId, $change->slug, $change->value);
    } elseif (in_array($change->event, ['connection_deleted', 'field_deleted'], true)) {
        remove($change->personId, $change->slug);
    }
    markProcessed($change->id);
});                                              // returns when the feed is empty

# Flask
@app.post("/allus/webhook")
def allus_webhook():
    try:
        change = client.handle_webhook(request.get_data(), dict(request.headers))
    except WebhookError:
        abort(401)              # bad / unknown signature, or unparseable envelope
    apply_change(change)   # NOT dedup-on-id: see the webhook delivery guarantee
    return ("", 200)     # 200 — the ONLY status allus counts as delivered

// Express — capture the RAW body bytes. handleWebhook is async: the handler must be
// async and await it, or the try/catch cannot catch a signature or parse failure.
app.post('/allus/webhook', express.raw({ type: '*/*' }), async (req, res) => {
  let change;
  try {
    change = await client.handleWebhook(req.body /* Buffer */, req.headers);
  } catch (e) {
    if (e instanceof WebhookError) return res.sendStatus(401);
    throw e;
  }
  applyChange(change);   // NOT dedup-on-id: see the webhook delivery guarantee
  res.sendStatus(200);   // 200 — the ONLY status allus counts as delivered
});

func webhook(client *companydata.Client) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        body, _ := io.ReadAll(r.Body)              // the RAW bytes — the HMAC is over them
        change, err := client.HandleWebhook(body, r.Header) // verify + parse
        if err != nil {                            // *WebhookError on a bad signature
            http.Error(w, "invalid webhook", http.StatusUnauthorized)
            return
        }
        apply(change)
        w.WriteHeader(http.StatusOK)               // 200 — the ONLY status allus counts as delivered
    }
}

// ASP.NET minimal API — read the EXACT bytes
app.MapPost("/allus/webhook", async (HttpRequest req, Client client) =>
{
    using var ms = new MemoryStream();
    await req.Body.CopyToAsync(ms);
    var headers = req.Headers.ToDictionary(h => h.Key, h => (string)h.Value!);
    try
    {
        var change = client.HandleWebhook(ms.ToArray(), headers); // verify + parse + decrypt
        Apply(change);
        return Results.Ok();   // 200 — the ONLY status allus counts as delivered
    }
    catch (WebhookException) { return Results.Unauthorized(); }
});

// Servlet
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    byte[] body = req.getInputStream().readAllBytes();   // the RAW bytes
    Map<String, String> headers = new HashMap<>();
    var names = req.getHeaderNames();
    while (names.hasMoreElements()) { String n = names.nextElement(); headers.put(n, req.getHeader(n)); }
    try {
        Change change = client.handleWebhook(body, headers);  // verify + parse
        apply(change);
        resp.setStatus(200);                                  // 200 — the ONLY status allus counts as delivered
    } catch (WebhookException e) {
        resp.setStatus(401);                                  // bad / unknown signature
    }
}

$rawBody = file_get_contents('php://input');                  // the RAW bytes
$headers = function_exists('getallheaders') ? getallheaders() : [];
try {
    $change = $client->handleWebhook($rawBody, $headers);
} catch (WebhookError) {
    http_response_code(401);   // bad / unknown signature, or unparseable envelope
    exit;
}
applyChange($change);
http_response_code(200);   // 200 — the ONLY status allus counts as delivered

if change.event == "key_rotated":
    # service Client — cache is keyed by SHARE CODE
    client.invalidate_public_key(change.share_code)
    # CustomerClient — cache is keyed by PERSON USER ID
    customer.invalidate_public_key(change.person_id)

if (change.event === 'key_rotated') {
  client.invalidatePublicKey(change.shareCode);      // service Client — keyed by SHARE CODE
  customer.invalidatePublicKey(change.personId);     // CustomerClient — keyed by PERSON USER ID
}

if c.Event == "key_rotated" {
    client.InvalidatePublicKey(c.ShareCode)          // service Client — keyed by SHARE CODE
    customer.InvalidatePublicKey(c.PersonID)         // CustomerClient — keyed by PERSON USER ID
}

if (change.Event == "key_rotated") {
    client.InvalidatePublicKey(change.ShareCode);    // service Client — keyed by SHARE CODE
    customer.InvalidatePublicKey(change.PersonId);   // CustomerClient — keyed by PERSON USER ID
}

if ("key_rotated".equals(change.event())) {
    client.invalidatePublicKey(change.shareCode());  // service Client — keyed by SHARE CODE
    customer.invalidatePublicKey(change.personId()); // CustomerClient — keyed by PERSON USER ID
}

if ($change->event === 'key_rotated') {
    $client->invalidatePublicKey($change->shareCode);   // service Client — keyed by SHARE CODE
    $customer->invalidatePublicKey($change->personId);  // CustomerClient — keyed by PERSON USER ID
}

customer.invalidate_service_key(body["company_share_code"], body["service_share_code"])

customer.invalidateServiceKey(body.company_share_code, body.service_share_code);

customer.InvalidateServiceKey(body["company_share_code"], body["service_share_code"])

customer.InvalidateServiceKey(body["company_share_code"], body["service_share_code"]);

customer.invalidateServiceKey(body.get("company_share_code"), body.get("service_share_code"));

$customer->invalidateServiceKey($body['company_share_code'], $body['service_share_code']);