@agenus-io/webhook-centralizer 1.0.26 → 1.0.27

package/README.md

@@ -1,6 +1,6 @@
 # Webhook Centralizer SDK
 
-SDK para centralização de webhooks focado atualmente em plataformas de pagamentos.
+SDK para gerenciamento de plataformas de webhook e centralização de eventos de plataformas de pagamento.
 
 ## Instalação
 
@@ -14,10 +14,12 @@ pnpm add @agenus-io/webhook-centralizer
 
 ## Funcionalidades
 
-Este SDK fornece funcionalidades para centralização de webhooks de plataformas de pagamentos, permitindo:
+Este SDK fornece funcionalidades para gerenciar plataformas de webhook e centralizar eventos de plataformas de pagamento, permitindo:
 
-1. **Gerenciamento de Configurações**: CRUD completo de configurações de webhooks
-2. **Processamento de Webhooks**: Recebimento e processamento de webhooks de plataformas de pagamento via AWS SQS
+1. **Gerenciamento de Plataformas**: CRUD completo de plataformas de webhook
+2. **Consulta de Webhooks**: Listagem e consulta de webhooks processados
+3. **KPIs**: Métricas de aceitação e rejeição de webhooks
+4. **Configurações**: Consulta de configurações disponíveis de plataformas
 
 ## Uso
 
@@ -25,325 +27,502 @@ Este SDK fornece funcionalidades para centralização de webhooks de plataformas
 
 ```typescript
 import { WebhookCentralizerSDK } from "@agenus-io/webhook-centralizer";
-import type { AWSConfig, Order } from "@agenus-io/webhook-centralizer";
-
-// Configure o SDK com suas credenciais AWS e credenciais da aplicação
-const config: AWSConfig = {
-  region: "us-east-1",
-  accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
-  secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
-  queueUrl: process.env.QUEUE_SALES_URL!,
-};
 
+// Configure o SDK com suas credenciais da aplicação
 const appId = process.env.APP_ID!;
 const appToken = process.env.APP_TOKEN!;
+const environment = process.env.NODE_ENV === "production" ? "production" : "develop";
 
-const sdk = new WebhookCentralizerSDK(config, appId, appToken);
+const sdk = new WebhookCentralizerSDK(appId, appToken, environment);
 ```
 
-### 1. Processar Webhook de Pagamento
+### 1. Criar Plataforma de Webhook
 
 ```typescript
-const order: Order = {
-  dispatch: "META", // "META", "GOOGLE" ou "TIKTOK"
-  event: "PURCHASE_COMPLETED", // ou "PURCHASE_PENDING"
-  checkout: "cartpanda",
-  orderId: "ORD-123456",
-  subscriptionId: "SUB-789012", // opcional
-  currency: "BRL",
-  valueGross: 347.0,
-  valueNet: 329.9,
-  createdAt: new Date(),
-  
-  // Pixel IDs (opcional, dependendo da plataforma)
-  fbc: "fb.1.1733718123.uYhGtFdSLoPqWeRtYuIo", // Meta/Facebook
-  fbp: "fb.1.1733718123.4455667788", // Meta/Facebook
-  fbclid: "fbclid-value", // Meta/Facebook
-  gclid: "Cj0KCQi...", // Google
-  gbraid: "gbraid-value", // Google
-  wbraid: "wbraid-value", // Google
-  
-  customer: {
-    email: "cliente@example.com",
-    externalId: "USR-123", // opcional
-    firstName: "João",
-    lastName: "Silva",
-    phone: "+55 11 99999-9999", // opcional
-    city: "São Paulo", // opcional
-    state: "SP", // opcional
-    zipCode: "01310-100", // opcional
-    country: "BR", // opcional
-    ip: "189.45.201.77", // opcional
-    userAgent: "Mozilla/5.0...", // opcional
+import { WebhookCentralizerPlatformEnum, WebhookPlatformRoleEnum } from "@agenus-io/webhook-centralizer";
+
+const result = await sdk.Create({
+  workSpaceId: "workspace-123",
+  title: "Plataforma Hotmart",
+  type: WebhookCentralizerPlatformEnum.HOTMART,
+  role: WebhookPlatformRoleEnum.PRODUCER,
+  platformToken: "token-da-plataforma", // opcional
+  apiToken: "api-token", // opcional
+  slug: "hotmart-slug", // opcional
+  meta: { // opcional
+    customField: "value"
   },
-  
-  products: [
-    {
-      id: "PROD-001",
-      title: "Produto 1",
-      externalId: "EXT-001",
-      quantity: 2,
-    },
-    {
-      id: "PROD-002",
-      title: "Produto 2",
-      externalId: "EXT-002",
-      quantity: 1,
-    },
-  ],
-};
+});
 
-try {
-  await sdk.SendOrder({
-    workspaceId: "workspace-123",
-    order,
-  });
-  console.log("Venda enviada com sucesso!");
-} catch (error) {
-  console.error("Erro ao enviar venda:", error);
+if (result.isError) {
+  console.error("Erro ao criar plataforma:", result.error);
+} else {
+  console.log("Plataforma criada com sucesso! ID:", result.id);
 }
 ```
 
