application

type About struct {
	Framework   string            `json:"framework"`
	Go          string            `json:"go"`
	Platform    string            `json:"platform"`
	Application string            `json:"application"`
	Environment string            `json:"environment"`
	TimeZone    string            `json:"time_zone"`
	Kernels     map[string]string `json:"kernels"`
	Maintenance string            `json:"maintenance"`
	Services    map[string]string `json:"services"`
}

type App struct {
	*foundation.App
	// contains filtered or unexported fields
}

type AttachmentSettings struct {
	Enabled bool
	Config  attachments.Config
}

type AuditSettings struct {
	Enabled  bool
	Database database.ConnectionName
	Schema   string
	Config   audit.Config
}

type AuthSettings struct {
	Registry          auth.Config
	Sessions          SessionSettings
	Tokens            TokenSettings
	MFA               MFASettings
	Browser           BrowserSettings
	DefaultTokenGuard auth.GuardName
}

type AuthorizationDeclaration struct {
	// contains filtered or unexported fields
}

type BrowserGuard[M model.Identifiable, K any] struct {
	Sessions *session.Sessions[M, K]
	Browser  *http.BrowserSessions[M, K]
	Binding  http.GuardBinding[M]
}

type BrowserGuardSettings struct {
	Cookie  http.CookieName
	Options http.CookieOptions
	CSRF    http.CSRFConfig
}

type BrowserGuardSettingsCSRFConfigKeySet struct {
	// TrustedOrigins selects csrf.trusted_origins. Set accepts []http.Origin.
	TrustedOrigins config.Key[BrowserGuardSettings, []http.Origin]
}

type BrowserGuardSettingsConfigKeySet struct {
	// Cookie selects cookie. Set accepts http.CookieName.
	Cookie  config.Key[BrowserGuardSettings, http.CookieName]
	Options BrowserGuardSettingsOptionsConfigKeySet
	CSRF    BrowserGuardSettingsCSRFConfigKeySet
}

type BrowserGuardSettingsOptionsConfigKeySet struct {
	// Path selects options.path. Set accepts string.
	Path config.Key[BrowserGuardSettings, string]
	// Domain selects options.domain. Set accepts string.
	Domain config.Key[BrowserGuardSettings, string]
	// Secure selects options.secure. Set accepts bool.
	Secure config.Key[BrowserGuardSettings, bool]
	// HTTPOnly selects options.http_only. Set accepts bool.
	HTTPOnly config.Key[BrowserGuardSettings, bool]
	// SameSite selects options.same_site. Set accepts http1.SameSite.
	SameSite config.Key[BrowserGuardSettings, http1.SameSite]
	// Partitioned selects options.partitioned. Set accepts bool.
	Partitioned config.Key[BrowserGuardSettings, bool]
	// MaxAge selects options.max_age. Set accepts time.Duration.
	MaxAge config.Key[BrowserGuardSettings, time.Duration]
	// Expires selects options.expires. Set accepts time.Time.
	Expires config.Key[BrowserGuardSettings, time.Time]
}

type BrowserGuards map[auth.GuardName]BrowserGuardSettings

type BrowserSettings struct {
	Default auth.GuardName
	Guards  BrowserGuards
}

type Builder struct {
	// contains filtered or unexported fields
}

type DatabaseCommandResources struct {
	Seeders   *seed.Registry
	Prunables *prune.Registry
}

type DownArguments struct {
	Retry      time.Duration
	Message    string
	Secret     string
	WithSecret bool
	Allow      []netip.Prefix
	Except     []maintenance.Rule
}

type EncryptionKeySettings struct {
	Key secret.String
}

type EncryptionKeySettingsConfigKeySet struct {
	// Key selects key. Set accepts secret.String.
	Key config.Key[EncryptionKeySettings, secret.String]
}

type EncryptionKeys map[encryption.KeyID]EncryptionKeySettings

type EncryptionSettings struct {
	KeyID    encryption.KeyID
	Key      secret.String
	Previous EncryptionKeys `config:",secret"`
}

type ErrorLogSettings struct {
	Enabled            bool
	Window             time.Duration
	MaxFingerprints    int
	DontReportFaults   []fault.Code `config:",json"`
	DontReportStatuses []int        `config:",json"`
}

type EventDeclaration struct {
	// contains filtered or unexported fields
}

type EventsSettings struct {
	Enabled            bool
	Config             events.Config
	QueuedListeners    bool
	ListenerConnection jobs.ConnectionName
	ListenerQueue      jobs.Queue
}

type ExtensionCleanupSettings struct {
	// Jobs names the job connection that runs the cleanup job. The deletion
	// enqueues it in its own transaction through the outbox, so it needs a
	// destination in features.outbox.jobs and a worker consuming the
	// connection's default queue. Empty keeps process-local after-commit cleanup.
	Jobs jobs.ConnectionName
}

type FeatureDeclarations struct {
	Owners        []extensions.Declaration
	Settings      []settings.Registration
	Metadata      []metadata.Registration
	Translations  []translations.Registration
	Attachments   []attachments.Registration
	Notifications []notifications.Registration
	Reports       []datatable.Registration
	Messages      []i18n.MessageDefinition
	Catalog       map[i18n.LocaleID]map[i18n.MessageKey]i18n.Template
	Outbox        []publisher.Route
	Readiness     []health.Probe
	// Pruning joins application stores to the maintenance schedule
	// (features.maintenance); it is ignored while that schedule is disabled.
	Pruning []Pruning
}

type FeatureSettings struct {
	Idempotency      IdempotencySettings
	Auth             AuthSettings
	Events           EventsSettings
	Outbox           OutboxSettings
	Audit            AuditSettings
	Locales          LocaleSettings
	Extensions       StoreSettings
	ExtensionCleanup ExtensionCleanupSettings
	Notifications    StoreSettings
	Attachments      AttachmentSettings
	Reports          ReportSettings
	Health           HealthSettings
	Observability    ObservabilitySettings
	// Maintenance schedules framework housekeeping (features.maintenance).
	Maintenance MaintenanceScheduleSettings
}

type Features func(Services) (FeatureDeclarations, error)

type HTTPSettings struct {
	StatementDetector StatementDetectorSettings
	Enabled           bool
	Server            http.ServerConfig
	SecurityHeaders   bool
	Probes            ProbeSettings
}

type HealthSettings struct {
	Enabled               bool
	Config                health.Config
	ConfiguredConnections bool
	ConfiguredStorage     bool
	ConfiguredMail        bool
}

type IdempotencySettings struct {
	Enabled  bool
	Database database.ConnectionName
	Config   idempotency.Config
}

type ImageSettings struct {
	Enabled bool
	Config  imaging.Config
}

type JobArchiveSettings struct {
	Enabled  bool
	Database database.ConnectionName
	Schema   string
}

type JobDeclaration struct {
	// contains filtered or unexported fields
}

type LocaleSettings struct {
	Enabled  bool
	Default  i18n.LocaleID
	Locales  []i18n.LocaleID `config:",json"`
	Fallback i18n.LocaleID
}

type LogChannels map[logging.ChannelName]logging.ChannelSettings

type LogSettings struct {
	Default  logging.ChannelName
	Channels LogChannels
}

type MFASettings struct {
	Enabled  bool
	Database database.ConnectionName
	Schema   string
	Config   mfa.Config
}

type MaintenanceScheduleSettings struct {
	Enabled  bool
	Defaults MaintenanceTaskSettings
	// Outbox removes published outbox rows completed before Retention; pending
	// and failed rows are never pruned.
	Outbox MaintenanceTaskSettings
	// Idempotency removes expired outcomes, but only while the store's own
	// pruner is disabled (features.idempotency.config.prune_interval = 0).
	Idempotency MaintenanceTaskSettings
	// Audit applies features.audit.config.retention_days to the configured
	// area; zero retention registers no audit task. MaxBatches does not apply:
	// one run removes every expired batch within its Timeout.
	Audit MaintenanceTaskSettings
	// JobArchive removes archived failed jobs older than Retention.
	JobArchive MaintenanceTaskSettings
	// Notifications removes inbox records older than Retention. Unread records
	// are kept unless NotificationsUnread is set.
	Notifications       MaintenanceTaskSettings
	NotificationsUnread bool
	// Sessions, Tokens, Models and Custom tune declared Pruning of each kind.
	Sessions MaintenanceTaskSettings
	Tokens   MaintenanceTaskSettings
	Models   MaintenanceTaskSettings
	Custom   MaintenanceTaskSettings
}

type MaintenanceSettings struct {
	Store        cache.StoreName
	PollInterval time.Duration
	Exempt       []maintenance.Rule `config:",json"`
	Allow        []netip.Prefix     `config:",json"`
	BypassTTL    time.Duration
}

type MaintenanceTaskSettings struct {
	// Disabled turns this task off.
	Disabled bool
	// Interval separates runs. Each task keeps a stable offset within its
	// interval, so housekeeping does not pile onto the top of every hour.
	Interval time.Duration
	// Batch bounds the rows one statement or transaction removes; MaxBatches
	// bounds the batches of one run, so a backlog continues at the next run.
	Batch      int
	MaxBatches int
	// Timeout bounds one run.
	Timeout time.Duration
	// Retention keeps younger rows of stores pruned by age (outbox, job archive
	// and notification inbox).
	Retention time.Duration
}

type ObservabilitySettings struct {
	Enabled, Maintenance                                             bool
	MaxSeries, MaxRecent, MaxActive, ErrorQueue, ReporterConcurrency int
	ReporterTimeout                                                  time.Duration
	SampleTraces                                                     bool
	// TraceSampleRatio selects the sampled fraction of traces; zero means 1.
	TraceSampleRatio                             float64
	TraceQueue, TraceConcurrency, TraceBatchSize int
	TraceTimeout                                 time.Duration
	ErrorLog                                     ErrorLogSettings
}

type Option func(*options) error

type OutboxSettings struct {
	Enabled  bool
	Database database.ConnectionName
	Schema   string
	Jobs     map[jobs.ConnectionName]outbox.Destination `config:",json"`
	// Events maps declared EventOutbox destinations to durable job connections.
	// Empty connection selects the default. Each connection uses its default
	// queue and jobs.DefaultPolicy for the framework event delivery job.
	Events                                     map[outbox.Destination]jobs.ConnectionName `config:",json"`
	Kernels                                    []foundation.KernelKind                    `config:",json"`
	MaxAttempts                                uint32
	RetryDelay, OperationTimeout, PollInterval time.Duration
	MaxRetryDelay, Jitter, MaxPollInterval     time.Duration
	MaxInFlight                                int
}

type ProbeSettings struct {
	Liveness      bool
	LivenessPath  string
	Readiness     bool
	ReadinessPath string
	// ReadinessCache is how long public readiness reuses one dependency check
	// (100ms to one minute); lifecycle and maintenance state are read live.
	ReadinessCache time.Duration
}

type Pruning struct {
	// contains filtered or unexported fields
}

type Realtime func(Services) (RealtimeDeclarations, error)

type RealtimeDeclarations struct {
	Channels       []websocket.Registration
	Authentication *http.Authentication
	Middleware     []http.Middleware
	Tickets        []auth.TicketRedeemer
}

