API Documentation

curl -X POST "https://api.calligraphymaker.com/api/v2/generate" \
  -H "Content-Type: application/json" \
  -H "x-api-key: YOUR_API_KEY" \
  -d '{
    "text": "नमस्ते दोस्त",
    "language": "hindi",
    "fontStyle": "calligraphy",
    "count": 3,
    "imageFormat": "png"
  }'

// Using fetch API
const response = await fetch('https://api.calligraphymaker.com/api/v2/generate', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-api-key': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    text: "नमस्ते दोस्त",
    language: "hindi", 
    fontStyle: "calligraphy",
    count: 3,
    imageFormat: "png"
  })
});

const data = await response.json();
if (data.success) {
  console.log('Generated images:', data.data.images);
} else {
  console.error('Generation failed:', data.error);
}

import requests

url = "https://api.calligraphymaker.com/api/v2/generate"
headers = {
    "Content-Type": "application/json",
    "x-api-key": "YOUR_API_KEY"
}

payload = {
    "text": "नमस्ते दोस्त",
    "language": "hindi",
    "fontStyle": "calligraphy",
    "count": 3,
    "imageFormat": "png"
}

response = requests.post(url, json=payload, headers=headers)
data = response.json()

if data.get('success'):
    for image in data['data']['images']:
        print(f"Image URL: {image['url']}")
        print(f"Font Used: {image['fontUsed']}")
else:
    print('Generation failed:', data.get('error'))

<?php
$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_URL => "https://api.calligraphymaker.com/api/v2/generate",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        "Content-Type: application/json",
        "x-api-key: YOUR_API_KEY"
    ],
    CURLOPT_POSTFIELDS => json_encode([
        "text" => "नमस्ते दोस्त",
        "language" => "hindi",
        "fontStyle" => "calligraphy",
        "count" => 3,
        "imageFormat" => "png"
    ])
]);

$response = curl_exec($curl);
curl_close($curl);

$data = json_decode($response, true);
if ($data['success']) {
    foreach ($data['data']['images'] as $image) {
        echo "Image URL: " . $image['url'] . "\n";
        echo "Font Used: " . $image['fontUsed'] . "\n";
    }
} else {
    echo "Generation failed: " . $data['error']['message'] . "\n";
}
?>

// React Native Example
import React from 'react';
import { View, Image, Text, Button } from 'react-native';

const generateCalligraphy = async () => {
  try {
    const response = await fetch('https://api.calligraphymaker.com/api/v2/generate', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': 'YOUR_API_KEY'
      },
      body: JSON.stringify({
        text: "नमस्ते दोस्त",
        language: "hindi",
        fontStyle: "calligraphy",
        count: 1,
        imageFormat: "png"
      })
    });

    const data = await response.json();
    if (data.success) {
      const imageUrl = data.data.images[0].url;
      // Use imageUrl in Image component
      return imageUrl;
    }
  } catch (error) {
    console.error('Error generating calligraphy:', error);
  }
};

// In your component
const CalligraphyDisplay = () => {
  const [imageUrl, setImageUrl] = React.useState(null);

  const handleGenerate = async () => {
    const url = await generateCalligraphy();
    setImageUrl(url);
  };

  return (
    <View>
      <Button title="Generate Calligraphy" onPress={handleGenerate} />
      {imageUrl && <Image source={{ uri: imageUrl }} style={{ width: 300, height: 150 }} />}
    </View>
  );
};

// Flutter Example
import 'package:http/http.dart' as http;
import 'dart:convert';

class CalligraphyService {
  static const String apiUrl = 'https://api.calligraphymaker.com/api/v2/generate';
  static const String apiKey = 'YOUR_API_KEY';

  static Future<String?> generateCalligraphy(String text) async {
    try {
      final response = await http.post(
        Uri.parse(apiUrl),
        headers: {
          'Content-Type': 'application/json',
          'x-api-key': apiKey,
        },
        body: jsonEncode({
          'text': text,
          'language': 'hindi',
          'fontStyle': 'calligraphy',
          'count': 1,
          'imageFormat': 'png',
        }),
      );

      if (response.statusCode == 200) {
        final data = jsonDecode(response.body);
        if (data['success']) {
          return data['data']['images'][0]['url'];
        }
      }
    } catch (e) {
      print('Error generating calligraphy: $e');
    }
    return null;
  }
}

