infrastructure

type BrokerDriver string

type BrokerSettings struct {
	Driver BrokerDriver
	Redis  redis.ConnectionName
	Config pubsub.Config
}

type BrokerSettingsConfigBufferConfigKeySet struct {
	// Messages selects config.buffer.messages. Set accepts int.
	Messages config.Key[BrokerSettings, int]
	// Bytes selects config.buffer.bytes. Set accepts int.
	Bytes config.Key[BrokerSettings, int]
	// PayloadBytes selects config.buffer.payload_bytes. Set accepts int.
	PayloadBytes config.Key[BrokerSettings, int]
	// Channels selects config.buffer.channels. Set accepts int.
	Channels config.Key[BrokerSettings, int]
}

type BrokerSettingsConfigConfigKeySet struct {
	Namespace BrokerSettingsConfigNamespaceConfigKeySet
	// MaxDeclarations selects config.max_declarations. Set accepts int.
	MaxDeclarations config.Key[BrokerSettings, int]
	// MaxKeyBytes selects config.max_key_bytes. Set accepts int.
	MaxKeyBytes config.Key[BrokerSettings, int]
	// MaxConcurrent selects config.max_concurrent. Set accepts int.
	MaxConcurrent config.Key[BrokerSettings, int]
	// MaxSubscriptions selects config.max_subscriptions. Set accepts int.
	MaxSubscriptions config.Key[BrokerSettings, int]
	// Timeout selects config.timeout. Set accepts time.Duration.
	Timeout config.Key[BrokerSettings, time.Duration]
	Buffer  BrokerSettingsConfigBufferConfigKeySet
}

type BrokerSettingsConfigKeySet struct {
	// Driver selects driver. Set accepts BrokerDriver.
	Driver config.Key[BrokerSettings, BrokerDriver]
	// Redis selects redis. Set accepts redis.ConnectionName.
	Redis  config.Key[BrokerSettings, redis.ConnectionName]
	Config BrokerSettingsConfigConfigKeySet
}

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

type Brokers map[pubsub.ConnectionName]BrokerSettings

type CacheDriver string

type CacheSettings struct {
	Driver       CacheDriver
	Config       cache.Config
	Memory       memory.Config
	File         FileCacheSettings
	Postgres     PostgresCacheSettings
	Redis        redis.ConnectionName
	Database     database.ConnectionName
	Require      cache.Requirements
	Leases       lease.Config
	Coordination cache.CoordinationConfig
}

type CacheSettingsConfigConfigKeySet struct {
	Namespace CacheSettingsConfigNamespaceConfigKeySet
	// MaxKeyBytes selects config.max_key_bytes. Set accepts int.
	MaxKeyBytes config.Key[CacheSettings, int]
	// MaxValueBytes selects config.max_value_bytes. Set accepts int.
	MaxValueBytes config.Key[CacheSettings, int]
	// MaxDeclarations selects config.max_declarations. Set accepts int.
	MaxDeclarations config.Key[CacheSettings, int]
	// MaxBatchEntries selects config.max_batch_entries. Set accepts int.
	//
	// Maximum batch input keys before deduplication; bounded by MaxBatchEntries.
	//
	MaxBatchEntries config.Key[CacheSettings, int]
	// MaxTags selects config.max_tags. Set accepts int.
	//
	// Maximum references in a tagged view/invalidation; bounded by cache.MaxTags.
	//
	MaxTags config.Key[CacheSettings, int]
	// MaxFills selects config.max_fills. Set accepts int.
	//
	// MaxFills bounds concurrent Remember loaders across this store.
	//
	MaxFills config.Key[CacheSettings, int]
	// MaxFillWaiters selects config.max_fill_waiters. Set accepts int.
	//
	// MaxFillWaiters bounds followers of each Remember loader (excluding its owner).
	//
	MaxFillWaiters config.Key[CacheSettings, int]
	// Timeout selects config.timeout. Set accepts time.Duration.
	//
	// Timeout bounds each backend step (read, write, metadata) and every other
	// operation. It does not cap Remember loaders; LoadTimeout does.
	//
	Timeout config.Key[CacheSettings, time.Duration]
	// LoadTimeout selects config.load_timeout. Set accepts time.Duration.
	//
	// LoadTimeout bounds one Remember loader run, detached from the requesting
	// caller's cancellation. A call can narrow it with WithLoadTimeout.
	//
	LoadTimeout config.Key[CacheSettings, time.Duration]
}

type CacheSettingsConfigKeySet struct {
	// Driver selects driver. Set accepts CacheDriver.
	Driver   config.Key[CacheSettings, CacheDriver]
	Config   CacheSettingsConfigConfigKeySet
	Memory   CacheSettingsMemoryConfigKeySet
	File     CacheSettingsFileConfigKeySet
	Postgres CacheSettingsPostgresConfigKeySet
	// Redis selects redis. Set accepts redis.ConnectionName.
	Redis config.Key[CacheSettings, redis.ConnectionName]
	// Database selects database. Set accepts database.ConnectionName.
	Database     config.Key[CacheSettings, database.ConnectionName]
	Require      CacheSettingsRequireConfigKeySet
	Leases       CacheSettingsLeasesConfigKeySet
	Coordination CacheSettingsCoordinationConfigKeySet
}

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

type CacheSettingsCoordinationConfigKeySet struct {
	// LeaseDuration selects coordination.lease_duration. Set accepts time.Duration.
	LeaseDuration config.Key[CacheSettings, time.Duration]
	// Wait selects coordination.wait. Set accepts time.Duration.
	Wait config.Key[CacheSettings, time.Duration]
}

