@oficialapi/sdk 9.0.1 → 9.0.3

package/README.md

@@ -20,9 +20,9 @@ import { OficialAPISDK } from '@oficialapi/sdk';
 const sdk = new OficialAPISDK({
   clientId: 'seu-client-id',
   clientSecret: 'seu-client-secret',
-  timeout: 30000, // opcional, padrão: 30000ms
-  maxRetries: 3, // opcional, padrão: 3
-  retryDelay: 1000, // opcional, padrão: 1000ms
+  timeout: 30000,  
+  maxRetries: 3,  
+  retryDelay: 1000, 
 });
 ```
 
@@ -37,15 +37,6 @@ const accessToken = tokenResponse.access_token;
 
 ## 📚 Exemplos de Uso
 
-### WhatsApp
-
-> **⚠️ Nota Importante:** Alguns métodos requerem upload prévio da mídia para obter o `mediaId` antes de enviar. Isso se aplica a:
-> - `sendAudio` - Use `uploadMedia` primeiro para obter o `mediaId`
-> - `sendVideo` - Use `uploadMedia` primeiro para obter o `mediaId`
-> - `sendDocument` - Use `uploadMedia` primeiro para obter o `mediaId`
-> - `sendSticker` - Use `uploadMedia` primeiro para obter o `mediaId`
->
-> O método `sendMedia` ainda aceita `fileUrl` diretamente para imagens e outros tipos de mídia.
 
 #### Enviar Mensagem de Texto
 
@@ -62,7 +53,7 @@ console.log(result.data.messageId);
 #### Enviar Mídia
 
 ```typescript
