cli

type AddOptions struct {
	Name string
	// Value is the explicit value; it is used only when HasValue is set.
	Value string
	// HasValue reports that a value argument was given, even an empty one.
	HasValue bool
	// ValueFromStdin reads the value from Stdin (--value-stdin).
	ValueFromStdin bool
	Description    string
	// Namespace is the App Configuration namespace to stage under (empty for the
	// null/default namespace and every other provider).
	Namespace string
	// ValueType is the provider-neutral value type to record on the staged entry
	// (AWS Parameter Store axis). Empty for providers without a type axis.
	ValueType domain.ValueType
}

type AddRunner struct {
	UseCase *stagingusecase.AddUseCase
	Stdout  io.Writer
	Stderr  io.Writer
	// Stdin is read for --value-stdin and decides whether the $EDITOR fallback
	// may run (only on a terminal). Nil is treated as a non-interactive stdin.
	Stdin      io.Reader
	OpenEditor editor.OpenFunc // Optional: defaults to editor.Open (TTY only) 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
	// ProviderLabel names the remote store in prompts and conflict warnings
	// (e.g. "AWS"); empty renders as "remote".
	ProviderLabel string
	Confirmer     applyConfirmer
	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

	// ProviderLabel is the human-readable provider name used in help text,
	// prompts, and messages (e.g., "AWS", "Google Cloud", "Azure").
	ProviderLabel string

	// CommandPath is the explicit command path of this service's stage group,
	// used in help examples and usage errors (e.g., "suve aws stage param",
	// "suve gcloud stage", "suve azure stage secret").
	CommandPath 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. Required: a nil resolver makes every staging command fail.
	ScopeResolver staging.ScopeResolver

	// HasDescription reports whether this service's writer honors a free-text
	// description (AWS param/secret and Google Cloud secret). When true, `stage
	// add`/`stage edit` register a --description flag; when false the flag is not
	// registered at all, so a description on an unsupported provider (Azure Key
	// Vault / App Configuration) is rejected as an unknown flag rather than being
	// accepted and then silently dropped on apply.
	HasDescription bool

	// 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)

	// ValueTypeFlags are provider-specific flags appended to the add and edit
	// commands so the staged entry can carry a value type (the AWS Parameter
	// Store --type/--secure axis). Nil for providers without a value-type axis.
	ValueTypeFlags []cli.Flag

	// ValueTypeFromCmd validates and resolves the staged value type from the
	// add/edit command flags (ValueTypeFlags). Nil for providers without a
	// value-type axis, in which case the staged value type is left unset. An
	// empty return means "not specified": create applies plaintext and update
	// preserves the existing type.
	ValueTypeFromCmd func(cmd *cli.Command) (domain.ValueType, 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
	// RemoteLabel names the remote in diff labels and warnings. Empty uses the
	// strategy's ServiceName (e.g. "App Configuration", "Key Vault").
	RemoteLabel string
	// contains filtered or unexported fields
}

type EditOptions struct {
	Name string
	// Value is the explicit value; it is used only when HasValue is set.
	Value string
	// HasValue reports that a value argument was given, even an empty one.
	HasValue bool
	// ValueFromStdin reads the value from Stdin (--value-stdin).
	ValueFromStdin bool
	Description    string
	// Namespace is the App Configuration namespace of the setting (empty for the
	// null/default namespace and every other provider).
	Namespace string
	// ValueType is the provider-neutral value type to record on the staged entry
	// (AWS Parameter Store axis). Empty preserves the existing type.
	ValueType domain.ValueType
}

type EditRunner struct {
	UseCase *stagingusecase.EditUseCase
	// ProviderLabel names the remote store in messages (e.g. "AWS"); empty
	// renders as "remote".
	ProviderLabel string
	Stdout        io.Writer
	Stderr        io.Writer
	// Stdin is read for --value-stdin and decides whether the $EDITOR fallback
	// may run (only on a terminal). Nil is treated as a non-interactive stdin.
	Stdin      io.Reader
	OpenEditor editor.OpenFunc // Optional: defaults to editor.Open (TTY only) if nil
}

type GlobalApplyRunner struct {
	UseCase *stagingusecase.GlobalApplyUseCase
	// ProviderLabel is the human-readable provider name (e.g. "AWS").
	ProviderLabel   string
	Stdout          io.Writer
	Stderr          io.Writer
	IgnoreConflicts bool
}

type GlobalConfig struct {
	// ProviderLabel is the human-readable provider name used in prompts and
	// messages (e.g. "AWS", "Azure").
	ProviderLabel string
	// CommandPath is the explicit command path of the provider's stage group,
	// used in help text and usage errors (e.g. "suve aws stage").
	CommandPath string
	// ScopeResolver resolves the one provider staging scope that the all-service
	// export/import (NewGlobalExportCommand / NewGlobalImportCommand) read and
	// write. Required when those commands are wired; status / diff / apply /
	// reset use each service's own ScopeResolver instead.
	ScopeResolver staging.ScopeResolver
	// Services lists the provider's services in stable display order.
	Services []GlobalServiceSpec
}

type GlobalDiffOptions struct {
	ParseJSON bool
	NoPager   bool
}

type GlobalDiffRunner struct {
	// Services lists one per-service diff use case per service with staged
	// changes, in stable display order.
	Services []*stagingusecase.DiffUseCase
	// ProviderLabel is the human-readable provider name (e.g. "AWS") that
	// labels the remote side of every diff and warning.
	ProviderLabel string
	Stdout        io.Writer
	Stderr        io.Writer
}

type GlobalResetRunner struct {
	// Services lists the provider services in stable display order.
	Services []GlobalServiceSpec
	// Store, when set, is used for every service (a test seam). When nil each
	// service resolves its own working store via its spec's ScopeResolver.
	Store  store.ReadWriteOperator
	Stdout io.Writer
	Stderr 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; wrap such a shared resolver in SharedScopeResolver so the
	// all-service commands resolve it once. Required.
	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 GlobalStatusOptions struct {
	Verbose bool
}

type GlobalStatusRunner struct {
	// Services lists the provider services in stable display order.
	Services []GlobalServiceSpec
	// Store, when set, is used for every service (a test seam). When nil each
	// service resolves its own working store via its spec's ScopeResolver — Azure
	// App Configuration and Key Vault live in separate staging buckets.
	Store  store.ReadWriteOperator
	Stdout io.Writer
	Stderr io.Writer
}

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
}