cli

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