API Documentation

const axios = require('axios');

class TimekeeperAPI {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseURL = 'https://api.timekeeper.404connernotfound.dev';
    this.client = axios.create({
      baseURL: this.baseURL,
      headers: {
        'X-API-Key': apiKey,
        'Content-Type': 'application/json'
      }
    });
  }

  async getGuildStatus(guildId) {
    const response = await this.client.get(
      `/api/v1/guild/${guildId}/status`
    );
    return response.data;
  }

  async clockIn(guildId, userId, category, description = null) {
    const data = { user_id: userId, category };
    if (description) data.description = description;
    
    const response = await this.client.post(
      `/api/v1/guild/${guildId}/clockin`,
      data
    );
    return response.data;
  }

  async getLeaderboard(guildId, category = null, timeframe = 'all') {
    const params = { timeframe };
    if (category) params.category = category;
    
    const response = await this.client.get(
      `/api/v1/guild/${guildId}/leaderboard`,
      { params }
    );
    return response.data;
  }
}

// Usage
(async () => {
  const api = new TimekeeperAPI('tk_your_api_key_here');

  // Get guild status
  const status = await api.getGuildStatus(123456789);
  console.log(`Total hours: ${status.total_time_hours}`);

  // Clock in a user
  const result = await api.clockIn(
    123456789,
    987654321,
    'Development',
    'API integration'
  );
  console.log(`Session started: ${result.session_id}`);

  // Get leaderboard
  const leaderboard = await api.getLeaderboard(123456789, null, 'week');
  leaderboard.leaderboard.slice(0, 5).forEach(entry => {
    console.log(`${entry.rank}. ${entry.username}: ${entry.hours}h`);
  });
})();

import axios, { AxiosInstance } from 'axios';

interface GuildStatus {
  guild_id: number;
  total_time_seconds: number;
  total_time_hours: number;
  total_users: number;
  active_sessions: number;
  categories: Record;
}

interface ClockInResponse {
  success: boolean;
  session_id: string;
  category: string;
  start_time: string;
  user_id: number;
}

class TimekeeperAPI {
  private client: AxiosInstance;

  constructor(private apiKey: string) {
    this.client = axios.create({
      baseURL: 'https://api.timekeeper.404connernotfound.dev',
      headers: {
        'X-API-Key': apiKey,
        'Content-Type': 'application/json'
      }
    });
  }

  async getGuildStatus(guildId: number): Promise {
    const response = await this.client.get(
      `/api/v1/guild/${guildId}/status`
    );
    return response.data;
  }

  async clockIn(
    guildId: number,
    userId: number,
    category: string,
    description?: string
  ): Promise {
    const data: any = { user_id: userId, category };
    if (description) data.description = description;
    
    const response = await this.client.post(
      `/api/v1/guild/${guildId}/clockin`,
      data
    );
    return response.data;
  }
}

// Usage
(async () => {
  const api = new TimekeeperAPI('tk_your_api_key_here');

  const status = await api.getGuildStatus(123456789);
  console.log(`Total hours: ${status.total_time_hours}`);

  const result = await api.clockIn(
    123456789,
    987654321,
    'Development',
    'API integration'
  );
  console.log(`Session started: ${result.session_id}`);
})();

use reqwest;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

#[derive(Debug, Deserialize)]
struct GuildStatus {
    guild_id: u64,
    total_time_seconds: u64,
    total_time_hours: f64,
    total_users: u32,
    active_sessions: u32,
    categories: HashMap,
}

#[derive(Debug, Serialize)]
struct ClockInRequest {
    user_id: u64,
    category: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    description: Option,
}

struct TimekeeperAPI {
    api_key: String,
    client: reqwest::Client,
}

impl TimekeeperAPI {
    fn new(api_key: String) -> Self {
        Self {
            api_key,
            client: reqwest::Client::new(),
        }
    }

    async fn get_guild_status(
        &self,
        guild_id: u64,
    ) -> Result {
        let url = format!(
            "https://api.timekeeper.404connernotfound.dev/api/v1/guild/{}/status",
            guild_id
        );
        
        self.client
            .get(&url)
            .header("X-API-Key", &self.api_key)
            .send()
            .await?
            .json::()
            .await
    }

    async fn clock_in(
        &self,
        guild_id: u64,
        user_id: u64,
        category: String,
        description: Option,
    ) -> Result<(), reqwest::Error> {
        let url = format!(
            "https://api.timekeeper.404connernotfound.dev/api/v1/guild/{}/clockin",
            guild_id
        );
        let data = ClockInRequest {
            user_id,
            category,
            description,
        };
        
        self.client
            .post(&url)
            .header("X-API-Key", &self.api_key)
            .json(&data)
            .send()
            .await?;
        
        Ok(())
    }
}

#[tokio::main]
async fn main() -> Result<(), Box> {
    let api = TimekeeperAPI::new("tk_your_api_key_here".to_string());

    let status = api.get_guild_status(123456789).await?;
    println!("Total hours: {}", status.total_time_hours);

    api.clock_in(
        123456789,
        987654321,
        "Development".to_string(),
        Some("API integration".to_string()),
    ).await?;

    Ok(())
}