-### 2. Gerenciar Configurações de Webhooks
+### 2. Listar Plataformas
 
-#### Criar Configuração de Webhook
+```typescript
+const result = await sdk.Get({
+  workSpaceId: "workspace-123",
+  page: 1,
+  pageSize: 10,
+  filter: undefined, // opcional - filtro de busca
+});
+
+console.log(result.data); // Array de plataformas
+console.log(result.meta); // Metadados de paginação
+// {
+//   total: 50,
+//   totalPages: 5,
+//   page: 1,
+//   pageSize: 10
+// }
+```
+
+### 3. Buscar Plataforma por ID
 
 ```typescript
-await sdk.Create({
-  workspaceId: "workspace-123",
-  data: {
-    title: "Pixel Meta",
-    status: true,
-    sendLead: true,
-    sendLeadText: "Lead capturado",
-    addToCart: true,
-    addToCartText: "Produto adicionado ao carrinho",
-    initiateCheckout: true,
-    initiateCheckoutDetection: "AUTOMATIC",
-    initiateCheckoutDetectionText: undefined,
-    purchaseSendType: "SALES_APPROVED",
-    purchaseValueType: "SALE_VALUE",
-    type: "META",
-    productIds: ["prod-1", "prod-2"],
-    sendIp: "IPV6_AND_IPV4",
-    pixelMeta: [
-      {
-        id: "pixel-id-123",
-        title: "Pixel Principal",
-        token: "pixel-token-123",
-      },
-    ],
-  },
+const result = await sdk.GetById({
+  id: "platform-id-123",
+  workSpaceId: "workspace-123",
 });
+
+if (result.isError) {
+  console.error("Erro ao buscar plataforma:", result.error);
+} else {
+  console.log("Plataforma encontrada:", result.data);
+}
 ```
 
-#### Listar Configurações de Webhooks
+### 4. Buscar Plataforma por Título
 
 ```typescript
-const result = await sdk.Get({
+const result = await sdk.GetByTitle({
+  title: "Plataforma Hotmart",
+  workSpaceId: "workspace-123",
+});
+
+console.log("Plataforma encontrada:", result);
+```
+
+### 5. Atualizar Plataforma
+
+```typescript
+const result = await sdk.Update({
+  id: "platform-id-123",
+  workSpaceId: "workspace-123",
+  title: "Plataforma Atualizada", // opcional
+  platformToken: "novo-token", // opcional
+  // Apenas os campos que deseja atualizar
+});
+
+if (result.isError) {
+  console.error("Erro ao atualizar plataforma:", result.error);
+} else {
+  console.log("Plataforma atualizada com sucesso!");
+}
+```
+
+### 6. Deletar Plataforma
+
+```typescript
+const result = await sdk.Delete({
+  id: "platform-id-123",
+  workSpaceId: "workspace-123",
+});
+
+if (result.isError) {
+  console.error("Erro ao deletar plataforma:", result.error);
+} else {
+  console.log("Plataforma deletada com sucesso!");
+}
+```
+
+### 7. Listar Webhooks de uma Plataforma
+
+```typescript
+import { WebhookCentralizerStatusEnum } from "@agenus-io/webhook-centralizer";
+
+const result = await sdk.GetWebhooks({
+  id: "platform-id-123",
   workSpaceId: "workspace-123",
   page: 1,
   pageSize: 10,
   filter: undefined, // opcional
+  status: WebhookCentralizerStatusEnum.COMPLETED, // opcional - filtrar por status
 });
 
-console.log(result.data); // Array de configurações de webhooks
+console.log(result.data); // Array de webhooks
 console.log(result.meta); // Metadados de paginação
 ```
 
