/**
 * Unified Footer Script for Mintlify
 * Handles both regular pages and custom pages
 */
(function() {
  // Configuration
  const footerConfig = {
    copyright: '© 2025 Centavo, Inc. All rights reserved | Centavo (DBA Payabli) is a registered Payment Facilitator of Wells Fargo Bank, NA, Concord, CA. Payabli is a registered ISO/MSP of Merrick Bank, South Jordan, UT.',
    links: [
      { text: 'Payabli', url: 'https://payabli.com' },
      { text: 'Test Cards & Accounts', url: '/references/test-accounts' },
      { text: 'Pay In Statuses', url: '/references/money-in-statuses' },
      { text: 'Pay Out Statuses', url: '/references/money-out-statuses' },
    ]
  };

  // Delay initial injection to ensure DOM is properly structured
  const INITIAL_DELAY = 700; // ms - adjust if needed
  
  // Initialize when DOM is ready
  if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', function() {
      setTimeout(init, INITIAL_DELAY);
    });
  } else {
    setTimeout(init, INITIAL_DELAY);
  }
  
  function init() {
    injectFooter();
    setupObserver();
    
    // Additional check after a delay to ensure footer exists
    setTimeout(function() {
      if (!footerExists()) {
        injectFooter();
      }
    }, 1000);
  }
  
  // Check if footer already exists by our ID
  function footerExists() {
    return document.getElementById('custom-footer') !== null;
  }
  
  // More reliable page type detection
  function getPageType() {
    // Skip injection on home page - checking for home.mdx specific elements
    if (document.querySelector('.home-content-container') || 
        document.querySelector('.home-card-section') ||
        document.querySelector('.home-header-container') ||
        window.location.pathname === '/' ||
        window.location.pathname === '/home' ||
        window.location.pathname.endsWith('home.mdx')) {
      console.log('Detected home page, skipping footer injection');
      return 'home';
    }
    
    // Check for custom page indicators
    if (document.querySelector('[class*="custom-page"]')) {
      console.log('Detected custom page');
      return 'custom';
    }
    
    // Check for existing footer
    if (document.querySelector('footer:not(#custom-footer)')) {
      console.log('Detected regular page with existing footer');
      return 'regular';
    }
    
    // Default to standalone if we can't determine
    console.log('Detected standalone page');
    return 'standalone';
  }
  
  // Create footer content (shared between all footer types)
  function createFooterContent() {
    const content = document.createElement('div');
    content.className = 'footer-content';
    
    // Copyright text
    const copyright = document.createElement('div');
    copyright.className = 'footer-copyright';
    copyright.textContent = footerConfig.copyright;
    
    // Links
    const links = document.createElement('div');
    links.className = 'footer-links';
    
    footerConfig.links.forEach(link => {
      const a = document.createElement('a');
      a.href = link.url;
      a.textContent = link.text;
      a.className = 'footer-link';
      a.target = '_blank'; // Open in new tab
      a.rel = 'noopener noreferrer'; // Security best practice
      links.appendChild(a);
    });
    
    // Assemble content
    content.appendChild(copyright);
    content.appendChild(links);
    
    return content;
  }
  
  // Inject footer based on page type
  function injectFooter() {
    // Skip if already exists
    if (footerExists()) {
      console.log('Footer already exists, skipping injection');
      return;
    }
    
    const pageType = getPageType();
    
    // Skip injection on home page
    if (pageType === 'home') {
      console.log('Home page detected, skipping footer injection');
      return;
    }
    
    // Add appropriate styles
    addFooterStyles();
    
    // Handle different page types
    switch (pageType) {
      case 'custom':
        injectCustomPageFooter();
        break;
      case 'regular':
        appendToExistingFooter();
        break;
      case 'standalone':
        injectStandaloneFooter();
        break;
    }
  }
  
  // Add footer to custom page (like home)
  function injectCustomPageFooter() {
    const footer = document.createElement('footer');
    footer.id = 'custom-footer';
    footer.className = 'custom-page-footer';
    
    footer.appendChild(createFooterContent());
    
    // More specific targeting for the home page
    // Find home container to append after - more robust targeting
    const homeContainer = document.querySelector('.home-content-container');
    const cardSection = document.querySelector('.home-card-section');
    const mainContent = document.querySelector('main');
    
    if (homeContainer) {
      console.log('Injecting after home-content-container');
      // Insert after the container
      if (homeContainer.nextSibling) {
        homeContainer.parentNode.insertBefore(footer, homeContainer.nextSibling);
      } else {
        homeContainer.parentNode.appendChild(footer);
      }
    } else if (cardSection) {
      console.log('Injecting after home-card-section');
      if (cardSection.nextSibling) {
        cardSection.parentNode.insertBefore(footer, cardSection.nextSibling);
      } else {
        cardSection.parentNode.appendChild(footer);
      }
    } else if (mainContent) {
      console.log('Injecting at end of main content');
      mainContent.appendChild(footer);
    } else {
      console.log('Fallback: appending to body');
      // Fallback to appending to body
      document.body.appendChild(footer);
    }
  }
  
  // Append content to existing footer
  function appendToExistingFooter() {
    const existingFooter = document.querySelector('footer:not(#custom-footer)');
    if (!existingFooter) {
      console.log('No existing footer found, falling back to standalone');
      injectStandaloneFooter();
      return;
    }
    
    const customContent = document.createElement('div');
    customContent.id = 'custom-footer';
    customContent.className = 'existing-footer-content';
    
    customContent.appendChild(createFooterContent());
    existingFooter.appendChild(customContent);
    console.log('Appended to existing footer');
  }
  
  // Create standalone footer
  function injectStandaloneFooter() {
    const footer = document.createElement('footer');
    footer.id = 'custom-footer';
    footer.className = 'standalone-footer';
    
    footer.appendChild(createFooterContent());
    
    // Try to find main content
    const mainContent = document.querySelector('main') || 
                       document.querySelector('[class*="content"]') ||
                       document.body;
    
    mainContent.appendChild(footer);
    console.log('Injected standalone footer');
  }
  
  // Add footer styles
  function addFooterStyles() {
    // Skip if styles already added
    if (document.getElementById('mintlify-footer-styles')) return;
    
    const style = document.createElement('style');
    style.id = 'mintlify-footer-styles';
    
    style.textContent = `
      /* Shared styles */
      .footer-content {
        max-width: 1200px;
        margin: 0 auto;
        padding: 0 1rem;
      }
      
      .footer-copyright {
        margin-bottom: 1rem;
        font-size: 0.875rem;
        line-height: 1.5;
      }
      
      .footer-links {
        display: flex;
        justify-content: center;
        gap: 1.5rem;
        flex-wrap: wrap;
      }
      
      .footer-link {
        color: var(--tw-prose-links, #0066cc);
        text-decoration: none;
      }
      
      .footer-link:hover {
        text-decoration: underline;
      }
      
      /* Custom page footer */
      .custom-page-footer {
        margin-top: 4rem;
        padding: 2rem 0;
        /* border-top: 1px solid #e5e7eb; */
        text-align: center;
        width: 100%;
        position: relative;
        z-index: 10;
      }
      
      /* Content appended to existing footer */
      .existing-footer-content {
        margin-top: 1rem;
        padding-top: 1rem;
        /*border-top: 1px solid rgba(0, 0, 0, 0.1);*/
        text-align: center;
      }
      
      /* Standalone footer */
      .standalone-footer {
        margin-top: 4rem;
        padding: 2rem 0;
        border-top: 1px solid #e5e7eb;
        text-align: center;
        width: 100%;
        position: relative;
        z-index: 10;
      }
      
      /* Dark mode support */
      @media (prefers-color-scheme: dark) {
        .custom-page-footer,
        .standalone-footer {
          border-color: #374151;
        }
        
        .existing-footer-content {
          border-color: rgba(255, 255, 255, 0.1);
        }
        
        .footer-link {
          color: var(--tw-prose-links, #60a5fa);
        }
      }
      
      .dark .custom-page-footer,
      .dark .standalone-footer,
      .dark-theme .custom-page-footer,
      .dark-theme .standalone-footer {
        border-color: #374151;
      }
      
      .dark .existing-footer-content,
      .dark-theme .existing-footer-content {
        border-color: rgba(255, 255, 255, 0.1);
      }
      
      .dark .footer-link,
      .dark-theme .footer-link {
        color: var(--tw-prose-links, #60a5fa);
      }
    `;
    
    document.head.appendChild(style);
    console.log('Footer styles added');
  }
  
  // Set up observer for page changes - with delay to prevent premature injection
  function setupObserver() {
    let debounceTimer;
    
    const observer = new MutationObserver(mutations => {
      // Clear any existing timer
      clearTimeout(debounceTimer);
      
      // Set a new timer
      debounceTimer = setTimeout(() => {
        if (!footerExists()) {
          console.log('DOM changed, checking for footer injection');
          injectFooter();
        }
      }, 300);
    });
    
    observer.observe(document.body, {
      childList: true,
      subtree: true
    });
    
    // Handle route changes if using Next.js
    if (window.next && window.next.router) {
      window.next.router.events.on('routeChangeComplete', () => {
        clearTimeout(debounceTimer);
        debounceTimer = setTimeout(injectFooter, 500);
      });
    }
    
    console.log('Observer set up');
  }
})();

