constructor(dragonfire: DragonFireClient, options?: MerlinClientOptions)

import { DragonFireClient } from '@dragonfire/client';
import { MerlinClient } from '@dragonfire/merlin-client';

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

// Initialize Merlin client
const merlin = new MerlinClient(dragonfire, {
  defaultPattern: 'phi',        // Mathematical pattern to use (phi, pi, sqrt2, sqrt3, e)
  adaptiveMode: true,           // Automatically select optimal patterns
  recursionDepth: 3,            // Maximum recursion depth for compression
  compressThreshold: 1024,      // Min size in bytes to trigger compression
  cacheResults: true            // Cache compression results
});

async compress(data: Buffer | ArrayBuffer | Uint8Array | string, options?: CompressionOptions): Promise

// Compress a string
const textData = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit...';
const result = await merlin.compress(textData);

console.log(`Original size: ${result.originalSize} bytes`);
console.log(`Compressed size: ${result.compressedSize} bytes`);
console.log(`Compression ratio: ${result.ratio.toFixed(2)}x`);
console.log(`Pattern used: ${result.patternUsed}`);

// Compress binary data with options
const binaryData = new Uint8Array([/* ... */]);
const result2 = await merlin.compress(binaryData, {
  pattern: 'pi',           // Override default pattern
  quality: 'max',          // Maximum compression quality
  lossless: true,          // Ensure lossless compression
  priority: 'ratio',       // Prioritize compression ratio over speed
  recursionDepth: 5,       // Higher recursion depth
  metadata: {              // Custom metadata
    contentType: 'image/png',
    fileName: 'example.png'
  }
});

async compressBatch(items: Array<{data: Buffer | ArrayBuffer | Uint8Array | string, options?: CompressionOptions}>, batchOptions?: BatchOptions): Promise>

// Compress multiple items
const results = await merlin.compressBatch([
  { 
    data: textData1,
    options: { pattern: 'phi', quality: 'high' }
  },
  { 
    data: imageData,
    options: { pattern: 'pi', lossless: true }
  },
  { 
    data: jsonData,
    options: { priority: 'ratio' }
  }
], {
  parallel: true,          // Process in parallel
  progressCallback: (progress) => {
    console.log(`Compression progress: ${progress.toFixed(2)}%`);
  }
});

// Log results
results.forEach((result, index) => {
  console.log(`Item ${index + 1}:`);
  console.log(`  Original size: ${result.originalSize} bytes`);
  console.log(`  Compressed size: ${result.compressedSize} bytes`);
  console.log(`  Ratio: ${result.ratio.toFixed(2)}x`);
});

async decompress(compressedData: Buffer | ArrayBuffer | Uint8Array, options?: DecompressionOptions): Promise

// Decompress data
const compressedData = result.data; // From previous compression
const decompressed = await merlin.decompress(compressedData);

console.log(`Decompressed size: ${decompressed.data.byteLength} bytes`);
console.log(`Original checksum verified: ${decompressed.checksumVerified}`);

// Get decompressed data as string
const textContent = decompressed.toString('utf8');

// Decompress with options
const decompressed2 = await merlin.decompress(compressedData, {
  outputFormat: 'string',    // Get result as string
  encoding: 'utf8',          // Output encoding
  verifyChecksum: true,      // Verify data integrity
  metadata: true             // Include original metadata
});

async decompressBatch(items: Array<{data: Buffer | ArrayBuffer | Uint8Array, options?: DecompressionOptions}>, batchOptions?: BatchOptions): Promise>

// Decompress multiple items
const decompressedResults = await merlin.decompressBatch([
  { data: compressedItem1 },
  { data: compressedItem2, options: { outputFormat: 'string' } },
  { data: compressedItem3 }
], {
  parallel: true,
  progressCallback: (progress) => {
    console.log(`Decompression progress: ${progress.toFixed(2)}%`);
  }
});

async analyzePattern(data: Buffer | ArrayBuffer | Uint8Array | string, options?: AnalysisOptions): Promise

// Analyze data to find optimal pattern
const analysis = await merlin.analyzePattern(data, {
  detailed: true,        // Include detailed breakdown
  testCompression: true  // Run test compressions
});

console.log('Recommended pattern:', analysis.recommendedPattern);
console.log('Pattern scores:');
for (const [pattern, score] of Object.entries(analysis.patternScores)) {
  console.log(`  ${pattern}: ${score.toFixed(2)}`);
}

// Use recommended pattern for compression
const result = await merlin.compress(data, {
  pattern: analysis.recommendedPattern
});

createCompressionStream(options?: CompressionOptions): MerlinCompressionStream

import { pipeline } from 'stream/promises';
import fs from 'fs';

// Create compression stream
const compressionStream = merlin.createCompressionStream({
  pattern: 'phi',
  quality: 'high',
  chunkSize: 65536  // 64 KB chunks
});

// Set up event listeners
compressionStream.on('progress', (progress) => {
  console.log(`Compression progress: ${progress.toFixed(2)}%`);
});

compressionStream.on('stats', (stats) => {
  console.log(`Current ratio: ${stats.currentRatio.toFixed(2)}x`);
  console.log(`Bytes processed: ${stats.bytesProcessed}`);
});

// Set up a pipeline
await pipeline(
  fs.createReadStream('largefile.dat'),
  compressionStream,
  fs.createWriteStream('largefile.dat.mln')
);

console.log('Compression complete');
console.log('Final stats:', compressionStream.getFinalStats());

createDecompressionStream(options?: DecompressionOptions): MerlinDecompressionStream

import { pipeline } from 'stream/promises';
import fs from 'fs';

// Create decompression stream
const decompressionStream = merlin.createDecompressionStream({
  verifyChecksum: true
});

// Set up a pipeline
await pipeline(
  fs.createReadStream('largefile.dat.mln'),
  decompressionStream,
  fs.createWriteStream('largefile_restored.dat')
);

console.log('Decompression complete');

async createProfile(name: string, sampleData: Array, options?: ProfileOptions): Promise

// Create a profile optimized for JSON data
const jsonSamples = [
  JSON.stringify({ id: 1, name: 'Test', data: [...] }),
  JSON.stringify({ id: 2, name: 'Sample', data: [...] }),
  // More samples...
];

const jsonProfile = await merlin.createProfile('json-data', jsonSamples, {
  iterationCount: 5,        // Number of optimization iterations
  optimizeFor: 'ratio',     // Optimize for maximum compression
  persistent: true          // Save profile for future sessions
});

console.log('Profile created:', jsonProfile.name);
console.log('Estimated compression ratio:', jsonProfile.estimatedRatio);

// Use the profile for compression
const compressedJson = await merlin.compress(jsonData, {
  profile: 'json-data'      // Reference profile by name
});

async optimizePerformance(options?: PerformanceOptions): Promise

// Optimize Merlin for the current environment
const performance = await merlin.optimizePerformance({
  testDuration: 5000,           // Run tests for 5 seconds
  balanceFactors: {
    speed: 0.7,                 // Prioritize speed (70%)
    memory: 0.3                 // Consider memory usage (30%)
  }
});

console.log('Optimized settings:', performance.recommendedSettings);

// Apply recommended settings
merlin.applySettings(performance.recommendedSettings);