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 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 ImportModeChooser struct {
	Prompter *confirm.Prompter
	Stderr   io.Writer
	Stdout   io.Writer
}

type ImportModeInput struct {
	MergeFlag     bool
	OverwriteFlag bool
	// SkipPrompt (--yes) accepts the default (Merge) without the interactive
	// Merge/Overwrite/Cancel prompt, for scripts/automation.
	SkipPrompt bool
	// PassphraseStdin (--passphrase-stdin) means stdin carries the passphrase, not
	// an interactive answer. Prompting would double-buffer/EOF against the
	// passphrase read (#472), so the mode is resolved from flags only (default
	// Merge) without prompting.
	PassphraseStdin bool
	HasChanges      bool
	ItemCount       int
	IsTTY           bool
}

type ImportModeResult struct {
	Mode      usestaging.ImportMode
	Cancelled bool
}

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 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
}