.card a:not(.card) {
    border-bottom: 1.5px solid #C3F4EF;
    ;
    font-weight: 600;
}

.card a:not(.card):hover {
    border-bottom: 2px solid #C3F4EF;
    ;
}

html:not(.dark) .card a:not(.card) {
    color: var(--tw-prose-links);
    min-width: 1em !important
}


/* The following code is a workaround for theming Mintlify docs correctly. */
/* As they do not support fully customized theming, we need to overwrite   */
/* css classes                                                             */
/*                                                                         */
/* See Figma for reference:
/* [https://www.figma.com/design/plALoHUzhePk7A2c4WCoFN/[Lego]-Jornada-PLG?node-id=887-1100&t=7Zr19nkRzV0S4ik9-0] */

:root {
    /* Defining Malga Colors */
    --malgreen-200: #BAE7C9;
    --malgreen-300: #38BFAD;
    --malgreen-400: #2FAC9B;
    --malblack-100: #666666;
    --malblack-200: #4D4D4D;
    --malblack-300: #333333;
    --malblack-400: #1A1A1A;
    --malwhite-100: #FFFFFF;
    --malwhite-200: #F9F9F9;
    --malwhite-300: #F1F1F1;
    --malwhite-500: #CBCBCB;
    --malred-200: #FFA4B3;
    --malinfo-100: #E1EEF4;
    --malinfo-300: #3C8DDD;
    --malinfo-400: #1e61b6;
    --malsuccess-100: #e4f2e8;
    --malsuccess-200: #bae7c9;
    --malsuccess-300: #00ae42;
    --malsuccess-400: #009033;
    --malsuccess-500: #00601B;
    --malwarning-100: #FFF8E6;
    --malwarning-200: #F9DF8D;
    --malwarning-300: #FFA400;
    --malwarning-400: #F0941A;
    --malwarning-500: #D47129;
    --malerror-100: #ffd2dc;

    --post-bg: #3C8DDD;
    --get-bg: #009033;
    --patch-bg: #F0941B;
    --delete-bg: #D12E2d;
}

/* General Titles and Subtitles in Light Mode and Dark Mode */

.text-gray-900,
.text-gray-800,
.text-gray-700 {
    color: var(--malblack-400);
}

.text-primary {
    color: var(--malgreen-400);
}

.prose :where(h1, h2, h3, h4, h5, h6):not(:where([class~=not-prose] *)) {
    color: var(--malblack-400);
}

.prose :where(h1, h2, h3, h4, h5, h6):where([class=dark] *):not(:where([class~=not-prose] *)) {
    color: var(--malwhite-200);
}

.prose :where(thead th):not(:where([class~=not-prose] *)) {
    color: var(--malblack-100)
}

:is(.dark .prose :where(thead th):not(:where([class~=not-prose] *))) {
    color: var(--malwhite-500)
}

:is(.dark .prose :is(h1, h2, h3, h4, h5, h6)) {
    color: var(--malwhite-200);
}

.text-gray-600 {
    color: var(--malblack-200);
}

.text-gray-500 {
    color: var(--malblack-100);
}

.text-gray-200 {
    color: var(--malwhite-200);
}

.text-gray-400 {
    color: var(--malwhite-500);
}

.z-10 {
    color: var(--malgreen-300)
}

.prose {
    color: var(--malblack-100);
}

:is(.dark .prose) {
    color: var(--malwhite-500);
}

:is(.dark .dark\:text-gray-200) {
    color: var(--malwhite-200);
}

:is(.dark .dark\:text-gray-400) {
    color: var(--malwhite-500);
}


:is(.dark .dark\:text-primary-light) {
    --tw-text-opacity: 1;
    color: var(--malgreen-300);
}

/*CTA "Quero Testar" */
:is(.dark #topbar-cta-button .dark\:bg-primary-light\/10) {
    background-color: var(--malgreen-400);
}

/* Navbar and Arrow */
#navbar .text-gray-600 {
    color: var(--malblack-100);
}

#sidebar li .text-gray-600 {
    color: var(--malblack-100);
}

#sidebar li .text-gray-700 {
    color: var(--malblack-100);
}

#sidebar li .bg-primary\/10 {
    background-color: rgba(47, 172, 155, 0.1);
    color: var(--malgreen-400);
}

:is(.dark #sidebar li .text-gray-600) {
    color: var(--malwhite-500) !important;
}

:is(.dark #sidebar .dark\:text-gray-200) {
    color: var(--malwhite-300);
}

:is(.dark #sidebar li .text-gray-700) {
    color: var(--malwhite-500) !important;
}

