synckit

type AdditiveMergeResolver struct{}

type AuditableOption interface {
	// contains filtered or unexported methods
}

type AuditableResolver struct {
	// contains filtered or unexported fields
}

type BackoffStrategy interface {
	// NextDelay returns the delay before the next reconnection attempt
	NextDelay(attempt int) time.Duration

	// Reset resets the backoff strategy after a successful connection
	Reset()
}

type BasicValidator struct{}

type CompositeOption interface {
	// contains filtered or unexported methods
}

type CompositeResolver struct {
	// contains filtered or unexported fields
}

type ConfigLoader struct {
	// contains filtered or unexported fields
}

type ConfigLoaderOption interface {
	// contains filtered or unexported methods
}

type ConfigSettings struct {
	DefaultFallback string            `json:"default_fallback,omitempty" yaml:"default_fallback,omitempty"`
	Timeouts        TimeoutSettings   `json:"timeouts,omitempty" yaml:"timeouts,omitempty"`
	Limits          LimitSettings     `json:"limits,omitempty" yaml:"limits,omitempty"`
	Features        map[string]bool   `json:"features,omitempty" yaml:"features,omitempty"`
	Custom          map[string]string `json:"custom,omitempty" yaml:"custom,omitempty"`
}

type ConfigTransformer interface {
	Transform(config *RuleConfig) (*RuleConfig, error)
	Name() string
}

type ConfigValidator interface {
	Validate(config *RuleConfig) error
	Name() string
}

type ConfigWatcher interface {
	OnConfigChanged(oldConfig, newConfig *RuleConfig)
	OnConfigError(err error)
	Name() string
}

type Conflict struct {
	EventType     string
	AggregateID   string
	ChangedFields []string
	Metadata      map[string]any

	Local  EventWithVersion
	Remote EventWithVersion
}

type ConflictResolver interface {
	Resolve(ctx context.Context, c Conflict) (ResolvedConflict, error)
}

type ConflictState struct {
	AggregateID   string         `json:"aggregate_id"`
	EventType     string         `json:"event_type,omitempty"`
	LocalVersion  string         `json:"local_version"`
	RemoteVersion string         `json:"remote_version"`
	LocalData     any            `json:"local_data,omitempty"`
	RemoteData    any            `json:"remote_data,omitempty"`
	ResolvedData  any            `json:"resolved_data,omitempty"`
	Metadata      map[string]any `json:"metadata,omitempty"`
}

type ConnectionStatus struct {
	Connected         bool
	LastConnected     time.Time
	ReconnectAttempts int
	Error             error
}

type CursorTransport interface {
	Transport

	// PullWithCursor retrieves events using a cursor-based pagination strategy.
	// Returns events, next cursor, and any error.
	PullWithCursor(ctx context.Context, since cursor.Cursor, limit int) ([]EventWithVersion, cursor.Cursor, error)
}

type DynamicResolver struct {
	// contains filtered or unexported fields
}

type Event = types.Event

type EventStore interface {
	// Store persists an event to the store
	Store(ctx context.Context, event Event, version Version) error

	// Load retrieves all events since the given version
	Load(ctx context.Context, since Version) ([]EventWithVersion, error)

	// LoadByAggregate retrieves events for a specific aggregate since the given version
	LoadByAggregate(ctx context.Context, aggregateID string, since Version) ([]EventWithVersion, error)

	// LatestVersion returns the latest version in the store
	LatestVersion(ctx context.Context) (Version, error)

	// ParseVersion converts a string representation into a Version
	// This allows different storage implementations to handle their own version formats
	ParseVersion(ctx context.Context, versionStr string) (Version, error)

	// Close closes the store and releases resources
	Close() error
}

type EventWithVersion = types.EventWithVersion

type ExponentialBackoff struct {
	InitialDelay time.Duration
	MaxDelay     time.Duration
	Multiplier   float64
}

type ExtendedMetricsCollector interface {
	MetricsCollector // Embed existing interface

	// New methods for detailed conflict resolution metrics
	RecordResolution(ruleName, groupName, decision string, duration time.Duration, success bool)
	RecordRuleMatch(ruleName, groupName string)
	RecordFallbackUsage(groupName string)
	RecordResolutionError(ruleName, groupName, errorType string)
	RecordManualReview(reason string)
}