type RealtimeServerSettings struct {
	Enabled bool
	// Shared serves upgrades at Path on the application HTTP listener instead
	// of a dedicated listener and WebSocket kernel; running foundation.HTTP then
	// serves both. HTTP request/connection limits must accommodate sockets.
	Shared bool
	// Publisher constructs a managed cross-process publisher for processes
	// that run no hub, such as workers. It requires a cluster connection and
	// the same channel declarations as the socket servers.
	Publisher  bool
	Connection websocket.ConnectionName
	Config     websocket.Config
	HTTP       http.ServerConfig
	Path       string
}

type ReportSettings struct {
	Enabled  bool
	Database database.ConnectionName
	Config   datatable.Config
}

type Routes func(Services) ([]http.RouteRegistration, error)

type SchedulerSettings struct {
	Enabled                             bool
	Group                               schedule.Group
	Concurrency, MaxHistory, MaxPerTick int
	PollInterval, LeadershipTTL, Grace  time.Duration
	CapacityWait, DrainTimeout          time.Duration
}

type Schedules func(Services) ([]schedule.Declaration, error)

type Services struct {
	*infrastructure.Services
	Logger *slog.Logger
	Logs   *logging.Channels
	// LogFiles borrows the existing logger owner for authorized file controls.
	LogFiles *logging.ChannelSet
	// contains filtered or unexported fields
}

type SessionSettings struct {
	Enabled  bool
	Database database.ConnectionName
	Schema   string
	Config   session.Config
}

type Settings struct {
	TimeZone    temporal.ZoneName
	Services    infrastructure.Settings
	HTTP        HTTPSettings
	Worker      WorkerSettings
	Scheduler   SchedulerSettings
	Realtime    RealtimeServerSettings
	Features    FeatureSettings
	Image       ImageSettings
	Log         LogSettings
	Maintenance MaintenanceSettings
	// Encryption is the application key ring (active key plus retained
	// previous keys) used for MFA factors and encrypted cookies.
	Encryption EncryptionSettings
	// ShutdownTimeout is the whole shutdown budget: StopDelay, kernel drain
	// (such as the HTTP shutdown grace) and every cleanup share it.
	ShutdownTimeout time.Duration
	// StopDelay is a lame-duck period after a shutdown request: readiness
	// fails while listeners keep serving, then admission closes and kernels
	// drain. Zero disables it. It must leave room for kernel drain.
	StopDelay time.Duration
	// StartupTimeout bounds provider boot; zero leaves it unbounded.
	StartupTimeout time.Duration
}

type SettingsConfigKeySet struct {
	// TimeZone selects time_zone. Set accepts temporal.ZoneName.
	TimeZone    config.Key[Settings, temporal.ZoneName]
	Services    SettingsServicesConfigKeySet
	HTTP        SettingsHTTPConfigKeySet
	Worker      SettingsWorkerConfigKeySet
	Scheduler   SettingsSchedulerConfigKeySet
	Realtime    SettingsRealtimeConfigKeySet
	Features    SettingsFeaturesConfigKeySet
	Image       SettingsImageConfigKeySet
	Log         SettingsLogConfigKeySet
	Maintenance SettingsMaintenanceConfigKeySet
	//
	// Encryption is the application key ring (active key plus retained
	// previous keys) used for MFA factors and encrypted cookies.
	//
	Encryption SettingsEncryptionConfigKeySet
	// ShutdownTimeout selects shutdown_timeout. Set accepts time.Duration.
	//
	// ShutdownTimeout is the whole shutdown budget: StopDelay, kernel drain
	// (such as the HTTP shutdown grace) and every cleanup share it.
	//
	ShutdownTimeout config.Key[Settings, time.Duration]
	// StopDelay selects stop_delay. Set accepts time.Duration.
	//
	// StopDelay is a lame-duck period after a shutdown request: readiness
	// fails while listeners keep serving, then admission closes and kernels
	// drain. Zero disables it. It must leave room for kernel drain.
	//
	StopDelay config.Key[Settings, time.Duration]
	// StartupTimeout selects startup_timeout. Set accepts time.Duration.
	//
	// StartupTimeout bounds provider boot; zero leaves it unbounded.
	//
	StartupTimeout config.Key[Settings, time.Duration]
}

type SettingsEncryptionConfigKeySet struct {
	// KeyID selects encryption.key_id. Set accepts encryption.KeyID.
	KeyID config.Key[Settings, encryption.KeyID]
	// Key selects encryption.key. Set accepts secret.String.
	Key config.Key[Settings, secret.String]
	// Previous selects encryption.previous. Set accepts EncryptionKeys.
	Previous config.Key[Settings, EncryptionKeys]
}

type SettingsFeaturesAttachmentsConfigConfigKeySet struct {
	// MaxActive selects features.attachments.config.max_active. Set accepts int.
	MaxActive config.Key[Settings, int]
	// MaxReads selects features.attachments.config.max_reads. Set accepts int.
	MaxReads config.Key[Settings, int]
	// Timeout selects features.attachments.config.timeout. Set accepts time.Duration.
	Timeout config.Key[Settings, time.Duration]
	// CleanupTimeout selects features.attachments.config.cleanup_timeout. Set accepts time.Duration.
	CleanupTimeout config.Key[Settings, time.Duration]
	// CleanupGrace selects features.attachments.config.cleanup_grace. Set accepts time.Duration.
	CleanupGrace config.Key[Settings, time.Duration]
	// StoredGrace selects features.attachments.config.stored_grace. Set accepts time.Duration.
	StoredGrace config.Key[Settings, time.Duration]
	// SettleAfter selects features.attachments.config.settle_after. Set accepts time.Duration.
	SettleAfter config.Key[Settings, time.Duration]
}

type SettingsFeaturesAttachmentsConfigKeySet struct {
	// Enabled selects features.attachments.enabled. Set accepts bool.
	Enabled config.Key[Settings, bool]
	Config  SettingsFeaturesAttachmentsConfigConfigKeySet
}

type SettingsFeaturesAuditConfigConfigKeySet struct {
	// Area selects features.audit.config.area. Set accepts audit.Area.
	Area config.Key[Settings, audit.Area]
	// RetentionDays selects features.audit.config.retention_days. Set accepts uint16.
	RetentionDays config.Key[Settings, uint16]
	// MaxValueBytes selects features.audit.config.max_value_bytes. Set accepts int.
	MaxValueBytes config.Key[Settings, int]
}

type SettingsFeaturesAuditConfigKeySet struct {
	// Enabled selects features.audit.enabled. Set accepts bool.
	Enabled config.Key[Settings, bool]
	// Database selects features.audit.database. Set accepts database.ConnectionName.
	Database config.Key[Settings, database.ConnectionName]
	// Schema selects features.audit.schema. Set accepts string.
	Schema config.Key[Settings, string]
	Config SettingsFeaturesAuditConfigConfigKeySet
}

type SettingsFeaturesAuthBrowserConfigKeySet struct {
	// Default selects features.auth.browser.default. Set accepts auth.GuardName.
	Default config.Key[Settings, auth.GuardName]
	// Guards selects features.auth.browser.guards. Set accepts BrowserGuards.
	Guards config.Key[Settings, BrowserGuards]
}

type SettingsFeaturesAuthConfigKeySet struct {
	Registry SettingsFeaturesAuthRegistryConfigKeySet
	Sessions SettingsFeaturesAuthSessionsConfigKeySet
	Tokens   SettingsFeaturesAuthTokensConfigKeySet
	MFA      SettingsFeaturesAuthMFAConfigKeySet
	Browser  SettingsFeaturesAuthBrowserConfigKeySet
	// DefaultTokenGuard selects features.auth.default_token_guard. Set accepts auth.GuardName.
	DefaultTokenGuard config.Key[Settings, auth.GuardName]
}

type SettingsFeaturesAuthMFAConfigConfigKeySet struct {
	Namespace SettingsFeaturesAuthMFAConfigNamespaceConfigKeySet
	// Issuer selects features.auth.mfa.config.issuer. Set accepts string.
	Issuer config.Key[Settings, string]
	// EnrollmentLifetime selects features.auth.mfa.config.enrollment_lifetime. Set accepts time.Duration.
	EnrollmentLifetime config.Key[Settings, time.Duration]
	// Window selects features.auth.mfa.config.window. Set accepts int.
	Window config.Key[Settings, int]
	// RecoveryCodes selects features.auth.mfa.config.recovery_codes. Set accepts int.
	RecoveryCodes config.Key[Settings, int]
	// MaxConcurrent selects features.auth.mfa.config.max_concurrent. Set accepts int.
	MaxConcurrent config.Key[Settings, int]
	// Timeout selects features.auth.mfa.config.timeout. Set accepts time.Duration.
	Timeout config.Key[Settings, time.Duration]
}

type SettingsFeaturesAuthMFAConfigKeySet struct {
	// Enabled selects features.auth.mfa.enabled. Set accepts bool.
	Enabled config.Key[Settings, bool]
	// Database selects features.auth.mfa.database. Set accepts database.ConnectionName.
	Database config.Key[Settings, database.ConnectionName]
	// Schema selects features.auth.mfa.schema. Set accepts string.
	Schema config.Key[Settings, string]
	Config SettingsFeaturesAuthMFAConfigConfigKeySet
}

type SettingsFeaturesAuthMFAConfigNamespaceConfigKeySet struct {
	// Application selects features.auth.mfa.config.namespace.application. Set accepts string.
	Application config.Key[Settings, string]
	// Environment selects features.auth.mfa.config.namespace.environment. Set accepts string.
	Environment config.Key[Settings, string]
}

type SettingsFeaturesAuthRegistryConfigKeySet struct {
	// MaxConcurrent selects features.auth.registry.max_concurrent. Set accepts int.
	MaxConcurrent config.Key[Settings, int]
	// Timeout selects features.auth.registry.timeout. Set accepts time.Duration.
	Timeout config.Key[Settings, time.Duration]
}

type SettingsFeaturesAuthSessionsConfigConfigKeySet struct {
	Namespace  SettingsFeaturesAuthSessionsConfigNamespaceConfigKeySet
	Regular    SettingsFeaturesAuthSessionsConfigRegularConfigKeySet
	Remembered SettingsFeaturesAuthSessionsConfigRememberedConfigKeySet
	Pending    SettingsFeaturesAuthSessionsConfigPendingConfigKeySet
	// MaxPerSubject selects features.auth.sessions.config.max_per_subject. Set accepts int.
	MaxPerSubject config.Key[Settings, int]
	// MaxPendingPerSubject selects features.auth.sessions.config.max_pending_per_subject. Set accepts int.
	MaxPendingPerSubject config.Key[Settings, int]
	// Limit selects features.auth.sessions.config.limit. Set accepts auth.LimitPolicy.
	Limit config.Key[Settings, auth.LimitPolicy]
	// MaxConcurrent selects features.auth.sessions.config.max_concurrent. Set accepts int.
	MaxConcurrent config.Key[Settings, int]
	// Timeout selects features.auth.sessions.config.timeout. Set accepts time.Duration.
	Timeout config.Key[Settings, time.Duration]
}

type SettingsFeaturesAuthSessionsConfigKeySet struct {
	// Enabled selects features.auth.sessions.enabled. Set accepts bool.
	Enabled config.Key[Settings, bool]
	// Database selects features.auth.sessions.database. Set accepts database.ConnectionName.
	Database config.Key[Settings, database.ConnectionName]
	// Schema selects features.auth.sessions.schema. Set accepts string.
	Schema config.Key[Settings, string]
	Config SettingsFeaturesAuthSessionsConfigConfigKeySet
}

