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 Config struct {
	// Store provides local event persistence (required).
	Store EventStore

	// Transport handles network communication (optional for local-only scenarios).
	Transport Transport

	// Logger for structured logging (optional; defaults to slog.Default()).
	Logger *slog.Logger

	// Cursor specifies the versioning strategy (Integer or Vector).
	// Default: CursorInteger.
	Cursor CursorMode

	// Retry defines backoff/retry policy for transient failures.
	// Default: no retries.
	Retry RetryPolicy

	// Resolvers is the conflict resolution registry (optional).
	// If nil, uses Last-Write-Wins as default resolver.
	// Note: ResolverRegistry type is forward-compatible placeholder; use ConflictResolver for now.
	Resolvers ConflictResolver

	// Timeout is the maximum duration for sync operations (0 = no timeout).
	// Default: 0 (no timeout).
	Timeout time.Duration

	// BatchSize limits the number of events to sync at once.
	// Default: 100.
	BatchSize int

	// SyncInterval for automatic periodic sync (0 = disabled).
	// Default: 0 (manual sync only).
	SyncInterval time.Duration

	// PushOnly restricts sync to only pushing local events (no pull).
	// Default: false.
	PushOnly bool

	// PullOnly restricts sync to only pulling remote events (no push).
	// Default: false.
	PullOnly bool

	// EnableValidation enables additional validation checks during sync.
	// Default: false.
	EnableValidation bool

	// EnableCompression enables data compression during transport.
	// Default: false.
	EnableCompression bool

	// Filter is an optional event filter function.
	// Events are synced only if Filter returns true.
	Filter func(Event) bool

	// MetricsCollector for observability hooks (optional).
	MetricsCollector MetricsCollector

	// Tracer for distributed tracing (optional).
	Tracer interface {
		StartSyncOperation(ctx context.Context, operation string) (context.Context, trace.Span)
		StartTransportOperation(ctx context.Context, operation, transport string) (context.Context, trace.Span)
		StartStorageOperation(ctx context.Context, operation, storageType string) (context.Context, trace.Span)
		StartConflictResolution(ctx context.Context, strategy string) (context.Context, trace.Span)
		RecordError(span trace.Span, err error, description string)
		SetSyncResult(span trace.Span, eventsPushed, eventsPulled, conflictsResolved int)
	}
}

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 = types.Conflict

type ConflictResolver = types.ConflictResolver

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 CursorMode int

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 = types.EventStore

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 Filter = types.Filter

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
	}
	// contains filtered or unexported fields
}

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 ProjectionConfig struct {
	// Runners are the projection runners to execute after successful sync
	Runners []ProjectionRunner

	// RunOnSync enables automatic projection execution after sync
	RunOnSync bool

	// MaxWorkers is the maximum number of concurrent projection workers
	MaxWorkers int

	// Timeout is the timeout for projection operations
	Timeout time.Duration
}

type ProjectionRunner interface {
	// ApplySince applies all events since the last saved offset
	ApplySince(ctx context.Context) (applied int, last Version, err error)

	// ApplyBatch applies a specific batch of events directly
	ApplyBatch(ctx context.Context, batch []EventWithVersion) error
}

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 = types.ResolvedConflict

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 RetryPolicy struct {
	// Max is the maximum number of retry attempts (0 = no retries, <0 = unlimited).
	Max int

	// Base is the initial delay between retries (must be > 0 if retries enabled).
	Base time.Duration

	// Cap is the maximum delay between retries (must be >= Base).
	Cap time.Duration

	// Jitter adds randomness to retry delays to avoid thundering herd (recommended: true).
	Jitter bool
}

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 StateAwareSyncResult struct {
	*SyncResult

	// StateTransitions contains the state transitions that occurred during sync
	StateTransitions []statemachine.StateTransition[SyncState]

	// FinalState is the final state of the sync operation
	FinalState SyncState

	// StateChanges is the number of state transitions that occurred
	StateChanges int
}

type StatefulDynamicResolver struct {
	// Embed the existing DynamicResolver for backward compatibility
	*DynamicResolver
	// contains filtered or unexported fields
}

type StatefulRealtimeNotifier interface {
	RealtimeNotifier
	statemachine.StatefulTransport
}

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

type StatefulRealtimeSyncOptions struct {
	RealtimeSyncOptions

	// TransportStateConfig for configuring transport state management
	TransportStateConfig statemachine.TransportStateManagerConfig

	// EnableTransportStateLogging enables detailed transport state logging
	EnableTransportStateLogging bool

	// ConnectionTimeout for transport connection attempts
	ConnectionTimeout time.Duration

	// MaxConnectionAttempts before marking transport as failed
	MaxConnectionAttempts int

	// ConnectionRetryDelay between connection attempts
	ConnectionRetryDelay time.Duration
}

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

type SyncNode = SyncManager

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 SyncState int

type SyncStateObserver struct {
	// OnStateChange is called when a sync state transition succeeds
	OnStateChange func(from, to SyncState, duration time.Duration, metadata map[string]interface{})

	// OnStateChangeError is called when a sync state transition fails
	OnStateChangeError func(from, to SyncState, err error, metadata map[string]interface{})
}

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 = types.Transport

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

type Version = types.Version