# Isis External Integration Examples (Typed)

Date: 2026-02-24  
Scope: `WS10-008` typed SDK examples for game engines and DCC automation.

## Overview

`@isis/client` now ships typed integration example builders for:

- game engines: `unreal`, `unity`, `godot`
- DCC automation: `blender`, `maya`, `houdini`

These examples provide ready-to-run typed payloads for:

- webhook subscription provisioning
- idempotent chained workflow triggers
- idempotent batch workflow triggers
- callback signing and replay-protected callback verification templates

## Import

```typescript
import {
  IsisClient,
  createExternalIntegrationExamples,
  findExternalIntegrationExampleById,
} from '@isis/client';
```

## 1) Game Engine Integration (Unity Example)

```typescript
const client = new IsisClient({
  apiKey: process.env.ISIS_API_KEY,
  generationApiUrl: 'https://api.oshun.io/isis',
  workflowRegistryUrl: 'https://api.oshun.io/isis-workflows',
  outputRegistryUrl: 'https://api.oshun.io/isis-outputs',
});

const examples = createExternalIntegrationExamples({
  projectId: 'project_cinematic_alpha',
  callbackBaseUrl: 'https://integrations.example.com/isis',
  signingSecret: process.env.ISIS_WEBHOOK_SECRET!,
  environment: 'production',
});

const unity = findExternalIntegrationExampleById(
  examples,
  'unity-content-lane'
);
if (!unity) throw new Error('Missing unity integration example');

// 1. Provision webhook subscription for workflow/job/output lifecycle events
await client.generation.createWebhookSubscription(unity.webhookSubscription);

// 2. Trigger deterministic chained workflow lane
const chain = await client.workflows.triggerChain(unity.workflowChain);

// 3. Trigger deterministic batch variant lane
const batch = await client.workflows.triggerBatch(unity.workflowBatch);

console.log({ chainId: chain.chainId, acceptedBatch: batch.accepted });
```

## 2) DCC Automation Integration (Blender Example)

```typescript
const blender = findExternalIntegrationExampleById(
  examples,
  'blender-automation-lane'
);
if (!blender) throw new Error('Missing blender integration example');

await client.generation.createWebhookSubscription(blender.webhookSubscription);

const dccChain = await client.workflows.triggerChain(blender.workflowChain);
const dccBatch = await client.workflows.triggerBatch(blender.workflowBatch);

console.log({
  chainAccepted: dccChain.accepted,
  batchAccepted: dccBatch.accepted,
});
```

## 3) Signed Callback Verification Template

```typescript
if (!unity) throw new Error('Missing unity integration example');

// Producer-side signature generation template
const signed = await client.generation.signWebhookCallback(
  unity.callbackSignTemplate
);

// Consumer-side verification template (replay protection enabled)
const verified = await client.generation.verifyWebhookCallback({
  ...unity.callbackVerifyTemplate,
  signature: signed.signature,
  timestamp: signed.timestamp,
  nonce: signed.nonce,
});

console.log({ valid: verified.valid, replayDetected: verified.replayDetected });
```

## Notes

- Example payloads are strongly typed and aligned with SDK contracts.
- Idempotency keys are deterministic per integration lane and environment.
- Callback verification templates default to replay protection with
  `toleranceSeconds: 300`.
