constructor(dragonfire: DragonFireClient, options?: CacheClientOptions)

import { DragonFireClient } from '@dragonfire/client';
import { DragonCacheClient } from '@dragonfire/cache-client';

// Initialize DragonFire client
const dragonfire = new DragonFireClient({
  apiKey: 'YOUR_API_KEY',
  region: 'us-west'
});
await dragonfire.connect();

// Initialize cache client
const cache = new DragonCacheClient(dragonfire, {
  dimension: 8,                  // Fractal dimension (6, 8, 10, 12, 14, or 16)
  resonancePattern: 'phi',       // Mathematical pattern for harmonization
  autoScale: true,               // Enable automatic scaling
  compressionEnabled: true,      // Enable compression for large values
  defaultTTL: 3600000            // Default time-to-live (1 hour in ms)
});

async set(key: string, value: any, options?: SetOptions): Promise

// Store a simple value
await cache.set('user.123.name', 'John Doe');

// Store a complex object with options
await cache.set('user.123.profile', {
  name: 'John Doe',
  email: 'john@example.com',
  preferences: {
    theme: 'dark',
    notifications: true
  }
}, {
  ttl: 86400000,              // 24 hours in milliseconds
  priority: 'high',           // Priority for this cache entry
  compress: true,             // Force compression regardless of size
  tags: ['user', 'profile']   // Tags for easier management
});

async get(key: string, options?: GetOptions): Promise

// Simple retrieval
const name = await cache.get('user.123.name');
console.log('User name:', name);  // 'John Doe'

// Typed retrieval with options
interface UserProfile {
  name: string;
  email: string;
  preferences: {
    theme: string;
    notifications: boolean;
  };
}

const profile = await cache.get('user.123.profile', {
  defaultValue: {              // Default value if not found
    name: 'Unknown',
    email: '',
    preferences: {
      theme: 'light',
      notifications: false
    }
  },
  consistencyLevel: 'eventual', // Read consistency level
  refreshTTL: true             // Refresh the TTL on read
});

console.log('User profile:', profile);

async delete(key: string, options?: DeleteOptions): Promise

// Delete a specific key
const deleted = await cache.delete('user.123.name');
console.log('Deleted:', deleted);  // true if key existed and was deleted

// Delete with cascade
await cache.delete('user.123', {
  cascade: true  // Delete all keys with prefix user.123.*
});

async exists(key: string): Promise

// Check if a key exists
const hasProfile = await cache.exists('user.123.profile');
if (hasProfile) {
  console.log('User profile exists in cache');
} else {
  console.log('User profile not found in cache');
}

async increment(key: string, value: number = 1, options?: SetOptions): Promise

// Increment a counter
let count = await cache.increment('visits.counter');
console.log('Visit count:', count);  // 1 if this is the first increment

// Increment by a specific amount
count = await cache.increment('visits.counter', 5);
console.log('Visit count:', count);  // Previous value + 5

async mget(keys: string[], options?: GetOptions): Promise>

// Get multiple values in one call
const values = await cache.mget([
  'user.123.name', 
  'user.123.email', 
  'user.123.preferences.theme'
]);

console.log('User name:', values.get('user.123.name'));
console.log('User email:', values.get('user.123.email'));
console.log('User theme:', values.get('user.123.preferences.theme'));

async mset(entries: Map | Record, options?: SetOptions): Promise

// Set multiple values in one call
await cache.mset({
  'user.123.name': 'John Doe',
  'user.123.email': 'john@example.com',
  'user.123.preferences.theme': 'dark'
}, {
  ttl: 86400000,  // 24 hours
  tags: ['user', 'profile']
});

async getOrSet(
  key: string, 
  factory: () => Promise | T, 
  options?: SetOptions
): Promise

// Get cached value or compute if not present
const userProfile = await cache.getOrSet('user.123.profile', async () => {
  // This only runs if the key doesn't exist in cache
  console.log('Cache miss, fetching from database...');
  return await database.getUserProfile('123');
}, {
  ttl: 3600000,  // 1 hour
  tags: ['user']
});

console.log('User profile:', userProfile);

async getStats(): Promise

// Get cache statistics
const stats = await cache.getStats();
console.log('Cache size:', stats.size);
console.log('Item count:', stats.itemCount);
console.log('Hit rate:', stats.hitRate);
console.log('Miss rate:', stats.missRate);
console.log('Average access time:', stats.avgAccessTime, 'ms');
console.log('Memory usage:', stats.memoryUsage, 'MB');

async optimize(options?: OptimizeOptions): Promise

// Optimize cache based on usage patterns
const result = await cache.optimize({
  strategy: 'access-pattern',   // Optimize based on access patterns
  aggressiveness: 0.7,          // Optimization aggressiveness (0-1)
  minImprovementThreshold: 0.1  // Minimum improvement to apply changes
});

console.log('Optimization complete');
console.log('Performance improvement:', result.performanceImprovement);
console.log('Redistribution count:', result.redistributionCount);
console.log('Time taken:', result.timeTaken, 'ms');