type CacheSettingsFileConfigKeySet struct {
	// Root selects file.root. Set accepts string.
	Root config.Key[CacheSettings, string]
	// MaxEntries selects file.max_entries. Set accepts int.
	MaxEntries config.Key[CacheSettings, int]
	// MaxBytes selects file.max_bytes. Set accepts int64.
	MaxBytes config.Key[CacheSettings, int64]
	// Sync selects file.sync. Set accepts bool.
	Sync config.Key[CacheSettings, bool]
	// PruneInterval selects file.prune_interval. Set accepts time.Duration.
	PruneInterval config.Key[CacheSettings, time.Duration]
}

type CacheSettingsLeasesConfigKeySet struct {
	Namespace CacheSettingsLeasesNamespaceConfigKeySet
	// MaxActive selects leases.max_active. Set accepts int.
	MaxActive config.Key[CacheSettings, int]
	// MaxDeclarations selects leases.max_declarations. Set accepts int.
	MaxDeclarations config.Key[CacheSettings, int]
	// MaxKeyBytes selects leases.max_key_bytes. Set accepts int.
	MaxKeyBytes config.Key[CacheSettings, int]
	// OperationTimeout selects leases.operation_timeout. Set accepts time.Duration.
	OperationTimeout config.Key[CacheSettings, time.Duration]
	// MaxWait selects leases.max_wait. Set accepts time.Duration.
	MaxWait config.Key[CacheSettings, time.Duration]
	// PollInterval selects leases.poll_interval. Set accepts time.Duration.
	PollInterval config.Key[CacheSettings, time.Duration]
}

type CacheSettingsLeasesNamespaceConfigKeySet struct {
	// Application selects leases.namespace.application. Set accepts string.
	Application config.Key[CacheSettings, string]
	// Environment selects leases.namespace.environment. Set accepts string.
	Environment config.Key[CacheSettings, string]
}

type CacheSettingsMemoryConfigKeySet struct {
	// MaxEntries selects memory.max_entries. Set accepts int.
	MaxEntries config.Key[CacheSettings, int]
	// MaxBytes selects memory.max_bytes. Set accepts int.
	MaxBytes config.Key[CacheSettings, int]
}

type CacheSettingsPostgresConfigKeySet struct {
	// Schema selects postgres.schema. Set accepts string.
	Schema config.Key[CacheSettings, string]
	// MaxEntries selects postgres.max_entries. Set accepts int.
	MaxEntries config.Key[CacheSettings, int]
	// MaxBytes selects postgres.max_bytes. Set accepts int64.
	MaxBytes config.Key[CacheSettings, int64]
	// PruneInterval selects postgres.prune_interval. Set accepts time.Duration.
	PruneInterval config.Key[CacheSettings, time.Duration]
}

type CacheSettingsRequireConfigKeySet struct {
	// Tags selects require.tags. Set accepts bool.
	Tags config.Key[CacheSettings, bool]
	// Counters selects require.counters. Set accepts bool.
	Counters config.Key[CacheSettings, bool]
	// Entries selects require.entries. Set accepts bool.
	Entries config.Key[CacheSettings, bool]
	// Batches selects require.batches. Set accepts bool.
	Batches config.Key[CacheSettings, bool]
	// DistributedFills selects require.distributed_fills. Set accepts bool.
	DistributedFills config.Key[CacheSettings, bool]
}

type CacheStores map[cache.StoreName]CacheSettings

type CachesSettings struct {
	Default cache.StoreName
	Stores  CacheStores
}

type CloudDiskSettings struct {
	Bucket, Region, Endpoint, Namespace, PublicBase string
	Credentials                                     credentials.Name
	PathStyle                                       bool
	PartBytes                                       int64
	MaxUploads, ReadAttempts, PartAttempts          int
	AbortTimeout                                    time.Duration
	PartConcurrency                                 int
	VerifyPublication                               bool
	// AllowHTTP and Compatible apply only to the s3_compatible driver.
	AllowHTTP  bool
	Compatible s3.CompatibleCapabilities
}

type ConnectionSettings struct {
	Primary        PostgreSQLSettings
	ReadEnabled    bool
	Read           PostgreSQLSettings
	MaxConnections int
	// SlowQueryThreshold logs statements at least this slow through the
	// application logger, without SQL text or arguments; zero disables it.
	SlowQueryThreshold time.Duration
	// StickyReadWindow routes reads to the primary for this long after a write
	// in a database.StickyReads request scope; zero disables it.
	StickyReadWindow time.Duration
}

type ConnectionSettingsConfigKeySet struct {
	Primary ConnectionSettingsPrimaryConfigKeySet
	// ReadEnabled selects read_enabled. Set accepts bool.
	ReadEnabled config.Key[ConnectionSettings, bool]
	Read        ConnectionSettingsReadConfigKeySet
	// MaxConnections selects max_connections. Set accepts int.
	MaxConnections config.Key[ConnectionSettings, int]
	// SlowQueryThreshold selects slow_query_threshold. Set accepts time.Duration.
	//
	// SlowQueryThreshold logs statements at least this slow through the
	// application logger, without SQL text or arguments; zero disables it.
	//
	SlowQueryThreshold config.Key[ConnectionSettings, time.Duration]
	// StickyReadWindow selects sticky_read_window. Set accepts time.Duration.
	//
	// StickyReadWindow routes reads to the primary for this long after a write
	// in a database.StickyReads request scope; zero disables it.
	//
	StickyReadWindow config.Key[ConnectionSettings, time.Duration]
}

