import * as _nozbe_watermelondb from '@nozbe/watermelondb';
import { Database, TableName, Model, ColumnSchema } from '@nozbe/watermelondb';
import * as _nozbe_watermelondb_Schema from '@nozbe/watermelondb/Schema';
import React from 'react';
import { RefreshControlProps } from 'react-native';

declare enum SyncOperation {
    CREATE = "CREATE",
    UPDATE = "UPDATE",
    DELETE = "DELETE"
}
declare enum SyncStatus {
    IDLE = "idle",
    SYNCING = "syncing",
    ERROR = "error"
}
declare enum ConflictStrategy {
    LAST_WRITE_WINS = "last-write-wins",
    SERVER_WINS = "server-wins",
    CLIENT_WINS = "client-wins",
    CUSTOM = "custom"
}
type NetworkStatus = {
    isConnected: boolean;
    isInternetReachable: boolean | null;
    type: string | null;
};
interface SyncQueueItem {
    id: string;
    operation: SyncOperation;
    tableName: string;
    recordId: string;
    payload: Record<string, any>;
    retryCount: number;
    errorMessage: string | null;
    createdAt: number;
    updatedAt: number;
}
interface ApiEndpoints {
    push: string;
    pull: string;
}
interface PushPayload {
    changes: {
        tableName: string;
        operation: SyncOperation;
        recordId: string;
        data: Record<string, any>;
    }[];
}
interface PushResponse {
    success: boolean;
    results: {
        recordId: string;
        serverId?: string;
        serverUpdatedAt?: number;
        error?: string;
    }[];
}
interface PullPayload {
    lastSyncAt: number | null;
    tables: string[];
}
interface PullResponse {
    timestamp: number;
    changes: {
        [tableName: string]: {
            created: Record<string, any>[];
            updated: Record<string, any>[];
            deleted: string[];
        };
    };
}
interface ApiClient {
    push: (payload: PushPayload) => Promise<PushResponse>;
    pull: (payload: PullPayload) => Promise<PullResponse>;
}
interface ConflictContext {
    tableName: string;
    recordId: string;
    localData: Record<string, any>;
    serverData: Record<string, any>;
    localUpdatedAt: number;
    serverUpdatedAt: number;
}
type ConflictResolverFn = (context: ConflictContext) => 'local' | 'server' | Record<string, any>;
interface SyncEngineConfig {
    database: Database;
    tables: TableName<Model>[];
    apiClient: ApiClient;
    conflictStrategy?: ConflictStrategy;
    customConflictResolver?: ConflictResolverFn;
    syncInterval?: number;
    maxRetries?: number;
    retryDelayBase?: number;
    enableBackgroundSync?: boolean;
    syncOnReconnect?: boolean;
    pushBatchSize?: number;
    debug?: boolean;
}
interface SyncEngineState {
    status: SyncStatus;
    lastSyncAt: number | null;
    pendingChanges: number;
    error: Error | null;
    isSyncing: boolean;
}
interface SyncStats {
    pushedCount: number;
    pulledCount: number;
    failedCount: number;
    duration: number;
}
interface SyncResult {
    success: boolean;
    stats: SyncStats;
    error?: Error;
}
type SyncStatusListener = (state: SyncEngineState) => void;
type NetworkStatusListener = (status: NetworkStatus) => void;
interface SyncMetadata {
    serverId?: string | null;
    serverUpdatedAt?: number | null;
    offlineSyncStatus?: 'pending' | 'synced' | 'failed' | null;
    lastSyncError?: string | null;
}
interface RetryConfig {
    maxRetries: number;
    baseDelay: number;
    maxDelay?: number;
}
interface BackoffCalculator {
    (attempt: number, config: RetryConfig): number;
}

declare class NetworkDetector {
    private listeners;
    private currentStatus;
    private unsubscribe?;
    private logger;
    constructor(debug?: boolean);
    initialize(): Promise<void>;
    destroy(): void;
    getStatus(): NetworkStatus;
    isOnline(): boolean;
    addListener(listener: NetworkStatusListener): () => void;
    removeListener(listener: NetworkStatusListener): void;
    private updateStatus;
    private notifyListeners;
}

