import { createClient } from '@db4/client';

// Create a client
const client = createClient({
  baseUrl: 'https://my-app.db4.io',
  apiKey: 'db4_live_key_12345',
});

// Access a collection
const users = client.collection('users');

// Create a document
const user = await users.create({
  name: 'Alice',
  email: 'alice@myapp.com/api',
  role: 'admin',
});

// Read a document
const fetchedUser = await users.get(user.id);

// Update a document
const updated = await users.update(user.id, {
  role: 'super-admin',
});

// Delete a document
await users.delete(user.id);

import { createClient } from '@db4/client';

const client = createClient({ baseUrl: 'https://my-app.db4.io' });
const posts = client.collection('posts');

// Find with filters
const recentPosts = await posts.find({
  filter: {
    createdAt: { $gte: new Date('2024-01-01') },
    status: 'published',
  },
  sort: { createdAt: 'desc' },
  limit: 10,
});

// Count documents
const count = await posts.count({
  filter: { authorId: 'user_123' },
});

import { createClient } from '@db4/client';

const client = createClient({ baseUrl: 'https://my-app.db4.io' });
const messages = client.collection('messages');

// Subscribe to document changes
const subscription = messages.subscribe(
  { filter: { roomId: 'room_123' } },
  {
    onInsert: (doc) => console.log('New message:', doc),
    onUpdate: (doc, changes) => console.log('Updated:', changes),
    onDelete: (id) => console.log('Deleted:', id),
  }
);

// Later, unsubscribe
subscription.unsubscribe();

import { createClient, createOfflineManager } from '@db4/client';

const client = createClient({ baseUrl: 'https://my-app.db4.io' });

// Enable offline support
const offline = createOfflineManager(client, {
  storage: 'indexeddb',
  conflictResolution: 'last-write-wins',
  syncInterval: 30000,
});

// Operations work offline and sync when online
const users = offline.collection('users');

// Create works offline
await users.create({ name: 'Bob' });

// Check sync status
const status = offline.getSyncStatus();
console.log(`Pending operations: ${status.pendingCount}`);

// Handle conflicts
offline.onConflict((conflict) => {
  console.log('Conflict detected:', conflict);
  return conflict.serverVersion; // or conflict.localVersion
});

import { createClient, createLiveQueryManager } from '@db4/client';

const client = createClient({ baseUrl: 'https://my-app.db4.io' });
const liveQueries = createLiveQueryManager(client);

// Create a live query that updates automatically
const activeUsers = liveQueries.query(
  'users',
  { filter: { status: 'active' } },
  (users) => {
    console.log('Active users updated:', users.length);
    renderUserList(users);
  }
);

// Query result updates automatically when data changes
// Unsubscribe when done
activeUsers.unsubscribe();

import { ConnectionPool } from '@db4/client';

const pool = new ConnectionPool({
  baseUrl: 'https://my-app.db4.io',
  maxConnections: 10,
  idleTimeout: 30000,
});

// Get a connection from the pool
const conn = await pool.acquire();
try {
  await conn.collection('users').create({ name: 'Test' });
} finally {
  pool.release(conn);
}

// Get pool statistics
const stats = pool.getStats();
console.log(`Active: ${stats.active}, Idle: ${stats.idle}`);

function createClient(config: ClientConfig): DB4Client;

interface DB4Client {
  collection<T>(name: string): Collection<T>;
  transaction<T>(fn: (tx: Transaction) => Promise<T>): Promise<T>;
}

interface ClientConfig {
  baseUrl: string;
  apiKey?: string;
  token?: string | (() => Promise<string>);
  timeout?: number;
  retries?: number;
}

function createClient(config: ClientConfig): DB4Client;

interface Collection<T> {
  create(data: T): Promise<CreateResult<T>>;
  createMany(data: T[]): Promise<CreateManyResult<T>>;
  get(id: string): Promise<T | null>;
  find(options: QueryOptions): Promise<T[]>;
  update(id: string, data: Partial<T>): Promise<UpdateResult<T>>;
  updateMany(filter: Filter, data: Partial<T>): Promise<UpdateManyResult>;
  delete(id: string): Promise<DeleteResult>;
  deleteMany(filter: Filter): Promise<DeleteManyResult>;
  count(options?: QueryOptions): Promise<CountResult>;
  subscribe(filter: Filter, callbacks: SubscriptionCallbacks): Subscription;
}

interface OfflineOptions {
  storage: 'memory' | 'localstorage' | 'indexeddb';
  conflictResolution: 'last-write-wins' | 'server-wins' | 'client-wins' | 'manual';
  syncInterval: number;
  maxRetries: number;
}

type ConflictHandler = (conflict: Conflict) => ConflictResolution;