// Usage in a Flutter widget
class CalligraphyWidget extends StatefulWidget {
  @override
  _CalligraphyWidgetState createState() => _CalligraphyWidgetState();
}

class _CalligraphyWidgetState extends State<CalligraphyWidget> {
  String? _imageUrl;

  void _generateCalligraphy() async {
    final url = await CalligraphyService.generateCalligraphy('नमस्ते दोस्त');
    setState(() {
      _imageUrl = url;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        ElevatedButton(
          onPressed: _generateCalligraphy,
          child: Text('Generate Calligraphy'),
        ),
        if (_imageUrl != null)
          Image.network(_imageUrl!),
      ],
    );
  }
}

// Android (Kotlin) Example with Retrofit
import retrofit2.Call
import retrofit2.http.*

// Data classes
data class CalligraphyRequest(
    val text: String,
    val language: String,
    val fontStyle: String,
    val count: Int,
    val imageFormat: String
)

data class CalligraphyResponse(
    val success: Boolean,
    val data: ResponseData
)

data class ResponseData(
    val images: List<GeneratedImage>
)

data class GeneratedImage(
    val url: String,
    val fontUsed: String,
    val width: Int,
    val height: Int
)

// Retrofit interface
interface CalligraphyApiService {
    @POST("api/v2/generate")
    @Headers("Content-Type: application/json")
    fun generateCalligraphy(
        @Header("x-api-key") apiKey: String,
        @Body request: CalligraphyRequest
    ): Call<CalligraphyResponse>
}

// Usage in Activity/Fragment
class CalligraphyActivity : AppCompatActivity() {
    private val apiKey = "YOUR_API_KEY"
    
    private fun generateCalligraphy() {
        val retrofit = Retrofit.Builder()
            .baseUrl("https://api.calligraphymaker.com/")
            .addConverterFactory(GsonConverterFactory.create())
            .build()
        
        val service = retrofit.create(CalligraphyApiService::class.java)
        
        val request = CalligraphyRequest(
            text = "नमस्ते दोस्त",
            language = "hindi",
            fontStyle = "calligraphy",
            count = 1,
            imageFormat = "png"
        )
        
        service.generateCalligraphy(apiKey, request).enqueue(object : Callback<CalligraphyResponse> {
            override fun onResponse(call: Call<CalligraphyResponse>, response: Response<CalligraphyResponse>) {
                if (response.isSuccessful && response.body()?.success == true) {
                    val imageUrl = response.body()?.data?.images?.firstOrNull()?.url
                    // Load image using Glide or Picasso
                    imageUrl?.let { loadImage(it) }
                }
            }
            
            override fun onFailure(call: Call<CalligraphyResponse>, t: Throwable) {
                // Handle error
                Log.e("CalligraphyAPI", "Error: ${t.message}")
            }
        })
    }
}

// iOS Swift Example with URLSession
import UIKit

struct CalligraphyRequest: Codable {
    let text: String
    let language: String
    let fontStyle: String
    let count: Int
    let imageFormat: String
}

struct CalligraphyResponse: Codable {
    let success: Bool
    let data: ResponseData
}

struct ResponseData: Codable {
    let images: [GeneratedImage]
}

struct GeneratedImage: Codable {
    let url: String
    let fontUsed: String
    let width: Int
    let height: Int
}

class CalligraphyService {
    static let apiKey = "YOUR_API_KEY"
    static let apiURL = "https://api.calligraphymaker.com/api/v2/generate"
    
