import { MetadataBuilder, SchemaBuilder } from '@dotdo/iceberg'

// Define schema
const schema = new SchemaBuilder()
  .addField({ name: 'id', type: 'long', required: true })
  .addField({ name: 'name', type: 'string' })
  .addField({ name: 'created_at', type: 'timestamptz' })
  .build()

// Create table metadata
const metadata = new MetadataBuilder({ location: 's3://bucket/table' })
  .setSchema(schema)
  .setPartitionSpec([{ sourceId: 3, transform: 'day', fieldId: 1000 }])
  .build()

import { SchemaBuilder } from '@dotdo/iceberg'

const schema = new SchemaBuilder()
  .addField({ name: 'id', type: 'long', required: true })
  .addField({ name: 'name', type: 'string' })
  .addField({ name: 'email', type: 'string' })
  .addField({ name: 'metadata', type: { type: 'map', keyType: 'string', valueType: 'string' } })
  .addField({ name: 'tags', type: { type: 'list', elementType: 'string' } })
  .addField({ name: 'created_at', type: 'timestamptz', required: true })
  .build()

import { SchemaEvolution } from '@dotdo/iceberg'

const evolution = new SchemaEvolution(existingSchema)

// Add new columns
evolution.addColumn({ name: 'status', type: 'string' })

// Rename columns (readers with old schema still work)
evolution.renameColumn('email', 'email_address')

// Widen types (int -> long, float -> double)
evolution.updateColumnType('count', 'long')

const newSchema = evolution.apply()

import { MetadataBuilder, createPartitionSpec, createSortOrder } from '@dotdo/iceberg'

const metadata = new MetadataBuilder({
  location: 's3://my-bucket/warehouse/events',
  tableUuid: crypto.randomUUID(),
})
  .setSchema(schema)
  .setPartitionSpec([
    { sourceId: 6, transform: 'day', fieldId: 1000, name: 'created_day' }
  ])
  .setSortOrder([
    { sourceId: 1, direction: 'asc', nullOrder: 'nulls-last', transform: 'identity' }
  ])
  .setProperties({
    'write.format.default': 'parquet',
    'write.parquet.compression-codec': 'zstd',
  })
  .build()

import { ManifestBuilder, ManifestListBuilder } from '@dotdo/iceberg'

// Build a manifest for data files
const manifest = new ManifestBuilder({ schema, partitionSpec })
  .addEntry({
    status: 'added',
    dataFile: {
      content: 'data',
      filePath: 'data/part-00000.parquet',
      fileFormat: 'PARQUET',
      recordCount: 10000,
      fileSizeInBytes: 1024 * 1024,
    }
  })
  .build()

// Build a manifest list for a snapshot
const manifestList = new ManifestListBuilder({ snapshotId: 1n })
  .addManifest({
    manifestPath: 'metadata/manifest-1.avro',
    manifestLength: 4096,
    partitionSpecId: 0,
    addedFilesCount: 1,
    addedRowsCount: 10000,
  })
  .build()

import { walRecordToRow, WAL_TABLE_SCHEMA } from '@dotdo/iceberg/wal'

const walRecord = {
  lsn: 12345678n,
  operation: 'INSERT',
  schema: 'public',
  table: 'users',
  newRow: { id: 1, name: 'Alice' },
  timestamp: Date.now(),
  doId: 'do-abc123',
}

// Convert to Iceberg row format
const row = walRecordToRow(walRecord)

// WAL_TABLE_SCHEMA is the Iceberg schema for WAL tables
// Use it to create a metadata builder for WAL storage

import {
  SchemaBuilder,      // Build schemas incrementally
  SchemaEvolution,    // Evolve existing schemas
  validateSchema,     // Validate schema correctness
  findFieldById,      // Find field by ID
  findFieldByName,    // Find field by name
} from '@dotdo/iceberg'

import type {
  // Core types
  IcebergSchema,
  IcebergField,
  IcebergType,
  IcebergPrimitiveType,

  // Partitioning
  IcebergPartitionSpec,
  IcebergPartitionField,
  IcebergTransform,

  // Sorting
  IcebergSortOrder,
  IcebergSortField,

  // Snapshots
  IcebergSnapshot,
  IcebergSnapshotSummary,
  IcebergTableMetadata,

  // Manifests
  IcebergManifestFile,
  IcebergManifestEntry,
  IcebergDataFile,
} from '@dotdo/iceberg'

import {
  MetadataBuilder,           // Build table metadata
  generateMetadataFileName,  // Generate v123.metadata.json names
  generateManifestFileName,  // Generate manifest file names
  generateDataFileName,      // Generate data file names
} from '@dotdo/iceberg'

import {
  BaseCatalog,              // Abstract catalog base class
  type ICatalog,            // Catalog interface
  type TableIdentifier,     // { namespace: string[], name: string }
  type NamespaceIdentifier, // string[]

  // Commit operations
  createAppendCommit,       // Create append commit request
  assertRefSnapshotId,      // Requirement for optimistic locking
} from '@dotdo/iceberg'