github.com/palantir/witchcraft-go-server/v2@v2.76.0/config/zz_generated_refreshables.go

// Generated by godel-refreshable-plugin: do not edit.

package config

import (
	httpclient "github.com/palantir/conjure-go-runtime/v2/conjure-go-client/httpclient"
	refreshable "github.com/palantir/pkg/refreshable"
	wlog "github.com/palantir/witchcraft-go-logging/wlog"
)

type RefreshableRuntime interface {
	refreshable.Refreshable
	CurrentRuntime() Runtime
	MapRuntime(func(Runtime) interface{}) refreshable.Refreshable
	SubscribeToRuntime(func(Runtime)) (unsubscribe func())

	DiagnosticsConfig() RefreshableDiagnosticsConfig
	HealthChecks() RefreshableHealthChecksConfig
	LoggerConfig() RefreshableLoggerConfigPtr
	ServiceDiscovery() RefreshableServicesConfig
}

type RefreshingRuntime struct {
	refreshable.Refreshable
}

func NewRefreshingRuntime(in refreshable.Refreshable) RefreshingRuntime {
	return RefreshingRuntime{Refreshable: in}
}

func (r RefreshingRuntime) CurrentRuntime() Runtime {
	return r.Current().(Runtime)
}

func (r RefreshingRuntime) MapRuntime(mapFn func(Runtime) interface{}) refreshable.Refreshable {
	return r.Map(func(i interface{}) interface{} {
		return mapFn(i.(Runtime))
	})
}

func (r RefreshingRuntime) SubscribeToRuntime(consumer func(Runtime)) (unsubscribe func()) {
	return r.Subscribe(func(i interface{}) {
		consumer(i.(Runtime))
	})
}

func (r RefreshingRuntime) DiagnosticsConfig() RefreshableDiagnosticsConfig {
	return NewRefreshingDiagnosticsConfig(r.MapRuntime(func(i Runtime) interface{} {
		return i.DiagnosticsConfig
	}))
}

func (r RefreshingRuntime) HealthChecks() RefreshableHealthChecksConfig {
	return NewRefreshingHealthChecksConfig(r.MapRuntime(func(i Runtime) interface{} {
		return i.HealthChecks
	}))
}

func (r RefreshingRuntime) LoggerConfig() RefreshableLoggerConfigPtr {
	return NewRefreshingLoggerConfigPtr(r.MapRuntime(func(i Runtime) interface{} {
		return i.LoggerConfig
	}))
}

func (r RefreshingRuntime) ServiceDiscovery() RefreshableServicesConfig {
	return NewRefreshingServicesConfig(r.MapRuntime(func(i Runtime) interface{} {
		return i.ServiceDiscovery
	}))
}

type RefreshableDiagnosticsConfig interface {
	refreshable.Refreshable
	CurrentDiagnosticsConfig() DiagnosticsConfig
	MapDiagnosticsConfig(func(DiagnosticsConfig) interface{}) refreshable.Refreshable
	SubscribeToDiagnosticsConfig(func(DiagnosticsConfig)) (unsubscribe func())

	DebugSharedSecret() refreshable.String
	DebugSharedSecretFile() refreshable.String
}

type RefreshingDiagnosticsConfig struct {
	refreshable.Refreshable
}

func NewRefreshingDiagnosticsConfig(in refreshable.Refreshable) RefreshingDiagnosticsConfig {
	return RefreshingDiagnosticsConfig{Refreshable: in}
}

func (r RefreshingDiagnosticsConfig) CurrentDiagnosticsConfig() DiagnosticsConfig {
	return r.Current().(DiagnosticsConfig)
}

func (r RefreshingDiagnosticsConfig) MapDiagnosticsConfig(mapFn func(DiagnosticsConfig) interface{}) refreshable.Refreshable {
	return r.Map(func(i interface{}) interface{} {
		return mapFn(i.(DiagnosticsConfig))
	})
}

func (r RefreshingDiagnosticsConfig) SubscribeToDiagnosticsConfig(consumer func(DiagnosticsConfig)) (unsubscribe func()) {
	return r.Subscribe(func(i interface{}) {
		consumer(i.(DiagnosticsConfig))
	})
}

func (r RefreshingDiagnosticsConfig) DebugSharedSecret() refreshable.String {
	return refreshable.NewString(r.MapDiagnosticsConfig(func(i DiagnosticsConfig) interface{} {
		return i.DebugSharedSecret
	}))
}

