reversible

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

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

type ClassificationResult struct {
	Type       ContentType
	Confidence float64
	Language   string
}

type Classifier interface {
	// Classify determines the content type.
	Classify(content string) ClassificationResult
}

type CommandRecord struct {
	Command    string        `json:"command"`
	Hash       string        `json:"hash"`
	Timestamp  time.Time     `json:"timestamp"`
	Duration   time.Duration `json:"duration"`
	Compressed bool          `json:"compressed"`
}

type Compressor interface {
	// Compress compresses data and returns the compressed bytes.
	Compress(data []byte) ([]byte, error)
	// Decompress decompresses data.
	Decompress(data []byte) ([]byte, error)
	// Name returns the compressor name.
	Name() string
}

type Config struct {
	// StorePath is the path to the SQLite database.
	StorePath string
	// EncryptionKey is the AES-256-GCM key (nil for no encryption).
	EncryptionKey []byte
	// DefaultAlgorithm is the default compression algorithm.
	DefaultAlgorithm string // "zstd", "lz4", "none"
	// MaxEntrySize is the maximum size for a single entry (default 100MB).
	MaxEntrySize int64
	// AutoVacuum enables automatic vacuum after deletes.
	AutoVacuum bool
}

type ContentType int

type Encryptor interface {
	// Encrypt encrypts data with the given key.
	Encrypt(plaintext []byte) ([]byte, error)
	// Decrypt decrypts data with the given key.
	Decrypt(ciphertext []byte) ([]byte, error)
}

type Entry struct {
	Hash           string      `json:"hash"`
	Original       string      `json:"original"`
	Compressed     string      `json:"compressed,omitempty"` // Not stored if encrypted
	Command        string      `json:"command,omitempty"`
	ContentType    ContentType `json:"content_type"`
	CompressionAlg string      `json:"compression_alg"` // "zstd", "lz4", "none"
	Encrypted      bool        `json:"encrypted"`
	CreatedAt      time.Time   `json:"created_at"`
	AccessedAt     time.Time   `json:"accessed_at"`
	AccessCount    int         `json:"access_count"`
	SizeOriginal   int64       `json:"size_original"`
	SizeCompressed int64       `json:"size_compressed"`
	// These fields are only populated when retrieving, not stored in DB
	CompressedData []byte `json:"-"` // Raw compressed bytes (encrypted if Encrypted=true)
}

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

type LZ4Compressor struct {
}

type ListFilter struct {
	Command     string
	ContentType ContentType
	Since       time.Time
	Before      time.Time
	MinSize     int64
	MaxSize     int64
	Limit       int
}

type Marker struct {
	Hash     string // First 16 chars of SHA-256
	FullHash string // Full 64-char hash for verification
}

type NoOpCompressor struct{}

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

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

type SimpleClassifier struct{}

type Store interface {
	// Save stores an entry and returns its hash.
	Save(entry *Entry) (string, error)
	// Retrieve gets an entry by hash (short or full).
	Retrieve(hash string) (*Entry, error)
	// Delete removes an entry.
	Delete(hash string) error
	// List returns all entries, optionally filtered.
	List(filter ListFilter) ([]*Entry, error)
	// Stats returns store statistics.
	Stats() (StoreStats, error)
	// Vacuum reclaims space.
	Vacuum() error
}

type StoreStats struct {
	TotalEntries  int64
	TotalSizeOrig int64
	TotalSizeComp int64
	OldestEntry   time.Time
	NewestEntry   time.Time
	ByContentType map[ContentType]int64
	ByCommand     map[string]int64
}

type StreamingReader interface {
	// Read reads decompressed data.
	Read(p []byte) (n int, err error)
	// Close closes the reader.
	Close() error
}

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