type ConnectionSettingsPrimaryConfigKeySet struct {
	// Host selects primary.host. Set accepts string.
	Host config.Key[ConnectionSettings, string]
	// Port selects primary.port. Set accepts uint16.
	Port config.Key[ConnectionSettings, uint16]
	// Database selects primary.database. Set accepts string.
	Database config.Key[ConnectionSettings, string]
	// User selects primary.user. Set accepts string.
	User config.Key[ConnectionSettings, string]
	// Schema selects primary.schema. Set accepts string.
	Schema config.Key[ConnectionSettings, string]
	// Password selects primary.password. Set accepts secret.String.
	Password config.Key[ConnectionSettings, secret.String]
	// TLS selects primary.tls. Set accepts postgres.TLSMode.
	TLS config.Key[ConnectionSettings, postgres.TLSMode]
	// ApplicationName selects primary.application_name. Set accepts string.
	ApplicationName config.Key[ConnectionSettings, string]
	Pool            ConnectionSettingsPrimaryPoolConfigKeySet
	// StatementCacheCapacity selects primary.statement_cache_capacity. Set accepts int.
	StatementCacheCapacity config.Key[ConnectionSettings, int]
	// MaxProtocolMessageBytes selects primary.max_protocol_message_bytes. Set accepts int.
	MaxProtocolMessageBytes config.Key[ConnectionSettings, int]
	// StatementTimeout selects primary.statement_timeout. Set accepts time.Duration.
	StatementTimeout config.Key[ConnectionSettings, time.Duration]
	// LockTimeout selects primary.lock_timeout. Set accepts time.Duration.
	LockTimeout config.Key[ConnectionSettings, time.Duration]
	// IdleInTransactionSessionTimeout selects primary.idle_in_transaction_session_timeout. Set accepts time.Duration.
	IdleInTransactionSessionTimeout config.Key[ConnectionSettings, time.Duration]
}

type ConnectionSettingsPrimaryPoolConfigKeySet struct {
	// MaxOpen selects primary.pool.max_open. Set accepts int.
	MaxOpen config.Key[ConnectionSettings, int]
	// MaxIdle selects primary.pool.max_idle. Set accepts int.
	MaxIdle config.Key[ConnectionSettings, int]
	// MaxLifetime selects primary.pool.max_lifetime. Set accepts time.Duration.
	MaxLifetime config.Key[ConnectionSettings, time.Duration]
	// MaxIdleTime selects primary.pool.max_idle_time. Set accepts time.Duration.
	MaxIdleTime config.Key[ConnectionSettings, time.Duration]
	// ConnectTimeout selects primary.pool.connect_timeout. Set accepts time.Duration.
	ConnectTimeout config.Key[ConnectionSettings, time.Duration]
	// AcquireTimeout selects primary.pool.acquire_timeout. Set accepts time.Duration.
	AcquireTimeout config.Key[ConnectionSettings, time.Duration]
	// CommitTimeout selects primary.pool.commit_timeout. Set accepts time.Duration.
	CommitTimeout config.Key[ConnectionSettings, time.Duration]
	// StartupTimeout selects primary.pool.startup_timeout. Set accepts time.Duration.
	StartupTimeout config.Key[ConnectionSettings, time.Duration]
}

type ConnectionSettingsReadConfigKeySet struct {
	// Host selects read.host. Set accepts string.
	Host config.Key[ConnectionSettings, string]
	// Port selects read.port. Set accepts uint16.
	Port config.Key[ConnectionSettings, uint16]
	// Database selects read.database. Set accepts string.
	Database config.Key[ConnectionSettings, string]
	// User selects read.user. Set accepts string.
	User config.Key[ConnectionSettings, string]
	// Schema selects read.schema. Set accepts string.
	Schema config.Key[ConnectionSettings, string]
	// Password selects read.password. Set accepts secret.String.
	Password config.Key[ConnectionSettings, secret.String]
	// TLS selects read.tls. Set accepts postgres.TLSMode.
	TLS config.Key[ConnectionSettings, postgres.TLSMode]
	// ApplicationName selects read.application_name. Set accepts string.
	ApplicationName config.Key[ConnectionSettings, string]
	Pool            ConnectionSettingsReadPoolConfigKeySet
	// StatementCacheCapacity selects read.statement_cache_capacity. Set accepts int.
	StatementCacheCapacity config.Key[ConnectionSettings, int]
	// MaxProtocolMessageBytes selects read.max_protocol_message_bytes. Set accepts int.
	MaxProtocolMessageBytes config.Key[ConnectionSettings, int]
	// StatementTimeout selects read.statement_timeout. Set accepts time.Duration.
	StatementTimeout config.Key[ConnectionSettings, time.Duration]
	// LockTimeout selects read.lock_timeout. Set accepts time.Duration.
	LockTimeout config.Key[ConnectionSettings, time.Duration]
	// IdleInTransactionSessionTimeout selects read.idle_in_transaction_session_timeout. Set accepts time.Duration.
	IdleInTransactionSessionTimeout config.Key[ConnectionSettings, time.Duration]
}

type ConnectionSettingsReadPoolConfigKeySet struct {
	// MaxOpen selects read.pool.max_open. Set accepts int.
	MaxOpen config.Key[ConnectionSettings, int]
	// MaxIdle selects read.pool.max_idle. Set accepts int.
	MaxIdle config.Key[ConnectionSettings, int]
	// MaxLifetime selects read.pool.max_lifetime. Set accepts time.Duration.
	MaxLifetime config.Key[ConnectionSettings, time.Duration]
	// MaxIdleTime selects read.pool.max_idle_time. Set accepts time.Duration.
	MaxIdleTime config.Key[ConnectionSettings, time.Duration]
	// ConnectTimeout selects read.pool.connect_timeout. Set accepts time.Duration.
	ConnectTimeout config.Key[ConnectionSettings, time.Duration]
	// AcquireTimeout selects read.pool.acquire_timeout. Set accepts time.Duration.
	AcquireTimeout config.Key[ConnectionSettings, time.Duration]
	// CommitTimeout selects read.pool.commit_timeout. Set accepts time.Duration.
	CommitTimeout config.Key[ConnectionSettings, time.Duration]
	// StartupTimeout selects read.pool.startup_timeout. Set accepts time.Duration.
	StartupTimeout config.Key[ConnectionSettings, time.Duration]
}