func (r RefreshingDiagnosticsConfig) DebugSharedSecretFile() refreshable.String {
	return refreshable.NewString(r.MapDiagnosticsConfig(func(i DiagnosticsConfig) interface{} {
		return i.DebugSharedSecretFile
	}))
}

type RefreshableHealthChecksConfig interface {
	refreshable.Refreshable
	CurrentHealthChecksConfig() HealthChecksConfig
	MapHealthChecksConfig(func(HealthChecksConfig) interface{}) refreshable.Refreshable
	SubscribeToHealthChecksConfig(func(HealthChecksConfig)) (unsubscribe func())

	SharedSecret() refreshable.String
}

type RefreshingHealthChecksConfig struct {
	refreshable.Refreshable
}

func NewRefreshingHealthChecksConfig(in refreshable.Refreshable) RefreshingHealthChecksConfig {
	return RefreshingHealthChecksConfig{Refreshable: in}
}

func (r RefreshingHealthChecksConfig) CurrentHealthChecksConfig() HealthChecksConfig {
	return r.Current().(HealthChecksConfig)
}

func (r RefreshingHealthChecksConfig) MapHealthChecksConfig(mapFn func(HealthChecksConfig) interface{}) refreshable.Refreshable {
	return r.Map(func(i interface{}) interface{} {
		return mapFn(i.(HealthChecksConfig))
	})
}

func (r RefreshingHealthChecksConfig) SubscribeToHealthChecksConfig(consumer func(HealthChecksConfig)) (unsubscribe func()) {
	return r.Subscribe(func(i interface{}) {
		consumer(i.(HealthChecksConfig))
	})
}

func (r RefreshingHealthChecksConfig) SharedSecret() refreshable.String {
	return refreshable.NewString(r.MapHealthChecksConfig(func(i HealthChecksConfig) interface{} {
		return i.SharedSecret
	}))
}

type RefreshableLoggerConfigPtr interface {
	refreshable.Refreshable
	CurrentLoggerConfigPtr() *LoggerConfig
	MapLoggerConfigPtr(func(*LoggerConfig) interface{}) refreshable.Refreshable
	SubscribeToLoggerConfigPtr(func(*LoggerConfig)) (unsubscribe func())

	Level() RefreshableLogLevel
}

type RefreshingLoggerConfigPtr struct {
	refreshable.Refreshable
}

func NewRefreshingLoggerConfigPtr(in refreshable.Refreshable) RefreshingLoggerConfigPtr {
	return RefreshingLoggerConfigPtr{Refreshable: in}
}

func (r RefreshingLoggerConfigPtr) CurrentLoggerConfigPtr() *LoggerConfig {
	return r.Current().(*LoggerConfig)
}

func (r RefreshingLoggerConfigPtr) MapLoggerConfigPtr(mapFn func(*LoggerConfig) interface{}) refreshable.Refreshable {
	return r.Map(func(i interface{}) interface{} {
		return mapFn(i.(*LoggerConfig))
	})
}

func (r RefreshingLoggerConfigPtr) SubscribeToLoggerConfigPtr(consumer func(*LoggerConfig)) (unsubscribe func()) {
	return r.Subscribe(func(i interface{}) {
		consumer(i.(*LoggerConfig))
	})
}

func (r RefreshingLoggerConfigPtr) Level() RefreshableLogLevel {
	return NewRefreshingLogLevel(r.MapLoggerConfigPtr(func(i *LoggerConfig) interface{} {
		return i.Level
	}))
}

type RefreshableLoggerConfig interface {
	refreshable.Refreshable
	CurrentLoggerConfig() LoggerConfig
	MapLoggerConfig(func(LoggerConfig) interface{}) refreshable.Refreshable
	SubscribeToLoggerConfig(func(LoggerConfig)) (unsubscribe func())

	Level() RefreshableLogLevel
}

type RefreshingLoggerConfig struct {
	refreshable.Refreshable
}

func NewRefreshingLoggerConfig(in refreshable.Refreshable) RefreshingLoggerConfig {
	return RefreshingLoggerConfig{Refreshable: in}
}

func (r RefreshingLoggerConfig) CurrentLoggerConfig() LoggerConfig {
	return r.Current().(LoggerConfig)
}

func (r RefreshingLoggerConfig) MapLoggerConfig(mapFn func(LoggerConfig) interface{}) refreshable.Refreshable {
	return r.Map(func(i interface{}) interface{} {
		return mapFn(i.(LoggerConfig))
	})
}

