staging

type AddInput struct {
	Key         staging.EntryKey
	Value       string
	Description string
	// ValueType is the provider-neutral value type for the staged create. It is
	// only meaningful on the AWS SSM Parameter Store axis (String / SecureString /
	// StringList); other providers leave it empty. An empty value applies as
	// plaintext, so callers that do not set it keep the prior behavior.
	ValueType domain.ValueType
}

type AddOutput struct {
	Name string
}

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

type ApplyEntryResult struct {
	Name string
	// Namespace is the App Configuration namespace the entry was applied under
	// (empty for the null/default namespace and every other provider).
	Namespace string
	Status    ApplyResultStatus
	Error     error
	// UnstageError is set when the cloud apply succeeded but clearing the entry
	// from the staging store afterwards failed. The entry is still staged, so a
	// later apply would re-run it; callers must surface this rather than ignore it.
	UnstageError 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 carries the full EntryKey (name + namespace) of each conflicting
	// entry so callers can render the namespace badge; empty namespace renders as
	// the bare name.
	Conflicts []staging.EntryKey
}

type ApplyResultStatus int

type ApplyTagResult struct {
	Name string
	// Namespace is the App Configuration namespace the tags were applied under
	// (empty for the null/default namespace and every other provider).
	Namespace string
	AddTags   map[string]string   // Tags that were added/updated
	RemoveTag maputil.Set[string] // Tag keys that were removed
	Error     error
	// UnstageError is set when the cloud tag apply succeeded but clearing the
	// staged tag afterwards failed (see ApplyEntryResult.UnstageError).
	UnstageError error
}

type ApplyUseCase struct {
	Strategy staging.ApplyStrategy
	Store    store.ReadWriteOperator
	// StrategyFor, when set, resolves the ApplyStrategy for a given namespace so
	// each staged entry is applied through a provider store scoped to its own
	// namespace (Azure App Configuration, whose settings share one staging store
	// across namespaces). When nil, Strategy applies every entry — the case for
	// namespace-agnostic providers (AWS, Google Cloud, Key Vault).
	StrategyFor func(namespace string) (staging.ApplyStrategy, error)
}

type BaselineInput struct {
	Key staging.EntryKey
}

type BaselineOutput struct {
	Value string
	// contains filtered or unexported fields
}

type DeleteInput struct {
	Key            staging.EntryKey
	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
	// Namespace is the App Configuration namespace of the entry (empty for the
	// null/default namespace and every other provider).
	Namespace        string
	Type             DiffEntryType
	Operation        staging.Operation
	RemoteValue      string
	RemoteIdentifier string
	StagedValue      string
	Description      *string
	Warning          string // For warnings like "already deleted in Key Vault"
	// Secret reports whether the entry's values are secret material (a secret
	// service, or a SecureString param), so a consumer masks both the remote and
	// staged values in the review. Keyed off the value type, not the service, so
	// a SecureString param is masked too (#677).
	Secret bool
}

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
	// Namespace is the App Configuration namespace of the tagged item (empty for
	// the null/default namespace and every other provider).
	Namespace string
	Add       map[string]string // Tags to add or update
	Remove    map[string]string // Tags to remove (key=current remote value)
}

type DiffUseCase struct {
	Strategy staging.DiffStrategy
	Store    store.ReadWriteOperator
	// StrategyFor, when set, resolves the DiffStrategy for a given namespace so
	// each staged entry is diffed against a provider store scoped to its own
	// namespace (Azure App Configuration). When nil, Strategy handles every
	// entry (namespace-agnostic providers).
	StrategyFor func(namespace string) (staging.DiffStrategy, error)
	// RemoteLabel names the remote in auto-unstage warnings (e.g. "already
	// deleted in AWS"). Empty uses the strategy's ServiceName.
	RemoteLabel string
}

type DraftInput struct {
	Key staging.EntryKey
}

type DraftOutput struct {
	Value    string
	IsStaged bool
}

type EditInput struct {
	Key         staging.EntryKey
	Value       string
	Description string
	// ValueType is the provider-neutral value type for the staged update. It is
	// only meaningful on the AWS SSM Parameter Store axis (String / SecureString /
	// StringList); other providers leave it empty. An empty value preserves the
	// existing (staged or cloud) type, so callers that do not set it keep the
	// prior type-preserving behavior.
	ValueType domain.ValueType
}

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

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

type EnvelopeReader interface {
	// ReadState returns the decoded state for svc.
	ReadState(ctx context.Context, svc staging.Service) (*staging.State, error)
}

type EnvelopeWriter interface {
	// WriteEnvelope serializes state (scoped to svc) to the export target.
	WriteEnvelope(ctx context.Context, svc staging.Service, state *staging.State) error
}