    static func generateCalligraphy(text: String, completion: @escaping (String?) -> Void) {
        guard let url = URL(string: apiURL) else {
            completion(nil)
            return
        }
        
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.setValue(apiKey, forHTTPHeaderField: "x-api-key")
        
        let requestBody = CalligraphyRequest(
            text: text,
            language: "hindi",
            fontStyle: "calligraphy",
            count: 1,
            imageFormat: "png"
        )
        
        do {
            request.httpBody = try JSONEncoder().encode(requestBody)
        } catch {
            completion(nil)
            return
        }
        
        URLSession.shared.dataTask(with: request) { data, response, error in
            guard let data = data, error == nil else {
                DispatchQueue.main.async {
                    completion(nil)
                }
                return
            }
            
            do {
                let response = try JSONDecoder().decode(CalligraphyResponse.self, from: data)
                if response.success, let imageUrl = response.data.images.first?.url {
                    DispatchQueue.main.async {
                        completion(imageUrl)
                    }
                }
            } catch {
                DispatchQueue.main.async {
                    completion(nil)
                }
            }
        }.resume()
    }
}

// Usage in ViewController
class CalligraphyViewController: UIViewController {
    @IBOutlet weak var imageView: UIImageView!
    
    @IBAction func generateButtonTapped(_ sender: UIButton) {
        CalligraphyService.generateCalligraphy(text: "नमस्ते दोस्त") { imageUrl in
            guard let imageUrl = imageUrl,
                  let url = URL(string: imageUrl) else { return }
            
            // Load image using URLSession or SDWebImage
            self.loadImage(from: url)
        }
    }
}

// Next.js Example with API Route and Client Component
// app/api/calligraphy/route.ts
import { NextResponse } from 'next/server';

export async function POST(request: Request) {
  try {
    const body = await request.json();
    
    const response = await fetch('https://api.calligraphymaker.com/api/v2/generate', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': process.env.CALLIGRAPHY_API_KEY!
      },
      body: JSON.stringify({
        text: body.text,
        language: body.language || 'hindi',
        fontStyle: body.fontStyle || 'calligraphy',
        count: body.count || 1,
        imageFormat: body.imageFormat || 'png'
      })
    });

    const data = await response.json();
    return NextResponse.json(data);
  } catch (error) {
    return NextResponse.json(
      { success: false, error: 'Failed to generate calligraphy' },
      { status: 500 }
    );
  }
}

// app/components/CalligraphyGenerator.tsx
'use client';

import { useState } from 'react';
import Image from 'next/image';

export default function CalligraphyGenerator() {
  const [text, setText] = useState('नमस्ते दोस्त');
  const [imageUrl, setImageUrl] = useState('');
  const [loading, setLoading] = useState(false);

  const generateCalligraphy = async () => {
    setLoading(true);
    try {
      const response = await fetch('/api/calligraphy', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ text })
      });

      const data = await response.json();
      if (data.success) {
        setImageUrl(data.data.images[0].url);
      }
    } catch (error) {
      console.error('Error:', error);
    } finally {
      setLoading(false);
    }
  };

  return (
    <div className="max-w-2xl mx-auto p-6">
      <h2 className="text-3xl font-bold mb-6">Calligraphy Generator</h2>
      
      <div className="space-y-4">
        <input
          type="text"
          value={text}
          onChange={(e) => setText(e.target.value)}
          className="w-full px-4 py-2 border rounded-lg"
          placeholder="Enter text for calligraphy"
        />
        
        <button
          onClick={generateCalligraphy}
          disabled={loading}
          className="w-full py-2 bg-blue-600 text-white rounded-lg hover:bg-blue-700 disabled:opacity-50"
        >
          {loading ? 'Generating...' : 'Generate Calligraphy'}
        </button>
        
        {imageUrl && (
          <div className="mt-6">
            <Image
              src={imageUrl}
              alt="Generated Calligraphy"
              width={600}
              height={300}
              className="rounded-lg shadow-lg"
            />
          </div>
        )}
      </div>
    </div>
  );
}

// WordPress Plugin Example
<?php
/**
 * Plugin Name: Calligraphy Maker Integration
 * Description: Generate beautiful calligraphy using Calligraphy Maker API
 * Version: 1.0.0
 */

// Add settings page
add_action('admin_menu', 'calligraphy_maker_menu');
function calligraphy_maker_menu() {
    add_options_page(
        'Calligraphy Maker Settings',
        'Calligraphy Maker',
        'manage_options',
        'calligraphy-maker',
        'calligraphy_maker_settings_page'
    );
}

