> ## Documentation Index
> Fetch the complete documentation index at: https://docs.triglit.com/llms.txt
> Use this file to discover all available pages before exploring further.

# TypeScript e Uso Avançado

> Tipos, logging, raw response e mais

## TypeScript

O SDK é totalmente tipado e fornece autocomplete completo. Todos os tipos de requisição e resposta estão disponíveis:

```typescript theme={null}
import Triglit from 'triglit';

const client = new Triglit({ apiKey: 'pk_...' });

// Tipos de parâmetros e respostas são inferidos automaticamente
const params: Triglit.TriggerCreateParams = {
  config: {},
  name: 'Meu Trigger',
  type: 'event',
  workflowVersionId: 'wfv_123',
};

const trigger: Triglit.Trigger = await client.triggers.create(params);
```

A documentação de cada método, parâmetro de requisição e campo de resposta está disponível em docstrings e aparecerá no hover na maioria dos editores modernos.

## Acessando Resposta Raw (Headers)

Para acessar a resposta raw do `fetch()` (por exemplo, para ler headers), você pode usar os métodos `.asResponse()` ou `.withResponse()`:

### `.asResponse()`

Retorna assim que os headers de uma resposta bem-sucedida são recebidos e não consome o corpo da resposta:

```typescript theme={null}
const response = await client.triggers
  .create({ config: {}, name: 'x', type: 'event', workflowVersionId: 'x' })
  .asResponse();

console.log(response.headers.get('X-My-Header'));
console.log(response.statusText); // Acessar o objeto Response subjacente
```

### `.withResponse()`

Retorna a resposta raw junto com os dados parseados. Diferente de `.asResponse()`, este método consome o corpo:

```typescript theme={null}
const { data: trigger, response: raw } = await client.triggers
  .create({ config: {}, name: 'x', type: 'event', workflowVersionId: 'x' })
  .withResponse();

console.log(raw.headers.get('X-My-Header'));
console.log(trigger.id);
```

## Logging

> \[!IMPORTANT]
> Todas as mensagens de log são destinadas apenas para debugging. O formato e conteúdo das mensagens de log podem mudar entre versões.

### Níveis de Log

O nível de log pode ser configurado de duas formas:

1. Via variável de ambiente `TRIGLIT_LOG`
2. Usando a opção `logLevel` do cliente (sobrescreve a variável de ambiente se definida)

```typescript theme={null}
import Triglit from 'triglit';

const client = new Triglit({
  apiKey: 'pk_...',
  logLevel: 'debug', // Mostrar todas as mensagens de log
});
```

Níveis de log disponíveis, do mais ao menos verboso:

* `'debug'` - Mostrar mensagens de debug, info, warnings e erros
* `'info'` - Mostrar mensagens de info, warnings e erros
* `'warn'` - Mostrar warnings e erros (padrão)
* `'error'` - Mostrar apenas erros
* `'off'` - Desabilitar todos os logs

No nível `'debug'`, todas as requisições e respostas HTTP são logadas, incluindo headers e corpos. Alguns headers relacionados à autenticação são redigidos, mas dados sensíveis nos corpos de requisição e resposta ainda podem estar visíveis.

### Logger Customizado

Por padrão, a biblioteca faz log em `globalThis.console`. Você também pode fornecer um logger customizado. A maioria das bibliotecas de logging são suportadas, incluindo [pino](https://www.npmjs.com/package/pino), [winston](https://www.npmjs.com/package/winston), [bunyan](https://www.npmjs.com/package/bunyan), [consola](https://www.npmjs.com/package/consola), [signale](https://www.npmjs.com/package/signale) e [@std/log](https://jsr.io/@std/log).

```typescript theme={null}
import Triglit from 'triglit';
import pino from 'pino';

const logger = pino();

const client = new Triglit({
  logger: logger.child({ name: 'Triglit' }),
  logLevel: 'debug', // Enviar todas as mensagens para pino, permitindo que ele filtre
});
```

Quando você fornece um logger customizado, a opção `logLevel` ainda controla quais mensagens são emitidas - mensagens abaixo do nível configurado não serão enviadas ao seu logger.

## Requisições Customizadas/Não Documentadas

Se você precisar acessar endpoints, parâmetros ou propriedades de resposta não documentados, a biblioteca ainda pode ser usada:

### Endpoints Não Documentados

Para fazer requisições a endpoints não documentados, você pode usar `client.get`, `client.post` e outros verbos HTTP:

```typescript theme={null}
await client.post('/some/path', {
  body: { some_prop: 'foo' },
  query: { some_query_arg: 'bar' },
});
```

### Parâmetros Não Documentados

Para fazer requisições usando parâmetros não documentados, você pode usar `// @ts-expect-error`:

```typescript theme={null}
client.triggers.triggerWebhook({
  // ...
  // @ts-expect-error baz ainda não é público
  baz: 'opção não documentada',
});
```

Para requisições com o verbo `GET`, quaisquer parâmetros extras estarão na query. Para todas as outras requisições, o parâmetro extra será enviado no corpo.

## Customizando o Fetch Client

Por padrão, esta biblioteca espera que uma função `fetch` global esteja definida. Se você quiser usar uma função `fetch` diferente, você pode:

1. Fazer polyfill do global:

```typescript theme={null}
import fetch from 'my-fetch';

globalThis.fetch = fetch;
```

2. Ou passá-la para o cliente:

```typescript theme={null}
import Triglit from 'triglit';
import fetch from 'my-fetch';

const client = new Triglit({ fetch });
```

### Fetch Options

Se você quiser definir opções customizadas de `fetch` sem sobrescrever a função `fetch`, você pode fornecer um objeto `fetchOptions` ao instanciar o cliente ou fazer uma requisição:

```typescript theme={null}
import Triglit from 'triglit';

const client = new Triglit({
  fetchOptions: {
    // Opções `RequestInit`
  },
});
```