cli

type AddOptions struct {
	Name        string
	Value       string // Optional: if set, skip editor and use this value
	Description string
	// Namespace is the App Configuration namespace to stage under (empty for the
	// null/default namespace and every other provider).
	Namespace string
}

type AddRunner struct {
	UseCase    *stagingusecase.AddUseCase
	Stdout     io.Writer
	Stderr     io.Writer
	OpenEditor editor.OpenFunc // Optional: defaults to editor.Open if nil
}

type ApplyOptions struct {
	Name            string // Optional: apply only this item, otherwise apply all
	IgnoreConflicts bool   // Skip conflict detection and force apply
}

type ApplyRunner struct {
	UseCase     *stagingusecase.ApplyUseCase
	Store       store.ReadWriteOperator
	Parser      staging.Parser
	Confirmer   confirmer
	SkipConfirm bool
	Stdout      io.Writer
	Stderr      io.Writer
}

type CommandConfig struct {
	// CommandName is the subcommand name (e.g., "param", "secret").
	CommandName string

	// ItemName is the item name for messages (e.g., "parameter", "secret").
	ItemName string

	// Factory creates a FullStrategy backed by a provider.Store.
	Factory staging.StrategyFactory

	// ParserFactory creates a Parser without provider access (for status, parsing).
	ParserFactory staging.ParserFactory

	// ScopeResolver resolves the provider staging scope used to key on-disk
	// state. When nil, it defaults to AWSScopeResolver, preserving AWS behavior.
	ScopeResolver staging.ScopeResolver

	// Namespace resolves the App Configuration namespace a single-item staging
	// op targets, from the command context (the --namespace flag). It records
	// the namespace on the staged entry as part of its identity. Nil for
	// providers without a namespace axis (the namespace is then always empty).
	Namespace func(ctx context.Context) string

	// StrategyForNamespace builds a strategy backed by a provider store scoped to
	// the given namespace, so status/diff/apply act on each staged entry under
	// its own namespace (App Configuration keeps all namespaces in one staging
	// store). Nil for providers without a namespace axis.
	StrategyForNamespace func(ctx context.Context, namespace string) (staging.FullStrategy, error)
}

type DeleteOptions struct {
	Name           string
	Force          bool // For Secrets Manager: force immediate deletion
	RecoveryWindow int  // For Secrets Manager: days before permanent deletion (7-30)
	// Namespace is the App Configuration namespace of the setting (empty for the
	// null/default namespace and every other provider).
	Namespace string
}

type DeleteRunner struct {
	UseCase *stagingusecase.DeleteUseCase
	Stdout  io.Writer
	Stderr  io.Writer
}

type DiffOptions struct {
	Name      string // Optional: diff only this item, otherwise diff all
	ParseJSON bool
	NoPager   bool
}

type DiffRunner struct {
	UseCase *stagingusecase.DiffUseCase
	Stdout  io.Writer
	Stderr  io.Writer
}

type EditOptions struct {
	Name        string
	Value       string // Optional: if set, skip editor and use this value
	Description string
	// Namespace is the App Configuration namespace of the setting (empty for the
	// null/default namespace and every other provider).
	Namespace string
}

type EditRunner struct {
	UseCase    *stagingusecase.EditUseCase
	Stdout     io.Writer
	Stderr     io.Writer
	OpenEditor editor.OpenFunc // Optional: defaults to editor.Open if nil
}

type GlobalConfig struct {
	// ProviderLabel is the human-readable provider name used in prompts and
	// messages (e.g. "AWS", "Google Cloud").
	ProviderLabel string
	// ScopeResolver resolves the provider staging scope. Nil defaults to AWS.
	ScopeResolver staging.ScopeResolver
	// Services lists the provider's services in stable display order.
	Services []GlobalServiceSpec
}

type GlobalDropRunner struct {
	FileStore *file.Store
	Stdout    io.Writer
}

