/**
 * Core Types for @dotdo/tanstack
 *
 * TanStack DB integration types for local-first sync with PostgreSQL/PGLite.
 */
/**
 * Base record type for collection items
 */
export interface BaseRecord {
    id: string | number;
}
/**
 * Collection configuration options
 */
export interface CollectionOptions<T extends BaseRecord> {
    /** Unique identifier for this collection */
    id: string;
    /** Optional schema name */
    schema?: string;
    /** Table name in PostgreSQL */
    table: string;
    /** Primary key field name */
    primaryKey?: keyof T;
    /** Timestamps configuration */
    timestamps?: {
        createdAt?: string;
        updatedAt?: string;
    };
}
/**
 * Query collection options - fetches data via TanStack Query
 */
export interface QueryCollectionOptions<T extends BaseRecord> extends CollectionOptions<T> {
    /** Query function for fetching data */
    queryFn: () => Promise<T[]>;
    /** Stale time in milliseconds */
    staleTime?: number;
    /** Cache time in milliseconds */
    cacheTime?: number;
    /** Refetch interval in milliseconds */
    refetchInterval?: number;
}
/**
 * Sync collection options - maintains real-time sync
 */
export interface SyncCollectionOptions<T extends BaseRecord> extends CollectionOptions<T> {
    /** Sync endpoint URL */
    syncUrl: string;
    /** Shape parameters for Electric-style sync */
    shapeParams?: Record<string, string>;
    /** Polling interval for sync in milliseconds */
    pollInterval?: number;
    /** Enable debug logging for mutation lifecycle (default: false) */
    debug?: boolean;
}
/**
 * Live query options for reactive queries
 */
export interface LiveQueryOptions<T extends BaseRecord, R = T[]> {
    /** Collection ID to query */
    collectionId: string;
    /** WHERE clause conditions */
    where?: Partial<T> | ((item: T) => boolean);
    /** ORDER BY configuration */
    orderBy?: {
        field: keyof T;
        direction: 'asc' | 'desc';
    };
    /** LIMIT clause */
    limit?: number;
    /** OFFSET clause */
    offset?: number;
    /** Transform function for results */
    select?: (items: T[]) => R;
}
/**
 * Mutation options for transactional writes
 */
export interface MutationOptions<T extends BaseRecord> {
    /** Collection ID to mutate */
    collectionId: string;
    /** Whether to apply optimistically */
    optimistic?: boolean;
    /** Rollback on error */
    rollbackOnError?: boolean;
    /** Custom conflict resolution */
    onConflict?: ConflictResolver<T>;
}
/**
 * Optimistic update state
 */
export interface OptimisticState<T extends BaseRecord> {
    /** Pending mutations not yet confirmed */
    pending: PendingMutation<T>[];
    /** Applied changes awaiting server confirmation */
    applied: AppliedMutation<T>[];
}
/**
 * Pending mutation waiting to be sent
 */
export interface PendingMutation<T extends BaseRecord> {
    id: string;
    type: 'insert' | 'update' | 'delete';
    collectionId: string;
    data: Partial<T>;
    timestamp: number;
}
/**
 * Applied mutation awaiting confirmation
 */
export interface AppliedMutation<T extends BaseRecord> {
    id: string;
    type: 'insert' | 'update' | 'delete';
    collectionId: string;
    recordId: string | number;
    data: Partial<T>;
    previousData?: T;
    timestamp: number;
    txId?: string;
}
/**
 * Conflict types that can occur during sync
 */
export type ConflictType = 'update-update' | 'update-delete' | 'delete-update' | 'insert-insert';
/**
 * Conflict information for resolution
 */
export interface Conflict<T extends BaseRecord> {
    type: ConflictType;
    collectionId: string;
    recordId: string | number;
    localValue?: Partial<T>;
    remoteValue?: Partial<T>;
    baseValue?: T;
    localTimestamp: number;
    remoteTimestamp: number;
}
/**
 * Conflict resolution strategy
 */
export type ConflictStrategy = 'local-wins' | 'remote-wins' | 'latest-wins' | 'merge' | 'manual';
/**
 * Conflict resolver function
 */
export type ConflictResolver<T extends BaseRecord> = (conflict: Conflict<T>) => Promise<T | null> | T | null;
/**
 * Sync state for a collection
 */
export interface SyncState {
    /** Whether sync is currently active */
    connected: boolean;
    /** Last successful sync timestamp */
    lastSyncAt?: number;
    /** Last sync error if any */
    lastError?: Error;
    /** Number of pending changes */
    pendingCount: number;
    /** Whether initial sync is complete */
    initialized: boolean;
}
/**
 * PGLite collection options for local database
 */
export interface PGLiteCollectionOptions<T extends BaseRecord> extends CollectionOptions<T> {
    /** PGLite instance or factory */
    pglite: PGLiteInterface | (() => Promise<PGLiteInterface>);
    /** Whether to create table if not exists */
    autoCreateTable?: boolean;
    /** Table schema definition for auto-create */
    tableSchema?: string;
}
/**
 * Minimal PGLite interface for type safety
 */
export interface PGLiteInterface {
    query<R = unknown>(sql: string, params?: unknown[]): Promise<{
        rows: R[];
    }>;
    exec(sql: string): Promise<void>;
    close(): Promise<void>;
}
/**
 * Collection instance with methods
 */
export interface Collection<T extends BaseRecord> {
    /** Collection ID */
    readonly id: string;
    /** Get all items */
    getAll(): T[];
    /** Get item by ID */
    get(id: string | number): T | undefined;
    /** Insert a new item */
    insert(data: Omit<T, 'id'> & {
        id?: T['id'];
    }): Promise<T>;
    /** Update an existing item */
    update(id: string | number, data: Partial<T>): Promise<T>;
    /** Delete an item */
    delete(id: string | number): Promise<void>;
    /** Subscribe to changes */
    subscribe(callback: (items: T[]) => void): () => void;
    /** Get current sync state */
    getSyncState(): SyncState;
}
/**
 * TanStack DB Store interface
 */
export interface TanStackStore {
    /** Get a collection by ID */
    getCollection<T extends BaseRecord>(id: string): Collection<T> | undefined;
    /** Register a new collection */
    registerCollection<T extends BaseRecord>(options: QueryCollectionOptions<T> | SyncCollectionOptions<T> | PGLiteCollectionOptions<T>): Collection<T>;
    /** Get all registered collection IDs */
    getCollectionIds(): string[];
    /** Dispose of all resources */
    dispose(): Promise<void>;
}
//# sourceMappingURL=types.d.ts.map