declare class SyncEngine {
    private queueManager;
    private pushSynchronizer;
    private pullSynchronizer;
    private networkDetector;
    private config;
    private state;
    private listeners;
    private syncIntervalId?;
    private logger;
    private isInitialized;
    constructor(config: SyncEngineConfig);
    initialize(): Promise<void>;
    destroy(): void;
    sync(): Promise<SyncResult>;
    queueOperation(operation: SyncOperation, tableName: string, recordId: string, payload: Record<string, any>): Promise<void>;
    getState(): SyncEngineState;
    getNetworkDetector(): NetworkDetector;
    addListener(listener: SyncStatusListener): () => void;
    removeListener(listener: SyncStatusListener): void;
    private startBackgroundSync;
    private stopBackgroundSync;
    private updatePendingCount;
    private updateState;
    private notifyListeners;
}

declare class SyncQueueManager {
    private database;
    private logger;
    constructor(database: Database | null, debug?: boolean);
    addToQueue(operation: SyncOperation, tableName: string, recordId: string, payload: Record<string, any>): Promise<void>;
    getQueuedItems(): Promise<SyncQueueItem[]>;
    getPendingItems(maxRetries: number): Promise<SyncQueueItem[]>;
    getFailedItems(maxRetries: number): Promise<SyncQueueItem[]>;
    getPendingCount(): Promise<number>;
    markAsProcessed(itemId: string): Promise<void>;
    incrementRetry(itemId: string, errorMessage: string): Promise<void>;
    clearFailedItems(maxRetries: number): Promise<number>;
    clearAllItems(): Promise<number>;
    private modelToQueueItem;
}

declare class PushSynchronizer {
    private database;
    private queueManager;
    private apiClient;
    private maxRetries;
    private batchSize;
    private logger;
    constructor(database: Database, queueManager: SyncQueueManager, apiClient: ApiClient, maxRetries?: number, batchSize?: number, debug?: boolean);
    push(): Promise<{
        pushedCount: number;
        failedCount: number;
    }>;
    private pushBatch;
    private updateLocalRecord;
}

interface IConflictResolver {
    resolve(context: ConflictContext): 'local' | 'server' | Record<string, any>;
}
declare class LastWriteWinsResolver implements IConflictResolver {
    resolve(context: ConflictContext): 'local' | 'server';
}
declare class ServerWinsResolver implements IConflictResolver {
    resolve(): 'server';
}
declare class ClientWinsResolver implements IConflictResolver {
    resolve(): 'local';
}
declare class CustomResolver implements IConflictResolver {
    private customFn;
    constructor(customFn: ConflictResolverFn);
    resolve(context: ConflictContext): 'local' | 'server' | Record<string, any>;
}
declare function createConflictResolver(strategy: ConflictStrategy, customResolver?: ConflictResolverFn): IConflictResolver;

declare class PullSynchronizer {
    private database;
    private apiClient;
    private tables;
    private conflictResolver;
    private logger;
    constructor(database: Database, apiClient: ApiClient, tables: TableName<Model>[], conflictResolver: IConflictResolver, debug?: boolean);
    pull(): Promise<{
        pulledCount: number;
    }>;
    private applyCreated;
    private applyUpdated;
    private applyDeleted;
    private updateRecord;
    private applyServerData;
    private getLastSyncTimestamp;
    private setLastSyncTimestamp;
}

declare class BaseModel extends Model implements SyncMetadata {
    serverId?: string | null;
    serverUpdatedAt?: number | null;
    offlineSyncStatus?: 'pending' | 'synced' | 'failed' | null;
    lastSyncError?: string | null;
    get isSynced(): boolean;
    get hasSyncError(): boolean;
    get isPendingSync(): boolean;
}