Link Transaction

Link Customer to Transaction

ApiKeyAuth

requestToken

Payabli Docs

Use these references to get to know Payabli's APIs

Intro

API Reference

Read answers to common questions and learn how to troubleshoot problems

Support Home

Changes, improvements, and fixes to the Payabli APIs and UIs in 2025

2025 API and UI Changelog

Changes, improvements, and fixes to the Payabli APIs and UIs in 2024

2024 API and UI Changelog

Changes, improvements, and fixes to the Payabli APIs and UIs in 2023

2023 API and UI Changelog

component.js Changelog

Embedded Components Library Changelog

Browse through resources by audience and area

Resources Index

Use these educational guides to become a payments expert

Overview Guides

Learn about Payabli's three Ps: Pay In, Pay Out, Pay Ops

The Three Ps

Learn how transactions, batches, and transfers work together in Payabli to move money

How Money Moves

Learn how to get from signing with Payabli to your first residual check

Getting Started

Get Started with Payabli

Learn about the Pay In transaction lifecycle and its stages and statuses

Pay In Transaction Lifecycle

ACH Payments Cycle

Credit Card Payments Cycle

Learn how payment disputes like chargebacks and ACH returns work

Payment Disputes

Learn about the fields required for Level I, II, and III processing

Level II & Level III Processing