-// Enviar imagem
+ 
 await sdk.whatsapp.sendMedia({
   token: 'sk_live_...',
   sender: '5511999999999',
@@ -71,14 +62,14 @@ await sdk.whatsapp.sendMedia({
   caption: 'Veja esta imagem!'
 }, accessToken);
 
-// Enviar documento com nome de arquivo
+ 
 await sdk.whatsapp.sendMedia({
   token: 'sk_live_...',
   sender: '5511999999999',
   fileUrl: 'https://example.com/documento.pdf',
   type: 'document',
   caption: 'Confira este documento',
-  fileName: 'meu_documento.pdf' // Opcional: se não fornecido, será extraído da URL
+  fileName: 'meu_documento.pdf'  
 }, accessToken);
 ```
 
@@ -629,23 +620,23 @@ await sdk.whatsapp.sendOrderStatus({
   token: 'sk_live_...',
   sender: '5511999999999',
   bodyText: 'Seu pedido foi enviado!',
-  footerText: 'Obrigado!', // Opcional
-  reference_id: 'pedido_12345_1704067200', // Mesmo ID usado em sendOrderDetails
-  order_status: 'shipped', // pending, processing, partially-shipped, shipped, completed, canceled
-  status_description: 'Sua encomenda foi despachada pelos Correios', // Opcional
-  payment_status: 'captured', // Opcional: pending, captured, failed
-  payment_timestamp: 1722445231 // Opcional: timestamp do pagamento em segundos
+  footerText: 'Obrigado!',  
+  reference_id: 'pedido_12345_1704067200', 
+  order_status: 'shipped',  
+  status_description: 'Sua encomenda foi despachada pelos Correios',  
+  payment_status: 'captured', 
+  payment_timestamp: 1722445231  
 }, accessToken);
 ```
 
 #### Enviar Sticker
 
 ```typescript
-// Requer upload prévio da mídia para obter o mediaId
+ 
 await sdk.whatsapp.sendSticker({
   token: 'sk_live_...',
   sender: '5511999999999',
-  mediaId: '798882015472548' // ID da mídia após upload (.webp até 500KB para animado, 100KB para estático)
+  mediaId: '798882015472548'  
 }, accessToken);
 ```
 
@@ -656,8 +647,8 @@ await sdk.whatsapp.sendLocationRequest({
   token: 'sk_live_...',
   sender: '5511999999999',
   bodyText: 'Por favor, compartilhe sua localização para entregarmos seu pedido.',
-  headerText: 'Confirme sua entrega', // Opcional (máximo 60 caracteres)
-  footerText: 'Sua privacidade é importante' // Opcional (máximo 60 caracteres)
+  headerText: 'Confirme sua entrega',  
+  footerText: 'Sua privacidade é importante'  
 }, accessToken);
 ```
 
@@ -668,14 +659,14 @@ await sdk.whatsapp.sendCtaUrl({
   token: 'sk_live_...',
   sender: '5511999999999',
   bodyText: 'Confira nosso site!',
-  buttonText: 'Acessar', // Máximo 20 caracteres
+  buttonText: 'Acessar',  
   url: 'https://example.com',
-  header: { // Opcional: cabeçalho com mídia
-    type: 'image', // ou 'video', 'document', 'text'
-    link: 'https://example.com/banner.jpg' // Para image/video/document
-    // ou text: 'Título' para tipo text
+  header: {  
+    type: 'image',  
+    link: 'https://example.com/banner.jpg' 
+    
   },
-  footerText: 'Ofertas válidas até 30/11' // Opcional (máximo 60 caracteres)
+  footerText: 'Ofertas válidas até 30/11'  
 }, accessToken);
 ```
 
@@ -685,14 +676,14 @@ await sdk.whatsapp.sendCtaUrl({
 await sdk.whatsapp.sendMediaCarousel({
   token: 'sk_live_...',
   sender: '5511999999999',
-  bodyText: 'Confira nossas ofertas da semana!', // Obrigatório
-  cards: [ // 2 a 10 cartões
+  bodyText: 'Confira nossas ofertas da semana!', 
+  cards: [  
     {
       cardIndex: 0,
-      headerType: 'image', // ou 'video'
+      headerType: 'image', 
       headerLink: 'https://example.com/image1.jpg',
-      bodyText: 'Oferta especial!', // Máximo 160 caracteres
-      buttonText: 'Comprar agora', // Máximo 20 caracteres
+      bodyText: 'Oferta especial!',  
+      buttonText: 'Comprar agora',  
       url: 'https://example.com/product1'
     },
     {
@@ -715,11 +706,11 @@ const media = await sdk.whatsapp.downloadMedia({
   url: 'https://lookaside.fbsbx.com/whatsapp_business/attachment/?mid=...'
 }, accessToken);
 
-// A mídia retorna em base64
-console.log(media.data.buffer); // Base64 string
-console.log(media.data.mimeType); // image/jpeg, video/mp4, etc.
-console.log(media.data.filename); // Nome do arquivo
-console.log(media.data.size); // Tamanho em bytes
+ 
+console.log(media.data.buffer);  
+console.log(media.data.mimeType);  
+console.log(media.data.filename);  
+console.log(media.data.size);  
 ```
 
 #### Responder Mensagem
@@ -727,10 +718,10 @@ console.log(media.data.size); // Tamanho em bytes
 ```typescript
 await sdk.whatsapp.replyMessage({
   token: 'sk_live_...',
-  sender: '5511999999999', // Obrigatório
+  sender: '5511999999999',  
   messageText: 'Esta é uma resposta!',
-  replyMessageId: 'wamid.xxx', // Opcional: ID da mensagem a responder
-  preview_url: false // Opcional: se true, mostra preview de URLs no texto
+  replyMessageId: 'wamid.xxx',  
+  preview_url: false  
 }, accessToken);
 ```
 
@@ -739,22 +730,22 @@ await sdk.whatsapp.replyMessage({
 ```typescript
 await sdk.whatsapp.reactMessage({
   token: 'sk_live_...',
-  sender: '5511999999999', // Obrigatório
-  emoji: '👍', // Emoji da reação
-  message_id: 'wamid.xxx' // Opcional: ID da mensagem específica a reagir
+  sender: '5511999999999',  
+  emoji: '👍',  
+  message_id: 'wamid.xxx'  
 }, accessToken);
 ```
 
 #### Gerenciar Templates
 
 ```typescript
-// Listar templates
+ 
 const templates = await sdk.whatsapp.listTemplates('sk_live_...', accessToken);
 
-// Obter detalhes de um template
+ 
 const template = await sdk.whatsapp.getTemplate('sk_live_...', 'template_id', accessToken);
 
-// Criar template
+ 
 await sdk.whatsapp.createTemplate({
   token: 'sk_live_...',
   name: 'welcome_message',
@@ -769,8 +760,7 @@ await sdk.whatsapp.createTemplate({
 }, accessToken);
 
 #### Upload de Mídia
-
-O método `uploadMedia` é usado para fazer upload de arquivos (imagens, vídeos, áudios, documentos) que serão usados em templates ou enviados via `sendAudio`, `sendVideo`, `sendDocument` ou `sendSticker`.
+ 
 
 **Exemplo 1: Upload de imagem sem filename (opcional)**
 
@@ -781,8 +771,9 @@ import fs from 'fs';
 const fileBuffer = fs.readFileSync('./imagem.jpg');
 const uploadResult = await sdk.whatsapp.uploadMedia({
   token: 'sk_live_...',
-  file: fileBuffer
-  // filename é opcional 
+  file: fileBuffer,
+  mediaType: 'image'
+  
 }, accessToken);
 
 const mediaId = uploadResult.data.handle; // "4::aW1hZ2UtMTIzNDU2Nzg5MGCE..."
@@ -798,6 +789,7 @@ const fileBuffer = fs.readFileSync('./imagem.jpg');
 const uploadResult = await sdk.whatsapp.uploadMedia({
   token: 'sk_live_...',
   file: fileBuffer,
+  mediaType: 'image',
   filename: 'minha_imagem.jpg'  
 }, accessToken);
 
@@ -813,10 +805,11 @@ const videoBuffer = fs.readFileSync('./video.mp4');
 const uploadResult = await sdk.whatsapp.uploadMedia({
   token: 'sk_live_...',
   file: videoBuffer,
+  mediaType: 'video',
   filename: 'meu_video.mp4'
 }, accessToken);
 
-// Use o mediaId para enviar o vídeo
+ 
 await sdk.whatsapp.sendVideo({
   token: 'sk_live_...',
   sender: '5511999999999',
@@ -829,12 +822,7 @@ await sdk.whatsapp.sendVideo({
 ```typescript
 import fs from 'fs';
 
-const pdfBuffer = fs.readFileSync('./documento.pdf');
-const uploadResult = await sdk.whatsapp.uploadMedia({
-  token: 'sk_live_...',
-  file: pdfBuffer,
-  filename: 'documento_importante.pdf'
-}, accessToken);
+
 
  
 await sdk.whatsapp.sendDocument({
@@ -847,24 +835,6 @@ await sdk.whatsapp.sendDocument({
 ```
  
 
-```typescript
-import fs from 'fs';
-
-const audioBuffer = fs.readFileSync('./audio.ogg');
-const uploadResult = await sdk.whatsapp.uploadMedia({
-  token: 'sk_live_...',
-  file: audioBuffer,
-  filename: 'mensagem_audio.ogg'
-}, accessToken);
-
- 
-await sdk.whatsapp.sendAudio({
-  token: 'sk_live_...',
-  sender: '5511999999999',
-  mediaId: uploadResult.data.handle,
-  voice: true // true para mensagem de voz
-}, accessToken);
-```
 
 **Exemplo 6: Upload de sticker (Node.js)**
 
@@ -875,10 +845,11 @@ const stickerBuffer = fs.readFileSync('./sticker.webp');
 const uploadResult = await sdk.whatsapp.uploadMedia({
   token: 'sk_live_...',
   file: stickerBuffer,
+  mediaType: 'image',  
   filename: 'sticker.webp'
 }, accessToken);
 
-// Use o mediaId para enviar o sticker
+ 
 await sdk.whatsapp.sendSticker({
   token: 'sk_live_...',
   sender: '5511999999999',
@@ -889,14 +860,22 @@ await sdk.whatsapp.sendSticker({
 **Exemplo 7: Upload em ambiente Browser (Frontend)**
 
 ```typescript
-// Em ambiente Browser
+ 
 const fileInput = document.querySelector('input[type="file"]');
 const file = fileInput.files[0];
 
+ 
+const getMediaType = (file: File): 'image' | 'video' | 'document' => {
+  if (file.type.startsWith('image/')) return 'image';
+  if (file.type.startsWith('video/')) return 'video';
+  return 'document';
+};
+
 const uploadResult = await sdk.whatsapp.uploadMedia({
   token: 'sk_live_...',
   file: file,
-  filename: file.name // Opcional
+  mediaType: getMediaType(file),
+  filename: file.name  
 }, accessToken);
 
 const mediaId = uploadResult.data.handle;
@@ -905,12 +884,13 @@ const mediaId = uploadResult.data.handle;
 **Exemplo 8: Upload usando Blob (Browser)**
 
 ```typescript
-// Criar um Blob a partir de dados
+ 
 const blob = new Blob(['conteúdo do arquivo'], { type: 'text/plain' });
 
 const uploadResult = await sdk.whatsapp.uploadMedia({
   token: 'sk_live_...',
   file: blob,
+  mediaType: 'document',
   filename: 'arquivo.txt'
 }, accessToken);
 
@@ -926,11 +906,12 @@ import fs from 'fs';
 const imageBuffer = fs.readFileSync('./logo.jpg');
 const uploadResult = await sdk.whatsapp.uploadMedia({
   token: 'sk_live_...',
-  file: imageBuffer
-  // filename não é necessário para templates
+  file: imageBuffer,
+  mediaType: 'image'
+ 
 }, accessToken);
 
-// Use o handle no template
+ 
 await sdk.whatsapp.createTemplate({
   token: 'sk_live_...',
   name: 'product_launch',
@@ -941,7 +922,7 @@ await sdk.whatsapp.createTemplate({
       type: 'HEADER',
       format: 'IMAGE',
       example: {
-        header_handle: [uploadResult.data.handle] // Use o handle aqui
+        header_handle: [uploadResult.data.handle]  
       }
     },
     {
@@ -953,15 +934,16 @@ await sdk.whatsapp.createTemplate({
 ```
 
 **Notas importantes:**
+- O parâmetro `mediaType` é **obrigatório** e deve ser um dos valores: `'image'`, `'video'` ou `'document'`.
 - O parâmetro `filename` é **opcional**. Se não fornecido, não será enviado ao servidor (a API da OficialAPI rejeita campos vazios).
 - O `mediaId` retornado está no formato `"4::aW1hZ2UtMTIzNDU2Nzg5MGCE..."` e deve ser usado diretamente nos métodos `sendAudio`, `sendVideo`, `sendDocument` ou `sendSticker`.
 - Para templates, use o `handle` retornado no campo `header_handle` ou `example.header_handle`.
 - Formatos suportados:
-  - **Imagens**: JPG, PNG, GIF, WEBP
-  - **Vídeos**: MP4, 3GP
-  - **Áudios**: OGG (codec OPUS para voz), MP3, M4A
-  - **Documentos**: PDF, DOC, DOCX, XLS, XLSX, PPT, PPTX
-  - **Stickers**: WEBP (até 500KB para animado, 100KB para estático)
+  - **Imagens** (`mediaType: 'image'`): JPG, PNG, GIF, WEBP
+  - **Vídeos** (`mediaType: 'video'`): MP4, 3GP
+  - **Áudios**: Use `mediaType: 'video'` para áudios (OGG codec OPUS para voz, MP3, M4A)
+  - **Documentos** (`mediaType: 'document'`): PDF, DOC, DOCX, XLS, XLSX, PPT, PPTX
+  - **Stickers**: Use `mediaType: 'image'` para stickers WEBP (até 500KB para animado, 100KB para estático)
 ```
 
 **Mais exemplos de templates:**
@@ -1464,22 +1446,25 @@ const media = await sdk.telegram.downloadMedia({
   fileId: 'AgACAgEAAxkBAAItNmlmklyYNCEtvaFphVfSSO7CrEOjAALUC2sbh9owR9hT7MhQnTGfAQADAgADcwADOAQ'
 }, accessToken);
 
-// A mídia retorna em base64
-console.log(media.data.buffer); // Base64 string
-console.log(media.data.mimeType); // image/jpeg, video/mp4, etc.
-console.log(media.data.filename); // Nome do arquivo
-console.log(media.data.size); // Tamanho em bytes
+ 
+console.log(media.data.buffer);  
+console.log(media.data.mimeType);  
+console.log(media.data.filename);  
+console.log(media.data.size); 
 ```
 
 ### WebChat
+ 
 
 #### Enviar Mensagem de Texto
 
 ```typescript
 await sdk.webchat.sendText({
-  token: 'sk_live_...',
-  sender: 'user123',
-  messageText: 'Olá!'
+  channelToken: 'sk_live_...',
+  chatId: 'chat_123456789',
+  messageText: 'Olá!',
+  typing: true,        // Opcional: mostrar indicador de digitação
+  typingTime: 2000     // Opcional: tempo de digitação em ms
 }, accessToken);
 ```
 
@@ -1487,18 +1472,22 @@ await sdk.webchat.sendText({
 
 ```typescript
 await sdk.webchat.sendCard({
-  token: 'sk_live_...',
-  sender: 'user123',
+  channelToken: 'sk_live_...',
+  chatId: 'chat_123456789',
   title: 'Produto',
   description: 'Descrição do produto',
   imageUrl: 'https://example.com/image.jpg',
   buttons: [
     {
-      type: 'url',
-      title: 'Ver Mais',
+      id: 'btn_1',                    // Opcional: ID único do botão
+      text: 'Ver Mais',
+      type: 'url',                    // 'text' | 'url' | 'phone' | 'postback'
+      url: 'https://example.com/product',
       value: 'https://example.com/product'
     }
-  ]
+  ],
+  typing: true,
+  typingTime: 3000
 }, accessToken);
 ```
 
@@ -1506,11 +1495,13 @@ await sdk.webchat.sendCard({
 
 ```typescript
 await sdk.webchat.sendMedia({
-  token: 'sk_live_...',
-  sender: 'user123',
+  channelToken: 'sk_live_...',
+  chatId: 'chat_123456789',
   fileUrl: 'https://example.com/image.jpg',
-  type: 'image',
-  caption: 'Veja esta imagem!'
+  type: 'image',                      // 'image' | 'video' | 'audio' | 'file'
+  caption: 'Veja esta imagem!',
+  typing: true,
+  typingTime: 2500
 }, accessToken);
 ```
 
@@ -1518,26 +1509,39 @@ await sdk.webchat.sendMedia({
 
 ```typescript
 await sdk.webchat.sendCarousel({
-  token: 'sk_live_...',
-  sender: 'user123',
+  channelToken: 'sk_live_...',
+  chatId: 'chat_123456789',
   cards: [
     {
       title: 'Produto 1',
-      description: 'Descrição do produto 1',
+      subtitle: 'Descrição do produto 1',
       imageUrl: 'https://example.com/product1.jpg',
       buttons: [
-        { type: 'url', title: 'Ver Mais', value: 'https://example.com/product1' }
+        {
+          id: 'btn_1',
+          text: 'Ver Mais',
+          type: 'url',
+          url: 'https://example.com/product1',
+          value: 'https://example.com/product1'
+        }
       ]
     },
     {
       title: 'Produto 2',
-      description: 'Descrição do produto 2',
+      subtitle: 'Descrição do produto 2',
       imageUrl: 'https://example.com/product2.jpg',
       buttons: [
-        { type: 'url', title: 'Ver Mais', value: 'https://example.com/product2' }
+        {
+          id: 'btn_2',
+          text: 'Comprar',
+          type: 'postback',
+          value: 'BUY_PRODUCT_2'
+        }
       ]
     }
-  ]
+  ],
+  typing: true,
+  typingTime: 4000
 }, accessToken);
 ```
 
@@ -1545,24 +1549,40 @@ await sdk.webchat.sendCarousel({
 
 ```typescript
 await sdk.webchat.sendForm({
-  token: 'sk_live_...',
-  sender: 'user123',
-  title: 'Formulário de Contato',
+  channelToken: 'sk_live_...',
+  chatId: 'chat_123456789',
+  id: 'form_contact',                // Opcional: ID único do formulário
+  title: 'Formulário de Contato',    // Opcional
   fields: [
     {
-      type: 'text',
-      name: 'name',
+      id: 'name',                     // Opcional: se não fornecido, usa 'name'
+      name: 'name',                   // Opcional: mantido para compatibilidade
+      type: 'text',                   // 'text' | 'email' | 'number' | 'tel' | 'date' | 'select'
       label: 'Nome',
+      placeholder: 'Digite seu nome',
       required: true
     },
     {
+      id: 'email',
       type: 'email',
-      name: 'email',
       label: 'E-mail',
+      placeholder: 'Digite seu e-mail',
       required: true
+    },
+    {
+      id: 'subject',
+      type: 'select',
+      label: 'Assunto',
+      required: true,
+      options: [
+        { value: 'support', label: 'Suporte' },
+        { value: 'sales', label: 'Vendas' }
+      ]
     }
   ],
-  submitButtonText: 'Enviar'
+  submitButtonText: 'Enviar',        // Opcional
+  typing: true,
+  typingTime: 3000
 }, accessToken);
 ```
 
@@ -1570,14 +1590,23 @@ await sdk.webchat.sendForm({
 
 ```typescript
 await sdk.webchat.sendQuickReplies({
-  token: 'sk_live_...',
-  sender: 'user123',
+  channelToken: 'sk_live_...',
+  chatId: 'chat_123456789',
   messageText: 'Como podemos ajudar?',
   quickReplies: [
-    { type: 'text', title: 'Suporte', payload: 'SUPPORT' },
-    { type: 'text', title: 'Vendas', payload: 'SALES' },
-    { type: 'location', title: 'Compartilhar Localização' }
-  ]
+    {
+      id: 'qr_1',                     // Opcional: ID único
+      text: 'Suporte',
+      value: 'SUPPORT'                // Opcional: valor para identificar a resposta
+    },
+    {
+      id: 'qr_2',
+      text: 'Vendas',
+      value: 'SALES'
+    }
+  ],
+  typing: true,
+  typingTime: 2000
 }, accessToken);
 ```
 
@@ -1585,13 +1614,26 @@ await sdk.webchat.sendQuickReplies({
 
 ```typescript
 await sdk.webchat.sendButtons({
-  token: 'sk_live_...',
-  sender: 'user123',
+  channelToken: 'sk_live_...',
+  chatId: 'chat_123456789',
   messageText: 'Escolha uma opção:',
   buttons: [
-    { type: 'url', title: 'Visitar Site', value: 'https://example.com' },
-    { type: 'postback', title: 'Falar com Atendente', value: 'HUMAN_AGENT' }
-  ]
+    {
+      id: 'btn_1',
+      text: 'Visitar Site',
+      type: 'url',
+      url: 'https://example.com',
+      value: 'https://example.com'
+    },
+    {
+      id: 'btn_2',
+      text: 'Falar com Atendente',
+      type: 'postback',
+      value: 'HUMAN_AGENT'
+    }
+  ],
+  typing: true,
+  typingTime: 2500
 }, accessToken);
 ```
 
@@ -1751,11 +1793,11 @@ const media = await sdk.facebook.downloadMedia({
   url: 'https://lookaside.fbsbx.com/ig_messaging_cdn/...'
 }, accessToken);
 
-// A mídia retorna em base64
-console.log(media.data.buffer); // Base64 string
-console.log(media.data.mimeType); // image/jpeg, video/mp4, etc.
-console.log(media.data.filename); // Nome do arquivo
-console.log(media.data.size); // Tamanho em bytes
+ 
+console.log(media.data.buffer);  
+console.log(media.data.mimeType);  
+console.log(media.data.filename); 
+console.log(media.data.size); 
 ```
 
 ### Instagram
@@ -1896,21 +1938,21 @@ await sdk.instagram.sendButtonTemplate({
 #### Enviar Ação do Remetente (Typing, Seen)
 
 ```typescript
-// Mostrar "digitando..."
+ 
 await sdk.instagram.sendSenderAction({
   token: 'sk_live_...',
   recipientId: 'user_id',
   action: 'typing_on'
 }, accessToken);
 
-// Parar de mostrar "digitando..."
+ 
 await sdk.instagram.sendSenderAction({
   token: 'sk_live_...',
   recipientId: 'user_id',
   action: 'typing_off'
 }, accessToken);
 
-// Marcar como visualizado
+ 
 await sdk.instagram.sendSenderAction({
   token: 'sk_live_...',
   recipientId: 'user_id',
@@ -1956,11 +1998,229 @@ const media = await sdk.instagram.downloadMedia({
   url: 'https://lookaside.fbsbx.com/ig_messaging_cdn/...'
 }, accessToken);
 
-// A mídia retorna em base64
-console.log(media.data.buffer); // Base64 string
-console.log(media.data.mimeType); // image/jpeg, video/mp4, etc.
-console.log(media.data.filename); // Nome do arquivo
-console.log(media.data.size); // Tamanho em bytes
+ 
+console.log(media.data.buffer);  
+console.log(media.data.mimeType);  
+console.log(media.data.filename);  
+console.log(media.data.size);  
+```
+
+#### Publicar Conteúdo no Instagram
+
+ 
+
+**1. Criar Contêiner de Mídia**
+
+```typescript
+// Publicar imagem
+const container = await sdk.instagram.createMediaContainer({
+  token: 'sk_live_...',
+  image_url: 'https://example.com/image.jpg',
+  media_type: 'IMAGE',
+  caption: 'Nossa nova coleção chegou! #moda #verao',
+  alt_text: 'Foto de um produto de moda'  // Opcional: texto alternativo
+}, accessToken);
+
+const creationId = container.data.data.id; // ID do contêiner criado
+```
+
+```typescript
+// Publicar vídeo
+const container = await sdk.instagram.createMediaContainer({
+  token: 'sk_live_...',
+  video_url: 'https://example.com/video.mp4',
+  media_type: 'VIDEO',
+  caption: 'Vídeo especial para nossos seguidores'
+}, accessToken);
+```
+
+```typescript
+// Publicar Reel
+const container = await sdk.instagram.createMediaContainer({
+  token: 'sk_live_...',
+  video_url: 'https://example.com/reel.mp4',
+  media_type: 'REELS',
+  caption: 'Confira nosso novo Reel!',
+  trial_params: {                    // Opcional: para reels de teste
+    graduation_strategy: 'MANUAL'
+  }
+}, accessToken);
+```
+
+```typescript
+// Publicar Story
+const container = await sdk.instagram.createMediaContainer({
+  token: 'sk_live_...',
+  video_url: 'https://example.com/story.mp4',
+  media_type: 'STORIES'
+}, accessToken);
+```
+
+```typescript
+// Criar carrossel (até 10 itens)
+// Primeiro, criar os contêineres filhos
+const child1 = await sdk.instagram.createMediaContainer({
+  token: 'sk_live_...',
+  image_url: 'https://example.com/image1.jpg',
+  media_type: 'IMAGE',
+  is_carousel_item: true
+}, accessToken);
+
+const child2 = await sdk.instagram.createMediaContainer({
+  token: 'sk_live_...',
+  image_url: 'https://example.com/image2.jpg',
+  media_type: 'IMAGE',
+  is_carousel_item: true
+}, accessToken);
+
+// Depois, criar o contêiner pai do carrossel
+const carousel = await sdk.instagram.createMediaContainer({
+  token: 'sk_live_...',
+  media_type: 'CAROUSEL',
+  caption: 'Balas de frutas',
+  children: [
+    child1.data.data.id,
+    child2.data.data.id
+  ]
+}, accessToken);
+```
+
+**2. Verificar Status do Contêiner** (para vídeos grandes)
+
+```typescript
+const status = await sdk.instagram.getContainerStatus({
+  token: 'sk_live_...',
+  container_id: '17841465415913137'
+}, accessToken);
+
+// Status possíveis: EXPIRED, ERROR, FINISHED, IN_PROGRESS, PUBLISHED
+console.log(status.data.data.status_code);
+
+// Para vídeos grandes, aguarde até o status ser 'FINISHED' antes de publicar
+if (status.data.data.status_code === 'FINISHED') {
+  // Pronto para publicar
+}
+```
+
+**3. Publicar Mídia**
+
+```typescript
+const published = await sdk.instagram.publishMedia({
+  token: 'sk_live_...',
+  creation_id: '17841465415913137'  // ID retornado ao criar o contêiner
+}, accessToken);
+
+console.log(published.data.data.id); // ID da publicação criada
+```
+
+**4. Verificar Limite de Publicação**
+
+```typescript
+const limit = await sdk.instagram.getPublishingLimit({
+  token: 'sk_live_...'
+}, accessToken);
+
+console.log(`Usado: ${limit.data.data.quota_used} de ${limit.data.data.quota_total}`);
+console.log(`Período: ${limit.data.data.quota_duration} segundos (24 horas)`);
+```
+
+**5. Upload de Vídeo Grande (Sessão Retomável)**
+
+Para vídeos grandes que podem ter interrupções de rede:
+
+```typescript
+// 1. Criar contêiner com upload_type=resumable
+const container = await sdk.instagram.createMediaContainer({
+  token: 'sk_live_...',
+  video_url: 'https://example.com/large-video.mp4',
+  media_type: 'VIDEO',
+  upload_type: 'resumable',
+  caption: 'Vídeo grande com upload retomável'
+}, accessToken);
+
+// 2. Fazer upload do vídeo
+const upload = await sdk.instagram.uploadVideo({
+  token: 'sk_live_...',
+  container_id: container.data.data.id,
+  file_url: 'https://example.com/large-video.mp4',
+  file_size: 10485760,  // Tamanho em bytes (opcional se file_url fornecido)
+  offset: 0              // Opcional: para retomar upload (padrão: 0)
+}, accessToken);
+
+// 3. Verificar status periodicamente até ser 'FINISHED'
+// 4. Publicar quando status for 'FINISHED'
+```
+
+**Exemplo Completo: Publicar Imagem**
+
+```typescript
+// 1. Criar contêiner
+const container = await sdk.instagram.createMediaContainer({
+  token: 'sk_live_...',
+  image_url: 'https://example.com/image.jpg',
+  media_type: 'IMAGE',
+  caption: 'Nossa nova coleção chegou! #moda #verao',
+  alt_text: 'Foto de um produto de moda',
+  location_id: '123456789',  // Opcional: ID da localização
+  user_tags: [               // Opcional: marcar usuários
+    { username: 'usuario1', x: 0.5, y: 0.5 }
+  ]
+}, accessToken);
+
+const creationId = container.data.data.id;
+
+// 2. Publicar imediatamente (imagens são processadas rapidamente)
+const published = await sdk.instagram.publishMedia({
+  token: 'sk_live_...',
+  creation_id: creationId
+}, accessToken);
+
+console.log(`Publicação criada com ID: ${published.data.data.id}`);
+```
+
+**Exemplo Completo: Publicar Vídeo com Verificação de Status**
+
+```typescript
+// 1. Criar contêiner de vídeo
+const container = await sdk.instagram.createMediaContainer({
+  token: 'sk_live_...',
+  video_url: 'https://example.com/video.mp4',
+  media_type: 'VIDEO',
+  caption: 'Vídeo especial para nossos seguidores'
+}, accessToken);
+
+const containerId = container.data.data.id;
+
+// 2. Verificar status periodicamente (vídeos podem demorar)
+let status = 'IN_PROGRESS';
+let attempts = 0;
+const maxAttempts = 10;
+
+while (status === 'IN_PROGRESS' && attempts < maxAttempts) {
+  await new Promise(resolve => setTimeout(resolve, 5000)); // Aguardar 5 segundos
+  
+  const statusCheck = await sdk.instagram.getContainerStatus({
+    token: 'sk_live_...',
+    container_id: containerId
+  }, accessToken);
+  
+  status = statusCheck.data.data.status_code;
+  attempts++;
+  
+  console.log(`Status: ${status} (tentativa ${attempts})`);
+}
+
+// 3. Publicar quando status for 'FINISHED'
+if (status === 'FINISHED') {
+  const published = await sdk.instagram.publishMedia({
+    token: 'sk_live_...',
+    creation_id: containerId
+  }, accessToken);
+  
+  console.log(`Vídeo publicado com ID: ${published.data.data.id}`);
+} else {
+  console.error(`Erro: Status final é ${status}`);
+}
 ```
 
 ### Canais