declare class SyncQueueItemModel extends Model {
    static table: string;
    operation: SyncOperation;
    tableName: string;
    recordId: string;
    payload: Record<string, any>;
    retryCount: number;
    errorMessage?: string | null;
    createdAt: Date;
    updatedAt: Date;
    hasExceededMaxRetries(maxRetries: number): boolean;
    get hasFailed(): boolean;
}

declare const syncQueueTableSchema: Readonly<{
    name: _nozbe_watermelondb.TableName<any>;
    columns: _nozbe_watermelondb_Schema.ColumnMap;
    columnArray: _nozbe_watermelondb.ColumnSchema[];
    unsafeSql?: (_: string) => string;
}>;
declare const getSyncQueueSchema: () => Readonly<{
    name: _nozbe_watermelondb.TableName<any>;
    columns: _nozbe_watermelondb_Schema.ColumnMap;
    columnArray: _nozbe_watermelondb.ColumnSchema[];
    unsafeSql?: (_: string) => string;
}>;

declare const syncMetadataColumns: ColumnSchema[];
declare const createTableSchemaWithSync: (tableName: string, columns: ColumnSchema[]) => {
    name: string;
    columns: ColumnSchema[];
};

declare function useSyncEngine(syncEngine: SyncEngine): {
    sync: () => Promise<SyncResult>;
    syncStatus: SyncStatus;
    lastSyncAt: number | null;
    pendingChanges: number;
    error: Error | null;
    isSyncing: boolean;
};

declare function useNetworkStatus(networkDetector: NetworkDetector): {
    isOnline: boolean;
    isConnected: boolean;
    isInternetReachable: boolean | null;
    type: string | null;
};

declare function useOptimisticUpdate(database: Database, syncEngine: SyncEngine): {
    execute: <T extends Model>(tableName: string, operation: SyncOperation, fn: (collection: any) => Promise<T>) => Promise<T>;
    isOptimistic: boolean;
};

interface SyncStatusBadgeProps {
    syncEngine: SyncEngine;
    style?: any;
}
declare const SyncStatusBadge: React.FC<SyncStatusBadgeProps>;

interface OfflineBannerProps {
    networkDetector: NetworkDetector;
    message?: string;
    style?: any;
}
declare const OfflineBanner: React.FC<OfflineBannerProps>;

interface SyncRefreshControlProps extends Omit<RefreshControlProps, 'refreshing' | 'onRefresh'> {
    syncEngine: SyncEngine;
}
declare const SyncRefreshControl: React.FC<SyncRefreshControlProps>;

declare class Logger {
    private debug;
    private prefix;
    constructor(prefix?: string, debug?: boolean);
    setDebug(enabled: boolean): void;
    log(...args: any[]): void;
    info(...args: any[]): void;
    warn(...args: any[]): void;
    error(...args: any[]): void;
}
declare const createLogger: (prefix?: string, debug?: boolean) => Logger;

declare const now: () => number;
declare const formatTimestamp: (timestamp: number) => string;

export { type ApiClient, type ApiEndpoints, type BackoffCalculator, BaseModel, ClientWinsResolver, type ConflictContext, type ConflictResolverFn, ConflictStrategy, CustomResolver, type IConflictResolver, LastWriteWinsResolver, NetworkDetector, type NetworkStatus, type NetworkStatusListener, OfflineBanner, type OfflineBannerProps, type PullPayload, type PullResponse, PullSynchronizer, type PushPayload, type PushResponse, PushSynchronizer, type RetryConfig, ServerWinsResolver, SyncEngine, type SyncEngineConfig, type SyncEngineState, type SyncMetadata, SyncOperation, type SyncQueueItem, SyncQueueItemModel, SyncQueueManager, SyncRefreshControl, type SyncRefreshControlProps, type SyncResult, type SyncStats, SyncStatus, SyncStatusBadge, type SyncStatusBadgeProps, type SyncStatusListener, createConflictResolver, createLogger, createTableSchemaWithSync, formatTimestamp, getSyncQueueSchema, now, syncMetadataColumns, syncQueueTableSchema, useNetworkStatus, useOptimisticUpdate, useSyncEngine };