/* 
** FIXES
** This section contains fixes for things that are broken on the site as opposed to subjectively making the site look better
*/

/* 
** START Make API reference example code blocks overflow with a scrollbar
*/

p.whitespace-pre-line:has(> code:only-child){
    display: inline-grid;
}

p.whitespace-pre-line>code {
    overflow-x: auto;
    overflow-wrap: normal;
    scrollbar-width:none; /* overlay scrollbars may hide content on some devices */
}

/* 
** END Make API reference example code blocks overflow with a scrollbar
*/

/* 
** CUSTOMIZATIONS
** This section contains stylings rather than fixing anything that is broken on the site
*/


/* 
** Resize the logo in the top left of the site
*/

div#navbar img
{
    height: 20px;
}

/* 
** Align all table headers
*/

table th{
    text-align: left;
}

/* 
** START Allows dropdown to be sticky and hide other menu items on scroll and hover
*/

#navigation-items button{
    position: sticky; 
    top: 20px;
    box-shadow: 0 -10px 5px 25px rgb(var(--background-light))
}

#navigation-items button:is(.dark *){
    box-shadow: 0 -10px 5px 25px rgb(var(--background-dark));
}

#navigation-items button:hover{
    background-color: rgb(var(--gray-100));
}

#navigation-items button:hover:is(.dark *){
    background-color: rgb(var(--gray-800));
}

/* 
** END Allows dropdown to be sticky and hide other menu items on scroll and hover
*/

#!/usr/bin/env node

const fs = require('fs');
const path = require('path');
const https = require('https');
const http = require('http');

/**
 * Downloads an OpenAPI specification from a URL and saves it to the specified location
 * @param {string} url - The URL of the OpenAPI specification
 * @param {string} category - The category name (e.g., 'hris')
 */
function downloadOAS(url, category) {
    // Create the directory structure
    const outputFilename = category + '.json';
    const outputDir = path.join(category, 'api-reference');
    ensureDirectoryExists(outputDir);

    const outputPath = path.join(outputDir, outputFilename);

    console.log(`Downloading OpenAPI spec from: ${url}`);
    console.log(`Saving to: ${outputPath}`);

    // Determine if we need http or https
    const client = url.startsWith('https') ? https : http;
    
    // Set up request options with headers
    const options = {
        headers: {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
            'Accept': 'application/json'
        }
    };

    // Create a file stream to save the downloaded content
    const fileStream = fs.createWriteStream(outputPath);

    // Download the file
    const request = client.get(url, options, (response) => {
        // Check if the request was successful        
        if (response.statusCode !== 200) {
            console.error(`Failed to download: ${response.statusCode} ${response.statusMessage}`);
            fileStream.close();
            fs.unlinkSync(outputPath); // Remove the file if download failed
            process.exit(1);
            return;
        }

        // Pipe the response to the file
        response.pipe(fileStream);

        // Handle completion
        fileStream.on('finish', () => {
            fileStream.close();
            console.log('Download completed successfully');

            // Validate the downloaded JSON
            try {
                const jsonContent = fs.readFileSync(outputPath, 'utf8');
                JSON.parse(jsonContent);
                console.log('OpenAPI specification is valid JSON');
            } catch (error) {
                console.error('Downloaded file is not valid JSON:', error.message);
                process.exit(1);
            }
        });
    });

    // Handle errors
    request.on('error', (error) => {
        console.error('Error downloading file:', error.message);
        fileStream.close();
        fs.unlinkSync(outputPath); // Remove the file if download failed
        process.exit(1);
    });

    fileStream.on('error', (error) => {
        console.error('Error writing file:', error.message);
        process.exit(1);
    });
}

/**
 * Ensures that a directory exists, creating it if necessary
 * @param {string} dirPath - The directory path to check/create
 */
function ensureDirectoryExists(dirPath) {
    if (!fs.existsSync(dirPath)) {
        fs.mkdirSync(dirPath, { recursive: true });
        console.log(`Created directory: ${dirPath}`);
    }
}

// Main execution
if (process.argv.length < 4) {
    console.error('Usage: node download-oas.js <url> <category>');
    console.error('Example: node download-oas.js https://example.com/api.json hris');
    process.exit(1);
}

const url = process.argv[2];
const category = process.argv[3];

downloadOAS(url, category); 

#!/usr/bin/env node

/**
 * This script installs Git hooks for the project.
 * It copies the pre-commit hook to the .git/hooks directory and makes it executable.
 * 
 * Usage:
 *   node scripts/install-hooks.js
 */

const fs = require('fs');
const path = require('path');
const { execSync } = require('child_process');