-#### Buscar uma Configuração de Webhook Específica
+### 8. Buscar Webhook por ID
 
 ```typescript
-const result = await sdk.GetOne({
-  id: "pixel-id-123",
+const result = await sdk.GetWebhookById({
+  id: "webhook-id-123",
   workSpaceId: "workspace-123",
 });
 
-console.log(result.data); // Dados da configuração de webhook ou null
+if (result.isError) {
+  console.error("Erro ao buscar webhook:", result.error);
+} else {
+  console.log("Webhook encontrado:", result.data);
+}
 ```
 
-#### Atualizar Configuração de Webhook
+### 9. Consultar Configurações de Plataformas Disponíveis
 
 ```typescript
-await sdk.Update({
-  id: "pixel-id-123",
-  workspaceId: "workspace-123",
-  data: {
-    title: "Pixel Atualizado",
-    status: false,
-    // Apenas os campos que deseja atualizar
-  },
-});
+const result = await sdk.GetPlatformSettings();
+
+console.log(result.data); // Array de configurações disponíveis
+// Cada configuração contém informações sobre:
+// - Plataformas suportadas
+// - Se tem PostBack
+// - Se tem Token
+// - Se tem Slug
+// - Se tem API
+// - Se está em preparação
 ```
 
-#### Deletar Configuração de Webhook
+### 10. Consultar KPIs
 
 ```typescript
-await sdk.Delete({
-  id: "pixel-id-123",
-  workspaceId: "workspace-123",
+import { 
+  WebhookCentralizerStatusEnum, 
+  WebhookCentralizerEventEnum 
+} from "@agenus-io/webhook-centralizer";
+
+const result = await sdk.Kpi({
+  id: "platform-id-123",
+  workSpaceId: "workspace-123",
+  status: [
+    WebhookCentralizerStatusEnum.COMPLETED,
+    WebhookCentralizerStatusEnum.PROCESSING
+  ],
+  event: [
+    WebhookCentralizerEventEnum.PURCHASE_CONFIRMED,
+    WebhookCentralizerEventEnum.PURCHASE_PENDING
+  ],
 });
+
+console.log("Total:", result.total);
+console.log("Aceitos:", result.amountAccepted);
+console.log("Rejeitados:", result.amountRejected);
 ```
 
 ## Tipos Exportados
 
-### `MarketingPlatform`
+### `webhookCentralizerPlatform`
+Plataformas de pagamento suportadas:
 ```typescript
-type MarketingPlatform = "GOOGLE" | "META" | "TIKTOK";
+type webhookCentralizerPlatform = 
+  | "BEMONY" 
+  | "B4YOU" 
+  | "BRAIP" 
+  | "CARTPANDA" 
+  | "NUTRALINK" 
+  | "HOTMART" 
+  | "KIRVANO" 
+  | "KIWIFY" 
+  | "LAST_LINK" 
+  | "PAYT" 
+  | "DIGISTORE";
 ```
 
-### `PurchaseEventType`
+### `webhookCentralizerEvent`
+Eventos de webhook suportados:
 ```typescript
-type PurchaseEventType = "PURCHASE_PENDING" | "PURCHASE_COMPLETED";
+type webhookCentralizerEvent = 
+  | "ABANDONED_CART"
+  | "PURCHASE_UPSELL"
+  | "PURCHASE_CONFIRMED"
+  | "PURCHASE_PENDING"
+  | "PURCHASE_EXPIRED"
+  | "PURCHASE_CANCELED"
+  | "PURCHASE_SHIPPED"
+  | "PURCHASE_REFUND"
+  | "PURCHASE_UPDATED"
+  | "PURCHASE_CHARGEBACK"
+  | "SUBSCRIPTION_INITIATED"
+  | "SUBSCRIPTION_RENEWAL"
+  | "SUBSCRIPTION_RENEWAL_PENDING"
+  | "SUBSCRIPTION_UPDATED"
+  | "SUBSCRIPTION_CANCELED"
+  | "SUBSCRIPTION_EXPIRED"
+  | "SUBSCRIPTION_RENEWAL_CANCELLED"
+  | "SUBSCRIPTION_RENEWAL_RESUMED"
+  | "REJECTED"
+  | "UNKNOWN";
 ```
 
-### `PurchaseSendType`
+### `webhookCentralizerOrderStatus`
+Status de pedidos:
 ```typescript
-type PurchaseSendType = "SALES_APPROVED" | "SALES_APPROVED_AND_PENDING";
+type webhookCentralizerOrderStatus = 
+  | "PENDING" 
+  | "PROCESSING" 
+  | "COMPLETED" 
+  | "FAILED";
 ```
 