func (r RefreshingLoggerConfig) SubscribeToLoggerConfig(consumer func(LoggerConfig)) (unsubscribe func()) {
	return r.Subscribe(func(i interface{}) {
		consumer(i.(LoggerConfig))
	})
}

func (r RefreshingLoggerConfig) Level() RefreshableLogLevel {
	return NewRefreshingLogLevel(r.MapLoggerConfig(func(i LoggerConfig) interface{} {
		return i.Level
	}))
}

type RefreshableLogLevel interface {
	refreshable.Refreshable
	CurrentLogLevel() wlog.LogLevel
	MapLogLevel(func(wlog.LogLevel) interface{}) refreshable.Refreshable
	SubscribeToLogLevel(func(wlog.LogLevel)) (unsubscribe func())
}

type RefreshingLogLevel struct {
	refreshable.Refreshable
}

func NewRefreshingLogLevel(in refreshable.Refreshable) RefreshingLogLevel {
	return RefreshingLogLevel{Refreshable: in}
}

func (r RefreshingLogLevel) CurrentLogLevel() wlog.LogLevel {
	return r.Current().(wlog.LogLevel)
}

func (r RefreshingLogLevel) MapLogLevel(mapFn func(wlog.LogLevel) interface{}) refreshable.Refreshable {
	return r.Map(func(i interface{}) interface{} {
		return mapFn(i.(wlog.LogLevel))
	})
}

func (r RefreshingLogLevel) SubscribeToLogLevel(consumer func(wlog.LogLevel)) (unsubscribe func()) {
	return r.Subscribe(func(i interface{}) {
		consumer(i.(wlog.LogLevel))
	})
}

type RefreshableServicesConfig interface {
	refreshable.Refreshable
	CurrentServicesConfig() httpclient.ServicesConfig
	MapServicesConfig(func(httpclient.ServicesConfig) interface{}) refreshable.Refreshable
	SubscribeToServicesConfig(func(httpclient.ServicesConfig)) (unsubscribe func())

	Default() RefreshableClientConfig
	Services() RefreshableStringToClientConfig
}

type RefreshingServicesConfig struct {
	refreshable.Refreshable
}

func NewRefreshingServicesConfig(in refreshable.Refreshable) RefreshingServicesConfig {
	return RefreshingServicesConfig{Refreshable: in}
}

func (r RefreshingServicesConfig) CurrentServicesConfig() httpclient.ServicesConfig {
	return r.Current().(httpclient.ServicesConfig)
}

func (r RefreshingServicesConfig) MapServicesConfig(mapFn func(httpclient.ServicesConfig) interface{}) refreshable.Refreshable {
	return r.Map(func(i interface{}) interface{} {
		return mapFn(i.(httpclient.ServicesConfig))
	})
}

func (r RefreshingServicesConfig) SubscribeToServicesConfig(consumer func(httpclient.ServicesConfig)) (unsubscribe func()) {
	return r.Subscribe(func(i interface{}) {
		consumer(i.(httpclient.ServicesConfig))
	})
}

func (r RefreshingServicesConfig) Default() RefreshableClientConfig {
	return NewRefreshingClientConfig(r.MapServicesConfig(func(i httpclient.ServicesConfig) interface{} {
		return i.Default
	}))
}

func (r RefreshingServicesConfig) Services() RefreshableStringToClientConfig {
	return NewRefreshingStringToClientConfig(r.MapServicesConfig(func(i httpclient.ServicesConfig) interface{} {
		return i.Services
	}))
}

type RefreshableClientConfig interface {
	refreshable.Refreshable
	CurrentClientConfig() httpclient.ClientConfig
	MapClientConfig(func(httpclient.ClientConfig) interface{}) refreshable.Refreshable
	SubscribeToClientConfig(func(httpclient.ClientConfig)) (unsubscribe func())

	ServiceName() refreshable.String
	URIs() refreshable.StringSlice
	APIToken() refreshable.StringPtr
	APITokenFile() refreshable.StringPtr
	BasicAuth() RefreshableBasicAuthPtr
	DisableHTTP2() refreshable.BoolPtr
	ProxyFromEnvironment() refreshable.BoolPtr
	ProxyURL() refreshable.StringPtr
	MaxNumRetries() refreshable.IntPtr
	InitialBackoff() refreshable.DurationPtr
	MaxBackoff() refreshable.DurationPtr
	ConnectTimeout() refreshable.DurationPtr
	ReadTimeout() refreshable.DurationPtr
	WriteTimeout() refreshable.DurationPtr
	IdleConnTimeout() refreshable.DurationPtr
	TLSHandshakeTimeout() refreshable.DurationPtr
	ExpectContinueTimeout() refreshable.DurationPtr
	HTTP2ReadIdleTimeout() refreshable.DurationPtr
	HTTP2PingTimeout() refreshable.DurationPtr
	MaxIdleConns() refreshable.IntPtr
	MaxIdleConnsPerHost() refreshable.IntPtr
	Metrics() RefreshableMetricsConfig
	Security() RefreshableSecurityConfig
}