// Get the root directory of the Git repository
const gitRoot = execSync('git rev-parse --show-toplevel', { encoding: 'utf8' }).trim();

// Paths for hooks
const hooksDir = path.join(gitRoot, '.git', 'hooks');
const preCommitSource = path.join(gitRoot, 'scripts', 'hooks', 'pre-commit');
const preCommitDest = path.join(hooksDir, 'pre-commit');

// Create hooks directory if it doesn't exist
if (!fs.existsSync(hooksDir)) {
  console.log(`Creating hooks directory: ${hooksDir}`);
  fs.mkdirSync(hooksDir, { recursive: true });
}

// Create scripts/hooks directory if it doesn't exist
const hooksSourceDir = path.join(gitRoot, 'scripts', 'hooks');
if (!fs.existsSync(hooksSourceDir)) {
  console.log(`Creating hooks source directory: ${hooksSourceDir}`);
  fs.mkdirSync(hooksSourceDir, { recursive: true });
}

// Create the pre-commit hook in the scripts/hooks directory
const preCommitContent = `#!/bin/sh

# Pre-commit hook to run wrap-images.js script
# This ensures all images in MDX files are properly wrapped with Frame tags

echo "Running wrap-images script to ensure all images are properly wrapped..."

# Get the directory of the git repository
REPO_ROOT=$(git rev-parse --show-toplevel)

# Get list of staged MDX files
STAGED_MDX_FILES=$(git diff --cached --name-only --diff-filter=ACMR | grep '\\.mdx$' || true)

if [ -z "$STAGED_MDX_FILES" ]; then
    echo "No staged MDX files found. Proceeding with commit..."
    exit 0
fi

# Process each staged MDX file
echo "Processing staged MDX files..."
for file in $STAGED_MDX_FILES; do
    echo "Checking $file"
    node "$REPO_ROOT/scripts/wrap-images.js" "$file"
    
    # Check if the script executed successfully
    if [ $? -ne 0 ]; then
        echo "Error: wrap-images script failed on $file. Aborting commit."
        exit 1
    fi
done

# Check if there are any changes in the staged MDX files after running the script
for file in $STAGED_MDX_FILES; do
    if [ -n "$(git diff --name-only "$file")" ]; then
        echo "Images were wrapped with Frame tags in $file. Please stage these changes and commit again."
        echo "Run 'git add $file' and try committing again."
        exit 1
    fi
done

echo "All images in staged MDX files are properly wrapped. Proceeding with commit..."
exit 0
`;

// Write the pre-commit hook to the scripts/hooks directory
console.log(`Creating pre-commit hook in: ${preCommitSource}`);
fs.writeFileSync(preCommitSource, preCommitContent, { mode: 0o755 });

// Copy the pre-commit hook to the .git/hooks directory
console.log(`Installing pre-commit hook to: ${preCommitDest}`);
fs.copyFileSync(preCommitSource, preCommitDest);

// Make the pre-commit hook executable
console.log('Making pre-commit hook executable');
fs.chmodSync(preCommitDest, 0o755);

console.log('Git hooks installed successfully!');
console.log('The pre-commit hook will now run the wrap-images.js script before each commit.'); 

#!/usr/bin/env node

/**
 * This script finds all .mdx files in the codebase and wraps markdown images
 * with <Frame> tags if they're not already wrapped.
 * 
 * Usage:
 *   node wrap-images.js                  # Process all .mdx files in the codebase
 *   node wrap-images.js path/to/file.mdx # Process a specific file
 *   node wrap-images.js --verbose        # Run with verbose logging
 *   node wrap-images.js path/to/file.mdx --verbose # Process a specific file with verbose logging
 */

const fs = require('fs');
const path = require('path');
const { promisify } = require('util');

const readdir = promisify(fs.readdir);
const readFile = promisify(fs.readFile);
const writeFile = promisify(fs.writeFile);

// Parse command line arguments
const args = process.argv.slice(2);
const verboseMode = args.includes('--verbose');
const fileArg = args.filter(arg => arg !== '--verbose')[0];

// Utility function for verbose logging
function verboseLog(...messages) {
    if (verboseMode) {
        console.log('[VERBOSE]', ...messages);
    }
}

// Regular expression to match markdown image syntax
const imageRegex = /!\[([^\]]*)\]$([^)]*)$/g;

/**
 * Recursively finds all .mdx files in a directory
 * @param {string} dir - Directory to search
 * @returns {Promise<string[]>} - Array of file paths
 */
