> ## 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.

# Exemplos

> Exemplos práticos de uso

## Criar um Workflow Completo

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

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

async function createCompleteWorkflow() {
  // 1. Criar o workflow
  const workflow = await client.workflows.create({
    name: 'Processar Pedido',
    description: 'Workflow para processar pedidos de clientes',
  });

  // 2. Criar uma versão
  const version = await client.workflows.versions.create({
    workflowId: workflow.id,
    nodes: [
      {
        id: 'node-1',
        type: 'trigger_webhook',
        name: 'Webhook Trigger',
        config: { path: '/pedido' },
        inputSchema: {},
        outputSchema: {},
      },
      {
        id: 'node-2',
        type: 'transform',
        name: 'Transform Data',
        config: {
          transformType: 'expression',
          expression: '{ ...input, status: "processed" }',
        },
        inputSchema: {},
        outputSchema: {},
      },
    ],
    edges: [
      {
        id: 'edge-1',
        sourceNodeId: 'node-1',
        targetNodeId: 'node-2',
      },
    ],
  });

  // 3. Publicar a versão
  const published = await client.workflows.versions.publish(version.id);

  // 4. Criar um trigger
  const trigger = await client.triggers.create({
    workflowVersionId: version.id,
    type: 'webhook',
    isActive: true,
  });

  return { workflow, version, trigger };
}
```

## Gerenciar Triggers

```typescript theme={null}
async function manageTriggers(client: Triglit, workflowVersionId: string) {
  // Listar todos os triggers
  const allTriggers = await client.triggers.list();
  
  // Listar triggers de uma versão específica
  const versionTriggers = await client.triggers.listByWorkflowVersion(
    workflowVersionId
  );

  // Criar um novo trigger
  const newTrigger = await client.triggers.create({
    workflowVersionId,
    type: 'webhook',
    name: 'Meu Webhook',
    isActive: true,
  });

  // Atualizar um trigger
  const updated = await client.triggers.update(newTrigger.id, {
    isActive: false,
  });

  // Deletar um trigger
  await client.triggers.delete(newTrigger.id);
}
```

## Processar Todos os Workflows

```typescript theme={null}
async function processAllWorkflows(client: Triglit) {
  const workflows = [];
  
  // Auto-paginação: busca todos os workflows automaticamente
  for await (const workflow of client.workflows.list({ pageSize: 50 })) {
    workflows.push(workflow);
    console.log(`Processando: ${workflow.name}`);
  }
  
  return workflows;
}
```

## Tratamento de Erros Robusto

```typescript theme={null}
async function safeCreateTrigger(client: Triglit, params: Triglit.TriggerCreateParams) {
  try {
    return await client.triggers.create(params);
  } catch (error) {
    if (error instanceof Triglit.AuthenticationError) {
      console.error('Erro de autenticação. Verifique sua chave de API.');
      throw new Error('Falha na autenticação');
    } else if (error instanceof Triglit.RateLimitError) {
      console.warn('Rate limit excedido. Aguardando...');
      // O SDK já faz retry automático, mas você pode adicionar lógica adicional
      throw error;
    } else if (error instanceof Triglit.APIError) {
      console.error(`Erro da API: ${error.status} - ${error.message}`);
      throw error;
    } else {
      // Erro não relacionado à API
      throw error;
    }
  }
}
```

## Referência Completa da API

Para ver todos os métodos e tipos disponíveis, consulte a [documentação completa da API](https://github.com/Triglit/typescript-sdk/blob/main/api.md) no GitHub.