type ExtendedNoOpMetricsCollector struct {
	NoOpMetricsCollector // Embed existing no-op collector
}

type FirstWriteWinsResolver struct{}

type GroupConfig struct {
	Name        string                 `json:"name" yaml:"name"`
	Description string                 `json:"description,omitempty" yaml:"description,omitempty"`
	Enabled     *bool                  `json:"enabled,omitempty" yaml:"enabled,omitempty"`
	Fallback    string                 `json:"fallback,omitempty" yaml:"fallback,omitempty"`
	Rules       []RuleConfigEntry      `json:"rules" yaml:"rules"`
	SubGroups   []GroupConfig          `json:"subgroups,omitempty" yaml:"subgroups,omitempty"`
	Metadata    map[string]interface{} `json:"metadata,omitempty" yaml:"metadata,omitempty"`
}

type Hooks struct {
	OnRuleMatched func(conflict Conflict, rule Rule)
	OnResolved    func(conflict Conflict, result ResolvedConflict)
	OnFallback    func(conflict Conflict)
	OnError       func(conflict Conflict, err error)
}

type InMemoryMementoCaretaker struct {
	// contains filtered or unexported fields
}

type LastWriteWinsResolver struct{}

type LimitSettings struct {
	MaxConflictsPerBatch int `json:"max_conflicts_per_batch,omitempty" yaml:"max_conflicts_per_batch,omitempty"`
	MaxRulesPerGroup     int `json:"max_rules_per_group,omitempty" yaml:"max_rules_per_group,omitempty"`
}

type Logger interface {
	Debug(msg string, args ...interface{})
	Error(msg string, args ...interface{})
}

type LoggingWatcher struct {
	// contains filtered or unexported fields
}

type ManagerOption func(*SyncManagerBuilder) error

type ManualReviewResolver struct{ Reason string }

type MatchConditions struct {
	EventTypes   []string          `json:"event_types,omitempty" yaml:"event_types,omitempty"`
	AggregateIDs []string          `json:"aggregate_ids,omitempty" yaml:"aggregate_ids,omitempty"`
	Fields       []string          `json:"fields,omitempty" yaml:"fields,omitempty"`
	CustomMatch  map[string]string `json:"custom_match,omitempty" yaml:"custom_match,omitempty"`
}

type MementoCaretaker interface {
	// Save stores a resolution memento
	Save(ctx context.Context, memento *ResolutionMemento) error

	// Get retrieves a specific memento by ID
	Get(ctx context.Context, id string) (*ResolutionMemento, error)

	// List retrieves mementos based on criteria
	List(ctx context.Context, criteria *MementoCriteria) ([]*ResolutionMemento, error)

	// Delete removes a memento (with appropriate authorization)
	Delete(ctx context.Context, id string) error

	// GetAuditTrail returns the complete audit trail for an aggregate
	GetAuditTrail(ctx context.Context, aggregateID string) ([]*ResolutionMemento, error)
}

type MementoCriteria struct {
	AggregateID  string     `json:"aggregate_id,omitempty"`
	UserID       string     `json:"user_id,omitempty"`
	ResolverName string     `json:"resolver_name,omitempty"`
	GroupName    string     `json:"group_name,omitempty"`
	FromTime     *time.Time `json:"from_time,omitempty"`
	ToTime       *time.Time `json:"to_time,omitempty"`
	Limit        int        `json:"limit,omitempty"`
	Offset       int        `json:"offset,omitempty"`
}

type MetricsCollector interface {
	// RecordSyncDuration records how long a sync operation took
	RecordSyncDuration(operation string, duration time.Duration)

	// RecordSyncEvents records the number of events pushed and pulled
	RecordSyncEvents(pushed, pulled int)

	// RecordSyncErrors records sync operation errors by type
	RecordSyncErrors(operation string, errorType string)

	// RecordConflicts records the number of conflicts resolved
	RecordConflicts(resolved int)
}