async function findMdxFiles(dir) {
    const files = [];

    async function traverse(currentDir) {
        try {
            const entries = await readdir(currentDir, { withFileTypes: true });

            for (const entry of entries) {
                const fullPath = path.join(currentDir, entry.name);

                // Skip .git and node_modules directories
                if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
                    await traverse(fullPath);
                } else if (entry.isFile() && entry.name.endsWith('.mdx')) {
                    files.push(fullPath);
                }
            }
        } catch (error) {
            console.error(`Error reading directory ${currentDir}:`, error.message);
        }
    }
    await traverse(dir);
    return files;
}

/**
 * Processes a single .mdx file to wrap images with Frame tags
 * @param {string} filePath - Path to the file
 * @returns {Promise<boolean>} - Whether the file was updated
 */
async function processFile(filePath) {
    try {
        const content = await readFile(filePath, 'utf8');
        verboseLog(`Processing file: ${filePath}`);
        
        // Function to check if an image at a specific position is wrapped in Frame tags
        function isWrappedInFrame(fullContent, matchIndex, matchLength) {
            // Check for <Frame> before the image
            const beforeContent = fullContent.substring(0, matchIndex).trim();
            const hasFrameBefore = beforeContent.endsWith('<Frame>');
            
            // Check for </Frame> after the image
            const afterContent = fullContent.substring(matchIndex + matchLength).trim();
            const hasFrameAfter = afterContent.startsWith('</Frame>');
            
            return hasFrameBefore && hasFrameAfter;
        }
        
        // Find all image matches and replace unwrapped ones
        let lastIndex = 0;
        let match;
        let resultParts = [];
        let unwrappedCount = 0;
        
        while ((match = imageRegex.exec(content)) !== null) {
            const matchIndex = match.index;
            const matchText = match[0];
            const alt = match[1];
            const src = match[2];
            
            // Add content before this match
            resultParts.push(content.substring(lastIndex, matchIndex));
            
            // Check if this image is already wrapped
            if (isWrappedInFrame(content, matchIndex, matchText.length)) {
                verboseLog(`Skipping already wrapped image: ${src}`);
                resultParts.push(matchText);
            } else {
                verboseLog(`Wrapping image: ![${alt}](${src})`);
                // Check if previous content ends with a newline or is empty
                const prevContent = content.substring(0, matchIndex).trim();
                const needsNewline = prevContent.length > 0 && !prevContent.endsWith('\n');
                resultParts.push(`${needsNewline ? '\n' : ''}<Frame>\n${matchText}\n</Frame>`);
                unwrappedCount++;
            }
            
            lastIndex = matchIndex + matchText.length;
        }
        
        // Add any remaining content
        resultParts.push(content.substring(lastIndex));
        
        // If no images were wrapped, we're done
        if (unwrappedCount === 0) {
            console.log(`No unframed images found in ${filePath}`);
            return false;
        }
        
        // Join all parts and write back to the file
        const updatedContent = resultParts.join('');
        await writeFile(filePath, updatedContent, 'utf8');
        console.log(`Updated ${unwrappedCount} images in ${filePath}`);
        return true;
    } catch (error) {
        console.error(`Error processing ${filePath}:`, error.message);
        return false;
    }
}

/**
 * Process a specific file
 * @param {string} filePath - Path to the file
 */
async function processSpecificFile(filePath) {
    try {
        if (!fs.existsSync(filePath)) {
            console.error(`File not found: ${filePath}`);
            process.exit(1);
        }

        if (!filePath.endsWith('.mdx')) {
            console.error(`File is not an MDX file: ${filePath}`);
            process.exit(1);
        }

        console.log(`Processing file: ${filePath}`);
        const wasUpdated = await processFile(filePath);

        console.log(`\nSummary:`);
        console.log(`File ${wasUpdated ? 'was updated' : 'did not need changes'}`);
    } catch (error) {
        console.error(`Error processing specific file:`, error.message);
        process.exit(1);
    }
}

/**
 * Process all MDX files in the codebase
 */
async function processAllFiles() {
    try {
        const rootDir = process.cwd();
        console.log(`Searching for .mdx files in ${rootDir}...`);

        const mdxFiles = await findMdxFiles(rootDir);
        console.log(`Found ${mdxFiles.length} .mdx files`);

        let updatedCount = 0;

        for (const file of mdxFiles) {
            const wasUpdated = await processFile(file);
            if (wasUpdated) {
                updatedCount++;
            }
        }

        console.log(`\nSummary:`);
        console.log(`Total .mdx files: ${mdxFiles.length}`);
        console.log(`Files updated: ${updatedCount}`);
        console.log(`Files with no changes needed: ${mdxFiles.length - updatedCount}`);
    } catch (error) {
        console.error(`Error processing all files:`, error.message);
        process.exit(1);
    }
}