type CoordinationDriver string

type CoordinationSettings struct {
	Enabled    bool
	Driver     CoordinationDriver
	Redis      redis.ConnectionName
	Config     lease.Config
	MaxEntries int
}

type CredentialSources map[credentials.Name]credentials.Settings

type DatabaseConnections map[database.ConnectionName]ConnectionSettings

type DatabaseSettings struct {
	Default        database.ConnectionName
	MaxConnections int
	Connections    DatabaseConnections `config:",secret"`
}

type DiskDriver string

type DiskSettings struct {
	Driver DiskDriver
	Config storage.Config
	Local  LocalDiskSettings
	Cloud  CloudDiskSettings
}

type DiskSettingsCloudCompatibleConfigKeySet struct {
	// ConditionalCreate selects cloud.compatible.conditional_create. Set accepts bool.
	ConditionalCreate config.Key[DiskSettings, bool]
	// ConditionalReplace selects cloud.compatible.conditional_replace. Set accepts bool.
	ConditionalReplace config.Key[DiskSettings, bool]
	// ConditionalDelete selects cloud.compatible.conditional_delete. Set accepts bool.
	ConditionalDelete config.Key[DiskSettings, bool]
	// Versions selects cloud.compatible.versions. Set accepts bool.
	Versions config.Key[DiskSettings, bool]
	// SingleRequestConditions selects cloud.compatible.single_request_conditions. Set accepts bool.
	SingleRequestConditions config.Key[DiskSettings, bool]
	// RequiresNFCKeys selects cloud.compatible.requires_nfc_keys. Set accepts bool.
	RequiresNFCKeys config.Key[DiskSettings, bool]
	// ServerCopy selects cloud.compatible.server_copy. Set accepts bool.
	ServerCopy config.Key[DiskSettings, bool]
	// ListingPathEncoding selects cloud.compatible.listing_path_encoding. Set accepts bool.
	ListingPathEncoding config.Key[DiskSettings, bool]
	// FormUploads selects cloud.compatible.form_uploads. Set accepts bool.
	FormUploads config.Key[DiskSettings, bool]
}

type DiskSettingsCloudConfigKeySet struct {
	// Bucket selects cloud.bucket. Set accepts string.
	Bucket config.Key[DiskSettings, string]
	// Region selects cloud.region. Set accepts string.
	Region config.Key[DiskSettings, string]
	// Endpoint selects cloud.endpoint. Set accepts string.
	Endpoint config.Key[DiskSettings, string]
	// Namespace selects cloud.namespace. Set accepts string.
	Namespace config.Key[DiskSettings, string]
	// PublicBase selects cloud.public_base. Set accepts string.
	PublicBase config.Key[DiskSettings, string]
	// Credentials selects cloud.credentials. Set accepts credentials.Name.
	Credentials config.Key[DiskSettings, credentials.Name]
	// PathStyle selects cloud.path_style. Set accepts bool.
	PathStyle config.Key[DiskSettings, bool]
	// PartBytes selects cloud.part_bytes. Set accepts int64.
	PartBytes config.Key[DiskSettings, int64]
	// MaxUploads selects cloud.max_uploads. Set accepts int.
	MaxUploads config.Key[DiskSettings, int]
	// ReadAttempts selects cloud.read_attempts. Set accepts int.
	ReadAttempts config.Key[DiskSettings, int]
	// PartAttempts selects cloud.part_attempts. Set accepts int.
	PartAttempts config.Key[DiskSettings, int]
	// AbortTimeout selects cloud.abort_timeout. Set accepts time.Duration.
	AbortTimeout config.Key[DiskSettings, time.Duration]
	// PartConcurrency selects cloud.part_concurrency. Set accepts int.
	PartConcurrency config.Key[DiskSettings, int]
	// VerifyPublication selects cloud.verify_publication. Set accepts bool.
	VerifyPublication config.Key[DiskSettings, bool]
	// AllowHTTP selects cloud.allow_http. Set accepts bool.
	//
	// AllowHTTP and Compatible apply only to the s3_compatible driver.
	//
	AllowHTTP  config.Key[DiskSettings, bool]
	Compatible DiskSettingsCloudCompatibleConfigKeySet
}

type DiskSettingsConfigConfigKeySet struct {
	// Visibility selects config.visibility. Set accepts storage.Visibility.
	Visibility config.Key[DiskSettings, storage.Visibility]
	// MaxObjectBytes selects config.max_object_bytes. Set accepts int64.
	MaxObjectBytes config.Key[DiskSettings, int64]
	// MaxActive selects config.max_active. Set accepts int.
	MaxActive config.Key[DiskSettings, int]
	// Timeout selects config.timeout. Set accepts time.Duration.
	Timeout config.Key[DiskSettings, time.Duration]
	// MaxStreams selects config.max_streams. Set accepts int.
	MaxStreams config.Key[DiskSettings, int]
	// StreamIdleTimeout selects config.stream_idle_timeout. Set accepts time.Duration.
	StreamIdleTimeout config.Key[DiskSettings, time.Duration]
}

type DiskSettingsConfigKeySet struct {
	// Driver selects driver. Set accepts DiskDriver.
	Driver config.Key[DiskSettings, DiskDriver]
	Config DiskSettingsConfigConfigKeySet
	Local  DiskSettingsLocalConfigKeySet
	Cloud  DiskSettingsCloudConfigKeySet
}