:is(.dark #navbar .dark\:text-gray-400) {
    color: var(--malwhite-500) !important;
}

:is(.dark #navbar .dark\:text-primary-light) {
    color: var(--malwhite-100);
}

/* Table of Contents */
:is(.dark #table-of-contents .text-primary) {
    color: var(--malgreen-400);
}

/* Cards */
.card .text-gray-600 {
    color: var(--malblack-100);
}

:is(.dark .card .dark\:text-gray-400) {
    color: var(--malwhite-500);
}

:is(.dark .card h2) {
    color: var(--malwhite-200);
}

/* Api Reference */

/*botão post clicado light mode*/
.bg-\[\#3064E3\] {
    background-color: var(--malinfo-400);
    color: var(--malwhite-100);
}

/*botão post clicado dark mode*/
:is(.dark .bg-\[\#3064E3\]) {
    background-color: var(--malinfo-300);
}

.text-white {
    color: var(--malwhite-100);
}

/*botão post não clicado darkmode*/
:is(.dark .dark\:bg-blue-400\/20) {
    color: var(--malinfo-300);
}

/*botão post não clicado lightmode*/
.bg-blue-400\/20 {
    background-color: var(--malinfo-100);
    color: var(--malinfo-400);
}

.bg-\[\#2AB673\] {
    background-color: var(--get-bg);
}

.bg-\[\#DA622B\] {
    background-color: var(--patch-bg);
}

.bg-\[\#CB3A32\] {
    background-color: var(--delete-bg);
}

.bg-green-400\/20 {
    background-color: var(--malsuccess-100);
    color: var(--get-bg);
}

:is(.dark .dark\:text-green-400) {
    color: var(--malsuccess-300)
}

.bg-orange-400\/20 {
    background-color: var(--malwarning-100);
    color: var(--patch-bg);
}

:is(.dark .dark\:text-orange-400) {
    color: var(--malwarning-300)
}

.bg-red-400\/20 {
    background-color: var(--malerror-100);
    color: var(--delete-bg);
}

:is(.dark .dark\:text-red-400) {
    color: var(--malred-200)
}

/* Icons */
:is(.dark .dark\:bg-primary-light) {
    background-color: var(--malgreen-400);
}

.stroke-gray-400 {
    stroke: var(--malgreen-400);
}

/* Tip */
.border-emerald-500\/20 {
    border-color: var(--malgreen-200);
}

.bg-emerald-50\/50 {
    background-color: var(--malsuccess-100);
}

.bg-emerald-50\/50 .text-emerald-900 {
    color: var(--malsuccess-500);
}

.bg-emerald-50\/50 svg.text-emerald-600 {
    color: var(--malsuccess-400);
}

:is(.dark svg.text-emerald-600) {
    color: var(--malsuccess-200);
}

:is(.dark .dark\:text-emerald-200) {
    color: var(--malsuccess-200);
}

/* Warning */
.border-amber-500\/20 {
    border-color: var(--malwarning-200);
}

.bg-amber-50\/50 {
    background-color: var(--malwarning-100);
}

.bg-amber-50\/50 .text-amber-900 {
    color: var(--malwarning-500);
}

.bg-amber-50\/50 svg.text-amber-400 {
    stroke: var(--malwarning-400);
}

:is(.dark .dark\:text-amber-200) {
    color: var(--malwarning-200);
}

:is(.dark svg.text-amber-400) {
    stroke: var(--malwarning-300);
}

.malga-icon-box .malga-icon[id="sodexo"],
.malga-icon-box .malga-icon[id="visa"],
.malga-icon-box .malga-icon[id="master"],
.malga-icon-box .malga-icon[id="amex"],
.malga-icon-box .malga-icon[id="dinners"],
.malga-icon-box .malga-icon[id="discover"],
.malga-icon-box .malga-icon[id="jcb"],
.malga-icon-box .malga-icon[id="vr"],
.malga-icon-box .malga-icon[id="elo"] {
    width: 55px !important;
    height: 55px !important;
}

/* Tables  */
.prose tbody tr:nth-child(odd) {
    background-color: var(--malwhite-200);
}

:is(.dark .prose tbody tr:nth-child(odd)) {
    background-color: var(--malblack-400);
}

td:is(:first-child) {     
    padding-left: 8px;
}

td:is(:last-child) {
    padding-right: 8px;
}

td {
    vertical-align: middle !important;
}

td[align="center"] {
    text-align: center;
    vertical-align: middle !important;
}

td[align="left"] {
    text-align: left;
    vertical-align: middle !important;
}

td[align="right"] {
    text-align: right;
    vertical-align: middle !important;
}

td > span {
    height: 36px !important;
}

/* Check Icon Badge Dark Mode */
:is(.dark .prose :where(.malga-check-badge):not(:where([class~=not-prose] *))) {
    background-color: var(--malblack-300);
}

.check-icon > p {
    margin: 0 !important;
}

.table-legend > p {
    font-size: 12px;
    margin: 0;
}

.mx-1 {
    margin: 0 1em;
}

import { readFileSync, writeFileSync } from "node:fs";
import {
  getProviderFileName,
  unsupportedByProvider,
  handleCapabilities,
  moveSandboxToFirst,
} from "./utils.js";

import Mustache from "mustache";
import * as fsExtra from "fs-extra";

const basePath = "documentations/providers";

export function generateProvidersDocs(providers) {
  fsExtra.emptyDirSync(basePath);

  const creditTemplate = readFileSync(
    "scripts/generate-providers/templates/credit-provider-documentation.txt",
    "utf8"
  );

  const defaultTemplate = readFileSync(
    "scripts/generate-providers/templates/provider-documentation.txt",
    "utf8"
  );

  const providersList = Object.values(providers);
  moveSandboxToFirst(providersList);

  const providersToRemove = ["Rede", "Itaú"];

  const generatedFiles = providersList
    .filter((provider) => !providersToRemove.includes(provider.name))
    .filter((provider) => provider.documentation)
    .map((provider) => {
      const hasOnlyCredit = checkIfProviderHasOnlyCredit(provider);

      const template = hasOnlyCredit ? creditTemplate : defaultTemplate;
      const output = Mustache.render(template, handleProvider(provider));

      const fileName = getProviderFileName(provider.name);

      const filePath = `${basePath}/${fileName}`;
      writeFileSync(`${filePath}.mdx`, output);

      return filePath;
    });

  return generatedFiles;
}

function checkIfProviderHasOnlyCredit(provider) {
  const hasCredit =
    provider.paymentMethods?.creditCard !== unsupportedByProvider &&
    provider.paymentMethods?.creditCard !== false;

  const dontHaveAnyOtherMethod = Object.entries(provider.paymentMethods).some(
    ([key, value]) => {
      if (key === "creditCard") {
        return false;
      }

      return value === unsupportedByProvider || value === false;
    }
  );

  return hasCredit && dontHaveAnyOtherMethod;
}

function handleProvider(provider) {
  const hasSplit = provider.paymentMethods?.creditCard?.hasSplit === true;
  const has3ds = provider.paymentMethods?.creditCard?.has3ds === true;
  const hasWallet = provider.paymentMethods?.creditCard?.wallet === true;
  const hasPixParcelado = provider.paymentMethods?.pixParcelado === true;

  return {
    name: provider.name,
    type: handleType(provider.connectionType),
    description: provider.documentation?.description,
    docUrl: provider.documentation?.documentationUrl,
    handleCapabilities: () => {
      return (templateArgument) =>
        handleCapabilities(provider, templateArgument);
    },
    hasSplit,
    has3ds,
    hasWallet,
    hasPixParcelado,
    hasAnyServices: hasSplit || has3ds || hasWallet || hasPixParcelado,
  };
}

function handleType(type) {
  const types = {
    "payment-connection": "Provedor de pagamento",
    "antifraud-connection": "Provedor de antifraude",
    "payment-method": "Método de pagamento",
  };

  return types[type];
}


import { readFileSync, writeFileSync } from "node:fs";
import {
  getProviderFileName,
  iconType,
  unsupportedByProvider,
  handleCapabilities,
  moveSandboxToFirst,
} from "./utils.js";

import Mustache from "mustache";

export function generateProvidersTable(providers) {
  const template = readFileSync(
    "scripts/generate-providers/templates/providers-table.txt",
    "utf8"
  );

  const providersToRemove = ["Rede", "Itaú"];

  const providersList = Object.values(providers)
    .filter((provider) => !providersToRemove.includes(provider.name))
    .filter((provider) => provider.documentation)
    .map((provider) => {
      const providerFileName = getProviderFileName(provider.name);
      const docUrl = `/documentations/providers/${providerFileName}`;

      return {
        icon: provider.documentation?.icon,
        iconBackgroundColor: provider.documentation?.iconBackgroundColor,
        name: provider.name,
        docUrl: docUrl,
        providerType: provider.providerType,
        handleServices: () => {
          const icons = [
            ...handleServicesIcon(
              provider,
              "paymentMethods.creditCard.hasSplit",
              "Split"
            ),
            ...handleServicesIcon(
              provider,
              "paymentMethods.creditCard.has3ds",
              "3DS2"
            ),
            ...handleServicesIcon(
              provider,
              "paymentMethods.creditCard.wallet",
              "Wallet"
            ),
            ...handleServicesIcon(
              provider,
              "paymentMethods.pixParcelado",
              "Pix Parcelado"
            ),
          ];

          if (!icons.length) {
            return "";
          }

          const checks = icons.join("");

          return `<div className="flex flex-row gap-2">${checks}</div>`;
        },
        handleCapabilities: () => {
          return (templateArgument) =>
            handleCapabilities(provider, templateArgument);
        },
      };
    });

  moveSandboxToFirst(providersList);

  const output = Mustache.render(template, { providers: providersList });
  const filePath =
    "documentations/type-tables/payment-methods-by-providers.mdx";

  writeFileSync(filePath, output);

  return "documentations/type-tables/payment-methods-by-providers";
}

function handleServicesIcon(provider, service, serviceName) {
  const features = service.split(".");
  const providerService = features.reduce((acc, feature) => {
    return acc?.[feature];
  }, provider);

  const isUnsupportedByProvider = providerService === unsupportedByProvider;

  if (isUnsupportedByProvider || !providerService) {
    return [];
  }

  const icon = iconType[true];

  return [`<CheckIconBadge ${icon}>${serviceName}</CheckIconBadge>`];
}


import { generateProvidersDocs } from "./generate-providers-docs.js";
import { generateProvidersTable } from "./generate-providers-table.js";
import { updateMintFile } from "./update-mint-file.js";

import Mustache from "mustache";

const providers = await fetch(
  "https://malga-providers.s3.amazonaws.com/providers.json"
).then((res) => res.json());

Mustache.escape = (str) => str;

const generatedTableFile = generateProvidersTable(providers);
const generatedDocs = generateProvidersDocs(providers);

const generatedFiles = [generatedTableFile, ...generatedDocs];

updateMintFile(generatedFiles);


import { readFileSync, writeFileSync } from "node:fs";

export function updateMintFile(files) {
  const mint = readFileSync("mint.json", "utf8");
  const mintJson = JSON.parse(mint);

  mintJson.navigation
    .find((e) => e.group === "Conexões")
    .pages.find((e) => e.group === "Provedores de pagamento").pages =
    files;

  writeFileSync("mint.json", JSON.stringify(mintJson), "utf8");
}


export const unsupportedByProvider = "unsupported-by-provider";

export const iconType = {
  true: `type="check" mode="success"`,
  false: `type="check" mode="noSupported"`,
  unsupportedByProvider: `type="xmark" mode="error"`,
};

export function getProviderFileName(providerName) {
  return providerName
    .replaceAll(/\./g, "")
    .replaceAll(" ", "-")
    .normalize("NFD")
    .replaceAll(/[\p{Diacritic}]/gu, "")
    .toLowerCase();
}

export function moveSandboxToFirst(providers) {
  const indexOfSandbox = providers.findIndex((provider) =>
    provider.providerType?.includes("SANDBOX")
  );
  const sandboxProvider = providers[indexOfSandbox];

  providers.splice(indexOfSandbox, 1);

  providers.unshift(sandboxProvider);
}

export function handleCapabilities(provider, templateArgument) {
  const features = templateArgument.split(".");

  const capability = features.reduce((acc, feature) => {
    return acc?.[feature];
  }, provider);

  if (!capability) {
    return iconType[false];
  }

  if (capability === unsupportedByProvider) {
    return iconType.unsupportedByProvider;
  }

  return iconType[true];
}


Dashboard

Nosso Blog

Status Page

Malga

Documentação

SDKs

Referência da API

Analytics

Release Notes

Quero testar

Suporte

PageInfo

Sobre a Malga

Sobre o produto

Primeiros passos

Autenticação

Guia de teste

Tratamento de erros

Ativando sua conta

Introdução

Cartão de crédito

Boleto

NuPay

Picpay

Drip

Voucher

Sandbox

Adyen

Barte

Banco do Brasil

Braintree

Braspag

Cielo

Getnet

Klap

Mercado Pago

Pagar.me

Pagar.me v5

PagSeguro

SafraPay

Stripe

WorldPay

Zoop

Provedores de antifraude

Idempotência

Migração de cartões

Token CVV

Validação de Cartões

Tokenização de Bandeira

Fluxos no Dashboard

Fluxos Inteligentes no Dashboard Malga

Visualização

Visualizando o fluxo

Criando fluxo

Começando um novo fluxo

Condicionais

Utilizando condicionais

Histórico

Histórico de fluxos

Editando Fluxo

Validação e publicação

Exemplos

Exemplos de uso

Erros

Gestão de Cobranças

Usuários e Permissões

Link de Pagamento

Exportando dados

Exportando dados através do Dashboard

Relatório Simples

Relatório simples (pelo último status da cobrança)

Relatório Completo

Relatório completo (com o histórico de operações das cobranças)

Renomear subcontas

Painel de Dados

v1.1

Webhooks v1.1

v1.0 (obsoleto)

Webhooks v1.0 (obsoleto)

Tabela de código de negação para declinedCode

Tabela de códigos MCC

Tabela tipos de moedas aceitas

Tabela tipos de paises e documentos cadastro de Customer

Tabela códigos dos principais bancos

Testando

Testando em Sandbox

Antifraudes Síncronos

Fluxo do Antifraude Síncrono

Antifraudes Assíncronos

Fluxo do Antifraude Assíncrono

Feeding

Fluxo de Feeding

Malga Checkout

Gerenciar Recebedores

Recebedor (seller)

Cobrança com Split

Provedores suportados

Cobrança com 3DS2

Como funciona o 3D Secure 2

Fluxos com desafio

Recorrência

Sessões

Getting Started

Node.js

Express

SDK JS

Checkout SDK em Javascript

SDK Angular.js

SDK React.js

SDK Vue.js

Checkout Full SDK em Javascript

Magento

WooCommerce

Conector VTEX

Sobre as APIs

Criar nova chave pública para uso no client-side

Listar cartões

Criar novo cartão a partir de token

Recuperar detalhes de cartão

Criar um novo token

Listar cobranças

Realizar nova cobrança

Recuperar detalhes de cobrança

Alterar o status de uma cobrança no ambiente de sandbox

Alterar o status do antifraude no ambiente de sandbox

Capturar cobrança pre-autorizada

Estornar cobrança aprovada

Criar nova sessão

Recuperar detalhes de uma sessão

Atualizar o status de uma sessão

Pagar uma sessão

Cancelar uma sessão

Recuperar o histórico da sessão

Recupera sessão com os dados das configurações da empresa

Listagem de customers cadastrados

Criação de novo customer para cobrança

Recuperar detalhes de customer

Deletar customer pelo id

Atualizar customer pelo id

Listagem dos cartões do customer

Adicionar cartão de crédito ao customer

Listagem de merchants cadastrados

Criação de novo merchant para cobrança

Recuperar detalhes de merchant pelo id

Deletar merchant pelo id

Atualizar configurações de merchant

Listagem de vendedores paginada

Criação de um novo vendedor

Atualizar um vendedor

Recuperar detalhes de um vendedor

Deletar vededor pelo id

Criação de um novo recebedor

Consultar um recebedor pelo ID

Consultar um recebedor por listagem paginada

Deletar recebedor por ID

Atualização de recebedor pelo ID

Recuperar todos os fluxos paginado

Consultar um fluxo pelo id

Listagem de webhooks cadastrados

Criação de novo webhook para notificação

Recuperar detalhes de webhook

Deletar webhook pelo id

Atualizar webhook pelo id

Exportar dados da base

Recuperar detalhes de uma exportação

Os arquivos podem ser baixados durante um período de até 30 dias após a data de exportação. Depois desse período, os arquivos não estarão mais disponíveis para download.

Fazer download de um arquivo

Sep 19 - Barte

Sep 10 - Usuários e permissões

Sep 04 - PicPay PIX

Melhorias de UX no Dashboard e novas documentações

Aug 29 - Dashboard

Aug 19 - Picpay

July 05 - Nova busca de cobranças

July 03 - Facilitadores de pagamentos

Adição do parâmetro splitRules no estorno para possibilitar o estorno parcial de split

June 28 - Estorno Parcial de Split

Novos campos de Tokenização de Bandeira

Jun 24 - Exportação de Cobranças

Adição da Barte como novo provedor de crédito

May 28 - Barte

May 28 - Tokens de Bandeira

May 23 - Correções Dash

May 09 - Filtro de disputa

Apr 18 - Export relatórios

Nova forma de encontrar cobranças pelo Dashboard Malga 🙌

Apr 02 - Filtro por provedor

Mar 11 - Pesquisa por NSU

Mar 06 - Cobrança por status

Reversão de uma operação de estorno bem sucedido

Mar 05 - Reversão de estorno

Feb 28 - Safrapay

Adição do campo de quantidade de parcelas máximas (opcional) para determinada transação realizada pela DRIP

Feb 21 - Parcelas pela Drip

CAMPO: OBJETO	DESCRIÇÃO
endCursor: String	Cursor indicando a paginação
hasNextPage: Boolean	Possui próxima página
hasPreviousPage: Boolean	Possui página anterior

Analytics API