type SettingsFeaturesAuthSessionsConfigNamespaceConfigKeySet struct {
	// Application selects features.auth.sessions.config.namespace.application. Set accepts string.
	Application config.Key[Settings, string]
	// Environment selects features.auth.sessions.config.namespace.environment. Set accepts string.
	Environment config.Key[Settings, string]
}

type SettingsFeaturesAuthSessionsConfigPendingConfigKeySet struct {
	// Idle selects features.auth.sessions.config.pending.idle. Set accepts time.Duration.
	Idle config.Key[Settings, time.Duration]
	// Absolute selects features.auth.sessions.config.pending.absolute. Set accepts time.Duration.
	Absolute config.Key[Settings, time.Duration]
	// Sliding selects features.auth.sessions.config.pending.sliding. Set accepts bool.
	Sliding config.Key[Settings, bool]
}

type SettingsFeaturesAuthSessionsConfigRegularConfigKeySet struct {
	// Idle selects features.auth.sessions.config.regular.idle. Set accepts time.Duration.
	Idle config.Key[Settings, time.Duration]
	// Absolute selects features.auth.sessions.config.regular.absolute. Set accepts time.Duration.
	Absolute config.Key[Settings, time.Duration]
	// Sliding selects features.auth.sessions.config.regular.sliding. Set accepts bool.
	Sliding config.Key[Settings, bool]
}

type SettingsFeaturesAuthSessionsConfigRememberedConfigKeySet struct {
	// Idle selects features.auth.sessions.config.remembered.idle. Set accepts time.Duration.
	Idle config.Key[Settings, time.Duration]
	// Absolute selects features.auth.sessions.config.remembered.absolute. Set accepts time.Duration.
	Absolute config.Key[Settings, time.Duration]
	// Sliding selects features.auth.sessions.config.remembered.sliding. Set accepts bool.
	Sliding config.Key[Settings, bool]
}

type SettingsFeaturesAuthTokensConfigChallengeConfigKeySet struct {
	// Access selects features.auth.tokens.config.challenge.access. Set accepts time.Duration.
	Access config.Key[Settings, time.Duration]
	// RefreshIdle selects features.auth.tokens.config.challenge.refresh_idle. Set accepts time.Duration.
	RefreshIdle config.Key[Settings, time.Duration]
	// Absolute selects features.auth.tokens.config.challenge.absolute. Set accepts time.Duration.
	Absolute config.Key[Settings, time.Duration]
}

type SettingsFeaturesAuthTokensConfigConfigKeySet struct {
	Namespace SettingsFeaturesAuthTokensConfigNamespaceConfigKeySet
	Personal  SettingsFeaturesAuthTokensConfigPersonalConfigKeySet
	Renewable SettingsFeaturesAuthTokensConfigRenewableConfigKeySet
	Challenge SettingsFeaturesAuthTokensConfigChallengeConfigKeySet
	// MaxPerSubject selects features.auth.tokens.config.max_per_subject. Set accepts int.
	MaxPerSubject config.Key[Settings, int]
	// MaxPendingPerSubject selects features.auth.tokens.config.max_pending_per_subject. Set accepts int.
	MaxPendingPerSubject config.Key[Settings, int]
	// Limit selects features.auth.tokens.config.limit. Set accepts auth.LimitPolicy.
	Limit config.Key[Settings, auth.LimitPolicy]
	// MaxRotations selects features.auth.tokens.config.max_rotations. Set accepts int.
	MaxRotations config.Key[Settings, int]
	// AccessGrace selects features.auth.tokens.config.access_grace. Set accepts time.Duration.
	AccessGrace config.Key[Settings, time.Duration]
	// Prefix selects features.auth.tokens.config.prefix. Set accepts string.
	Prefix config.Key[Settings, string]
	// MaxConcurrent selects features.auth.tokens.config.max_concurrent. Set accepts int.
	MaxConcurrent config.Key[Settings, int]
	// Timeout selects features.auth.tokens.config.timeout. Set accepts time.Duration.
	Timeout config.Key[Settings, time.Duration]
	// TicketLifetime selects features.auth.tokens.config.ticket_lifetime. Set accepts time.Duration.
	TicketLifetime config.Key[Settings, time.Duration]
	// MaxTicketsPerFamily selects features.auth.tokens.config.max_tickets_per_family. Set accepts int.
	MaxTicketsPerFamily config.Key[Settings, int]
}

type SettingsFeaturesAuthTokensConfigKeySet struct {
	// Enabled selects features.auth.tokens.enabled. Set accepts bool.
	Enabled config.Key[Settings, bool]
	// Database selects features.auth.tokens.database. Set accepts database.ConnectionName.
	Database config.Key[Settings, database.ConnectionName]
	// Schema selects features.auth.tokens.schema. Set accepts string.
	Schema config.Key[Settings, string]
	Config SettingsFeaturesAuthTokensConfigConfigKeySet
}

type SettingsFeaturesAuthTokensConfigNamespaceConfigKeySet struct {
	// Application selects features.auth.tokens.config.namespace.application. Set accepts string.
	Application config.Key[Settings, string]
	// Environment selects features.auth.tokens.config.namespace.environment. Set accepts string.
	Environment config.Key[Settings, string]
}

type SettingsFeaturesAuthTokensConfigPersonalConfigKeySet struct {
	// Access selects features.auth.tokens.config.personal.access. Set accepts time.Duration.
	Access config.Key[Settings, time.Duration]
	// RefreshIdle selects features.auth.tokens.config.personal.refresh_idle. Set accepts time.Duration.
	RefreshIdle config.Key[Settings, time.Duration]
	// Absolute selects features.auth.tokens.config.personal.absolute. Set accepts time.Duration.
	Absolute config.Key[Settings, time.Duration]
}

type SettingsFeaturesAuthTokensConfigRenewableConfigKeySet struct {
	// Access selects features.auth.tokens.config.renewable.access. Set accepts time.Duration.
	Access config.Key[Settings, time.Duration]
	// RefreshIdle selects features.auth.tokens.config.renewable.refresh_idle. Set accepts time.Duration.
	RefreshIdle config.Key[Settings, time.Duration]
	// Absolute selects features.auth.tokens.config.renewable.absolute. Set accepts time.Duration.
	Absolute config.Key[Settings, time.Duration]
}

type SettingsFeaturesConfigKeySet struct {
	Idempotency      SettingsFeaturesIdempotencyConfigKeySet
	Auth             SettingsFeaturesAuthConfigKeySet
	Events           SettingsFeaturesEventsConfigKeySet
	Outbox           SettingsFeaturesOutboxConfigKeySet
	Audit            SettingsFeaturesAuditConfigKeySet
	Locales          SettingsFeaturesLocalesConfigKeySet
	Extensions       SettingsFeaturesExtensionsConfigKeySet
	ExtensionCleanup SettingsFeaturesExtensionCleanupConfigKeySet
	Notifications    SettingsFeaturesNotificationsConfigKeySet
	Attachments      SettingsFeaturesAttachmentsConfigKeySet
	Reports          SettingsFeaturesReportsConfigKeySet
	Health           SettingsFeaturesHealthConfigKeySet
	Observability    SettingsFeaturesObservabilityConfigKeySet
	//
	// Maintenance schedules framework housekeeping (features.maintenance).
	//
	Maintenance SettingsFeaturesMaintenanceConfigKeySet
}

type SettingsFeaturesEventsConfigConfigKeySet struct {
	// MaxInFlight selects features.events.config.max_in_flight. Set accepts int.
	MaxInFlight config.Key[Settings, int]
	// MaxDepth selects features.events.config.max_depth. Set accepts int.
	MaxDepth config.Key[Settings, int]
}

type SettingsFeaturesEventsConfigKeySet struct {
	// Enabled selects features.events.enabled. Set accepts bool.
	Enabled config.Key[Settings, bool]
	Config  SettingsFeaturesEventsConfigConfigKeySet
	// QueuedListeners selects features.events.queued_listeners. Set accepts bool.
	QueuedListeners config.Key[Settings, bool]
	// ListenerConnection selects features.events.listener_connection. Set accepts jobs.ConnectionName.
	ListenerConnection config.Key[Settings, jobs.ConnectionName]
	// ListenerQueue selects features.events.listener_queue. Set accepts jobs.Queue.
	ListenerQueue config.Key[Settings, jobs.Queue]
}

type SettingsFeaturesExtensionCleanupConfigKeySet struct {
	// Jobs selects features.extension_cleanup.jobs. Set accepts jobs.ConnectionName.
	//
	// Jobs names the job connection that runs the cleanup job. The deletion
	// enqueues it in its own transaction through the outbox, so it needs a
	// destination in features.outbox.jobs and a worker consuming the
	// connection's default queue. Empty keeps process-local after-commit cleanup.
	//
	Jobs config.Key[Settings, jobs.ConnectionName]
}

type SettingsFeaturesExtensionsConfigKeySet struct {
	// Enabled selects features.extensions.enabled. Set accepts bool.
	Enabled config.Key[Settings, bool]
	// Database selects features.extensions.database. Set accepts database.ConnectionName.
	Database config.Key[Settings, database.ConnectionName]
	// Schema selects features.extensions.schema. Set accepts string.
	Schema config.Key[Settings, string]
	// MaxActive selects features.extensions.max_active. Set accepts int.
	MaxActive config.Key[Settings, int]
	// Timeout selects features.extensions.timeout. Set accepts time.Duration.
	Timeout config.Key[Settings, time.Duration]
}

type SettingsFeaturesHealthConfigConfigKeySet struct {
	// MaxProbes selects features.health.config.max_probes. Set accepts int.
	MaxProbes config.Key[Settings, int]
	// MaxConcurrent selects features.health.config.max_concurrent. Set accepts int.
	MaxConcurrent config.Key[Settings, int]
	// CheckTimeout selects features.health.config.check_timeout. Set accepts time.Duration.
	CheckTimeout config.Key[Settings, time.Duration]
	// ProbeTimeout selects features.health.config.probe_timeout. Set accepts time.Duration.
	ProbeTimeout config.Key[Settings, time.Duration]
}

type SettingsFeaturesHealthConfigKeySet struct {
	// Enabled selects features.health.enabled. Set accepts bool.
	Enabled config.Key[Settings, bool]
	Config  SettingsFeaturesHealthConfigConfigKeySet
	// ConfiguredConnections selects features.health.configured_connections. Set accepts bool.
	ConfiguredConnections config.Key[Settings, bool]
	// ConfiguredStorage selects features.health.configured_storage. Set accepts bool.
	ConfiguredStorage config.Key[Settings, bool]
	// ConfiguredMail selects features.health.configured_mail. Set accepts bool.
	ConfiguredMail config.Key[Settings, bool]
}