type RefreshingClientConfig struct {
	refreshable.Refreshable
}

func NewRefreshingClientConfig(in refreshable.Refreshable) RefreshingClientConfig {
	return RefreshingClientConfig{Refreshable: in}
}

func (r RefreshingClientConfig) CurrentClientConfig() httpclient.ClientConfig {
	return r.Current().(httpclient.ClientConfig)
}

func (r RefreshingClientConfig) MapClientConfig(mapFn func(httpclient.ClientConfig) interface{}) refreshable.Refreshable {
	return r.Map(func(i interface{}) interface{} {
		return mapFn(i.(httpclient.ClientConfig))
	})
}

func (r RefreshingClientConfig) SubscribeToClientConfig(consumer func(httpclient.ClientConfig)) (unsubscribe func()) {
	return r.Subscribe(func(i interface{}) {
		consumer(i.(httpclient.ClientConfig))
	})
}

func (r RefreshingClientConfig) ServiceName() refreshable.String {
	return refreshable.NewString(r.MapClientConfig(func(i httpclient.ClientConfig) interface{} {
		return i.ServiceName
	}))
}

func (r RefreshingClientConfig) URIs() refreshable.StringSlice {
	return refreshable.NewStringSlice(r.MapClientConfig(func(i httpclient.ClientConfig) interface{} {
		return i.URIs
	}))
}

func (r RefreshingClientConfig) APIToken() refreshable.StringPtr {
	return refreshable.NewStringPtr(r.MapClientConfig(func(i httpclient.ClientConfig) interface{} {
		return i.APIToken
	}))
}

func (r RefreshingClientConfig) APITokenFile() refreshable.StringPtr {
	return refreshable.NewStringPtr(r.MapClientConfig(func(i httpclient.ClientConfig) interface{} {
		return i.APITokenFile
	}))
}

func (r RefreshingClientConfig) BasicAuth() RefreshableBasicAuthPtr {
	return NewRefreshingBasicAuthPtr(r.MapClientConfig(func(i httpclient.ClientConfig) interface{} {
		return i.BasicAuth
	}))
}

func (r RefreshingClientConfig) DisableHTTP2() refreshable.BoolPtr {
	return refreshable.NewBoolPtr(r.MapClientConfig(func(i httpclient.ClientConfig) interface{} {
		return i.DisableHTTP2
	}))
}

func (r RefreshingClientConfig) ProxyFromEnvironment() refreshable.BoolPtr {
	return refreshable.NewBoolPtr(r.MapClientConfig(func(i httpclient.ClientConfig) interface{} {
		return i.ProxyFromEnvironment
	}))
}

func (r RefreshingClientConfig) ProxyURL() refreshable.StringPtr {
	return refreshable.NewStringPtr(r.MapClientConfig(func(i httpclient.ClientConfig) interface{} {
		return i.ProxyURL
	}))
}

func (r RefreshingClientConfig) MaxNumRetries() refreshable.IntPtr {
	return refreshable.NewIntPtr(r.MapClientConfig(func(i httpclient.ClientConfig) interface{} {
		return i.MaxNumRetries
	}))
}

func (r RefreshingClientConfig) InitialBackoff() refreshable.DurationPtr {
	return refreshable.NewDurationPtr(r.MapClientConfig(func(i httpclient.ClientConfig) interface{} {
		return i.InitialBackoff
	}))
}

func (r RefreshingClientConfig) MaxBackoff() refreshable.DurationPtr {
	return refreshable.NewDurationPtr(r.MapClientConfig(func(i httpclient.ClientConfig) interface{} {
		return i.MaxBackoff
	}))
}