// Settings page HTML
function calligraphy_maker_settings_page() {
    ?>
    <div class="wrap">
        <h2>Calligraphy Maker Settings</h2>
        <form method="post" action="options.php">
            <?php settings_fields('calligraphy_maker_settings'); ?>
            <table class="form-table">
                <tr>
                    <th scope="row">API Key</th>
                    <td>
                        <input type="text" name="calligraphy_maker_api_key" 
                               value="<?php echo get_option('calligraphy_maker_api_key'); ?>" />
                    </td>
                </tr>
            </table>
            <?php submit_button(); ?>
        </form>
    </div>
    <?php
}

// Register settings
add_action('admin_init', 'calligraphy_maker_settings_init');
function calligraphy_maker_settings_init() {
    register_setting('calligraphy_maker_settings', 'calligraphy_maker_api_key');
}

// Shortcode for generating calligraphy
add_shortcode('calligraphy', 'calligraphy_maker_shortcode');
function calligraphy_maker_shortcode($atts) {
    $atts = shortcode_atts([
        'text' => 'नमस्ते',
        'language' => 'hindi',
        'fontStyle' => 'calligraphy'
    ], $atts);
    
    $api_key = get_option('calligraphy_maker_api_key');
    if (!$api_key) {
        return '<p>Please configure your Calligraphy Maker API key.</p>';
    }
    
    // Generate unique ID for this instance
    $unique_id = 'calligraphy_' . uniqid();
    
    ob_start();
    ?>
    <div id="<?php echo $unique_id; ?>" class="calligraphy-container">
        <button class="calligraphy-generate" data-text="<?php echo esc_attr($atts['text']); ?>" 
                data-language="<?php echo esc_attr($atts['language']); ?>"
                data-fontStyle="<?php echo esc_attr($atts['fontStyle']); ?>">
            Generate Calligraphy
        </button>
        <div class="calligraphy-result"></div>
    </div>
    
    <script>
    jQuery(document).ready(function($) {
        $('#<?php echo $unique_id; ?> .calligraphy-generate').click(function() {
            var button = $(this);
            var container = button.closest('.calligraphy-container');
            var resultDiv = container.find('.calligraphy-result');
            
            button.prop('disabled', true).text('Generating...');
            
            $.ajax({
                url: '<?php echo admin_url('admin-ajax.php'); ?>',
                type: 'POST',
                data: {
                    action: 'generate_calligraphy',
                    text: button.data('text'),
                    language: button.data('language'),
                    fontStyle: button.data('fontStyle'),
                    nonce: '<?php echo wp_create_nonce('calligraphy_nonce'); ?>'
                },
                success: function(response) {
                    if (response.success && response.data.imageUrl) {
                        resultDiv.html('<img src="' + response.data.imageUrl + '" alt="Calligraphy" />');
                    } else {
                        resultDiv.html('<p>Error generating calligraphy</p>');
                    }
                },
                complete: function() {
                    button.prop('disabled', false).text('Generate Calligraphy');
                }
            });
        });
    });
    </script>
    <?php
    return ob_get_clean();
}

// AJAX handler
add_action('wp_ajax_generate_calligraphy', 'handle_calligraphy_generation');
add_action('wp_ajax_nopriv_generate_calligraphy', 'handle_calligraphy_generation');
function handle_calligraphy_generation() {
    check_ajax_referer('calligraphy_nonce', 'nonce');
    
    $api_key = get_option('calligraphy_maker_api_key');
    $text = sanitize_text_field($_POST['text']);
    $language = sanitize_text_field($_POST['language']);
    $fontStyle = sanitize_text_field($_POST['fontStyle']);
    
    $response = wp_remote_post('https://api.calligraphymaker.com/api/v2/generate', [
        'headers' => [
            'Content-Type' => 'application/json',
            'x-api-key' => $api_key
        ],
        'body' => json_encode([
            'text' => $text,
            'language' => $language,
            'fontStyle' => $fontStyle,
            'count' => 1,
            'imageFormat' => 'png'
        ])
    ]);
    
    if (!is_wp_error($response)) {
        $body = json_decode(wp_remote_retrieve_body($response), true);
        if ($body['success']) {
            wp_send_json_success(['imageUrl' => $body['data']['images'][0]['url']]);
        }
    }
    
    wp_send_json_error('Failed to generate calligraphy');
}