type SettingsFeaturesIdempotencyConfigConfigKeySet struct {
	// Schema selects features.idempotency.config.schema. Set accepts string.
	Schema config.Key[Settings, string]
	// MaxActive selects features.idempotency.config.max_active. Set accepts int.
	MaxActive config.Key[Settings, int]
	// MaxRetainedPerCaller selects features.idempotency.config.max_retained_per_caller. Set accepts int.
	MaxRetainedPerCaller config.Key[Settings, int]
	// MaxKeyBytes selects features.idempotency.config.max_key_bytes. Set accepts int.
	MaxKeyBytes config.Key[Settings, int]
	// MaxInputBytes selects features.idempotency.config.max_input_bytes. Set accepts int.
	MaxInputBytes config.Key[Settings, int]
	// MaxResultBytes selects features.idempotency.config.max_result_bytes. Set accepts int.
	MaxResultBytes config.Key[Settings, int]
	// Timeout selects features.idempotency.config.timeout. Set accepts time.Duration.
	Timeout config.Key[Settings, time.Duration]
	// DuplicateWait selects features.idempotency.config.duplicate_wait. Set accepts time.Duration.
	DuplicateWait config.Key[Settings, time.Duration]
	// Retention selects features.idempotency.config.retention. Set accepts time.Duration.
	Retention config.Key[Settings, time.Duration]
	// PruneInterval selects features.idempotency.config.prune_interval. Set accepts time.Duration.
	PruneInterval config.Key[Settings, time.Duration]
	// PruneBatch selects features.idempotency.config.prune_batch. Set accepts int.
	PruneBatch config.Key[Settings, int]
}

type SettingsFeaturesIdempotencyConfigKeySet struct {
	// Enabled selects features.idempotency.enabled. Set accepts bool.
	Enabled config.Key[Settings, bool]
	// Database selects features.idempotency.database. Set accepts database.ConnectionName.
	Database config.Key[Settings, database.ConnectionName]
	Config   SettingsFeaturesIdempotencyConfigConfigKeySet
}

type SettingsFeaturesLocalesConfigKeySet struct {
	// Enabled selects features.locales.enabled. Set accepts bool.
	Enabled config.Key[Settings, bool]
	// Default selects features.locales.default. Set accepts i18n.LocaleID.
	Default config.Key[Settings, i18n.LocaleID]
	// Locales selects features.locales.locales. Set accepts []i18n.LocaleID.
	Locales config.Key[Settings, []i18n.LocaleID]
	// Fallback selects features.locales.fallback. Set accepts i18n.LocaleID.
	Fallback config.Key[Settings, i18n.LocaleID]
}

type SettingsFeaturesMaintenanceAuditConfigKeySet struct {
	// Disabled selects features.maintenance.audit.disabled. Set accepts bool.
	//
	// Disabled turns this task off.
	//
	Disabled config.Key[Settings, bool]
	// Interval selects features.maintenance.audit.interval. Set accepts time.Duration.
	//
	// Interval separates runs. Each task keeps a stable offset within its
	// interval, so housekeeping does not pile onto the top of every hour.
	//
	Interval config.Key[Settings, time.Duration]
	// Batch selects features.maintenance.audit.batch. Set accepts int.
	//
	// Batch bounds the rows one statement or transaction removes; MaxBatches
	// bounds the batches of one run, so a backlog continues at the next run.
	//
	Batch config.Key[Settings, int]
	// MaxBatches selects features.maintenance.audit.max_batches. Set accepts int.
	MaxBatches config.Key[Settings, int]
	// Timeout selects features.maintenance.audit.timeout. Set accepts time.Duration.
	//
	// Timeout bounds one run.
	//
	Timeout config.Key[Settings, time.Duration]
	// Retention selects features.maintenance.audit.retention. Set accepts time.Duration.
	//
	// Retention keeps younger rows of stores pruned by age (outbox, job archive
	// and notification inbox).
	//
	Retention config.Key[Settings, time.Duration]
}

type SettingsFeaturesMaintenanceConfigKeySet struct {
	// Enabled selects features.maintenance.enabled. Set accepts bool.
	Enabled  config.Key[Settings, bool]
	Defaults SettingsFeaturesMaintenanceDefaultsConfigKeySet
	//
	// Outbox removes published outbox rows completed before Retention; pending
	// and failed rows are never pruned.
	//
	Outbox SettingsFeaturesMaintenanceOutboxConfigKeySet
	//
	// Idempotency removes expired outcomes, but only while the store's own
	// pruner is disabled (features.idempotency.config.prune_interval = 0).
	//
	Idempotency SettingsFeaturesMaintenanceIdempotencyConfigKeySet
	//
	// Audit applies features.audit.config.retention_days to the configured
	// area; zero retention registers no audit task. MaxBatches does not apply:
	// one run removes every expired batch within its Timeout.
	//
	Audit SettingsFeaturesMaintenanceAuditConfigKeySet
	//
	// JobArchive removes archived failed jobs older than Retention.
	//
	JobArchive SettingsFeaturesMaintenanceJobArchiveConfigKeySet
	//
	// Notifications removes inbox records older than Retention. Unread records
	// are kept unless NotificationsUnread is set.
	//
	Notifications SettingsFeaturesMaintenanceNotificationsConfigKeySet
	// NotificationsUnread selects features.maintenance.notifications_unread. Set accepts bool.
	NotificationsUnread config.Key[Settings, bool]
	//
	// Sessions, Tokens, Models and Custom tune declared Pruning of each kind.
	//
	Sessions SettingsFeaturesMaintenanceSessionsConfigKeySet
	Tokens   SettingsFeaturesMaintenanceTokensConfigKeySet
	Models   SettingsFeaturesMaintenanceModelsConfigKeySet
	Custom   SettingsFeaturesMaintenanceCustomConfigKeySet
}

type SettingsFeaturesMaintenanceCustomConfigKeySet struct {
	// Disabled selects features.maintenance.custom.disabled. Set accepts bool.
	//
	// Disabled turns this task off.
	//
	Disabled config.Key[Settings, bool]
	// Interval selects features.maintenance.custom.interval. Set accepts time.Duration.
	//
	// Interval separates runs. Each task keeps a stable offset within its
	// interval, so housekeeping does not pile onto the top of every hour.
	//
	Interval config.Key[Settings, time.Duration]
	// Batch selects features.maintenance.custom.batch. Set accepts int.
	//
	// Batch bounds the rows one statement or transaction removes; MaxBatches
	// bounds the batches of one run, so a backlog continues at the next run.
	//
	Batch config.Key[Settings, int]
	// MaxBatches selects features.maintenance.custom.max_batches. Set accepts int.
	MaxBatches config.Key[Settings, int]
	// Timeout selects features.maintenance.custom.timeout. Set accepts time.Duration.
	//
	// Timeout bounds one run.
	//
	Timeout config.Key[Settings, time.Duration]
	// Retention selects features.maintenance.custom.retention. Set accepts time.Duration.
	//
	// Retention keeps younger rows of stores pruned by age (outbox, job archive
	// and notification inbox).
	//
	Retention config.Key[Settings, time.Duration]
}

type SettingsFeaturesMaintenanceDefaultsConfigKeySet struct {
	// Disabled selects features.maintenance.defaults.disabled. Set accepts bool.
	//
	// Disabled turns this task off.
	//
	Disabled config.Key[Settings, bool]
	// Interval selects features.maintenance.defaults.interval. Set accepts time.Duration.
	//
	// Interval separates runs. Each task keeps a stable offset within its
	// interval, so housekeeping does not pile onto the top of every hour.
	//
	Interval config.Key[Settings, time.Duration]
	// Batch selects features.maintenance.defaults.batch. Set accepts int.
	//
	// Batch bounds the rows one statement or transaction removes; MaxBatches
	// bounds the batches of one run, so a backlog continues at the next run.
	//
	Batch config.Key[Settings, int]
	// MaxBatches selects features.maintenance.defaults.max_batches. Set accepts int.
	MaxBatches config.Key[Settings, int]
	// Timeout selects features.maintenance.defaults.timeout. Set accepts time.Duration.
	//
	// Timeout bounds one run.
	//
	Timeout config.Key[Settings, time.Duration]
	// Retention selects features.maintenance.defaults.retention. Set accepts time.Duration.
	//
	// Retention keeps younger rows of stores pruned by age (outbox, job archive
	// and notification inbox).
	//
	Retention config.Key[Settings, time.Duration]
}

type SettingsFeaturesMaintenanceIdempotencyConfigKeySet struct {
	// Disabled selects features.maintenance.idempotency.disabled. Set accepts bool.
	//
	// Disabled turns this task off.
	//
	Disabled config.Key[Settings, bool]
	// Interval selects features.maintenance.idempotency.interval. Set accepts time.Duration.
	//
	// Interval separates runs. Each task keeps a stable offset within its
	// interval, so housekeeping does not pile onto the top of every hour.
	//
	Interval config.Key[Settings, time.Duration]
	// Batch selects features.maintenance.idempotency.batch. Set accepts int.
	//
	// Batch bounds the rows one statement or transaction removes; MaxBatches
	// bounds the batches of one run, so a backlog continues at the next run.
	//
	Batch config.Key[Settings, int]
	// MaxBatches selects features.maintenance.idempotency.max_batches. Set accepts int.
	MaxBatches config.Key[Settings, int]
	// Timeout selects features.maintenance.idempotency.timeout. Set accepts time.Duration.
	//
	// Timeout bounds one run.
	//
	Timeout config.Key[Settings, time.Duration]
	// Retention selects features.maintenance.idempotency.retention. Set accepts time.Duration.
	//
	// Retention keeps younger rows of stores pruned by age (outbox, job archive
	// and notification inbox).
	//
	Retention config.Key[Settings, time.Duration]
}

type SettingsFeaturesMaintenanceJobArchiveConfigKeySet struct {
	// Disabled selects features.maintenance.job_archive.disabled. Set accepts bool.
	//
	// Disabled turns this task off.
	//
	Disabled config.Key[Settings, bool]
	// Interval selects features.maintenance.job_archive.interval. Set accepts time.Duration.
	//
	// Interval separates runs. Each task keeps a stable offset within its
	// interval, so housekeeping does not pile onto the top of every hour.
	//
	Interval config.Key[Settings, time.Duration]
	// Batch selects features.maintenance.job_archive.batch. Set accepts int.
	//
	// Batch bounds the rows one statement or transaction removes; MaxBatches
	// bounds the batches of one run, so a backlog continues at the next run.
	//
	Batch config.Key[Settings, int]
	// MaxBatches selects features.maintenance.job_archive.max_batches. Set accepts int.
	MaxBatches config.Key[Settings, int]
	// Timeout selects features.maintenance.job_archive.timeout. Set accepts time.Duration.
	//
	// Timeout bounds one run.
	//
	Timeout config.Key[Settings, time.Duration]
	// Retention selects features.maintenance.job_archive.retention. Set accepts time.Duration.
	//
	// Retention keeps younger rows of stores pruned by age (outbox, job archive
	// and notification inbox).
	//
	Retention config.Key[Settings, time.Duration]
}

type SettingsFeaturesMaintenanceModelsConfigKeySet struct {
	// Disabled selects features.maintenance.models.disabled. Set accepts bool.
	//
	// Disabled turns this task off.
	//
	Disabled config.Key[Settings, bool]
	// Interval selects features.maintenance.models.interval. Set accepts time.Duration.
	//
	// Interval separates runs. Each task keeps a stable offset within its
	// interval, so housekeeping does not pile onto the top of every hour.
	//
	Interval config.Key[Settings, time.Duration]
	// Batch selects features.maintenance.models.batch. Set accepts int.
	//
	// Batch bounds the rows one statement or transaction removes; MaxBatches
	// bounds the batches of one run, so a backlog continues at the next run.
	//
	Batch config.Key[Settings, int]
	// MaxBatches selects features.maintenance.models.max_batches. Set accepts int.
	MaxBatches config.Key[Settings, int]
	// Timeout selects features.maintenance.models.timeout. Set accepts time.Duration.
	//
	// Timeout bounds one run.
	//
	Timeout config.Key[Settings, time.Duration]
	// Retention selects features.maintenance.models.retention. Set accepts time.Duration.
	//
	// Retention keeps younger rows of stores pruned by age (outbox, job archive
	// and notification inbox).
	//
	Retention config.Key[Settings, time.Duration]
}