type DiskSettingsLocalConfigKeySet struct {
	// Root selects local.root. Set accepts string.
	Root config.Key[DiskSettings, string]
	// MaxScan selects local.max_scan. Set accepts int.
	MaxScan config.Key[DiskSettings, int]
	// Sync selects local.sync. Set accepts bool.
	Sync config.Key[DiskSettings, bool]
}

type Disks map[storage.DiskID]DiskSettings

type FileCacheSettings struct {
	Root          string
	MaxEntries    int
	MaxBytes      int64
	Sync          bool
	PruneInterval time.Duration
}

type HTTPClientSettings struct{ Config httpclient.Config }

type HTTPClientSettingsConfigConfigKeySet struct {
	//
	// Destination optionally enforces direct, address-checked outbound networking.
	//
	Destination HTTPClientSettingsConfigDestinationConfigKeySet
	// Name selects config.name. Set accepts httpclient.Name.
	Name config.Key[HTTPClientSettings, httpclient.Name]
	// BaseURL selects config.base_url. Set accepts string.
	BaseURL config.Key[HTTPClientSettings, string]
	// Headers selects config.headers. Set accepts http.Header.
	Headers config.Key[HTTPClientSettings, http.Header]
	// ConnectTimeout selects config.connect_timeout. Set accepts time.Duration.
	ConnectTimeout config.Key[HTTPClientSettings, time.Duration]
	// AttemptTimeout selects config.attempt_timeout. Set accepts time.Duration.
	AttemptTimeout config.Key[HTTPClientSettings, time.Duration]
	// Timeout selects config.timeout. Set accepts time.Duration.
	Timeout config.Key[HTTPClientSettings, time.Duration]
	// Concurrency selects config.concurrency. Set accepts int.
	Concurrency config.Key[HTTPClientSettings, int]
	// RequestBytes selects config.request_bytes. Set accepts int64.
	RequestBytes config.Key[HTTPClientSettings, int64]
	// ResponseBytes selects config.response_bytes. Set accepts int64.
	ResponseBytes config.Key[HTTPClientSettings, int64]
	// HeaderBytes selects config.header_bytes. Set accepts int.
	HeaderBytes config.Key[HTTPClientSettings, int]
	Retry       HTTPClientSettingsConfigRetryConfigKeySet
	// PropagateTrace selects config.propagate_trace. Set accepts bool.
	//
	// PropagateTrace opts this named destination into bounded W3C correlation.
	// When enabled, framework context replaces manual trace headers on the
	// owned request copy. Disabled clients do not add propagation headers.
	//
	PropagateTrace config.Key[HTTPClientSettings, bool]
	//
	// TLS customizes certificate verification and client certificates for the
	// owned transport. A supplied custom transport cannot combine with it.
	//
	TLS HTTPClientSettingsConfigTLSConfigKeySet
}

type HTTPClientSettingsConfigDestinationConfigKeySet struct {
	// Mode selects config.destination.mode. Set accepts httpclient.DestinationMode.
	Mode config.Key[HTTPClientSettings, httpclient.DestinationMode]
	// Schemes selects config.destination.schemes. Set accepts []httpclient.Scheme.
	Schemes config.Key[HTTPClientSettings, []httpclient.Scheme]
	// Ports selects config.destination.ports. Set accepts []uint16.
	Ports config.Key[HTTPClientSettings, []uint16]
	// Hosts selects config.destination.hosts. Set accepts []string.
	Hosts config.Key[HTTPClientSettings, []string]
	// Networks selects config.destination.networks. Set accepts []netip.Prefix.
	Networks config.Key[HTTPClientSettings, []netip.Prefix]
}

type HTTPClientSettingsConfigKeySet struct {
	Config HTTPClientSettingsConfigConfigKeySet
}

type HTTPClientSettingsConfigRetryConfigKeySet struct {
	// Mode selects config.retry.mode. Set accepts httpclient.RetryMode.
	Mode config.Key[HTTPClientSettings, httpclient.RetryMode]
	// Attempts selects config.retry.attempts. Set accepts int.
	Attempts config.Key[HTTPClientSettings, int]
	// InitialBackoff selects config.retry.initial_backoff. Set accepts time.Duration.
	InitialBackoff config.Key[HTTPClientSettings, time.Duration]
	// MaxBackoff selects config.retry.max_backoff. Set accepts time.Duration.
	MaxBackoff config.Key[HTTPClientSettings, time.Duration]
	// Jitter selects config.retry.jitter. Set accepts bool.
	Jitter config.Key[HTTPClientSettings, bool]
	// Statuses selects config.retry.statuses. Set accepts []int.
	Statuses config.Key[HTTPClientSettings, []int]
}

type HTTPClientSettingsConfigTLSConfigKeySet struct {
	// CertificateAuthorities selects config.tls.certificate_authorities. Set accepts string.
	CertificateAuthorities config.Key[HTTPClientSettings, string]
	// AppendSystemRoots selects config.tls.append_system_roots. Set accepts bool.
	AppendSystemRoots config.Key[HTTPClientSettings, bool]
	// Certificate selects config.tls.certificate. Set accepts secret.String.
	Certificate config.Key[HTTPClientSettings, secret.String]
	// PrivateKey selects config.tls.private_key. Set accepts secret.String.
	PrivateKey config.Key[HTTPClientSettings, secret.String]
	// ServerName selects config.tls.server_name. Set accepts string.
	ServerName config.Key[HTTPClientSettings, string]
}

type HTTPClients map[httpclient.Name]HTTPClientSettings

