SDKs & Libraries

class VardaCalClient {
  constructor(apiKey, apiSecret) {
    this.apiKey = apiKey;
    this.apiSecret = apiSecret;
    this.baseURL = 'https://api.vardacal.com/api/v1/platform';
  }

  async request(endpoint, options = {}) {
    const url = `${this.baseURL}${endpoint}`;
    const response = await fetch(url, {
      ...options,
      headers: {
        'X-API-Key': this.apiKey,
        'X-API-Secret': this.apiSecret,
        'Content-Type': 'application/json',
        ...options.headers
      }
    });

    if (!response.ok) {
      throw new Error(`API Error: ${response.status}`);
    }

    return response.json();
  }

  // Usage statistics
  async getUsage() {
    return this.request('/usage');
  }

  // Event Types
  async listEventTypes() {
    return this.request('/event_types');
  }

  async createEventType(data) {
    return this.request('/event_types', {
      method: 'POST',
      body: JSON.stringify(data)
    });
  }

  // Bookings
  async listBookings() {
    return this.request('/bookings');
  }

  async createBooking(data) {
    return this.request('/bookings', {
      method: 'POST',
      body: JSON.stringify(data)
    });
  }

  async getBooking(id) {
    return this.request(`/bookings/${id}`);
  }

  // Webhooks
  async createWebhook(url, events) {
    return this.request('/webhooks', {
      method: 'POST',
      body: JSON.stringify({ url, events, enabled: true })
    });
  }
}

// Usage
const client = new VardaCalClient('vca_live_sk_...', 'secret_...');

// Get usage stats
const usage = await client.getUsage();
console.log(`API calls: ${usage.api_calls.count}`);

// Create a booking
const booking = await client.createBooking({
  event_type_id: 123,
  start_time: '2025-11-01T10:00:00Z',
  attendee: {
    name: 'John Doe',
    email: 'john@example.com'
  }
});

import requests
from typing import Dict, List, Optional

class VardaCalClient:
    def __init__(self, api_key: str, api_secret: str):
        self.api_key = api_key
        self.api_secret = api_secret
        self.base_url = 'https://api.vardacal.com/api/v1/platform'

    def request(self, endpoint: str, method: str = 'GET', data: Optional[Dict] = None) -> Dict:
        url = f"{self.base_url}{endpoint}"
        headers = {
            'X-API-Key': self.api_key,
            'X-API-Secret': self.api_secret,
            'Content-Type': 'application/json'
        }

        response = requests.request(
            method=method,
            url=url,
            headers=headers,
            json=data
        )
        response.raise_for_status()
        return response.json()

    # Usage statistics
    def get_usage(self) -> Dict:
        return self.request('/usage')

    # Event Types
    def list_event_types(self) -> List[Dict]:
        return self.request('/event_types')

    def create_event_type(self, data: Dict) -> Dict:
        return self.request('/event_types', method='POST', data=data)

    # Bookings
    def list_bookings(self) -> List[Dict]:
        return self.request('/bookings')

    def create_booking(self, data: Dict) -> Dict:
        return self.request('/bookings', method='POST', data=data)

    def get_booking(self, booking_id: int) -> Dict:
        return self.request(f'/bookings/{booking_id}')

    # Webhooks
    def create_webhook(self, url: str, events: List[str]) -> Dict:
        return self.request('/webhooks', method='POST',
                          data={'url': url, 'events': events, 'enabled': True})

# Usage
client = VardaCalClient('vca_live_sk_...', 'secret_...')

# Get usage stats
usage = client.get_usage()
print(f"API calls: {usage['api_calls']['count']}")

# Create a booking
booking = client.create_booking({
    'event_type_id': 123,
    'start_time': '2025-11-01T10:00:00Z',
    'attendee': {
        'name': 'John Doe',
        'email': 'john@example.com'
    }
})

require 'net/http'
require 'json'

class VardaCalClient
  def initialize(api_key, api_secret)
    @api_key = api_key
    @api_secret = api_secret
    @base_url = 'https://api.vardacal.com/api/v1/platform'
  end

  def request(endpoint, method: :get, data: nil)
    uri = URI("#{@base_url}#{endpoint}")
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true

    request = case method
              when :get then Net::HTTP::Get.new(uri)
              when :post then Net::HTTP::Post.new(uri)
              when :put then Net::HTTP::Put.new(uri)
              when :patch then Net::HTTP::Patch.new(uri)
              when :delete then Net::HTTP::Delete.new(uri)
              end

    request['X-API-Key'] = @api_key
    request['X-API-Secret'] = @api_secret
    request['Content-Type'] = 'application/json'
    request.body = data.to_json if data

    response = http.request(request)
    raise "API Error: #{response.code}" unless response.is_a?(Net::HTTPSuccess)

    JSON.parse(response.body)
  end

  # Usage statistics
  def get_usage
    request('/usage')
  end

  # Event Types
  def list_event_types
    request('/event_types')
  end

  def create_event_type(data)
    request('/event_types', method: :post, data: data)
  end

  # Bookings
  def list_bookings
    request('/bookings')
  end

  def create_booking(data)
    request('/bookings', method: :post, data: data)
  end

  def get_booking(id)
    request("/bookings/#{id}")
  end

  # Webhooks
  def create_webhook(url, events)
    request('/webhooks', method: :post,
            data: { url: url, events: events, enabled: true })
  end
end

# Usage
client = VardaCalClient.new('vca_live_sk_...', 'secret_...')

# Get usage stats
usage = client.get_usage
puts "API calls: #{usage['api_calls']['count']}"

# Create a booking
booking = client.create_booking(
  event_type_id: 123,
  start_time: '2025-11-01T10:00:00Z',
  attendee: {
    name: 'John Doe',
    email: 'john@example.com'
  }
)