type SettingsFeaturesMaintenanceNotificationsConfigKeySet struct {
	// Disabled selects features.maintenance.notifications.disabled. Set accepts bool.
	//
	// Disabled turns this task off.
	//
	Disabled config.Key[Settings, bool]
	// Interval selects features.maintenance.notifications.interval. Set accepts time.Duration.
	//
	// Interval separates runs. Each task keeps a stable offset within its
	// interval, so housekeeping does not pile onto the top of every hour.
	//
	Interval config.Key[Settings, time.Duration]
	// Batch selects features.maintenance.notifications.batch. Set accepts int.
	//
	// Batch bounds the rows one statement or transaction removes; MaxBatches
	// bounds the batches of one run, so a backlog continues at the next run.
	//
	Batch config.Key[Settings, int]
	// MaxBatches selects features.maintenance.notifications.max_batches. Set accepts int.
	MaxBatches config.Key[Settings, int]
	// Timeout selects features.maintenance.notifications.timeout. Set accepts time.Duration.
	//
	// Timeout bounds one run.
	//
	Timeout config.Key[Settings, time.Duration]
	// Retention selects features.maintenance.notifications.retention. Set accepts time.Duration.
	//
	// Retention keeps younger rows of stores pruned by age (outbox, job archive
	// and notification inbox).
	//
	Retention config.Key[Settings, time.Duration]
}

type SettingsFeaturesMaintenanceOutboxConfigKeySet struct {
	// Disabled selects features.maintenance.outbox.disabled. Set accepts bool.
	//
	// Disabled turns this task off.
	//
	Disabled config.Key[Settings, bool]
	// Interval selects features.maintenance.outbox.interval. Set accepts time.Duration.
	//
	// Interval separates runs. Each task keeps a stable offset within its
	// interval, so housekeeping does not pile onto the top of every hour.
	//
	Interval config.Key[Settings, time.Duration]
	// Batch selects features.maintenance.outbox.batch. Set accepts int.
	//
	// Batch bounds the rows one statement or transaction removes; MaxBatches
	// bounds the batches of one run, so a backlog continues at the next run.
	//
	Batch config.Key[Settings, int]
	// MaxBatches selects features.maintenance.outbox.max_batches. Set accepts int.
	MaxBatches config.Key[Settings, int]
	// Timeout selects features.maintenance.outbox.timeout. Set accepts time.Duration.
	//
	// Timeout bounds one run.
	//
	Timeout config.Key[Settings, time.Duration]
	// Retention selects features.maintenance.outbox.retention. Set accepts time.Duration.
	//
	// Retention keeps younger rows of stores pruned by age (outbox, job archive
	// and notification inbox).
	//
	Retention config.Key[Settings, time.Duration]
}

type SettingsFeaturesMaintenanceSessionsConfigKeySet struct {
	// Disabled selects features.maintenance.sessions.disabled. Set accepts bool.
	//
	// Disabled turns this task off.
	//
	Disabled config.Key[Settings, bool]
	// Interval selects features.maintenance.sessions.interval. Set accepts time.Duration.
	//
	// Interval separates runs. Each task keeps a stable offset within its
	// interval, so housekeeping does not pile onto the top of every hour.
	//
	Interval config.Key[Settings, time.Duration]
	// Batch selects features.maintenance.sessions.batch. Set accepts int.
	//
	// Batch bounds the rows one statement or transaction removes; MaxBatches
	// bounds the batches of one run, so a backlog continues at the next run.
	//
	Batch config.Key[Settings, int]
	// MaxBatches selects features.maintenance.sessions.max_batches. Set accepts int.
	MaxBatches config.Key[Settings, int]
	// Timeout selects features.maintenance.sessions.timeout. Set accepts time.Duration.
	//
	// Timeout bounds one run.
	//
	Timeout config.Key[Settings, time.Duration]
	// Retention selects features.maintenance.sessions.retention. Set accepts time.Duration.
	//
	// Retention keeps younger rows of stores pruned by age (outbox, job archive
	// and notification inbox).
	//
	Retention config.Key[Settings, time.Duration]
}

type SettingsFeaturesMaintenanceTokensConfigKeySet struct {
	// Disabled selects features.maintenance.tokens.disabled. Set accepts bool.
	//
	// Disabled turns this task off.
	//
	Disabled config.Key[Settings, bool]
	// Interval selects features.maintenance.tokens.interval. Set accepts time.Duration.
	//
	// Interval separates runs. Each task keeps a stable offset within its
	// interval, so housekeeping does not pile onto the top of every hour.
	//
	Interval config.Key[Settings, time.Duration]
	// Batch selects features.maintenance.tokens.batch. Set accepts int.
	//
	// Batch bounds the rows one statement or transaction removes; MaxBatches
	// bounds the batches of one run, so a backlog continues at the next run.
	//
	Batch config.Key[Settings, int]
	// MaxBatches selects features.maintenance.tokens.max_batches. Set accepts int.
	MaxBatches config.Key[Settings, int]
	// Timeout selects features.maintenance.tokens.timeout. Set accepts time.Duration.
	//
	// Timeout bounds one run.
	//
	Timeout config.Key[Settings, time.Duration]
	// Retention selects features.maintenance.tokens.retention. Set accepts time.Duration.
	//
	// Retention keeps younger rows of stores pruned by age (outbox, job archive
	// and notification inbox).
	//
	Retention config.Key[Settings, time.Duration]
}

type SettingsFeaturesNotificationsConfigKeySet struct {
	// Enabled selects features.notifications.enabled. Set accepts bool.
	Enabled config.Key[Settings, bool]
	// Database selects features.notifications.database. Set accepts database.ConnectionName.
	Database config.Key[Settings, database.ConnectionName]
	// Schema selects features.notifications.schema. Set accepts string.
	Schema config.Key[Settings, string]
	// MaxActive selects features.notifications.max_active. Set accepts int.
	MaxActive config.Key[Settings, int]
	// Timeout selects features.notifications.timeout. Set accepts time.Duration.
	Timeout config.Key[Settings, time.Duration]
}

type SettingsFeaturesObservabilityConfigKeySet struct {
	// Enabled selects features.observability.enabled. Set accepts bool.
	Enabled config.Key[Settings, bool]
	// Maintenance selects features.observability.maintenance. Set accepts bool.
	Maintenance config.Key[Settings, bool]
	// MaxSeries selects features.observability.max_series. Set accepts int.
	MaxSeries config.Key[Settings, int]
	// MaxRecent selects features.observability.max_recent. Set accepts int.
	MaxRecent config.Key[Settings, int]
	// MaxActive selects features.observability.max_active. Set accepts int.
	MaxActive config.Key[Settings, int]
	// ErrorQueue selects features.observability.error_queue. Set accepts int.
	ErrorQueue config.Key[Settings, int]
	// ReporterConcurrency selects features.observability.reporter_concurrency. Set accepts int.
	ReporterConcurrency config.Key[Settings, int]
	// ReporterTimeout selects features.observability.reporter_timeout. Set accepts time.Duration.
	ReporterTimeout config.Key[Settings, time.Duration]
	// SampleTraces selects features.observability.sample_traces. Set accepts bool.
	SampleTraces config.Key[Settings, bool]
	// TraceSampleRatio selects features.observability.trace_sample_ratio. Set accepts float64.
	//
	// TraceSampleRatio selects the sampled fraction of traces; zero means 1.
	//
	TraceSampleRatio config.Key[Settings, float64]
	// TraceQueue selects features.observability.trace_queue. Set accepts int.
	TraceQueue config.Key[Settings, int]
	// TraceConcurrency selects features.observability.trace_concurrency. Set accepts int.
	TraceConcurrency config.Key[Settings, int]
	// TraceBatchSize selects features.observability.trace_batch_size. Set accepts int.
	TraceBatchSize config.Key[Settings, int]
	// TraceTimeout selects features.observability.trace_timeout. Set accepts time.Duration.
	TraceTimeout config.Key[Settings, time.Duration]
	ErrorLog     SettingsFeaturesObservabilityErrorLogConfigKeySet
}

type SettingsFeaturesObservabilityErrorLogConfigKeySet struct {
	// Enabled selects features.observability.error_log.enabled. Set accepts bool.
	Enabled config.Key[Settings, bool]
	// Window selects features.observability.error_log.window. Set accepts time.Duration.
	Window config.Key[Settings, time.Duration]
	// MaxFingerprints selects features.observability.error_log.max_fingerprints. Set accepts int.
	MaxFingerprints config.Key[Settings, int]
	// DontReportFaults selects features.observability.error_log.dont_report_faults. Set accepts []foundryfault.Code.
	DontReportFaults config.Key[Settings, []foundryfault.Code]
	// DontReportStatuses selects features.observability.error_log.dont_report_statuses. Set accepts []int.
	DontReportStatuses config.Key[Settings, []int]
}

type SettingsFeaturesOutboxConfigKeySet struct {
	// Enabled selects features.outbox.enabled. Set accepts bool.
	Enabled config.Key[Settings, bool]
	// Database selects features.outbox.database. Set accepts database.ConnectionName.
	Database config.Key[Settings, database.ConnectionName]
	// Schema selects features.outbox.schema. Set accepts string.
	Schema config.Key[Settings, string]
	// Jobs selects features.outbox.jobs. Set accepts map[jobs.ConnectionName]outbox.Destination.
	Jobs config.Key[Settings, map[jobs.ConnectionName]outbox.Destination]
	// Events selects features.outbox.events. Set accepts map[outbox.Destination]jobs.ConnectionName.
	//
	// Events maps declared EventOutbox destinations to durable job connections.
	// Empty connection selects the default. Each connection uses its default
	// queue and jobs.DefaultPolicy for the framework event delivery job.
	//
	Events config.Key[Settings, map[outbox.Destination]jobs.ConnectionName]
	// Kernels selects features.outbox.kernels. Set accepts []foundation.KernelKind.
	Kernels config.Key[Settings, []foundation.KernelKind]
	// MaxAttempts selects features.outbox.max_attempts. Set accepts uint32.
	MaxAttempts config.Key[Settings, uint32]
	// RetryDelay selects features.outbox.retry_delay. Set accepts time.Duration.
	RetryDelay config.Key[Settings, time.Duration]
	// OperationTimeout selects features.outbox.operation_timeout. Set accepts time.Duration.
	OperationTimeout config.Key[Settings, time.Duration]
	// PollInterval selects features.outbox.poll_interval. Set accepts time.Duration.
	PollInterval config.Key[Settings, time.Duration]
	// MaxRetryDelay selects features.outbox.max_retry_delay. Set accepts time.Duration.
	MaxRetryDelay config.Key[Settings, time.Duration]
	// Jitter selects features.outbox.jitter. Set accepts time.Duration.
	Jitter config.Key[Settings, time.Duration]
	// MaxPollInterval selects features.outbox.max_poll_interval. Set accepts time.Duration.
	MaxPollInterval config.Key[Settings, time.Duration]
	// MaxInFlight selects features.outbox.max_in_flight. Set accepts int.
	MaxInFlight config.Key[Settings, int]
}