type MockMetricsCollector struct {
	DurationCalls []struct {
		Operation string
		Duration  time.Duration
	}
	EventCalls []struct {
		Pushed, Pulled int
	}
	ErrorCalls []struct {
		Operation, ErrorType string
	}
	ConflictCalls []struct {
		Resolved int
	}
}

type NoOpMetricsCollector struct{}

type Notification struct {
	// Type of notification (data_changed, sync_requested, etc.)
	Type string

	// Source identifies where the change originated
	Source string

	// AggregateIDs that were affected (optional, for filtering)
	AggregateIDs []string

	// Metadata for additional context
	Metadata map[string]interface{}

	// Timestamp when the notification was created
	Timestamp time.Time
}

type NotificationFilter func(notification Notification) bool

type NotificationHandler func(notification Notification) error

type ObservableOption interface {
	// contains filtered or unexported methods
}

type ObservableResolver struct {
	// contains filtered or unexported fields
}

type Option interface {
	// contains filtered or unexported methods
}

type RealtimeNotifier interface {
	// Subscribe starts listening for real-time notifications
	// The handler will be called when new data is available for sync
	Subscribe(ctx context.Context, handler NotificationHandler) error

	// Unsubscribe stops listening for notifications
	Unsubscribe() error

	// Notify sends a notification to connected clients (server-side)
	Notify(ctx context.Context, notification Notification) error

	// IsConnected returns true if the real-time connection is active
	IsConnected() bool

	// Close closes the notifier connection
	Close() error
}

type RealtimeSyncManager interface {
	SyncManager

	// EnableRealtime starts real-time notifications
	EnableRealtime(ctx context.Context) error

	// DisableRealtime stops real-time notifications and falls back to polling
	DisableRealtime() error

	// IsRealtimeActive returns true if real-time notifications are active
	IsRealtimeActive() bool

	// GetConnectionStatus returns the current real-time connection status
	GetConnectionStatus() ConnectionStatus
}

type RealtimeSyncOptions struct {
	SyncOptions

	// RealtimeNotifier for push notifications (optional)
	RealtimeNotifier RealtimeNotifier

	// NotificationFilter to process only relevant notifications
	NotificationFilter NotificationFilter

	// DisablePolling stops periodic sync when real-time is active
	DisablePolling bool

	// FallbackInterval for polling when real-time connection is lost
	FallbackInterval time.Duration

	// ReconnectBackoff strategy for reconnecting to real-time notifications
	ReconnectBackoff BackoffStrategy
}

type ResolutionConfig struct {
	Strategy string                 `json:"strategy" yaml:"strategy"`
	Options  map[string]interface{} `json:"options,omitempty" yaml:"options,omitempty"`
}

type ResolutionHooks struct {
	OnConflict    func(ctx context.Context, conflict *Conflict)
	OnRuleMatched func(ctx context.Context, conflict *Conflict, rule *Rule, group *RuleGroup)
	OnResolution  func(ctx context.Context, result *ResolvedConflict, duration time.Duration)
	OnFallback    func(ctx context.Context, conflict *Conflict, group *RuleGroup)
	OnError       func(ctx context.Context, conflict *Conflict, err error)
}

type ResolutionMemento struct {
	// Unique identifier for this resolution
	ID string `json:"id"`

	// Timestamp when the resolution occurred
	Timestamp time.Time `json:"timestamp"`

	// Conflict information (serialization-friendly)
	EventType     string         `json:"event_type"`
	AggregateID   string         `json:"aggregate_id"`
	ChangedFields []string       `json:"changed_fields,omitempty"`
	Metadata      map[string]any `json:"metadata,omitempty"`

	// Resolution result (serialization-friendly)
	Decision string   `json:"decision"`
	Reasons  []string `json:"reasons,omitempty"`

	// Resolution metadata
	ResolverName string         `json:"resolver_name"`
	RuleName     string         `json:"rule_name,omitempty"`
	GroupName    string         `json:"group_name,omitempty"`
	Context      map[string]any `json:"context,omitempty"`

	// Audit trail information
	UserID    string `json:"user_id,omitempty"`
	SessionID string `json:"session_id,omitempty"`
	Origin    string `json:"origin,omitempty"`

	// Performance metrics
	ResolutionDuration time.Duration `json:"resolution_duration"`

	// State before resolution (for rollback)
	BeforeState *ConflictState `json:"before_state,omitempty"`

	// State after resolution
	AfterState *ConflictState `json:"after_state,omitempty"`

	// For internal use - not serialized
	OriginalConflict Conflict         `json:"-"`
	ResolvedConflict ResolvedConflict `json:"-"`
}

