Tratamento de Erros

import {
  NotFoundError,
  RateLimitError,
  ConflictError,
  SignDocsBrasilApiError,
  SignDocsBrasilError,
} from '@signdocs-brasil/api';

try {
  const tx = await client.transactions.get('tx-inexistente');
} catch (err) {
  if (err instanceof NotFoundError) {
    console.log('Não encontrado:', err.detail);
  } else if (err instanceof RateLimitError) {
    console.log('Rate limit, retry em:', err.retryAfterSeconds, 'segundos');
  } else if (err instanceof ConflictError) {
    console.log('Conflito:', err.detail);
  } else if (err instanceof SignDocsBrasilApiError) {
    console.log('Erro de API:', err.status, err.title, err.detail);
    console.log('ProblemDetail:', err.problemDetail);
  } else if (err instanceof SignDocsBrasilError) {
    console.log('Erro de infraestrutura:', err.message);
  }
}

from signdocs_brasil.errors import (
    NotFoundError,
    RateLimitError,
    ConflictError,
    SignDocsBrasilApiError,
    SignDocsBrasilError,
)

try:
    tx = client.transactions.get('tx-inexistente')
except NotFoundError as e:
    print(f'Não encontrado: {e.problem_detail.detail}')
except RateLimitError as e:
    print(f'Rate limit, retry em: {e.retry_after_seconds}s')
except ConflictError as e:
    print(f'Conflito: {e.problem_detail.detail}')
except SignDocsBrasilApiError as e:
    print(f'Erro de API: {e.problem_detail.status} {e.problem_detail.title}')
except SignDocsBrasilError as e:
    print(f'Erro de infraestrutura: {e}')

import (
    "errors"
    signdocs "github.com/signdocsbrasil/signdocsbrasil-go/v2"
)

tx, err := client.Transactions.Get(ctx, "tx-inexistente")
if err != nil {
    var notFound *signdocs.NotFoundError
    var rateLimit *signdocs.RateLimitError
    var conflict *signdocs.ConflictError
    var apiErr *signdocs.ApiError

    if errors.As(err, &notFound) {
        fmt.Println("Não encontrado:", notFound.ProblemDetail.Detail)
    } else if errors.As(err, &rateLimit) {
        fmt.Println("Rate limit, retry em:", rateLimit.RetryAfterSeconds, "segundos")
    } else if errors.As(err, &conflict) {
        fmt.Println("Conflito:", conflict.ProblemDetail.Detail)
    } else if errors.As(err, &apiErr) {
        fmt.Println("Erro de API:", apiErr.StatusCode, apiErr.ProblemDetail.Title)
    } else {
        fmt.Println("Erro:", err)
    }
}

// Funções auxiliares
if signdocs.IsNotFound(err) { /* ... */ }
if signdocs.IsRateLimit(err) { /* ... */ }
if signdocs.IsConflict(err) { /* ... */ }

import com.signdocsbrasil.api.exceptions.*;

try {
    Transaction tx = client.transactions().get("tx-inexistente");
} catch (NotFoundException e) {
    System.out.println("Não encontrado: " + e.getProblemDetail().getDetail());
} catch (RateLimitException e) {
    System.out.println("Rate limit, retry em: " + e.getRetryAfterSeconds() + "s");
} catch (ConflictException e) {
    System.out.println("Conflito: " + e.getProblemDetail().getDetail());
} catch (ApiException e) {
    System.out.println("Erro de API: " + e.getStatus() + " " + e.getTitle());
} catch (SignDocsBrasilException e) {
    System.out.println("Erro de infraestrutura: " + e.getMessage());
}

use SignDocsBrasil\Api\Exceptions\NotFoundException;
use SignDocsBrasil\Api\Exceptions\RateLimitException;
use SignDocsBrasil\Api\Exceptions\ConflictException;
use SignDocsBrasil\Api\Exceptions\ApiException;
use SignDocsBrasil\Api\Exceptions\SignDocsBrasilException;

try {
    $tx = $client->transactions->get('tx-inexistente');
} catch (NotFoundException $e) {
    echo 'Não encontrado: ' . $e->getProblemDetail()->detail;
} catch (RateLimitException $e) {
    echo 'Rate limit, retry em: ' . $e->retryAfterSeconds . 's';
} catch (ConflictException $e) {
    echo 'Conflito: ' . $e->getProblemDetail()->detail;
} catch (ApiException $e) {
    echo 'Erro de API: ' . $e->getStatus() . ' ' . $e->getTitle();
} catch (SignDocsBrasilException $e) {
    echo 'Erro de infraestrutura: ' . $e->getMessage();
}

using SignDocsBrasil.Api;
using SignDocsBrasil.Api.Models;

try
{
    var tx = await client.Transactions.CreateAsync(request);
}
catch (NotFoundException ex)
{
    Console.WriteLine($"Não encontrado: {ex.Message}");
}
catch (ValidationException ex)
{
    Console.WriteLine($"Validação: {ex.Message}");
    foreach (var field in ex.Fields)
        Console.WriteLine($"  {field.Name}: {field.Message}");
}
catch (RateLimitException ex)
{
    Console.WriteLine($"Rate limit. Retry após {ex.RetryAfterSeconds}s");
}
catch (ConflictException ex)
{
    Console.WriteLine($"Conflito: {ex.Message}");
}
catch (SignDocsException ex)
{
    Console.WriteLine($"Erro {ex.StatusCode}: {ex.Message}");
}