// Vue.js 3 Composition API Example
<template>
  <div class="calligraphy-generator">
    <h2>Calligraphy Generator</h2>
    
    <div class="form-group">
      <label>Text:</label>
      <input v-model="text" type="text" placeholder="Enter text" />
    </div>
    
    <div class="form-group">
      <label>Language:</label>
      <select v-model="language">
        <option value="hindi">Hindi</option>
        <option value="marathi">Marathi</option>
        <option value="gujarati">Gujarati</option>
        <option value="english">English</option>
      </select>
    </div>
    
    <button @click="generateCalligraphy" :disabled="loading">
      {{ loading ? 'Generating...' : 'Generate Calligraphy' }}
    </button>
    
    <div v-if="error" class="error">{{ error }}</div>
    
    <div v-if="images.length > 0" class="results">
      <h3>Generated Images:</h3>
      <div v-for="(image, index) in images" :key="index" class="image-container">
        <img :src="image.url" :alt="'Calligraphy ' + (index + 1)" />
        <p>Font: {{ image.fontUsed }}</p>
      </div>
    </div>
  </div>
</template>

<script setup>
import { ref } from 'vue'
import axios from 'axios'

const API_KEY = 'YOUR_API_KEY'
const API_URL = 'https://api.calligraphymaker.com/api/v2/generate'

const text = ref('नमस्ते दोस्त')
const language = ref('hindi')
const loading = ref(false)
const error = ref('')
const images = ref([])

const generateCalligraphy = async () => {
  loading.value = true
  error.value = ''
  images.value = []
  
  try {
    const response = await axios.post(API_URL, {
      text: text.value,
      language: language.value,
      fontStyle: 'calligraphy',
      count: 3,
      imageFormat: 'png'
    }, {
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': API_KEY
      }
    })
    
    if (response.data.success) {
      images.value = response.data.data.images
    } else {
      error.value = response.data.error.message || 'Failed to generate calligraphy'
    }
  } catch (err) {
    error.value = err.message || 'An error occurred'
  } finally {
    loading.value = false
  }
}
</script>

<style scoped>
.calligraphy-generator {
  max-width: 600px;
  margin: 0 auto;
  padding: 20px;
}

.form-group {
  margin-bottom: 15px;
}

.form-group label {
  display: block;
  margin-bottom: 5px;
  font-weight: bold;
}

.form-group input,
.form-group select {
  width: 100%;
  padding: 8px;
  border: 1px solid #ddd;
  border-radius: 4px;
}

button {
  background-color: #007bff;
  color: white;
  padding: 10px 20px;
  border: none;
  border-radius: 4px;
  cursor: pointer;
  font-size: 16px;
}

button:disabled {
  opacity: 0.6;
  cursor: not-allowed;
}

.error {
  color: #dc3545;
  margin-top: 10px;
}

.results {
  margin-top: 20px;
}

.image-container {
  margin-bottom: 20px;
  text-align: center;
}

.image-container img {
  max-width: 100%;
  height: auto;
  border: 1px solid #ddd;
  border-radius: 4px;
}
</style>

// Node.js Example with Express
const express = require('express');
const axios = require('axios');

const app = express();
app.use(express.json());

const CALLIGRAPHY_API_KEY = process.env.CALLIGRAPHY_API_KEY;
const CALLIGRAPHY_API_URL = 'https://api.calligraphymaker.com/api/v2/generate';