type SettingsFeaturesReportsConfigConfigKeySet struct {
	// TimeZone selects features.reports.config.time_zone. Set accepts temporal.ZoneName.
	//
	// TimeZone is the default export presentation zone. Empty means UTC for a
	// direct manager, or inherits the application timezone during assembly.
	//
	TimeZone config.Key[Settings, temporal.ZoneName]
	// Schema selects features.reports.config.schema. Set accepts string.
	Schema config.Key[Settings, string]
	// MaxActive selects features.reports.config.max_active. Set accepts int.
	MaxActive config.Key[Settings, int]
	// Timeout selects features.reports.config.timeout. Set accepts time.Duration.
	Timeout config.Key[Settings, time.Duration]
	// MaxPageSize selects features.reports.config.max_page_size. Set accepts int.
	MaxPageSize config.Key[Settings, int]
	// MaxOffset selects features.reports.config.max_offset. Set accepts int.
	MaxOffset config.Key[Settings, int]
	// MaxRowBytes selects features.reports.config.max_row_bytes. Set accepts int.
	MaxRowBytes config.Key[Settings, int]
	// MaxPageBytes selects features.reports.config.max_page_bytes. Set accepts int.
	MaxPageBytes config.Key[Settings, int]
	// MaxExports selects features.reports.config.max_exports. Set accepts int.
	//
	// MaxExports bounds concurrent export generation (query, formatting and
	// file writing). A slot is released once the artifact is complete.
	//
	MaxExports config.Key[Settings, int]
	// MaxArtifacts selects features.reports.config.max_artifacts. Set accepts int.
	//
	// MaxArtifacts bounds completed artifacts still open for delivery, and so
	// the private temporary files held on disk. It is at least MaxExports.
	//
	MaxArtifacts config.Key[Settings, int]
	// ExportTimeout selects features.reports.config.export_timeout. Set accepts time.Duration.
	ExportTimeout config.Key[Settings, time.Duration]
	// MaxExportRows selects features.reports.config.max_export_rows. Set accepts int.
	MaxExportRows config.Key[Settings, int]
	// MaxExportBytes selects features.reports.config.max_export_bytes. Set accepts int64.
	MaxExportBytes config.Key[Settings, int64]
	// MaxXMLBytes selects features.reports.config.max_xml_bytes. Set accepts int64.
	MaxXMLBytes config.Key[Settings, int64]
	// MaxCellBytes selects features.reports.config.max_cell_bytes. Set accepts int.
	MaxCellBytes config.Key[Settings, int]
	// TempDir selects features.reports.config.temp_dir. Set accepts string.
	TempDir config.Key[Settings, string]
}

type SettingsFeaturesReportsConfigKeySet struct {
	// Enabled selects features.reports.enabled. Set accepts bool.
	Enabled config.Key[Settings, bool]
	// Database selects features.reports.database. Set accepts database.ConnectionName.
	Database config.Key[Settings, database.ConnectionName]
	Config   SettingsFeaturesReportsConfigConfigKeySet
}

type SettingsHTTPConfigKeySet struct {
	StatementDetector SettingsHTTPStatementDetectorConfigKeySet
	// Enabled selects http.enabled. Set accepts bool.
	Enabled config.Key[Settings, bool]
	Server  SettingsHTTPServerConfigKeySet
	// SecurityHeaders selects http.security_headers. Set accepts bool.
	SecurityHeaders config.Key[Settings, bool]
	Probes          SettingsHTTPProbesConfigKeySet
}

type SettingsHTTPProbesConfigKeySet struct {
	// Liveness selects http.probes.liveness. Set accepts bool.
	Liveness config.Key[Settings, bool]
	// LivenessPath selects http.probes.liveness_path. Set accepts string.
	LivenessPath config.Key[Settings, string]
	// Readiness selects http.probes.readiness. Set accepts bool.
	Readiness config.Key[Settings, bool]
	// ReadinessPath selects http.probes.readiness_path. Set accepts string.
	ReadinessPath config.Key[Settings, string]
	// ReadinessCache selects http.probes.readiness_cache. Set accepts time.Duration.
	//
	// ReadinessCache is how long public readiness reuses one dependency check
	// (100ms to one minute); lifecycle and maintenance state are read live.
	//
	ReadinessCache config.Key[Settings, time.Duration]
}

type SettingsHTTPServerConfigKeySet struct {
	// Address selects http.server.address. Set accepts string.
	//
	// Address is a TCP host:port. Port zero allocates a port reported by Ready.
	//
	Address config.Key[Settings, string]
	// ReadHeaderTimeout selects http.server.read_header_timeout. Set accepts time.Duration.
	//
	// ReadHeaderTimeout bounds socket time spent reading request headers.
	//
	ReadHeaderTimeout config.Key[Settings, time.Duration]
	// ReadTimeout selects http.server.read_timeout. Set accepts time.Duration.
	//
	// ReadTimeout bounds reading the full request, including its body. It does
	// not terminate handler computations or replace their context deadlines.
	//
	ReadTimeout config.Key[Settings, time.Duration]
	// WriteTimeout selects http.server.write_timeout. Set accepts time.Duration.
	//
	// WriteTimeout bounds response socket writes, including streaming writes.
	// It does not terminate a handler that ignores write errors/cancellation.
	//
	WriteTimeout config.Key[Settings, time.Duration]
	// IdleTimeout selects http.server.idle_timeout. Set accepts time.Duration.
	//
	// IdleTimeout bounds waiting for another request on a keep-alive connection.
	//
	IdleTimeout config.Key[Settings, time.Duration]
	// RequestTimeout selects http.server.request_timeout. Set accepts time.Duration.
	//
	// RequestTimeout bounds the request context after admission. Cooperative
	// handlers and database calls observe its cancellation. Ownership lasts
	// until actual handler exit; raw handlers own their response behavior.
	// A matched route declared with WithTimeout replaces it for that route.
	//
	RequestTimeout config.Key[Settings, time.Duration]
	// ShutdownTimeout selects http.server.shutdown_timeout. Set accepts time.Duration.
	//
	// ShutdownTimeout allows admitted handlers to finish before cancellation and
	// connection closure. Dependency ownership still lasts until actual exit.
	//
	ShutdownTimeout config.Key[Settings, time.Duration]
	// MaxHeaderBytes selects http.server.max_header_bytes. Set accepts int.
	//
	// MaxHeaderBytes configures the native net/http request-header limit.
	//
	MaxHeaderBytes config.Key[Settings, int]
	// MaxBodyBytes selects http.server.max_body_bytes. Set accepts int64.
	//
	// MaxBodyBytes is a positive default ceiling for known and streamed bodies.
	// Increasing it does not preallocate a buffer; raw handlers own their reads.
	// A matched route declared with WithBodyLimit replaces it for that route only.
	//
	MaxBodyBytes config.Key[Settings, int64]
	// MaxConcurrentRequests selects http.server.max_concurrent_requests. Set accepts int.
	//
	// MaxConcurrentRequests bounds handlers that have actually entered the
	// server. Zero uses DefaultServerConfig's limit. A request waits briefly for
	// a slot in arrival order (at most min(RequestTimeout, 5s)); exhaustion then
	// returns 503 with Retry-After. Cancelled handlers retain their slot until
	// they really return.
	//
	MaxConcurrentRequests config.Key[Settings, int]
	// MaxConnections selects http.server.max_connections. Set accepts int.
	//
	// MaxConnections bounds accepted TCP connections, including connections
	// still reading headers and hijacked connections until their owner closes
	// them. Zero uses the default. Extra peers wait in the OS listen backlog.
	//
	MaxConnections config.Key[Settings, int]
	// TrustTraceContext selects http.server.trust_trace_context. Set accepts bool.
	//
	// TrustTraceContext accepts valid W3C trace headers as correlation metadata.
	// It grants no identity or sampling authority. False starts a fresh trace
	// for every request; invalid or duplicate parents also start a fresh trace.
	//
	TrustTraceContext config.Key[Settings, bool]
	// MaintenanceReadPaths selects http.server.maintenance_read_paths. Set accepts []string.
	//
	// MaintenanceReadPaths permits GET/HEAD on at most 16 exact static paths
	// while paused or draining. Use URLs derived from protected diagnostics
	// routes. This bypasses only maintenance admission: normal route auth,
	// policies, request limits and actual server shutdown still apply.
	//
	MaintenanceReadPaths config.Key[Settings, []string]
	// AccessLog selects http.server.access_log. Set accepts bool.
	//
	// AccessLog emits one metadata-only completion event to the server logger.
	//
	AccessLog config.Key[Settings, bool]
}

type SettingsHTTPStatementDetectorConfigKeySet struct {
	// Enabled selects http.statement_detector.enabled. Set accepts bool.
	Enabled config.Key[Settings, bool]
	// AllowNonDevelopment selects http.statement_detector.allow_non_development. Set accepts bool.
	AllowNonDevelopment config.Key[Settings, bool]
	Limits              SettingsHTTPStatementDetectorLimitsConfigKeySet
}

type SettingsHTTPStatementDetectorLimitsConfigKeySet struct {
	// Threshold selects http.statement_detector.limits.threshold. Set accepts int.
	Threshold config.Key[Settings, int]
	// MaxShapes selects http.statement_detector.limits.max_shapes. Set accepts int.
	MaxShapes config.Key[Settings, int]
}

type SettingsImageConfigConfigKeySet struct {
	// Backend selects image.config.backend. Set accepts imaging.Backend.
	Backend config.Key[Settings, imaging.Backend]
	Limits  SettingsImageConfigLimitsConfigKeySet
	// MaxActive selects image.config.max_active. Set accepts int.
	MaxActive config.Key[Settings, int]
	// Timeout selects image.config.timeout. Set accepts time.Duration.
	Timeout config.Key[Settings, time.Duration]
}

type SettingsImageConfigKeySet struct {
	// Enabled selects image.enabled. Set accepts bool.
	Enabled config.Key[Settings, bool]
	Config  SettingsImageConfigConfigKeySet
}

type SettingsImageConfigLimitsConfigKeySet struct {
	// InputBytes selects image.config.limits.input_bytes. Set accepts int64.
	InputBytes config.Key[Settings, int64]
	// OutputBytes selects image.config.limits.output_bytes. Set accepts int64.
	OutputBytes config.Key[Settings, int64]
	// Width selects image.config.limits.width. Set accepts int.
	Width config.Key[Settings, int]
	// Height selects image.config.limits.height. Set accepts int.
	Height config.Key[Settings, int]
	// Pixels selects image.config.limits.pixels. Set accepts int64.
	Pixels config.Key[Settings, int64]
	// Frames selects image.config.limits.frames. Set accepts int.
	Frames config.Key[Settings, int]
	// WorkingBytes selects image.config.limits.working_bytes. Set accepts int64.
	WorkingBytes config.Key[Settings, int64]
}

type SettingsLogConfigKeySet struct {
	// Default selects log.default. Set accepts logging.ChannelName.
	Default config.Key[Settings, logging.ChannelName]
	// Channels selects log.channels. Set accepts LogChannels.
	Channels config.Key[Settings, LogChannels]
}