type HTTPClientsSettings struct {
	Default httpclient.Name
	Clients HTTPClients `config:",secret"`
}

type JobConnectionSettings struct {
	Driver       JobDriver
	Redis        redis.ConnectionName
	AllowMemory  bool
	DefaultQueue jobs.Queue
	Dispatch     jobs.DispatchConfig
	Queue        jobs.QueueConfig
}

type JobConnectionSettingsConfigKeySet struct {
	// Driver selects driver. Set accepts JobDriver.
	Driver config.Key[JobConnectionSettings, JobDriver]
	// Redis selects redis. Set accepts redis.ConnectionName.
	Redis config.Key[JobConnectionSettings, redis.ConnectionName]
	// AllowMemory selects allow_memory. Set accepts bool.
	AllowMemory config.Key[JobConnectionSettings, bool]
	// DefaultQueue selects default_queue. Set accepts jobs.Queue.
	DefaultQueue config.Key[JobConnectionSettings, jobs.Queue]
	Dispatch     JobConnectionSettingsDispatchConfigKeySet
	Queue        JobConnectionSettingsQueueConfigKeySet
}

type JobConnectionSettingsDispatchConfigKeySet struct {
	Namespace JobConnectionSettingsDispatchNamespaceConfigKeySet
	// MaxInFlight selects dispatch.max_in_flight. Set accepts int.
	MaxInFlight config.Key[JobConnectionSettings, int]
}

type JobConnectionSettingsDispatchNamespaceConfigKeySet struct {
	// Application selects dispatch.namespace.application. Set accepts string.
	Application config.Key[JobConnectionSettings, string]
	// Environment selects dispatch.namespace.environment. Set accepts string.
	Environment config.Key[JobConnectionSettings, string]
}

type JobConnectionSettingsQueueConfigKeySet struct {
	// MaxEntries selects queue.max_entries. Set accepts int.
	MaxEntries config.Key[JobConnectionSettings, int]
	// MaxBytes selects queue.max_bytes. Set accepts int64.
	MaxBytes config.Key[JobConnectionSettings, int64]
	// MaxHistory selects queue.max_history. Set accepts int.
	MaxHistory config.Key[JobConnectionSettings, int]
	// Retention selects queue.retention. Set accepts time.Duration.
	Retention config.Key[JobConnectionSettings, time.Duration]
	// MaxRetained selects queue.max_retained. Set accepts int.
	MaxRetained config.Key[JobConnectionSettings, int]
}

type JobConnections map[jobs.ConnectionName]JobConnectionSettings

type JobDriver string

type JobsSettings struct {
	Default     jobs.ConnectionName
	Connections JobConnections
}

type LocalDiskSettings struct {
	Root    string
	MaxScan int
	Sync    bool
}

type MailAPISettings struct {
	Endpoint         string
	Timeout          time.Duration
	Token            secret.String
	AccountID        string
	Domain           string
	MessageStream    string
	Region           string
	ConfigurationSet string
	Credentials      credentials.Name
}

type MailDriver string

type MailSettings struct {
	Default email.MailerName
	Mailers Mailers `config:",secret"`
}

type MailerSettings struct {
	Driver         MailDriver
	Config         email.Config
	SMTP           SMTPSettings
	API            MailAPISettings
	MemoryCapacity int
	Transports     []email.MailerName `config:",json"`
}

type MailerSettingsAPIConfigKeySet struct {
	// Endpoint selects api.endpoint. Set accepts string.
	Endpoint config.Key[MailerSettings, string]
	// Timeout selects api.timeout. Set accepts time.Duration.
	Timeout config.Key[MailerSettings, time.Duration]
	// Token selects api.token. Set accepts secret.String.
	Token config.Key[MailerSettings, secret.String]
	// AccountID selects api.account_id. Set accepts string.
	AccountID config.Key[MailerSettings, string]
	// Domain selects api.domain. Set accepts string.
	Domain config.Key[MailerSettings, string]
	// MessageStream selects api.message_stream. Set accepts string.
	MessageStream config.Key[MailerSettings, string]
	// Region selects api.region. Set accepts string.
	Region config.Key[MailerSettings, string]
	// ConfigurationSet selects api.configuration_set. Set accepts string.
	ConfigurationSet config.Key[MailerSettings, string]
	// Credentials selects api.credentials. Set accepts credentials.Name.
	Credentials config.Key[MailerSettings, credentials.Name]
}

type MailerSettingsConfigConfigKeySet struct {
	// From selects config.from. Set accepts email.Address.
	//
	// From supplies Mailer.Message; explicit NewMessage senders are never replaced.
	//
	From config.Key[MailerSettings, email.Address]
	// MaxActive selects config.max_active. Set accepts int.
	MaxActive config.Key[MailerSettings, int]
	// MaxMessageBytes selects config.max_message_bytes. Set accepts int.
	MaxMessageBytes config.Key[MailerSettings, int]
	// MaxAttachmentBytes selects config.max_attachment_bytes. Set accepts int.
	MaxAttachmentBytes config.Key[MailerSettings, int]
	// Timeout selects config.timeout. Set accepts time.Duration.
	Timeout config.Key[MailerSettings, time.Duration]
	// MessageIDDomain selects config.message_id_domain. Set accepts string.
	//
	// MessageIDDomain is the right-hand side of generated Message-ID headers.
	// Empty uses each message's sender domain.
	//
	MessageIDDomain config.Key[MailerSettings, string]
}

