staging

type AddInput struct {
	Name        string
	Value       string
	Description string
}

type AddOutput struct {
	Name string
}

type AddUseCase struct {
	Strategy staging.EditStrategy
	Store    store.ReadWriteOperator
}

type ApplyEntryResult struct {
	Name   string
	Status ApplyResultStatus
	Error  error
}

type ApplyInput struct {
	Name            string // Optional: apply only this item
	IgnoreConflicts bool   // Skip conflict detection
}

type ApplyOutput struct {
	ServiceName string
	ItemName    string
	// Entry results
	EntryResults   []ApplyEntryResult
	EntrySucceeded int
	EntryFailed    int
	// Tag results
	TagResults   []ApplyTagResult
	TagSucceeded int
	TagFailed    int
	// Conflicts
	Conflicts []string
}

type ApplyResultStatus int

type ApplyTagResult struct {
	Name      string
	AddTags   map[string]string   // Tags that were added/updated
	RemoveTag maputil.Set[string] // Tag keys that were removed
	Error     error
}

type ApplyUseCase struct {
	Strategy staging.ApplyStrategy
	Store    store.ReadWriteOperator
}

type BaselineInput struct {
	Name string
}

type BaselineOutput struct {
	Value        string
	IsStagedEdit bool // True if the baseline is from a staged edit (not AWS)
}

type DeleteInput struct {
	Name           string
	Force          bool // For Secrets Manager: force immediate deletion
	RecoveryWindow int  // For Secrets Manager: days before permanent deletion (7-30)
}

type DeleteOutput struct {
	Name              string
	Unstaged          bool // True if a staged CREATE was removed instead of staging DELETE
	ShowDeleteOptions bool // True if delete options (Force/RecoveryWindow) should be shown
	Force             bool
	RecoveryWindow    int
}

type DeleteUseCase struct {
	Strategy staging.DeleteStrategy
	Store    store.ReadWriteOperator
}

type DiffEntry struct {
	Name          string
	Type          DiffEntryType
	Operation     staging.Operation
	AWSValue      string
	AWSIdentifier string
	StagedValue   string
	Description   *string
	Warning       string // For warnings like "already deleted in AWS"
}

type DiffEntryType int

type DiffInput struct {
	Name string // Optional: diff only this item
}

type DiffOutput struct {
	ItemName   string
	Entries    []DiffEntry
	TagEntries []DiffTagEntry
}

type DiffTagEntry struct {
	Name   string
	Add    map[string]string // Tags to add or update
	Remove map[string]string // Tags to remove (key=current value from AWS)
}

type DiffUseCase struct {
	Strategy staging.DiffStrategy
	Store    store.ReadWriteOperator
}

type DraftInput struct {
	Name string
}

type DraftOutput struct {
	Value    string
	IsStaged bool
}

type EditInput struct {
	Name        string
	Value       string
	Description string
}

type EditOutput struct {
	Name     string
	Skipped  bool // True if the edit was skipped because value matches AWS
	Unstaged bool // True if the entry was auto-unstaged
}

type EditUseCase struct {
	Strategy staging.EditStrategy
	Store    store.ReadWriteOperator
}

type ResetInput struct {
	Spec string // Name with optional version spec
	All  bool   // Reset all staged items for this service
}

type ResetOutput struct {
	Type         ResetResultType
	Name         string
	VersionLabel string
	Count        int // Number of items unstaged (for UnstagedAll)
	ServiceName  string
	ItemName     string
}

type ResetResultType int

type ResetUseCase struct {
	Parser  staging.Parser
	Fetcher staging.ResetStrategy
	Store   store.ReadWriteOperator
}

type StashMode int

type StashPopError struct {
	Op       string // "load", "write", "delete"
	Err      error
	NonFatal bool // If true, the error is non-fatal (state was already written)
}

type StashPopInput struct {
	// Service filters the drain to a specific service. Empty means all services.
	Service staging.Service
	// Keep preserves the file after draining.
	Keep bool
	// Mode determines how to handle conflicts with existing agent memory.
	// StashModeMerge combines file changes with existing agent memory.
	// StashModeOverwrite replaces existing agent memory.
	Mode StashMode
}

type StashPopOutput struct {
	// Merged indicates whether the state was merged with existing agent state.
	Merged bool
	// EntryCount is the number of entries in the final state.
	EntryCount int
	// TagCount is the number of tag entries in the final state.
	TagCount int
}

type StashPopUseCase struct {
	FileStore  store.FileStore
	AgentStore store.AgentStore
}

type StashPushError struct {
	Op       string // "load", "write", "clear"
	Err      error
	NonFatal bool // If true, the error is non-fatal (state was already written)
}

type StashPushInput struct {
	// Service filters the persist to a specific service. Empty means all services.
	Service staging.Service
	// Keep preserves the agent memory after persisting.
	Keep bool
	// Mode determines how to handle existing stash file.
	// StashModeMerge combines agent data with existing file data.
	// StashModeOverwrite replaces existing file data.
	Mode StashMode
}

type StashPushOutput struct {
	// EntryCount is the number of entries persisted.
	EntryCount int
	// TagCount is the number of tag entries persisted.
	TagCount int
}

type StashPushUseCase struct {
	AgentStore store.AgentStore
	FileStore  store.FileStore
}

type StatusEntry struct {
	Name              string
	Operation         staging.Operation
	Value             *string
	Description       *string
	DeleteOptions     *staging.DeleteOptions
	StagedAt          time.Time
	ShowDeleteOptions bool
}

type StatusInput struct {
	Name string // Optional: if set, show only this item
}

type StatusOutput struct {
	Service     staging.Service
	ServiceName string
	ItemName    string
	Entries     []StatusEntry
	TagEntries  []StatusTagEntry
}

type StatusTagEntry struct {
	Name     string
	Add      map[string]string   // Tags to add or update
	Remove   maputil.Set[string] // Tag keys to remove
	StagedAt time.Time
}

type StatusUseCase struct {
	Strategy staging.ServiceStrategy
	Store    store.ReadOperator
}

type TagInput struct {
	Name string
	Tags map[string]string
}

type TagOutput struct {
	Name string
}

type TagUseCase struct {
	Strategy staging.EditStrategy
	Store    store.ReadWriteOperator
}

type UntagInput struct {
	Name    string
	TagKeys maputil.Set[string]
}

type UntagOutput struct {
	Name string
}