export

type BackendProvider interface {
	BackupBackend(backend string, useCase modulecapabilities.BackendUseCase) (modulecapabilities.BackupBackend, error)
}

type ExportClient interface {
	// Prepare asks a participant to reserve its export slot.
	Prepare(ctx context.Context, host string, req *ExportRequest) error
	// Commit tells a participant to start the export.
	Commit(ctx context.Context, host, exportID string) error
	// Abort tells a participant to release its reservation.
	Abort(ctx context.Context, host, exportID string) error
	// IsRunning checks whether a participant node is still running the given export.
	IsRunning(ctx context.Context, host, exportID string) (bool, error)
}

type ExportMetadata struct {
	ID              string                                     `json:"id"`
	Backend         string                                     `json:"backend"`
	StartedAt       time.Time                                  `json:"startedAt"`
	CompletedAt     time.Time                                  `json:"completedAt"`
	Status          export.Status                              `json:"status"`
	Classes         []string                                   `json:"classes"`
	NodeAssignments map[string]map[string][]string             `json:"nodeAssignments,omitempty"` // node → className → []shardName
	Error           string                                     `json:"error,omitempty"`
	ShardStatus     map[string]map[string]models.ShardProgress `json:"shardStatus,omitempty"`
}

type ExportMetrics struct {
	ObjectsTotal         prometheus.Counter
	OperationsTotal      *prometheus.CounterVec
	CoordinationDuration prometheus.Histogram
	Duration             prometheus.Histogram
}

type ExportRequest struct {
	ID           string              `json:"id"`
	Backend      string              `json:"backend"`
	Classes      []string            `json:"classes"`
	Shards       map[string][]string `json:"shards"` // className → []shardName
	Bucket       string              `json:"bucket"`
	Path         string              `json:"path"`
	NodeName     string              `json:"nodeName"`
	SiblingNodes []string            `json:"siblingNodes,omitempty"` // other node names in the same export

	// Fields below are set for multi-node exports
	StartedAt       time.Time                      `json:"startedAt,omitempty"`
	NodeAssignments map[string]map[string][]string `json:"nodeAssignments,omitempty"` // node → className → []shardName
}

type ExportStatusResponse struct {
	Running bool `json:"running"`
}

type NodeResolver interface {
	NodeHostname(nodeName string) (string, bool)
}

type NodeStatus struct {
	NodeName      string                               `json:"nodeName"`
	Status        export.Status                        `json:"status"`
	ShardProgress map[string]map[string]*ShardProgress `json:"shardProgress,omitempty"` // className → shardName → progress
	Error         string                               `json:"error,omitempty"`
	CompletedAt   time.Time                            `json:"completedAt,omitempty"`
	Version       string                               `json:"version"`
	// contains filtered or unexported fields
}

type ParquetRow struct {
	ID           string `parquet:"id,dict"`
	CreationTime int64  `parquet:"creation_time"`
	UpdateTime   int64  `parquet:"update_time"`
	Vector       []byte `parquet:"vector,optional"`
	NamedVectors []byte `parquet:"named_vectors,optional"`
	MultiVectors []byte `parquet:"multi_vectors,optional"`
	Properties   []byte `parquet:"properties,optional"`
}

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

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

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

type Selector interface {
	ListClasses(ctx context.Context) []string
	ShardOwnership(ctx context.Context, className string) (map[string][]string, error)
	IsMultiTenant(ctx context.Context, className string) bool
	IsAsyncReplicationEnabled(ctx context.Context, className string) bool

	// SnapshotShards creates point-in-time snapshots of the objects buckets
	// for the given shards of a class. For active (loaded) shards it flushes
	// and hard-links from the live bucket. For inactive (unloaded) shards it
	// hard-links directly from the on-disk bucket directory without loading
	// the shard. Skipped shards (e.g. offloaded tenants) are included in the
	// result with a skip reason and nil snapshot.
	SnapshotShards(ctx context.Context, className string, shardNames []string, exportID string) ([]ShardSnapshotResult, error)
}

type ShardProgress struct {
	Status          export.ShardStatus `json:"status"`
	ObjectsExported int64              `json:"objectsExported"`
	Error           string             `json:"error,omitempty"`
	SkipReason      string             `json:"skipReason,omitempty"`
	// contains filtered or unexported fields
}

type ShardSnapshotResult struct {
	ShardName   string
	SnapshotDir string // path to the snapshot directory; empty if skipped
	Strategy    string // bucket strategy (e.g. StrategyReplace)
	SkipReason  string // non-empty if the shard was skipped
}