> For the complete documentation index, see [llms.txt](https://docs.skail.dev/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.skail.dev/quickstart/mais-exemplos-praticos/integracao-entre-linguagens-diferentes.md).

# Integração entre linguagens diferentes

### Pausando uma função até um evento externo ocorrer

Na vida real, nem todo fluxo depende só do seu código.

Às vezes você precisa esperar:

* uma aprovação humana
* um webhook
* a resposta de outro sistema

Com o skail, isso vira algo simples: você pausa o código e continua quando o evento acontece.<br>

Para isso, o skail usa o par:

* `SkailTask.`[`WaitForEvent`](/funcionalidades/sdk/externalevents.md#waitforevent)`<T>(eventName, instanceId)`: pausa a função até o evento chegar.
* `SkailTask.`[`FireEvent`](/funcionalidades/sdk/externalevents.md#fireevent)`(eventName, instanceId, payload)`: dispara o evento que libera a espera.

\
O importante é usar o mesmo `eventName` e `instanceId` nos dois lados — é isso que conecta quem está esperando com quem dispara o evento.<br>

#### Exemplo 1 — Aprovação manual + API externa

```csharp
// SkailFunction = função durável. Se cair no meio, retoma de onde parou.
[SkailFunction]
public async SkailTask ProcessarSolicitacao(SolicitacaoRequest request)
{
    // Etapa 1: operação no banco
    // SkailCommand = checkpoint. Se o banco der timeout, retry automático.
    await ExecutarValidacao(request);

    // Etapa 2: espera aprovação manual
    // WaitForEvent = hiberna a função. Zero custo enquanto espera.
    // Quando alguém aprova no frontend, faz um POST/fire-event e acorda.
    var aprovacao = await SkailTask.WaitForEvent<AprovacaoRequest>(
        "APROVACAO_SOLICITACAO",
        request.Id
    );

    if (!aprovacao.Aprovado) return;

    // Etapa 3: chama API externa
    // Se a API cair, retry automático com backoff.
    var resultado = await ChamarApiExterna(aprovacao);

    // Etapa 4: espera confirmação externa
    // Exemplo: webhook recebido por outro endpoint dispara um fire-event.
    var confirmacao = await SkailTask.WaitForEvent<ConfirmacaoExterna>(
        "CONFIRMACAO_EXTERNA",
        resultado.TransacaoId
    );

    await RegistrarConclusao(request.Id, confirmacao);
}
```

#### Node.js chamando o skail

Para iniciar o processo basta um POST para o endpoint de trigger. O payload enviado para o trigger deve ser um array:

```typescript
const url = `${SKAIL_BASE_URL}/trigger/${WORKLOAD}/${VERSION}/ProcessarSolicitacao/${requestId}`;

await fetch(url, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    Authorization: `Bearer ${SKAIL_KEY}`,
    'skail-key': SKAIL_KEY,
    'Skail-namespace': SKAIL_NAMESPACE,
  },
  body: JSON.stringify([request]),
});

```

Para continuar uma execução que está aguardando ([`WaitForEvent`](/funcionalidades/sdk/externalevents.md#waitforevent)) um evento, basta disparar um [`FireEvent`](/funcionalidades/sdk/externalevents.md#fireevent) com o mesmo nome e instanceId.

```typescript
// Exemplo: aprovação manual feita no frontend.
const url = `${SKAIL_BASE_URL}/api/v1/fire/APROVACAO_SOLICITACAO/${requestId}`;

await fetch(url, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    Authorization: `Bearer ${SKAIL_KEY}`,
    'skail-key': SKAIL_KEY,
    'Skail-namespace': SKAIL_NAMESPACE,
  },
  body: JSON.stringify({
    aprovado: true,
    observacao: 'ok',
  }),
});

```

O mesmo padrão vale para webhooks externos (e qualquer outra integração):

```typescript
// Exemplo: confirmação recebida da API externa.
const url = `${SKAIL_BASE_URL}/api/v1/fire/CONFIRMACAO_EXTERNA/${transacaoId}`;

await fetch(url, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    Authorization: `Bearer ${SKAIL_KEY}`,
    'skail-key': SKAIL_KEY,
    'Skail-namespace': SKAIL_NAMESPACE,
  },
  body: JSON.stringify(confirmacao),
});
```