import { AtlasClient } from "@tallestguy/atlas-sdk";

const atlas = new AtlasClient({
  apiUrl: "https://your-atlas-instance.com/api",
  websiteId: "your-website-id",
  apiKey: "your-api-key", // Optional for public endpoints
});

// Fetch content with pagination
const content = await atlas.getContent({
  limit: 10,
  page: 1,
  status: "published",
});

console.log(content.data); // Array of ContentItem[]
console.log(content.pagination); // Pagination metadata

import { atlas } from "@tallestguy/atlas-sdk";

// Uses environment variables automatically
const content = await atlas.getContent();

interface AtlasClientConfig {
  apiUrl: string; // Atlas CMS API base URL
  websiteId: string; // Your website identifier
  apiKey?: string; // API key for authenticated endpoints
  timeout?: number; // Request timeout (default: 10000ms)
  cache?: boolean; // Enable/disable caching (default: true)
  cacheDuration?: number; // Cache TTL in minutes (default: 5)
  retries?: number; // Number of retry attempts (default: 3)
  retryDelay?: number; // Delay between retries (default: 1000ms)
}

// Basic content fetching
const content = await atlas.getContent();

// Advanced filtering and pagination
const filteredContent = await atlas.getContent({
  contentType: 'article',
  status: 'published',
  featured: true,
  categories: ['technology', 'ai'],
  tags: ['nodejs', 'typescript'],
  limit: 20,
  page: 2,
  sortBy: 'created_at',
  sortOrder: 'desc',
  search: 'artificial intelligence'
});

// Response structure
interface ApiResponse<ContentItem[]> {
  data: ContentItem[];
  pagination: {
    page: number;
    limit: number;
    total: number;
    totalPages: number;
    hasNext: boolean;
    hasPrev: boolean;
  };
  success: boolean;
  message?: string;
}

const article = await atlas.getContentBySlug("my-article-slug");

if (article.data) {
  console.log(article.data.title);
  console.log(article.data.content);
}

interface ContentItem {
  id: string;
  title: string;
  slug: string;
  content: string;
  excerpt?: string;
  content_type: string;
  categories?: string[];
  tags?: string[];
  meta_title?: string;
  meta_description?: string;
  status: "draft" | "published" | "scheduled" | "archived";
  publish_date?: string;
  is_featured?: boolean;
  is_premium?: boolean;
  created_at: string;
  updated_at: string;
}

const publications = await atlas.getActivePublicationsByAgency("agency-name", {
  limit: 15,
  page: 1,
});

console.log(publications.data); // Publication[]

import { ContentService, PublicationService } from "@tallestguy/atlas-sdk";
import { MemoryCache, HttpClient } from "@tallestguy/atlas-sdk";

// Setup dependencies
const config = {
  /* your config */
};
const cache = new MemoryCache();
const http = new HttpClient({
  /* options */
});

// Initialize services
const contentService = new ContentService(config, cache, http);
const publicationService = new PublicationService(config, cache, http);

// Content operations
const content = await contentService.list({ limit: 10 });
const newContent = await contentService.create({
  title: "New Article",
  slug: "new-article",
  content: "Article content...",
  content_type: "article",
  status: "draft",
});

await contentService.update("content-id", { status: "published" });
await contentService.delete("content-id");

// Publication operations
const publications = await publicationService.search({
  query: "software engineer",
  location: "Amsterdam",
});

const stats = await publicationService.getStatistics();

const atlas = new AtlasClient(config);

// Clear all cached data
atlas.clearCache();

// Update configuration (including cache settings)
atlas.updateConfig({
  cacheDuration: 10, // 10 minutes
  cache: false, // Disable caching
});

import { AtlasError, AtlasValidationError } from "@tallestguy/atlas-sdk";

try {
  const content = await atlas.getContent({ limit: -1 }); // Invalid limit
} catch (error) {
  if (error instanceof AtlasValidationError) {
    console.error("Validation error:", error.message);
  } else if (error instanceof AtlasError) {
    console.error("Atlas API error:", error.message, error.code);
  } else {
    console.error("Unexpected error:", error);
  }
}

import type {
  ContentItem,
  ContentQueryOptions,
  ApiResponse,
  AtlasClientConfig,
  Publication,
  PublicationStatistics
} from '@tallestguy/atlas-sdk';

// Full autocompletion and type checking
const client: AtlasClient = new AtlasClient(config);
const response: ApiResponse<ContentItem[]> = await client.getContent();

import { AtlasClient } from "@tallestguy/atlas-sdk";

class BlogService {
  private atlas: AtlasClient;

  constructor() {
    this.atlas = new AtlasClient({
      apiUrl: process.env.ATLAS_API_URL!,
      websiteId: process.env.ATLAS_WEBSITE_ID!,
      apiKey: process.env.ATLAS_API_KEY,
    });
  }

  // Get latest blog posts for homepage
  async getLatestPosts(limit = 5) {
    return this.atlas.getContent({
      contentType: "blog-post",
      status: "published",
      sortBy: "publish_date",
      sortOrder: "desc",
      limit,
    });
  }

  // Get featured articles
  async getFeaturedPosts() {
    return this.atlas.getContent({
      contentType: "blog-post",
      status: "published",
      featured: true,
      limit: 3,
    });
  }

  // Get single blog post
  async getPost(slug: string) {
    const response = await this.atlas.getContentBySlug(slug);

    if (!response.data) {
      throw new Error("Post not found");
    }

    return response.data;
  }

  // Get posts by category
  async getPostsByCategory(category: string, page = 1) {
    return this.atlas.getContent({
      contentType: "blog-post",
      status: "published",
      categories: [category],
      page,
      limit: 10,
    });
  }
}

import { PublicationService } from "@tallestguy/atlas-sdk";

class JobBoard {
  private publications: PublicationService;

  constructor() {
    // Initialize service (setup cache, http client, config)
    this.publications = new PublicationService(/* dependencies */);
  }

  // Search jobs
  async searchJobs(query: string, location?: string) {
    return this.publications.search({
      query,
      location,
      limit: 20,
    });
  }

  // Get jobs by company
  async getJobsByAgency(agency: string) {
    return this.publications.getActiveByAgency(agency);
  }

  // Get job statistics
  async getJobStats() {
    return this.publications.getStatistics();
  }
}