/**
 * Main function
 */
async function main() {
    try {
        if (verboseMode) {
            console.log('Running in verbose mode');
        }

        if (fileArg) {
            await processSpecificFile(path.resolve(process.cwd(), fileArg));
        } else {
            await processAllFiles();
        }
    } catch (error) {
        console.error('Error:', error.message);
        process.exit(1);
    }
}

// Run the script
main(); 

Understanding Rate Limiting

What Happens When You Hit the Rate Limit?

StackOne’s Rate Limiting Policy

Handling Rate Limiting in Your Application

Rate Limiting

Stackone

Overview

Learn how to leverage StackOne integrations in your AI agent with StackOne

Getting Started

Filter tools when using the StackOne AI SDK

Tool Filtering

Use Open API specs as tools via the StackOne (typescript) AI SDK

OpenAPI Tools

Welcome to StackOne's Unified API for HRIS, ATS, CRM and more!

Getting Started with StackOne

Connect your Frontend via the StackOne React Hub

Connect your Backend with StackOne

A basic introduction to the dashboard, logging in etc

Dashboard Overview

Browse and take actions on any of the project's linked accounts

Accounts

Get your customer to connect their tool with only a link!

Auth Link

API Keys

Request Logs

Enable, disable and manage integrations for any StackOne Project

Managing Integration

Managing Projects

Webhooks

Managing your Organization

Custom Unified Fields enable users to create and unify bespoke fields to extend the existing Unified API models & resources.

Introduction

Define what source fields, the custom unified field will use for each integration.

Integration Field Mapping

Custom unified fields use an expression language that can be used to create more complex field mappings

Expression language syntax

Outline the list of supported SDKs to use the API with language-native libraries

Postman is a tool that allows developers to send API requests and receive responses to verify whether an API works correctly. This document describes how to use Postman to call the StackOne Unified API.

Using Postman

Using Expand & Include API Parameters

Use filters that are supported by the underlying provider requests

Using the Passthrough (Proxy) query parameters

StackOne Unified API: Error Codes & Resolution Guide

Unified API Error Codes and Troubleshooting  Guide

Making your first API request

Pagination

StackOne Identifiers

Transform HR operations with StackOne's HRIS API, providing intelligent tools for employee management, payroll tracking, and workforce insights across platforms.

Automate bringing users into your application from your customer HRIS

User Syncing from HRIS

Automate the creation and update of employees in your customer's HRIS

Automated Employee Provisioning

Unify and transform recruitment workflows across multiple platforms with StackOne's comprehensive ATS API, enabling data integration, real-time synchronization, and intelligent candidate management.

Learn how StackOne simplifies job board integrations with multiple ATS platforms, reducing custom code and maintenance

Job Board - Easy Apply

Learn how to integrate real-time interview data into your SaaS to deliver intelligent insights and seamlessly sync back to your customers’ ATS

Interview Intelligence

Automated application and candidate screening or scoring (eg. for AI-powered resume scoring).

Automated Application Screening

Learn how to integrate real-time assessment data, AI insights, and ATS syncing to simplify user workflows and improve candidate evaluation

Assessment & Background Checks

Automated candidate screening and scoring to simplify application management and HR decisions

Intelligent Candidate Screening

Accelerate CRM operations with StackOne's Unified API, connecting disparate platforms to unlock intelligent customer data management and real-time insights.

Amplify marketing performance with StackOne's Marketing API, delivering intelligent tools for campaign management, lead tracking, and multi-channel engagement across platforms

Essential details about the StackOne Documents API and its capabilities for organizing, managing, and accessing digital content efficiently within a document management system

Optimize learning management with StackOne's LMS API, delivering powerful tools for content creation, user tracking, and educational process integration across platforms.

Elevate identity security with StackOne's IAM API, providing comprehensive tools for managing user access, roles, and permissions across diverse platforms

The Admin API provides essential tools for managing and interacting with accounts and connectors

Integrate with StackOne

StackOne Dashboard

StackOne API

Rate Limiting

Understanding Rate Limiting

StackOne’s Rate Limiting Policy

What Happens When You Hit the Rate Limit?

Handling Rate Limiting in Your Application

Integrate with StackOne

StackOne Dashboard

StackOne API

​Understanding Rate Limiting

​StackOne’s Rate Limiting Policy

​What Happens When You Hit the Rate Limit?

​Handling Rate Limiting in Your Application

Understanding Rate Limiting

StackOne’s Rate Limiting Policy

What Happens When You Hit the Rate Limit?

Handling Rate Limiting in Your Application