type ResolvedConflict struct {
	ResolvedEvents []EventWithVersion
	Decision       string
	Reasons        []string
}

type RetryConfig struct {
	// MaxAttempts is the maximum number of retry attempts
	MaxAttempts int

	// InitialDelay is the initial delay between retries
	InitialDelay time.Duration

	// MaxDelay is the maximum delay between retries
	MaxDelay time.Duration

	// Multiplier is the factor by which the delay increases
	Multiplier float64
}

type RollbackAnalysis struct {
	TargetMemento        *ResolutionMemento   `json:"target_memento"`
	AffectedResolutions  []*ResolutionMemento `json:"affected_resolutions"`
	RollbackComplexity   string               `json:"rollback_complexity"`
	RequiresReprocessing bool                 `json:"requires_reprocessing"`
	Warnings             []string             `json:"warnings,omitempty"`
}

type RollbackCapability struct {
	// contains filtered or unexported fields
}

type Rule struct {
	Name     string
	Matcher  Spec
	Resolver ConflictResolver
}

type RuleConfig struct {
	Version     string                 `json:"version" yaml:"version"`
	Name        string                 `json:"name" yaml:"name"`
	Description string                 `json:"description,omitempty" yaml:"description,omitempty"`
	Metadata    map[string]interface{} `json:"metadata,omitempty" yaml:"metadata,omitempty"`

	// Global settings
	Settings ConfigSettings `json:"settings,omitempty" yaml:"settings,omitempty"`

	// Rule groups
	Groups []GroupConfig `json:"groups" yaml:"groups"`

	// Global rules (not in any group)
	Rules []RuleConfigEntry `json:"rules,omitempty" yaml:"rules,omitempty"`
}

type RuleConfigEntry struct {
	Name        string `json:"name" yaml:"name"`
	Description string `json:"description,omitempty" yaml:"description,omitempty"`
	Enabled     *bool  `json:"enabled,omitempty" yaml:"enabled,omitempty"`
	Priority    int    `json:"priority,omitempty" yaml:"priority,omitempty"`

	// Matching conditions
	Conditions MatchConditions `json:"conditions" yaml:"conditions"`

	// Resolution configuration
	Resolution ResolutionConfig `json:"resolution" yaml:"resolution"`

	// Metadata for custom extensions
	Metadata map[string]interface{} `json:"metadata,omitempty" yaml:"metadata,omitempty"`
}

type RuleGroup struct {
	Name        string
	Description string
	// contains filtered or unexported fields
}

type RuleGroupOption interface {
	// contains filtered or unexported methods
}

type RuleGroupStats struct {
	Name          string           `json:"name"`
	Enabled       bool             `json:"enabled"`
	RuleCount     int              `json:"rule_count"`     // Direct rules in this group
	SubGroupCount int              `json:"subgroup_count"` // Number of direct subgroups
	TotalRules    int              `json:"total_rules"`    // Total rules including subgroups
	SubGroups     []RuleGroupStats `json:"subgroups,omitempty"`
}

type Spec func(Conflict) bool

type SyncManager interface {
	// Sync performs a bidirectional sync operation
	Sync(ctx context.Context) (*SyncResult, error)

	// Push sends local events to remote
	Push(ctx context.Context) (*SyncResult, error)

	// Pull retrieves remote events to local
	Pull(ctx context.Context) (*SyncResult, error)

	// StartAutoSync begins automatic synchronization at the configured interval
	StartAutoSync(ctx context.Context) error

	// StopAutoSync stops automatic synchronization
	StopAutoSync() error

	// Subscribe to sync events (optional)
	Subscribe(handler func(*SyncResult)) error

	// Close shuts down the sync manager
	Close() error
}