// Route to generate calligraphy
app.post('/generate-calligraphy', async (req, res) => {
  try {
    const { text, language = 'hindi', fontStyle = 'calligraphy' } = req.body;
    
    if (!text) {
      return res.status(400).json({ error: 'Text is required' });
    }
    
    const response = await axios.post(CALLIGRAPHY_API_URL, {
      text,
      language,
      fontStyle,
      count: 3,
      imageFormat: 'png'
    }, {
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': CALLIGRAPHY_API_KEY
      }
    });
    
    if (response.data.success) {
      res.json({
        success: true,
        images: response.data.data.images
      });
    } else {
      res.status(400).json({
        success: false,
        error: response.data.error
      });
    }
  } catch (error) {
    console.error('Calligraphy generation error:', error);
    res.status(500).json({
      success: false,
      error: 'Failed to generate calligraphy'
    });
  }
});

// Webhook endpoint to receive notifications
app.post('/webhook/calligraphy', express.raw({ type: 'application/json' }), (req, res) => {
  const signature = req.headers['x-calligraphy-signature'];
  const payload = req.body;
  
  // Verify webhook signature
  const crypto = require('crypto');
  const expectedSignature = crypto
    .createHmac('sha256', process.env.WEBHOOK_SECRET)
    .update(payload)
    .digest('hex');
  
  if (signature !== expectedSignature) {
    return res.status(401).send('Invalid signature');
  }
  
  const event = JSON.parse(payload);
  
  // Handle different event types
  switch (event.type) {
    case 'generation.completed':
      console.log('Generation completed:', event.data);
      // Process completed generation
      break;
    case 'generation.failed':
      console.error('Generation failed:', event.data);
      // Handle failed generation
      break;
    case 'batch.completed':
      console.log('Batch completed:', event.data);
      // Process completed batch
      break;
    default:
      console.log('Unknown event type:', event.type);
  }
  
  res.status(200).send('OK');
});

// Health check endpoint
app.get('/health', (req, res) => {
  res.json({ status: 'ok', service: 'calligraphy-integration' });
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

// SVG Download Example
const downloadSVG = async (resultText, fontName) => {
  try {
    const response = await fetch('https://api.calligraphymaker.com/api/v2/download-svg', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': 'YOUR_API_KEY'
      },
      body: JSON.stringify({
        resultText: resultText,
        fontName: fontName
      })
    });

    const data = await response.json();
    if (data.success) {
      // Download SVG as file
      const svgBlob = new Blob([data.data.svgString], { type: 'image/svg+xml' });
      const url = URL.createObjectURL(svgBlob);
      const a = document.createElement('a');
      a.href = url;
      a.download = 'calligraphy.svg';
      a.click();
      
      return data.data.svgBase64; // Return base64 for display
    }
  } catch (error) {
    console.error('SVG download failed:', error);
  }
};

// Image Download Example
const downloadImage = async (resultText, fontName, format = 'png') => {
  try {
    const response = await fetch('https://api.calligraphymaker.com/api/v2/download-image', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': 'YOUR_API_KEY'
      },
      body: JSON.stringify({
        resultText: resultText,
        fontName: fontName,
        imageWidth: 800,
        imageHeight: 600,
        imageQuality: 90,
        imageFormat: format,
        backgroundColor: '#ffffff',
        textColor: '#000000'
      })
    });

    const data = await response.json();
    if (data.success) {
      // Download image as file
      const a = document.createElement('a');
      a.href = data.data.imageBase64;
      a.download = `calligraphy.${format}`;
      a.click();
      
      return data.data.imageBase64; // Return base64 for display
    }
  } catch (error) {
    console.error('Image download failed:', error);
  }
};

// Webhook signature verification (Node.js)
const crypto = require('crypto');

function verifyWebhookSignature(payload, signature, secret) {
  const expectedSignature = crypto
    .createHmac('sha256', secret)
    .update(payload)
    .digest('hex');
  
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expectedSignature)
  );
}

// Express.js webhook handler
app.post('/webhook', express.raw({type: 'application/json'}), (req, res) => {
  const signature = req.headers['x-calligraphy-signature'];
  const payload = req.body;
  
  if (!verifyWebhookSignature(payload, signature, process.env.WEBHOOK_SECRET)) {
    return res.status(401).send('Invalid signature');
  }
  
  const event = JSON.parse(payload);
  console.log('Received event:', event.type);
  
  res.status(200).send('OK');
});