type GlobalServiceSpec struct {
	// Service is the staging service (param or secret).
	Service staging.Service
	// ParserFactory builds a network-free parser for this service.
	ParserFactory staging.ParserFactory
	// Factory builds a provider-backed strategy for this service.
	Factory staging.StrategyFactory
	// ScopeResolver resolves THIS service's staging scope. It is per-service
	// because a provider's services may live in independent resources with
	// separate staging buckets: Azure App Configuration (param) is keyed by
	// store name, Key Vault (secret) by vault name. AWS keeps one account scope
	// for both. Nil defaults to AWS (AWSScopeResolver).
	ScopeResolver staging.ScopeResolver
	// StrategyForNamespace, when set, builds a strategy scoped to a given
	// namespace so apply/diff act on each staged entry under its own namespace
	// (Azure App Configuration keeps all namespaces in one staging store). Nil
	// for services without a namespace axis — the single Factory strategy is used.
	StrategyForNamespace func(ctx context.Context, namespace string) (staging.FullStrategy, error)
}

type ResetOptions struct {
	Spec string // Name with optional version spec
	All  bool   // Reset all staged items for this service
	// Namespace is the App Configuration namespace of the entry to reset (empty
	// for the null/default namespace and every other provider; ignored with All).
	Namespace string
}

type ResetRunner struct {
	UseCase *stagingusecase.ResetUseCase
	Stdout  io.Writer
	Stderr  io.Writer
}

type ServiceDropRunner struct {
	FileStore *file.Store
	Service   staging.Service
	Stdout    io.Writer
}

type StashPopModeChooser struct {
	Prompter *confirm.Prompter
	Stderr   io.Writer
	Stdout   io.Writer
}

type StashPopModeInput struct {
	MergeFlag     bool
	OverwriteFlag bool
	HasChanges    bool
	ItemCount     int
	IsTTY         bool
}

type StashPopModeResult struct {
	Mode      stagingusecase.StashMode
	Cancelled bool
}

type StashPopOptions struct {
	// Service filters the operation to a specific service. Empty means all services.
	Service staging.Service
	// Keep preserves the file after popping.
	Keep bool
	// Mode determines how to handle conflicts with the existing working staging area.
	Mode stagingusecase.StashMode
}

type StashPopRunner struct {
	UseCase *stagingusecase.StashPopUseCase
	Stdout  io.Writer
	Stderr  io.Writer
}

type StashPushOptions struct {
	// Service filters the operation to a specific service. Empty means all services.
	Service staging.Service
	// Keep preserves the working staging area after pushing to the stash file.
	Keep bool
	// Mode determines how to handle existing stash file.
	Mode usestaging.StashMode
}

type StashPushRunner struct {
	UseCase   *usestaging.StashPushUseCase
	Stdout    io.Writer
	Stderr    io.Writer
	Encrypted bool // Whether the file is encrypted (for output messages)
}

type StashShowOptions struct {
	// Service filters the display to a specific service. Empty means all services.
	Service staging.Service
	// Verbose shows detailed information.
	Verbose bool
}

type StashShowRunner struct {
	FileStore *file.Store
	Stdout    io.Writer
	Stderr    io.Writer
}

type StatusOptions struct {
	Name    string
	Verbose bool
}

type StatusRunner struct {
	UseCase *stagingusecase.StatusUseCase
	Stdout  io.Writer
	Stderr  io.Writer
}

type TagOptions struct {
	Name string
	// Namespace is the App Configuration namespace of the resource (empty for the
	// null/default namespace and every other provider).
	Namespace string
	Tags      []string // key=value pairs to add
}

type TagRunner struct {
	UseCase *stagingusecase.TagUseCase
	Stdout  io.Writer
	Stderr  io.Writer
}

type UntagOptions struct {
	Name string
	// Namespace is the App Configuration namespace of the resource (empty for the
	// null/default namespace and every other provider).
	Namespace string
	Keys      []string // tag keys to remove
}

type UntagRunner struct {
	UseCase *stagingusecase.TagUseCase
	Stdout  io.Writer
	Stderr  io.Writer
}