type SyncManagerBuilder struct {
	// contains filtered or unexported fields
}

type SyncOptions struct {
	// LastCursorLoader loads the last saved cursor for cursor-based syncs
	LastCursorLoader func() cursor.Cursor

	// CursorSaver saves the latest cursor after a successful sync
	CursorSaver func(cursor.Cursor) error

	// PushOnly indicates this client should only push events, not pull
	PushOnly bool

	// PullOnly indicates this client should only pull events, not push
	PullOnly bool

	// ConflictResolver to use for handling conflicts
	ConflictResolver ConflictResolver

	// Filter can be used to sync only specific events
	Filter func(Event) bool

	// BatchSize limits how many events to sync at once
	BatchSize int

	// SyncInterval for automatic periodic sync (0 disables)
	SyncInterval time.Duration

	// RetryConfig configures retry behavior for sync operations
	RetryConfig *RetryConfig

	// EnableValidation enables additional validation checks during sync
	EnableValidation bool

	// Timeout sets the maximum duration for sync operations
	Timeout time.Duration

	// EnableCompression enables data compression during transport
	EnableCompression bool

	// MetricsCollector for observability hooks (optional)
	MetricsCollector MetricsCollector

	// Tracer for distributed tracing (optional)
	Tracer interface {
		// StartSyncOperation starts a new span for a sync operation
		StartSyncOperation(ctx context.Context, operation string) (context.Context, trace.Span)
		// StartTransportOperation starts a new span for transport operations
		StartTransportOperation(ctx context.Context, operation, transport string) (context.Context, trace.Span)
		// StartStorageOperation starts a new span for storage operations
		StartStorageOperation(ctx context.Context, operation, storageType string) (context.Context, trace.Span)
		// StartConflictResolution starts a new span for conflict resolution
		StartConflictResolution(ctx context.Context, strategy string) (context.Context, trace.Span)
		// RecordError records an error on a span
		RecordError(span trace.Span, err error, description string)
		// SetSyncResult sets sync result attributes on a span
		SetSyncResult(span trace.Span, eventsPushed, eventsPulled, conflictsResolved int)
	}
}

type SyncResult struct {
	// EventsPushed is the number of events sent to remote
	EventsPushed int

	// EventsPulled is the number of events received from remote
	EventsPulled int

	// ConflictsResolved is the number of conflicts that were resolved
	ConflictsResolved int

	// Errors contains any non-fatal errors that occurred during sync
	Errors []error

	// StartTime is when the sync operation began
	StartTime time.Time

	// Duration is how long the sync took
	Duration time.Duration

	// LocalVersion is the local version after sync
	LocalVersion Version

	// RemoteVersion is the remote version after sync
	RemoteVersion Version
}

type TestEvent struct{}

type TestEventStore struct {
	// contains filtered or unexported fields
}

type TestTransport struct {
	// contains filtered or unexported fields
}

type TestVersion struct{}

type TimeoutSettings struct {
	ResolutionTimeoutMs   int `json:"resolution_timeout_ms,omitempty" yaml:"resolution_timeout_ms,omitempty"`
	ManualReviewTimeoutMs int `json:"manual_review_timeout_ms,omitempty" yaml:"manual_review_timeout_ms,omitempty"`
}

type Transport interface {
	// Push sends events to the remote endpoint
	Push(ctx context.Context, events []EventWithVersion) error

	// Pull retrieves events from the remote endpoint since the given version
	Pull(ctx context.Context, since Version) ([]EventWithVersion, error)

	// GetLatestVersion efficiently retrieves the latest version from remote without pulling events
	GetLatestVersion(ctx context.Context) (Version, error)

	// Subscribe listens for real-time updates (optional for polling-based transports)
	Subscribe(ctx context.Context, handler func([]EventWithVersion) error) error

	// Close closes the transport connection
	Close() error
}

type Validator interface {
	Validate(options *resolverOptions) error
}

type Version = types.Version