-### `PurchaseValueType`
+### `webhookCentralizerDispatchType`
+Tipo de despacho:
 ```typescript
-type PurchaseValueType = "SALE_VALUE" | "COMMISSION";
+type webhookCentralizerDispatchType = "WEBHOOK" | "POST_BACK";
 ```
 
-### `PixelDetection`
+### `webhookPlatformRole`
+Papel da plataforma:
 ```typescript
-type PixelDetection = "AUTOMATIC" | "CONTAINS_TEXT" | "CONTAINS_CSS" | "CONTAINS_URL";
+type webhookPlatformRole = "PRODUCER" | "CO_PRODUCER" | "AFFILIATE";
 ```
 
-### `SendIp`
+### Enums Disponíveis
+
+O SDK exporta enums para facilitar o uso:
+
 ```typescript
-type SendIp = "IPV6_AND_IPV4" | "ONLY_IPV6" | "DONT_SEND";
+import {
+  WebhookCentralizerPlatformEnum,
+  WebhookCentralizerEventEnum,
+  WebhookCentralizerStatusEnum,
+  WebhookCentralizerDispatchTypeEnum,
+  WebhookPlatformRoleEnum,
+} from "@agenus-io/webhook-centralizer";
+
+// Exemplo de uso
+const platform = WebhookCentralizerPlatformEnum.HOTMART;
+const event = WebhookCentralizerEventEnum.PURCHASE_CONFIRMED;
+const status = WebhookCentralizerStatusEnum.COMPLETED;
 ```
 
-### `Order`
-Estrutura completa de dados da venda (veja exemplo acima).
+### Tipos de Dados Centralizados
 
-### `AWSConfig`
-Configuração necessária para conexão com AWS SQS:
-- `region`: string - Região AWS
-- `accessKeyId`: string - Access Key ID
-- `secretAccessKey`: string - Secret Access Key
-- `queueUrl`: string - URL da fila SQS
+O SDK também exporta tipos para estruturas de dados centralizadas:
 
-### `SendSaleParams`
-Parâmetros para envio de venda:
-- `workspaceId`: string - ID do workspace
-- `order`: Order - Dados da venda/pedido
+```typescript
+import type {
+  ICentralizedSaleDTO,
+  ICentralizedSubscriptionDTO,
+  ICentralizedAbandonedCartDTO,
+} from "@agenus-io/webhook-centralizer";
+```
 
 ## Variáveis de Ambiente
 