type MailerSettingsConfigKeySet struct {
	// Driver selects driver. Set accepts MailDriver.
	Driver config.Key[MailerSettings, MailDriver]
	Config MailerSettingsConfigConfigKeySet
	SMTP   MailerSettingsSMTPConfigKeySet
	API    MailerSettingsAPIConfigKeySet
	// MemoryCapacity selects memory_capacity. Set accepts int.
	MemoryCapacity config.Key[MailerSettings, int]
	// Transports selects transports. Set accepts []email.MailerName.
	Transports config.Key[MailerSettings, []email.MailerName]
}

type MailerSettingsSMTPConfigKeySet struct {
	// Address selects smtp.address. Set accepts string.
	Address config.Key[MailerSettings, string]
	// Security selects smtp.security. Set accepts smtp.Security.
	Security config.Key[MailerSettings, smtp.Security]
	// Username selects smtp.username. Set accepts string.
	Username config.Key[MailerSettings, string]
	// Password selects smtp.password. Set accepts secret.String.
	Password config.Key[MailerSettings, secret.String]
	// Auth selects smtp.auth. Set accepts smtp.Mechanism.
	Auth config.Key[MailerSettings, smtp.Mechanism]
	// LocalName selects smtp.local_name. Set accepts string.
	LocalName config.Key[MailerSettings, string]
	// Timeout selects smtp.timeout. Set accepts time.Duration.
	Timeout config.Key[MailerSettings, time.Duration]
	// MaxIdle selects smtp.max_idle. Set accepts int.
	MaxIdle config.Key[MailerSettings, int]
	// IdleTimeout selects smtp.idle_timeout. Set accepts time.Duration.
	IdleTimeout config.Key[MailerSettings, time.Duration]
}

type Mailers map[email.MailerName]MailerSettings

type MigrationGroup struct {
	Connections []database.ConnectionName
	Schema      string
	Definitions []migrate.Definition
}

type MigrationTarget struct {
	Connection  database.ConnectionName
	Schema      string
	Definitions []migrate.Definition
}

type Option func(*options) error

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

type PostgreSQLSettings struct {
	Host                                            string
	Port                                            uint16
	Database, User                                  string
	Schema                                          string
	Password                                        secret.String
	TLS                                             postgres.TLSMode
	ApplicationName                                 string
	Pool                                            database.PoolConfig
	StatementCacheCapacity, MaxProtocolMessageBytes int
	StatementTimeout                                time.Duration
	LockTimeout                                     time.Duration
	IdleInTransactionSessionTimeout                 time.Duration
}

type PostgresCacheSettings struct {
	Schema        string
	MaxEntries    int
	MaxBytes      int64
	PruneInterval time.Duration
}

type PubSubSettings struct {
	Default     pubsub.ConnectionName
	Connections Brokers
}

type RealtimeConnectionSettings struct {
	Driver  RealtimeDriver
	Redis   redis.ConnectionName
	Cluster websocket.ClusterConfig
}

type RealtimeConnectionSettingsClusterBufferConfigKeySet struct {
	// Messages selects cluster.buffer.messages. Set accepts int.
	Messages config.Key[RealtimeConnectionSettings, int]
	// Bytes selects cluster.buffer.bytes. Set accepts int.
	Bytes config.Key[RealtimeConnectionSettings, int]
	// PayloadBytes selects cluster.buffer.payload_bytes. Set accepts int.
	PayloadBytes config.Key[RealtimeConnectionSettings, int]
	// Channels selects cluster.buffer.channels. Set accepts int.
	Channels config.Key[RealtimeConnectionSettings, int]
}

type RealtimeConnectionSettingsClusterConfigKeySet struct {
	Namespace RealtimeConnectionSettingsClusterNamespaceConfigKeySet
	// MaxConnections selects cluster.max_connections. Set accepts int.
	MaxConnections config.Key[RealtimeConnectionSettings, int]
	// MaxConnectionsPerSubject selects cluster.max_connections_per_subject. Set accepts int.
	MaxConnectionsPerSubject config.Key[RealtimeConnectionSettings, int]
	// ConnectionTTL selects cluster.connection_ttl. Set accepts time.Duration.
	ConnectionTTL config.Key[RealtimeConnectionSettings, time.Duration]
	// OperationTimeout selects cluster.operation_timeout. Set accepts time.Duration.
	OperationTimeout config.Key[RealtimeConnectionSettings, time.Duration]
	Buffer           RealtimeConnectionSettingsClusterBufferConfigKeySet
	// RetainConnectionsOnGap selects cluster.retain_connections_on_gap. Set accepts bool.
	//
	// RetainConnectionsOnGap keeps local sockets open across a lost fan-out
	// stream; events published during the gap are then missed silently. The
	// default closes them with a retryable status so clients reconnect and
	// request replay.
	//
	RetainConnectionsOnGap config.Key[RealtimeConnectionSettings, bool]
	// ExcludeRemoteConnections selects cluster.exclude_remote_connections. Set accepts bool.
	//
	// ExcludeRemoteConnections lets ExceptConnection name a connection hosted
	// by another instance by carrying the exclusion in the fan-out envelope.
	// Instances before this field reject such envelopes, so enable it only
	// once every instance in the namespace runs a release that has it.
	// Excluding a connection of this instance (RelayToOthers) never needs it.
	//
	ExcludeRemoteConnections config.Key[RealtimeConnectionSettings, bool]
}

type RealtimeConnectionSettingsClusterNamespaceConfigKeySet struct {
	// Application selects cluster.namespace.application. Set accepts string.
	Application config.Key[RealtimeConnectionSettings, string]
	// Environment selects cluster.namespace.environment. Set accepts string.
	Environment config.Key[RealtimeConnectionSettings, string]
}