Level II and Level III Processing

Learn how pass-through fees work in Payabli

Pass-Through Fees

Learn how Payabli handles chargebacks and ACH returns for split transactions

Split Chargebacks and Returns

Split Payment Chargebacks and Returns

Learn how payment method tokenization secures sensitive data and enhances security for your payments

Tokenization Overview

Payment Method Tokenization

Learn about refunds and what to do when refunds fail

Refunds and Refund Failures

Understand Refunds and Failures

Learn about Cardholder Initiated Transaction (CIT) and Merchant Initiated Transaction (MIT) indicators for Pay In transactions

CIT & MIT indicators

Understanding CIT and MIT Indicators

Learn about managed payables and the vendor enablement process

Managed Payables

Understanding Managed Payables

Learn more about the know-your-customer (KYC) and know-your-business (KYB) fields required for merchant onboarding

KYC and KYB Requirements

Required Fields for Boarding Applications

Use these developer-focused guides and to build your integration with Payabli

Integration Guides and Developer Resources

Learn how to build a world-class payments integration with Payabli

Getting Started for Developers

Learn the difference between these commonly used terms

Paypoint vs Entrypoint

Use these references to look up glossary terms, response codes, errors, and statuses

References

Understand common terms used in Payabli and across the payments industry

Payment Glossary

Use these payment methods to test your integration with Payabli

Payment Methods for Testing

Money In Schemas

Money In Statuses

Understand how to handle different types of ACH returns

ACH Return Codes

ACH Return Codes Reference

Learn about payment response codes for different payment methods

Payment Responses

Payment Response Codes and Errors

Learn about money out statuses and events and how they work together

Money Out Schemas

Money Out Statuses

Learn about statuses and substatuses during the merchant boarding process

Boarding Statuses

Boarding Statuses Reference

TransEvent Reference

Use these guides to learn about using Payabli as a partner or a merchant

User Guides

Learn how to set up a PAX A920 device in PayHub to make card-present sales

PAX A920 Setup

Set Up a PAX A920 Device in PayHub

Learn about enabling Apple Pay via the Payabli UI

Activate Apple Pay

Activate Apple Pay (UI)

Learn about managing Apple Pay and payment method domains via the Payabli UI

Manage Apple Pay

Manage Apple Pay (UI)

Learn how to get the check image for a paid payout to a vendor from PartnerHub or PayHub

Get payout check image

Get Payout Transaction Check Image