func (r RefreshingClientConfig) ConnectTimeout() refreshable.DurationPtr {
	return refreshable.NewDurationPtr(r.MapClientConfig(func(i httpclient.ClientConfig) interface{} {
		return i.ConnectTimeout
	}))
}

func (r RefreshingClientConfig) ReadTimeout() refreshable.DurationPtr {
	return refreshable.NewDurationPtr(r.MapClientConfig(func(i httpclient.ClientConfig) interface{} {
		return i.ReadTimeout
	}))
}

func (r RefreshingClientConfig) WriteTimeout() refreshable.DurationPtr {
	return refreshable.NewDurationPtr(r.MapClientConfig(func(i httpclient.ClientConfig) interface{} {
		return i.WriteTimeout
	}))
}

func (r RefreshingClientConfig) IdleConnTimeout() refreshable.DurationPtr {
	return refreshable.NewDurationPtr(r.MapClientConfig(func(i httpclient.ClientConfig) interface{} {
		return i.IdleConnTimeout
	}))
}

func (r RefreshingClientConfig) TLSHandshakeTimeout() refreshable.DurationPtr {
	return refreshable.NewDurationPtr(r.MapClientConfig(func(i httpclient.ClientConfig) interface{} {
		return i.TLSHandshakeTimeout
	}))
}

func (r RefreshingClientConfig) ExpectContinueTimeout() refreshable.DurationPtr {
	return refreshable.NewDurationPtr(r.MapClientConfig(func(i httpclient.ClientConfig) interface{} {
		return i.ExpectContinueTimeout
	}))
}

func (r RefreshingClientConfig) HTTP2ReadIdleTimeout() refreshable.DurationPtr {
	return refreshable.NewDurationPtr(r.MapClientConfig(func(i httpclient.ClientConfig) interface{} {
		return i.HTTP2ReadIdleTimeout
	}))
}

func (r RefreshingClientConfig) HTTP2PingTimeout() refreshable.DurationPtr {
	return refreshable.NewDurationPtr(r.MapClientConfig(func(i httpclient.ClientConfig) interface{} {
		return i.HTTP2PingTimeout
	}))
}

func (r RefreshingClientConfig) MaxIdleConns() refreshable.IntPtr {
	return refreshable.NewIntPtr(r.MapClientConfig(func(i httpclient.ClientConfig) interface{} {
		return i.MaxIdleConns
	}))
}

func (r RefreshingClientConfig) MaxIdleConnsPerHost() refreshable.IntPtr {
	return refreshable.NewIntPtr(r.MapClientConfig(func(i httpclient.ClientConfig) interface{} {
		return i.MaxIdleConnsPerHost
	}))
}

func (r RefreshingClientConfig) Metrics() RefreshableMetricsConfig {
	return NewRefreshingMetricsConfig(r.MapClientConfig(func(i httpclient.ClientConfig) interface{} {
		return i.Metrics
	}))
}

func (r RefreshingClientConfig) Security() RefreshableSecurityConfig {
	return NewRefreshingSecurityConfig(r.MapClientConfig(func(i httpclient.ClientConfig) interface{} {
		return i.Security
	}))
}

type RefreshableBasicAuthPtr interface {
	refreshable.Refreshable
	CurrentBasicAuthPtr() *httpclient.BasicAuth
	MapBasicAuthPtr(func(*httpclient.BasicAuth) interface{}) refreshable.Refreshable
	SubscribeToBasicAuthPtr(func(*httpclient.BasicAuth)) (unsubscribe func())

	User() refreshable.String
	Password() refreshable.String
}

type RefreshingBasicAuthPtr struct {
	refreshable.Refreshable
}

func NewRefreshingBasicAuthPtr(in refreshable.Refreshable) RefreshingBasicAuthPtr {
	return RefreshingBasicAuthPtr{Refreshable: in}
}

func (r RefreshingBasicAuthPtr) CurrentBasicAuthPtr() *httpclient.BasicAuth {
	return r.Current().(*httpclient.BasicAuth)
}

func (r RefreshingBasicAuthPtr) MapBasicAuthPtr(mapFn func(*httpclient.BasicAuth) interface{}) refreshable.Refreshable {
	return r.Map(func(i interface{}) interface{} {
		return mapFn(i.(*httpclient.BasicAuth))
	})
}

func (r RefreshingBasicAuthPtr) SubscribeToBasicAuthPtr(consumer func(*httpclient.BasicAuth)) (unsubscribe func()) {
	return r.Subscribe(func(i interface{}) {
		consumer(i.(*httpclient.BasicAuth))
	})
}