-As credenciais AWS e da aplicação devem ser fornecidas ao instanciar o SDK. Recomendamos usar variáveis de ambiente:
+As credenciais da aplicação devem ser fornecidas ao instanciar o SDK. Recomendamos usar variáveis de ambiente:
 
 ```env
-AWS_REGION=us-east-1
-AWS_ACCESS_KEY_ID=AKIA...
-AWS_SECRET_ACCESS_KEY=secret...
-QUEUE_SALES_URL=https://sqs.us-east-1.amazonaws.com/123456789012/queue-name
 APP_ID=your-app-id
 APP_TOKEN=your-app-token
+NODE_ENV=production # ou develop
 ```
 
 ## Exemplo Completo
 
 ```typescript
-import { WebhookCentralizerSDK } from "@agenus-io/webhook-centralizer";
-import type { AWSConfig, Order } from "@agenus-io/webhook-centralizer";
+import { 
+  WebhookCentralizerSDK,
+  WebhookCentralizerPlatformEnum,
+  WebhookPlatformRoleEnum,
+  WebhookCentralizerStatusEnum,
+  WebhookCentralizerEventEnum,
+} from "@agenus-io/webhook-centralizer";
 
 // 1. Configurar SDK
-const config: AWSConfig = {
-  region: process.env.AWS_REGION!,
-  accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
-  secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
-  queueUrl: process.env.QUEUE_SALES_URL!,
-};
-
 const sdk = new WebhookCentralizerSDK(
-  config,
   process.env.APP_ID!,
-  process.env.APP_TOKEN!
+  process.env.APP_TOKEN!,
+  process.env.NODE_ENV === "production" ? "production" : "develop"
 );
 
-// 2. Mapear venda do seu sistema para o formato do SDK
-function mapOrderToSDKFormat(order: YourOrderType): Order {
-  return {
-    dispatch: order.platform, // "META", "GOOGLE", ou "TIKTOK"
-    event: order.status === "completed" ? "PURCHASE_COMPLETED" : "PURCHASE_PENDING",
-    checkout: order.checkoutProvider,
-    orderId: order.id,
-    currency: order.currency,
-    valueGross: order.total,
-    valueNet: order.subtotal,
-    createdAt: order.createdAt,
-    customer: {
-      email: order.customer.email,
-      firstName: order.customer.firstName,
-      lastName: order.customer.lastName,
-      phone: order.customer.phone,
-      // ... outros campos opcionais
-    },
-    products: order.items.map(item => ({
-      id: item.productId,
-      title: item.title,
-      externalId: item.externalId,
-      quantity: item.quantity,
-    })),
-  };
-}
+// 2. Criar uma nova plataforma
+async function criarPlataforma() {
+  const result = await sdk.Create({
+    workSpaceId: "workspace-123",
+    title: "Minha Plataforma Hotmart",
+    type: WebhookCentralizerPlatformEnum.HOTMART,
+    role: WebhookPlatformRoleEnum.PRODUCER,
+    platformToken: "token-da-plataforma",
+  });
 
-// 3. Enviar venda
-async function handleOrderCompleted(order: YourOrderType, workspaceId: string) {
-  const orderData = mapOrderToSDKFormat(order);
-  
-  try {
-    await sdk.SendOrder({
-      workspaceId,
-      order: orderData,
-    });
-    console.log(`Venda ${order.id} enviada com sucesso!`);
-  } catch (error) {
-    console.error(`Erro ao enviar venda ${order.id}:`, error);
-    // Implemente sua lógica de retry ou notificação aqui
+  if (result.isError) {
+    console.error("Erro:", result.error);
+    return;
   }
+
+  console.log("Plataforma criada com ID:", result.id);
+  return result.id;
 }
 
-// 4. Exemplo de uso completo com gerenciamento de pixels
+// 3. Listar todas as plataformas
+async function listarPlataformas(workSpaceId: string) {
+  const result = await sdk.Get({
+    workSpaceId,
+    page: 1,
+    pageSize: 10,
+  });
+
+  console.log(`Total de plataformas: ${result.meta.total}`);
+  result.data.forEach(platform => {
+    console.log(`- ${platform.title} (${platform.type})`);
+    console.log(`  Aceitos: ${platform.amountAccepted}, Rejeitados: ${platform.amountRejected}`);
+  });
+}
+
+// 4. Consultar webhooks de uma plataforma
+async function consultarWebhooks(platformId: string, workSpaceId: string) {
+  const result = await sdk.GetWebhooks({
+    id: platformId,
+    workSpaceId,
+    page: 1,
+    pageSize: 20,
+    status: WebhookCentralizerStatusEnum.COMPLETED,
+  });
+
+  console.log(`Total de webhooks: ${result.meta.total}`);
+  result.data.forEach(webhook => {
+    console.log(`- ${webhook.event} (${webhook.status}) - ${webhook.code}`);
+  });
+}
+
+// 5. Consultar KPIs
+async function consultarKPIs(platformId: string, workSpaceId: string) {
+  const result = await sdk.Kpi({
+    id: platformId,
+    workSpaceId,
+    status: [
+      WebhookCentralizerStatusEnum.COMPLETED,
+      WebhookCentralizerStatusEnum.PROCESSING,
+    ],
+    event: [
+      WebhookCentralizerEventEnum.PURCHASE_CONFIRMED,
+      WebhookCentralizerEventEnum.PURCHASE_PENDING,
+    ],
+  });
+
+  console.log("KPIs da Plataforma:");
+  console.log(`Total: ${result.total}`);
+  console.log(`Aceitos: ${result.amountAccepted}`);
+  console.log(`Rejeitados: ${result.amountRejected}`);
+  console.log(`Taxa de sucesso: ${((result.amountAccepted / result.total) * 100).toFixed(2)}%`);
+}
+
+// 6. Fluxo completo
 async function exemploCompleto() {
-  // Listar configurações de webhooks
-  const webhooks = await sdk.Get({
+  const workSpaceId = "workspace-123";
+
+  // Listar plataformas existentes
+  await listarPlataformas(workSpaceId);
+
+  // Criar nova plataforma
+  const platformId = await criarPlataforma();
+
+  if (platformId) {
+    // Consultar webhooks
+    await consultarWebhooks(platformId, workSpaceId);
+
+    // Consultar KPIs
+    await consultarKPIs(platformId, workSpaceId);
+  }
+}
+```
+
+## Tratamento de Erros
+
+Todos os métodos que podem retornar erros seguem o padrão:
+
+```typescript
+const result = await sdk.Create({ /* ... */ });
+
+if (result.isError) {
+  // Tratar erro
+  console.error("Erro:", result.error);
+} else {
+  // Sucesso
+  console.log("ID:", result.id);
+}
+```
+
+Para métodos que lançam exceções (`Get`, `GetByTitle`, `GetWebhooks`), use try/catch:
+
+```typescript
+try {
+  const result = await sdk.Get({
     workSpaceId: "workspace-123",
     page: 1,
     pageSize: 10,
   });
-  
-  console.log(`Total de configurações de webhooks: ${webhooks.meta.total}`);
-  
-  // Processar um webhook de pagamento
-  await handleOrderCompleted(myOrder, "workspace-123");
+  // Processar resultado
+} catch (error) {
+  console.error("Erro ao listar plataformas:", error);
 }
 ```
 