Board Merchants

Learn how to see an application's notes and events in PartnerHub

Notes & Events

Get Boarding App Notes and Events in PartnerHub

Learn how to bulk board merchants in Payabli

Bulk Boarding

Bulk Boarding Guide

Learn how to access Payabli's PartnerHub and PayHub UIs

Access UI

Access PartnerHub and PayHub

Learn about how threshold amounts affect your payment processing

Thresholds

Understanding Thresholds

Learn how to update a paypoint's bank account information

Change Bank Accounts

Request Bank Account Change

Learn which countries and territories are supported for money in and money out features

Supported Regions

Learn about merchant pricing structures offered by Payabli

Pricing Structures

Understanding Merchant Pricing Structures

Learn how to interpret merchant statements for processing fees

Merchant Statements

Understanding Processing Fees Statements

Learn how migrating tokenized card data works in Payabli

Card Token Migration

Migrate Tokenized Card Data

Learn how to migrate tokenized payment data from Stripe into Payabli

From Stripe

Migrate from Stripe

Learn how to migrate tokenized payment data from Authorize.net into Payabli

From Authorize.net

Migrate from Authorize.net

Learn how to migrate tokenized payment data from Payabli to a different provider

Out of Payabli

Migrate Token Data from Payabli

Payabli's public PGP key for migrating stored payment method tokens

Public PGP Key

Understand how entities work in PartnerHub and PayHub

Entities Overview

Entities Overview for Partners and Paypoints

Learn how to add and manage customers in PartnerHub and PayHub

Manage Customers

Manage Customers in the UI

Learn how to add and manage users in PartnerHub and PayHub

Manage Users

Manage Users in the UI

Learn how to add and manage vendors in PartnerHub and PayHub

Manage Vendors

Manage Vendors in the UI

Learn how custom identifiers work and how to manage them in PartnerHub

Custom Identifiers

Support

Learn more about Payabli's Pay In features for developers, and find all the guides in one place.

Pay In Developer Overview

Learn more about Payabli's Pay Out features for developers, and find all the guides in one place.

Pay Out Developer Overview

Learn more about Payabli's Pay Ops features for developers, and find all the guides in one place.

Pay Ops Developer Overview

Use Creator to build your own PCI-compliant embeddable components with no code

Build Your Own Components

Learn how authentication and API tokens work with the Payabli API

Authentication and API Tokens

Use idempotency keys to prevent duplicate requests

Request Idempotency

Prevent Duplicate Requests

Learn about the environments you can use to build with Payabli

Environments

Learn about entrypoints and how they are used in Payabli

Entrypoint Overview

Learn about responseCode and resultCodes returned by the API

API Responses

API responseCode and resultCode Reference

Learn about request limits and fraud controls in Payabli

Rate Limits

Download a Payabli Postman collection to get testing fast

Postman Collection

Make a single transaction. This method authorizes and captures a payment in one step.

Make Transaction

Make a Sale Transaction

Authorize a card transaction. This returns an authorization code and reserves funds for the merchant. Authorized transactions aren't flagged for settlement until [captured](/api-reference/moneyin/capture-an-authorized-transaction).

**Note**: Only card transactions can be authorized. This endpoint can't be used for ACH transactions.


Authorize Transaction

Capture an [authorized transaction](/api-reference/moneyin/authorize-a-transaction) to complete the transaction and move funds from the customer to merchant account.

Capture Transaction

Capture Authorized Transaction

Retrieve a processed transaction's details.

Get Transaction Details

Get Details for Processed Transaction

Validates a card number without running a transaction or authorizing a charge.

Validate Card

Cancel a transaction that hasn't been settled yet. Voiding non-captured authorizations prevents future captures. If a transaction has been settled, refund it instead.

Void Transaction

Refund a transaction that has settled and send money back to the account holder. If a transaction hasn't been settled, void it instead.

Refund Transaction

Refund Settled Transaction

Refunds a settled transaction with split instructions.

Refund Split Transaction

Refund Settled Transaction with Split Instructions

A reversal either refunds or voids a transaction independent of the transaction's settlement status. Send a reversal request for a transaction, and Payabli automatically determines whether it's a refund or void. You don't need to know whether the transaction is settled or not.

API Basics

Pay In Endpoints

Pay Out Endpoints

Pay Ops Endpoints

Object Models

Link Customer to Transaction

Authorizations

Path Parameters

Response