func (r RefreshingBasicAuthPtr) User() refreshable.String {
	return refreshable.NewString(r.MapBasicAuthPtr(func(i *httpclient.BasicAuth) interface{} {
		return i.User
	}))
}

func (r RefreshingBasicAuthPtr) Password() refreshable.String {
	return refreshable.NewString(r.MapBasicAuthPtr(func(i *httpclient.BasicAuth) interface{} {
		return i.Password
	}))
}

type RefreshableBasicAuth interface {
	refreshable.Refreshable
	CurrentBasicAuth() httpclient.BasicAuth
	MapBasicAuth(func(httpclient.BasicAuth) interface{}) refreshable.Refreshable
	SubscribeToBasicAuth(func(httpclient.BasicAuth)) (unsubscribe func())

	User() refreshable.String
	Password() refreshable.String
}

type RefreshingBasicAuth struct {
	refreshable.Refreshable
}

func NewRefreshingBasicAuth(in refreshable.Refreshable) RefreshingBasicAuth {
	return RefreshingBasicAuth{Refreshable: in}
}

func (r RefreshingBasicAuth) CurrentBasicAuth() httpclient.BasicAuth {
	return r.Current().(httpclient.BasicAuth)
}

func (r RefreshingBasicAuth) MapBasicAuth(mapFn func(httpclient.BasicAuth) interface{}) refreshable.Refreshable {
	return r.Map(func(i interface{}) interface{} {
		return mapFn(i.(httpclient.BasicAuth))
	})
}

func (r RefreshingBasicAuth) SubscribeToBasicAuth(consumer func(httpclient.BasicAuth)) (unsubscribe func()) {
	return r.Subscribe(func(i interface{}) {
		consumer(i.(httpclient.BasicAuth))
	})
}

func (r RefreshingBasicAuth) User() refreshable.String {
	return refreshable.NewString(r.MapBasicAuth(func(i httpclient.BasicAuth) interface{} {
		return i.User
	}))
}

func (r RefreshingBasicAuth) Password() refreshable.String {
	return refreshable.NewString(r.MapBasicAuth(func(i httpclient.BasicAuth) interface{} {
		return i.Password
	}))
}

type RefreshableMetricsConfig interface {
	refreshable.Refreshable
	CurrentMetricsConfig() httpclient.MetricsConfig
	MapMetricsConfig(func(httpclient.MetricsConfig) interface{}) refreshable.Refreshable
	SubscribeToMetricsConfig(func(httpclient.MetricsConfig)) (unsubscribe func())

	Enabled() refreshable.BoolPtr
	Tags() RefreshableStringToString
}

type RefreshingMetricsConfig struct {
	refreshable.Refreshable
}

func NewRefreshingMetricsConfig(in refreshable.Refreshable) RefreshingMetricsConfig {
	return RefreshingMetricsConfig{Refreshable: in}
}

func (r RefreshingMetricsConfig) CurrentMetricsConfig() httpclient.MetricsConfig {
	return r.Current().(httpclient.MetricsConfig)
}

func (r RefreshingMetricsConfig) MapMetricsConfig(mapFn func(httpclient.MetricsConfig) interface{}) refreshable.Refreshable {
	return r.Map(func(i interface{}) interface{} {
		return mapFn(i.(httpclient.MetricsConfig))
	})
}

func (r RefreshingMetricsConfig) SubscribeToMetricsConfig(consumer func(httpclient.MetricsConfig)) (unsubscribe func()) {
	return r.Subscribe(func(i interface{}) {
		consumer(i.(httpclient.MetricsConfig))
	})
}

func (r RefreshingMetricsConfig) Enabled() refreshable.BoolPtr {
	return refreshable.NewBoolPtr(r.MapMetricsConfig(func(i httpclient.MetricsConfig) interface{} {
		return i.Enabled
	}))
}

func (r RefreshingMetricsConfig) Tags() RefreshableStringToString {
	return NewRefreshingStringToString(r.MapMetricsConfig(func(i httpclient.MetricsConfig) interface{} {
		return i.Tags
	}))
}

type RefreshableStringToString interface {
	refreshable.Refreshable
	CurrentStringToString() map[string]string
	MapStringToString(func(map[string]string) interface{}) refreshable.Refreshable
	SubscribeToStringToString(func(map[string]string)) (unsubscribe func())
}