-## Manutenção
+## Ambientes
 
-Quando houver atualizações no SDK:
+O SDK suporta dois ambientes:
 
-1. A versão será atualizada no npm
-2. Atualize o pacote nos seus apps: `npm update @agenus-io/webhook-centralizer`
-3. Se houver breaking changes, serão documentados nas release notes
+- **production**: Conecta-se a `https://webhook-centralizer-production.up.railway.app`
+- **develop**: Conecta-se a `https://service-webhook-develop.up.railway.app`
 
-## Segurança
+O ambiente é definido no construtor:
 
-⚠️ **IMPORTANTE**: Nunca commite credenciais AWS ou tokens de aplicação no código fonte. Sempre use variáveis de ambiente ou serviços de gerenciamento de segredos (AWS Secrets Manager, etc).
+```typescript
+const sdk = new WebhookCentralizerSDK(
+  appId,
+  appToken,
+  "production" // ou "develop"
+);
+```
 
 ## API de Webhooks
 
-O SDK se conecta à API de centralização de webhooks hospedada em: `https://micro-service-pixel-production-4826.up.railway.app`
+O SDK se conecta à API de centralização de webhooks hospedada em:
 
-Todas as operações CRUD de configurações de webhooks utilizam autenticação via headers:
+- **Produção**: `https://webhook-centralizer-production.up.railway.app`
+- **Desenvolvimento**: `https://service-webhook-develop.up.railway.app`
+
+Todas as operações utilizam autenticação via headers:
 - `app-id`: ID da aplicação
 - `app-secret-token`: Token secreto da aplicação
-- `work-space-id`: ID do workspace
+- `work-space-id`: ID do workspace (quando aplicável)
+
+## Schemas de Validação
+
+O SDK exporta schemas Zod para validação:
+
+```typescript
+import {
+  WebhookCentralizerCreatePlatformSchema,
+  WebhookCentralizerUpdatePlatformSchema,
+  WebhookCentralizerGetPlatformsSchema,
+  WebhookCentralizerGetPlatformWebhooksSchema,
+} from "@agenus-io/webhook-centralizer";
+
+// Validar dados antes de criar
+const data = WebhookCentralizerCreatePlatformSchema.parse({
+  title: "Minha Plataforma",
+  type: "HOTMART",
+  role: "PRODUCER",
+});
+```
+
+## Manutenção
+
+Quando houver atualizações no SDK:
+
+1. A versão será atualizada no npm
+2. Atualize o pacote nos seus apps: `npm update @agenus-io/webhook-centralizer`
+3. Se houver breaking changes, serão documentados nas release notes
+
+## Segurança
+
+⚠️ **IMPORTANTE**: Nunca commite credenciais ou tokens no código fonte. Sempre use variáveis de ambiente ou serviços de gerenciamento de segredos.
 
 ## Suporte
 

package/dist/WebhookTypes/index.d.ts

@@ -16,6 +16,7 @@ export interface ICentralizedSaleDTO {
 }
 export interface ICentralizedAbandonedCartDTO {
     cart_token?: string;
+    cart_url?: string;
     products: ICentralizedProduct[];
     value?: number;
     userAgent?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agenus-io/webhook-centralizer",
-  "version": "1.0.26",
+  "version": "1.0.27",
   "description": "SDK para centralização de webhooks focado atualmente em plataformas de pagamentos",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",