type RealtimeConnectionSettingsConfigKeySet struct {
	// Driver selects driver. Set accepts RealtimeDriver.
	Driver config.Key[RealtimeConnectionSettings, RealtimeDriver]
	// Redis selects redis. Set accepts redis.ConnectionName.
	Redis   config.Key[RealtimeConnectionSettings, redis.ConnectionName]
	Cluster RealtimeConnectionSettingsClusterConfigKeySet
}

type RealtimeConnections map[websocket.ConnectionName]RealtimeConnectionSettings

type RealtimeDriver string

type RealtimeSettings struct {
	Default     websocket.ConnectionName
	Connections RealtimeConnections
}

type RedisConnectionInventory struct {
	Connection redis.ConnectionName `json:"connection"`
	Keys       []RedisKeySpace      `json:"keys"`
	Channels   []RedisKeySpace      `json:"channels"`
}

type RedisConnectionSettings struct {
	Host                                                                    string
	Port                                                                    uint16
	Database                                                                int
	User                                                                    string
	Password                                                                secret.String
	TLS                                                                     redis.TLSMode
	MaxConnections, MaxOperations, MaxSubscriptions                         int
	ConnectTimeout, OperationTimeout, PoolTimeout, MaxIdleTime, MaxLifetime time.Duration
	MaxValueBytes                                                           int
}

type RedisConnectionSettingsConfigKeySet struct {
	// Host selects host. Set accepts string.
	Host config.Key[RedisConnectionSettings, string]
	// Port selects port. Set accepts uint16.
	Port config.Key[RedisConnectionSettings, uint16]
	// Database selects database. Set accepts int.
	Database config.Key[RedisConnectionSettings, int]
	// User selects user. Set accepts string.
	User config.Key[RedisConnectionSettings, string]
	// Password selects password. Set accepts secret.String.
	Password config.Key[RedisConnectionSettings, secret.String]
	// TLS selects tls. Set accepts redis.TLSMode.
	TLS config.Key[RedisConnectionSettings, redis.TLSMode]
	// MaxConnections selects max_connections. Set accepts int.
	MaxConnections config.Key[RedisConnectionSettings, int]
	// MaxOperations selects max_operations. Set accepts int.
	MaxOperations config.Key[RedisConnectionSettings, int]
	// MaxSubscriptions selects max_subscriptions. Set accepts int.
	MaxSubscriptions config.Key[RedisConnectionSettings, int]
	// ConnectTimeout selects connect_timeout. Set accepts time.Duration.
	ConnectTimeout config.Key[RedisConnectionSettings, time.Duration]
	// OperationTimeout selects operation_timeout. Set accepts time.Duration.
	OperationTimeout config.Key[RedisConnectionSettings, time.Duration]
	// PoolTimeout selects pool_timeout. Set accepts time.Duration.
	PoolTimeout config.Key[RedisConnectionSettings, time.Duration]
	// MaxIdleTime selects max_idle_time. Set accepts time.Duration.
	MaxIdleTime config.Key[RedisConnectionSettings, time.Duration]
	// MaxLifetime selects max_lifetime. Set accepts time.Duration.
	MaxLifetime config.Key[RedisConnectionSettings, time.Duration]
	// MaxValueBytes selects max_value_bytes. Set accepts int.
	MaxValueBytes config.Key[RedisConnectionSettings, int]
}

type RedisConnections map[redis.ConnectionName]RedisConnectionSettings

type RedisKeySpace struct {
	Feature   keyspace.Feature   `json:"feature"`
	Namespace keyspace.Namespace `json:"namespace"`
	Version   string             `json:"version"`
	Prefix    string             `json:"prefix"`
}

type RedisSettings struct {
	Default        redis.ConnectionName
	MaxConnections int
	Connections    RedisConnections `config:",secret"`
}

type RedisStore interface {
	// contains filtered or unexported methods
}

type SMTPSettings struct {
	Address     string
	Security    smtp.Security
	Username    string
	Password    secret.String
	Auth        smtp.Mechanism
	LocalName   string
	Timeout     time.Duration
	MaxIdle     int
	IdleTimeout time.Duration
}

type Services struct {
	Databases    *database.Connections
	Redis        *redis.Connections
	Storage      *storage.Registry
	Caches       *cache.Stores
	Mailers      *email.Mailers
	Jobs         *jobs.Connections
	HTTPClients  *httpclient.Clients
	Brokers      *pubsub.Brokers
	Realtime     *websocket.Connections
	Coordination *lease.Manager
}

type Settings struct {
	Namespace    keyspace.Namespace
	Database     DatabaseSettings
	Redis        RedisSettings
	Storage      StorageSettings
	Cache        CachesSettings
	Mail         MailSettings
	Jobs         JobsSettings
	HTTPClients  HTTPClientsSettings
	PubSub       PubSubSettings
	Realtime     RealtimeSettings
	Coordination CoordinationSettings
	Credentials  CredentialSources `config:",secret"`
}

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

type SettingsConfigKeySet struct {
	Namespace    SettingsNamespaceConfigKeySet
	Database     SettingsDatabaseConfigKeySet
	Redis        SettingsRedisConfigKeySet
	Storage      SettingsStorageConfigKeySet
	Cache        SettingsCacheConfigKeySet
	Mail         SettingsMailConfigKeySet
	Jobs         SettingsJobsConfigKeySet
	HTTPClients  SettingsHTTPClientsConfigKeySet
	PubSub       SettingsPubSubConfigKeySet
	Realtime     SettingsRealtimeConfigKeySet
	Coordination SettingsCoordinationConfigKeySet
	// Credentials selects credentials. Set accepts CredentialSources.
	Credentials config.Key[Settings, CredentialSources]
}

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

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

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

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

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

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

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

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

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

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

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

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

type StorageSettings struct {
	Default storage.DiskID
	Disks   Disks
}