type RefreshingStringToString struct {
	refreshable.Refreshable
}

func NewRefreshingStringToString(in refreshable.Refreshable) RefreshingStringToString {
	return RefreshingStringToString{Refreshable: in}
}

func (r RefreshingStringToString) CurrentStringToString() map[string]string {
	return r.Current().(map[string]string)
}

func (r RefreshingStringToString) MapStringToString(mapFn func(map[string]string) interface{}) refreshable.Refreshable {
	return r.Map(func(i interface{}) interface{} {
		return mapFn(i.(map[string]string))
	})
}

func (r RefreshingStringToString) SubscribeToStringToString(consumer func(map[string]string)) (unsubscribe func()) {
	return r.Subscribe(func(i interface{}) {
		consumer(i.(map[string]string))
	})
}

type RefreshableSecurityConfig interface {
	refreshable.Refreshable
	CurrentSecurityConfig() httpclient.SecurityConfig
	MapSecurityConfig(func(httpclient.SecurityConfig) interface{}) refreshable.Refreshable
	SubscribeToSecurityConfig(func(httpclient.SecurityConfig)) (unsubscribe func())

	CAFiles() refreshable.StringSlice
	CertFile() refreshable.String
	KeyFile() refreshable.String
}

type RefreshingSecurityConfig struct {
	refreshable.Refreshable
}

func NewRefreshingSecurityConfig(in refreshable.Refreshable) RefreshingSecurityConfig {
	return RefreshingSecurityConfig{Refreshable: in}
}

func (r RefreshingSecurityConfig) CurrentSecurityConfig() httpclient.SecurityConfig {
	return r.Current().(httpclient.SecurityConfig)
}

func (r RefreshingSecurityConfig) MapSecurityConfig(mapFn func(httpclient.SecurityConfig) interface{}) refreshable.Refreshable {
	return r.Map(func(i interface{}) interface{} {
		return mapFn(i.(httpclient.SecurityConfig))
	})
}

func (r RefreshingSecurityConfig) SubscribeToSecurityConfig(consumer func(httpclient.SecurityConfig)) (unsubscribe func()) {
	return r.Subscribe(func(i interface{}) {
		consumer(i.(httpclient.SecurityConfig))
	})
}

func (r RefreshingSecurityConfig) CAFiles() refreshable.StringSlice {
	return refreshable.NewStringSlice(r.MapSecurityConfig(func(i httpclient.SecurityConfig) interface{} {
		return i.CAFiles
	}))
}

func (r RefreshingSecurityConfig) CertFile() refreshable.String {
	return refreshable.NewString(r.MapSecurityConfig(func(i httpclient.SecurityConfig) interface{} {
		return i.CertFile
	}))
}

func (r RefreshingSecurityConfig) KeyFile() refreshable.String {
	return refreshable.NewString(r.MapSecurityConfig(func(i httpclient.SecurityConfig) interface{} {
		return i.KeyFile
	}))
}

type RefreshableStringToClientConfig interface {
	refreshable.Refreshable
	CurrentStringToClientConfig() map[string]httpclient.ClientConfig
	MapStringToClientConfig(func(map[string]httpclient.ClientConfig) interface{}) refreshable.Refreshable
	SubscribeToStringToClientConfig(func(map[string]httpclient.ClientConfig)) (unsubscribe func())
}

type RefreshingStringToClientConfig struct {
	refreshable.Refreshable
}

func NewRefreshingStringToClientConfig(in refreshable.Refreshable) RefreshingStringToClientConfig {
	return RefreshingStringToClientConfig{Refreshable: in}
}

func (r RefreshingStringToClientConfig) CurrentStringToClientConfig() map[string]httpclient.ClientConfig {
	return r.Current().(map[string]httpclient.ClientConfig)
}

func (r RefreshingStringToClientConfig) MapStringToClientConfig(mapFn func(map[string]httpclient.ClientConfig) interface{}) refreshable.Refreshable {
	return r.Map(func(i interface{}) interface{} {
		return mapFn(i.(map[string]httpclient.ClientConfig))
	})
}

func (r RefreshingStringToClientConfig) SubscribeToStringToClientConfig(consumer func(map[string]httpclient.ClientConfig)) (unsubscribe func()) {
	return r.Subscribe(func(i interface{}) {
		consumer(i.(map[string]httpclient.ClientConfig))
	})
}