type ExportError struct {
	Op       ExportOp
	Err      error
	NonFatal bool // If true, the error is non-fatal (state was already written)
}

type ExportInput struct {
	// Service filters the export to a specific service. Empty means all services
	// that have staged changes.
	Service staging.Service
	// Keep preserves the working staging area after exporting.
	Keep bool
}

type ExportOp string

type ExportOutput struct {
	// EntryCount is the number of entries exported.
	EntryCount int
	// TagCount is the number of tag entries exported.
	TagCount int
}

type ExportUseCase struct {
	// Working is the working staging area (param.json/secret.json).
	Working store.WorkingStore
	// Target receives the exported per-service state.
	Target EnvelopeWriter
}

type GlobalApplyConflict struct {
	ServiceName string
	Key         staging.EntryKey
}

type GlobalApplyInput struct {
	IgnoreConflicts bool // Skip conflict detection
}

type GlobalApplyOutput struct {
	// Services holds one ApplyOutput per service that had staged changes, in the
	// use case's service order. It is empty when the apply was rejected.
	Services []*ApplyOutput
	// Conflicts lists every conflict in service order, then (name, namespace)
	// order. A non-empty list means nothing was applied.
	Conflicts []GlobalApplyConflict
	// Succeeded and Failed count entry and tag applies across every service.
	Succeeded int
	Failed    int
}

type GlobalApplyUseCase struct {
	// Services lists one per-service apply use case per service, in stable
	// apply order. Each carries its own store and strategy.
	Services []*ApplyUseCase
}

type ImportError struct {
	Op  ImportOp
	Err error
}

type ImportInput struct {
	// Service filters the import to a specific service. Empty means all services.
	Service staging.Service
	// Mode determines how to reconcile with an existing working staging area.
	// ImportModeMerge combines the imported state with the working area.
	// ImportModeOverwrite replaces the working area with the imported state.
	Mode ImportMode
	// ReAnchor requests re-basing each staged item's BaseModifiedAt against the
	// target scope's current LastModified. It is set for a cross-scope import
	// (CLI --allow-scope-mismatch / GUI force), where the envelope's
	// BaseModifiedAt belongs to a foreign scope's timeline and would make apply's
	// conflict detection meaningless. It is a no-op unless the use case also has
	// a ReAnchor resolver configured.
	ReAnchor bool
}

type ImportMode int

type ImportOp string

type ImportOutput struct {
	// Merged indicates whether the imported state was merged with pre-existing
	// working state.
	Merged bool
	// EntryCount is the number of entries in the final working state.
	//
	//declscope:ignore overexported // internal/gui/staging_transfer.go reads it behind production || dev
	EntryCount int
	// TagCount is the number of tag entries in the final working state.
	//
	//declscope:ignore overexported // internal/gui/staging_transfer.go reads it behind production || dev
	TagCount int
	// Warnings holds non-fatal diagnostics produced during import, e.g. an item
	// left unanchored because its LastModified could not be fetched from the
	// target scope during a cross-scope re-anchor.
	Warnings []string
}

type ImportUseCase struct {
	// Source provides the imported per-service state.
	Source EnvelopeReader
	// Working is the working staging area (param.json/secret.json).
	Working store.WorkingStore
	// ReAnchor, when set, resolves a strategy that fetches the target scope's
	// current LastModified so a cross-scope import (ImportInput.ReAnchor) re-bases
	// each staged item's conflict-detection timestamp. Nil disables re-anchoring
	// even when ImportInput.ReAnchor is set (same-scope import needs none).
	ReAnchor ReAnchorResolver
}

type ReAnchorResolver func(svc staging.Service, namespace string) (staging.ApplyStrategy, error)

type ResetInput struct {
	Spec string // Name with optional version spec
	All  bool   // Reset all staged items for this service
	// Namespace is the Azure App Configuration namespace of the entry to reset;
	// empty is the null/default namespace and the only value for every other
	// provider. Ignored when All is set (UnstageAll clears every namespace).
	Namespace string
}

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 StatusEntry struct {
	Name string
	// Namespace is the App Configuration namespace of the entry (empty for the
	// null/default namespace and every other provider).
	Namespace         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 {
	ServiceName string
	Entries     []StatusEntry
	TagEntries  []StatusTagEntry
	// contains filtered or unexported fields
}

type StatusTagEntry struct {
	Name string
	// Namespace is the App Configuration namespace of the tagged item (empty for
	// the null/default namespace and every other provider).
	Namespace 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 {
	Key  staging.EntryKey
	Tags map[string]string
}

type TagOutput struct {
	Name string
}

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

type UntagInput struct {
	Key     staging.EntryKey
	TagKeys maputil.Set[string]
}

type UntagOutput struct {
	Name string
}