type SettingsMaintenanceConfigKeySet struct {
	// Store selects maintenance.store. Set accepts cache.StoreName.
	Store config.Key[Settings, cache.StoreName]
	// PollInterval selects maintenance.poll_interval. Set accepts time.Duration.
	PollInterval config.Key[Settings, time.Duration]
	// Exempt selects maintenance.exempt. Set accepts []maintenance.Rule.
	Exempt config.Key[Settings, []maintenance.Rule]
	// Allow selects maintenance.allow. Set accepts []netip.Prefix.
	Allow config.Key[Settings, []netip.Prefix]
	// BypassTTL selects maintenance.bypass_ttl. Set accepts time.Duration.
	BypassTTL config.Key[Settings, time.Duration]
}

type SettingsRealtimeConfigConfigKeySet struct {
	// MaxPresenceScopes selects realtime.config.max_presence_scopes. Set accepts int.
	MaxPresenceScopes config.Key[Settings, int]
	// MaxConnections selects realtime.config.max_connections. Set accepts int.
	MaxConnections config.Key[Settings, int]
	// MaxSubscriptions selects realtime.config.max_subscriptions. Set accepts int.
	MaxSubscriptions config.Key[Settings, int]
	// MaxFrameBytes selects realtime.config.max_frame_bytes. Set accepts int.
	MaxFrameBytes config.Key[Settings, int]
	// InboundQueue selects realtime.config.inbound_queue. Set accepts int.
	//
	// InboundQueue bounds frames read but not yet processed. Generated clients
	// limit their in-flight operations to it; overflowing it closes the socket.
	//
	InboundQueue config.Key[Settings, int]
	// OutboundQueue selects realtime.config.outbound_queue. Set accepts int.
	//
	// OutboundQueue bounds queued frames per connection. MaxQueuedBytes bounds
	// their actual bytes, including inbound frames and pending-admission
	// buffers; MaxTotalQueuedBytes bounds all connections together. Exceeding
	// either disconnects the slow connection instead of blocking publishers.
	//
	OutboundQueue config.Key[Settings, int]
	// MaxQueuedBytes selects realtime.config.max_queued_bytes. Set accepts int.
	MaxQueuedBytes config.Key[Settings, int]
	// MaxTotalQueuedBytes selects realtime.config.max_total_queued_bytes. Set accepts int64.
	MaxTotalQueuedBytes config.Key[Settings, int64]
	// MaxOperations selects realtime.config.max_operations. Set accepts int.
	//
	// MaxOperations bounds concurrent trusted publication, presence and
	// disconnect operations. Callers wait briefly, then receive fault.Overloaded.
	//
	MaxOperations config.Key[Settings, int]
	// MaxPresenceMembers selects realtime.config.max_presence_members. Set accepts int.
	MaxPresenceMembers config.Key[Settings, int]
	// MaxMemberBytes selects realtime.config.max_member_bytes. Set accepts int.
	MaxMemberBytes config.Key[Settings, int]
	// OperationTimeout selects realtime.config.operation_timeout. Set accepts time.Duration.
	OperationTimeout config.Key[Settings, time.Duration]
	// WriteTimeout selects realtime.config.write_timeout. Set accepts time.Duration.
	WriteTimeout config.Key[Settings, time.Duration]
	// HeartbeatInterval selects realtime.config.heartbeat_interval. Set accepts time.Duration.
	HeartbeatInterval config.Key[Settings, time.Duration]
	// PongTimeout selects realtime.config.pong_timeout. Set accepts time.Duration.
	PongTimeout config.Key[Settings, time.Duration]
	// AuthRefreshInterval selects realtime.config.auth_refresh_interval. Set accepts time.Duration.
	AuthRefreshInterval config.Key[Settings, time.Duration]
	// DrainTimeout selects realtime.config.drain_timeout. Set accepts time.Duration.
	DrainTimeout config.Key[Settings, time.Duration]
	// MaxConnectionsPerIP selects realtime.config.max_connections_per_ip. Set accepts int.
	MaxConnectionsPerIP config.Key[Settings, int]
	// MaxConnectionsPerSubject selects realtime.config.max_connections_per_subject. Set accepts int.
	MaxConnectionsPerSubject config.Key[Settings, int]
	// DeduplicationEntries selects realtime.config.deduplication_entries. Set accepts int.
	DeduplicationEntries config.Key[Settings, int]
	MessageRate          SettingsRealtimeConfigMessageRateConfigKeySet
	Payload              SettingsRealtimeConfigPayloadConfigKeySet
	// AdditionalOrigins selects realtime.config.additional_origins. Set accepts []http.Origin.
	//
	// AdditionalOrigins are exact HTTP(S) origins, never wildcard patterns.
	// Same-origin is accepted after trusted-proxy handling. Originless clients
	// must be explicitly allowed; serialized opaque/null origins never are.
	//
	AdditionalOrigins config.Key[Settings, []http.Origin]
	// AllowOriginless selects realtime.config.allow_originless. Set accepts bool.
	AllowOriginless config.Key[Settings, bool]
}

type SettingsRealtimeConfigKeySet struct {
	// Enabled selects realtime.enabled. Set accepts bool.
	Enabled config.Key[Settings, bool]
	// Shared selects realtime.shared. Set accepts bool.
	//
	// Shared serves upgrades at Path on the application HTTP listener instead
	// of a dedicated listener and WebSocket kernel; running foundation.HTTP then
	// serves both. HTTP request/connection limits must accommodate sockets.
	//
	Shared config.Key[Settings, bool]
	// Publisher selects realtime.publisher. Set accepts bool.
	//
	// Publisher constructs a managed cross-process publisher for processes
	// that run no hub, such as workers. It requires a cluster connection and
	// the same channel declarations as the socket servers.
	//
	Publisher config.Key[Settings, bool]
	// Connection selects realtime.connection. Set accepts websocket.ConnectionName.
	Connection config.Key[Settings, websocket.ConnectionName]
	Config     SettingsRealtimeConfigConfigKeySet
	HTTP       SettingsRealtimeHTTPConfigKeySet
	// Path selects realtime.path. Set accepts string.
	Path config.Key[Settings, string]
}

type SettingsRealtimeConfigMessageRateConfigKeySet struct {
	// Requests selects realtime.config.message_rate.requests. Set accepts uint32.
	Requests config.Key[Settings, uint32]
	// Window selects realtime.config.message_rate.window. Set accepts time.Duration.
	Window config.Key[Settings, time.Duration]
}

type SettingsRealtimeConfigPayloadConfigKeySet struct {
	// Bytes selects realtime.config.payload.bytes. Set accepts int.
	Bytes config.Key[Settings, int]
	// Depth selects realtime.config.payload.depth. Set accepts int.
	Depth config.Key[Settings, int]
	// Nodes selects realtime.config.payload.nodes. Set accepts int.
	Nodes config.Key[Settings, int]
	// Steps selects realtime.config.payload.steps. Set accepts int.
	Steps config.Key[Settings, int]
	// Issues selects realtime.config.payload.issues. Set accepts int.
	Issues config.Key[Settings, int]
}

type SettingsRealtimeHTTPConfigKeySet struct {
	// Address selects realtime.http.address. Set accepts string.
	//
	// Address is a TCP host:port. Port zero allocates a port reported by Ready.
	//
	Address config.Key[Settings, string]
	// ReadHeaderTimeout selects realtime.http.read_header_timeout. Set accepts time.Duration.
	//
	// ReadHeaderTimeout bounds socket time spent reading request headers.
	//
	ReadHeaderTimeout config.Key[Settings, time.Duration]
	// ReadTimeout selects realtime.http.read_timeout. Set accepts time.Duration.
	//
	// ReadTimeout bounds reading the full request, including its body. It does
	// not terminate handler computations or replace their context deadlines.
	//
	ReadTimeout config.Key[Settings, time.Duration]
	// WriteTimeout selects realtime.http.write_timeout. Set accepts time.Duration.
	//
	// WriteTimeout bounds response socket writes, including streaming writes.
	// It does not terminate a handler that ignores write errors/cancellation.
	//
	WriteTimeout config.Key[Settings, time.Duration]
	// IdleTimeout selects realtime.http.idle_timeout. Set accepts time.Duration.
	//
	// IdleTimeout bounds waiting for another request on a keep-alive connection.
	//
	IdleTimeout config.Key[Settings, time.Duration]
	// RequestTimeout selects realtime.http.request_timeout. Set accepts time.Duration.
	//
	// RequestTimeout bounds the request context after admission. Cooperative
	// handlers and database calls observe its cancellation. Ownership lasts
	// until actual handler exit; raw handlers own their response behavior.
	// A matched route declared with WithTimeout replaces it for that route.
	//
	RequestTimeout config.Key[Settings, time.Duration]
	// ShutdownTimeout selects realtime.http.shutdown_timeout. Set accepts time.Duration.
	//
	// ShutdownTimeout allows admitted handlers to finish before cancellation and
	// connection closure. Dependency ownership still lasts until actual exit.
	//
	ShutdownTimeout config.Key[Settings, time.Duration]
	// MaxHeaderBytes selects realtime.http.max_header_bytes. Set accepts int.
	//
	// MaxHeaderBytes configures the native net/http request-header limit.
	//
	MaxHeaderBytes config.Key[Settings, int]
	// MaxBodyBytes selects realtime.http.max_body_bytes. Set accepts int64.
	//
	// MaxBodyBytes is a positive default ceiling for known and streamed bodies.
	// Increasing it does not preallocate a buffer; raw handlers own their reads.
	// A matched route declared with WithBodyLimit replaces it for that route only.
	//
	MaxBodyBytes config.Key[Settings, int64]
	// MaxConcurrentRequests selects realtime.http.max_concurrent_requests. Set accepts int.
	//
	// MaxConcurrentRequests bounds handlers that have actually entered the
	// server. Zero uses DefaultServerConfig's limit. A request waits briefly for
	// a slot in arrival order (at most min(RequestTimeout, 5s)); exhaustion then
	// returns 503 with Retry-After. Cancelled handlers retain their slot until
	// they really return.
	//
	MaxConcurrentRequests config.Key[Settings, int]
	// MaxConnections selects realtime.http.max_connections. Set accepts int.
	//
	// MaxConnections bounds accepted TCP connections, including connections
	// still reading headers and hijacked connections until their owner closes
	// them. Zero uses the default. Extra peers wait in the OS listen backlog.
	//
	MaxConnections config.Key[Settings, int]
	// TrustTraceContext selects realtime.http.trust_trace_context. Set accepts bool.
	//
	// TrustTraceContext accepts valid W3C trace headers as correlation metadata.
	// It grants no identity or sampling authority. False starts a fresh trace
	// for every request; invalid or duplicate parents also start a fresh trace.
	//
	TrustTraceContext config.Key[Settings, bool]
	// MaintenanceReadPaths selects realtime.http.maintenance_read_paths. Set accepts []string.
	//
	// MaintenanceReadPaths permits GET/HEAD on at most 16 exact static paths
	// while paused or draining. Use URLs derived from protected diagnostics
	// routes. This bypasses only maintenance admission: normal route auth,
	// policies, request limits and actual server shutdown still apply.
	//
	MaintenanceReadPaths config.Key[Settings, []string]
	// AccessLog selects realtime.http.access_log. Set accepts bool.
	//
	// AccessLog emits one metadata-only completion event to the server logger.
	//
	AccessLog config.Key[Settings, bool]
}

type SettingsSchedulerConfigKeySet struct {
	// Enabled selects scheduler.enabled. Set accepts bool.
	Enabled config.Key[Settings, bool]
	// Group selects scheduler.group. Set accepts schedule.Group.
	Group config.Key[Settings, schedule.Group]
	// Concurrency selects scheduler.concurrency. Set accepts int.
	Concurrency config.Key[Settings, int]
	// MaxHistory selects scheduler.max_history. Set accepts int.
	MaxHistory config.Key[Settings, int]
	// MaxPerTick selects scheduler.max_per_tick. Set accepts int.
	MaxPerTick config.Key[Settings, int]
	// PollInterval selects scheduler.poll_interval. Set accepts time.Duration.
	PollInterval config.Key[Settings, time.Duration]
	// LeadershipTTL selects scheduler.leadership_ttl. Set accepts time.Duration.
	LeadershipTTL config.Key[Settings, time.Duration]
	// Grace selects scheduler.grace. Set accepts time.Duration.
	Grace config.Key[Settings, time.Duration]
	// CapacityWait selects scheduler.capacity_wait. Set accepts time.Duration.
	CapacityWait config.Key[Settings, time.Duration]
	// DrainTimeout selects scheduler.drain_timeout. Set accepts time.Duration.
	DrainTimeout config.Key[Settings, time.Duration]
}

type SettingsServicesCacheConfigKeySet struct {
	// Default selects services.cache.default. Set accepts cache.StoreName.
	Default config.Key[Settings, cache.StoreName]
	// Stores selects services.cache.stores. Set accepts infrastructure.CacheStores.
	Stores config.Key[Settings, infrastructure.CacheStores]
}

type SettingsServicesConfigKeySet struct {
	Namespace    SettingsServicesNamespaceConfigKeySet
	Database     SettingsServicesDatabaseConfigKeySet
	Redis        SettingsServicesRedisConfigKeySet
	Storage      SettingsServicesStorageConfigKeySet
	Cache        SettingsServicesCacheConfigKeySet
	Mail         SettingsServicesMailConfigKeySet
	Jobs         SettingsServicesJobsConfigKeySet
	HTTPClients  SettingsServicesHTTPClientsConfigKeySet
	PubSub       SettingsServicesPubSubConfigKeySet
	Realtime     SettingsServicesRealtimeConfigKeySet
	Coordination SettingsServicesCoordinationConfigKeySet
	// Credentials selects services.credentials. Set accepts infrastructure.CredentialSources.
	Credentials config.Key[Settings, infrastructure.CredentialSources]
}

type SettingsServicesCoordinationConfigConfigKeySet struct {
	Namespace SettingsServicesCoordinationConfigNamespaceConfigKeySet
	// MaxActive selects services.coordination.config.max_active. Set accepts int.
	MaxActive config.Key[Settings, int]
	// MaxDeclarations selects services.coordination.config.max_declarations. Set accepts int.
	MaxDeclarations config.Key[Settings, int]
	// MaxKeyBytes selects services.coordination.config.max_key_bytes. Set accepts int.
	MaxKeyBytes config.Key[Settings, int]
	// OperationTimeout selects services.coordination.config.operation_timeout. Set accepts time.Duration.
	OperationTimeout config.Key[Settings, time.Duration]
	// MaxWait selects services.coordination.config.max_wait. Set accepts time.Duration.
	MaxWait config.Key[Settings, time.Duration]
	// PollInterval selects services.coordination.config.poll_interval. Set accepts time.Duration.
	PollInterval config.Key[Settings, time.Duration]
}

type SettingsServicesCoordinationConfigKeySet struct {
	// Enabled selects services.coordination.enabled. Set accepts bool.
	Enabled config.Key[Settings, bool]
	// Driver selects services.coordination.driver. Set accepts infrastructure.CoordinationDriver.
	Driver config.Key[Settings, infrastructure.CoordinationDriver]
	// Redis selects services.coordination.redis. Set accepts redis.ConnectionName.
	Redis  config.Key[Settings, redis.ConnectionName]
	Config SettingsServicesCoordinationConfigConfigKeySet
	// MaxEntries selects services.coordination.max_entries. Set accepts int.
	MaxEntries config.Key[Settings, int]
}

type SettingsServicesCoordinationConfigNamespaceConfigKeySet struct {
	// Application selects services.coordination.config.namespace.application. Set accepts string.
	Application config.Key[Settings, string]
	// Environment selects services.coordination.config.namespace.environment. Set accepts string.
	Environment config.Key[Settings, string]
}

type SettingsServicesDatabaseConfigKeySet struct {
	// Default selects services.database.default. Set accepts database.ConnectionName.
	Default config.Key[Settings, database.ConnectionName]
	// MaxConnections selects services.database.max_connections. Set accepts int.
	MaxConnections config.Key[Settings, int]
	// Connections selects services.database.connections. Set accepts infrastructure.DatabaseConnections.
	Connections config.Key[Settings, infrastructure.DatabaseConnections]
}

type SettingsServicesHTTPClientsConfigKeySet struct {
	// Default selects services.http_clients.default. Set accepts httpclient.Name.
	Default config.Key[Settings, httpclient.Name]
	// Clients selects services.http_clients.clients. Set accepts infrastructure.HTTPClients.
	Clients config.Key[Settings, infrastructure.HTTPClients]
}

type SettingsServicesJobsConfigKeySet struct {
	// Default selects services.jobs.default. Set accepts jobs.ConnectionName.
	Default config.Key[Settings, jobs.ConnectionName]
	// Connections selects services.jobs.connections. Set accepts infrastructure.JobConnections.
	Connections config.Key[Settings, infrastructure.JobConnections]
}

type SettingsServicesMailConfigKeySet struct {
	// Default selects services.mail.default. Set accepts email.MailerName.
	Default config.Key[Settings, email.MailerName]
	// Mailers selects services.mail.mailers. Set accepts infrastructure.Mailers.
	Mailers config.Key[Settings, infrastructure.Mailers]
}

type SettingsServicesNamespaceConfigKeySet struct {
	// Application selects services.namespace.application. Set accepts string.
	Application config.Key[Settings, string]
	// Environment selects services.namespace.environment. Set accepts string.
	Environment config.Key[Settings, string]
}

type SettingsServicesPubSubConfigKeySet struct {
	// Default selects services.pub_sub.default. Set accepts pubsub.ConnectionName.
	Default config.Key[Settings, pubsub.ConnectionName]
	// Connections selects services.pub_sub.connections. Set accepts infrastructure.Brokers.
	Connections config.Key[Settings, infrastructure.Brokers]
}

type SettingsServicesRealtimeConfigKeySet struct {
	// Default selects services.realtime.default. Set accepts websocket.ConnectionName.
	Default config.Key[Settings, websocket.ConnectionName]
	// Connections selects services.realtime.connections. Set accepts infrastructure.RealtimeConnections.
	Connections config.Key[Settings, infrastructure.RealtimeConnections]
}

type SettingsServicesRedisConfigKeySet struct {
	// Default selects services.redis.default. Set accepts redis.ConnectionName.
	Default config.Key[Settings, redis.ConnectionName]
	// MaxConnections selects services.redis.max_connections. Set accepts int.
	MaxConnections config.Key[Settings, int]
	// Connections selects services.redis.connections. Set accepts infrastructure.RedisConnections.
	Connections config.Key[Settings, infrastructure.RedisConnections]
}

type SettingsServicesStorageConfigKeySet struct {
	// Default selects services.storage.default. Set accepts storage.DiskID.
	Default config.Key[Settings, storage.DiskID]
	// Disks selects services.storage.disks. Set accepts infrastructure.Disks.
	Disks config.Key[Settings, infrastructure.Disks]
}

type SettingsWorkerArchiveConfigKeySet struct {
	// Enabled selects worker.archive.enabled. Set accepts bool.
	Enabled config.Key[Settings, bool]
	// Database selects worker.archive.database. Set accepts database.ConnectionName.
	Database config.Key[Settings, database.ConnectionName]
	// Schema selects worker.archive.schema. Set accepts string.
	Schema config.Key[Settings, string]
}

type SettingsWorkerConfigConfigKeySet struct {
	// FailureLog selects worker.config.failure_log. Set accepts bool.
	FailureLog config.Key[Settings, bool]
	// RetryUnregistered selects worker.config.retry_unregistered. Set accepts bool.
	RetryUnregistered config.Key[Settings, bool]
	Namespace         SettingsWorkerConfigNamespaceConfigKeySet
	// Queues selects worker.config.queues. Set accepts []jobs.Subscription.
	Queues config.Key[Settings, []jobs.Subscription]
	// Concurrency selects worker.config.concurrency. Set accepts int.
	Concurrency config.Key[Settings, int]
	// LeaseDuration selects worker.config.lease_duration. Set accepts time.Duration.
	LeaseDuration config.Key[Settings, time.Duration]
	// HeartbeatInterval selects worker.config.heartbeat_interval. Set accepts time.Duration.
	HeartbeatInterval config.Key[Settings, time.Duration]
	// OperationTimeout selects worker.config.operation_timeout. Set accepts time.Duration.
	OperationTimeout config.Key[Settings, time.Duration]
	// PollInterval selects worker.config.poll_interval. Set accepts time.Duration.
	PollInterval config.Key[Settings, time.Duration]
	// MaxPollInterval selects worker.config.max_poll_interval. Set accepts time.Duration.
	MaxPollInterval config.Key[Settings, time.Duration]
	// DrainTimeout selects worker.config.drain_timeout. Set accepts time.Duration.
	DrainTimeout config.Key[Settings, time.Duration]
	// FailureBackoff selects worker.config.failure_backoff. Set accepts time.Duration.
	FailureBackoff config.Key[Settings, time.Duration]
}

type SettingsWorkerConfigKeySet struct {
	// Enabled selects worker.enabled. Set accepts bool.
	Enabled config.Key[Settings, bool]
	// Connection selects worker.connection. Set accepts jobs.ConnectionName.
	Connection config.Key[Settings, jobs.ConnectionName]
	Config     SettingsWorkerConfigConfigKeySet
	Archive    SettingsWorkerArchiveConfigKeySet
}

type SettingsWorkerConfigNamespaceConfigKeySet struct {
	// Application selects worker.config.namespace.application. Set accepts string.
	Application config.Key[Settings, string]
	// Environment selects worker.config.namespace.environment. Set accepts string.
	Environment config.Key[Settings, string]
}

type StatementDetectorSettings struct {
	Enabled             bool
	AllowNonDevelopment bool
	Limits              database.StatementDetectorConfig
}

type StoreSettings struct {
	Enabled   bool
	Database  database.ConnectionName
	Schema    string
	MaxActive int
	Timeout   time.Duration
}

type TokenGuard[M model.Identifiable, K any] struct {
	Tokens         *token.Tokens[M, K]
	Authentication *http.Authentication
	Binding        http.GuardBinding[M]
}

type TokenSettings struct {
	Enabled  bool
	Database database.ConnectionName
	Schema   string
	Config   token.Config
}

type WorkerSettings struct {
	Enabled    bool
	Connection jobs.ConnectionName
	Config     jobs.WorkerConfig
	Archive    JobArchiveSettings
}