config

type Archival struct {
	// History is the config for the history archival
	History HistoryArchival `yaml:"history"`
	// Visibility is the config for visibility archival
	Visibility VisibilityArchival `yaml:"visibility"`
}

type ArchivalNamespaceDefaults struct {
	// History is the namespace default history archival config for each namespace
	History HistoryArchivalNamespaceDefaults `yaml:"history"`
	// Visibility is the namespace default visibility archival config for each namespace
	Visibility VisibilityArchivalNamespaceDefaults `yaml:"visibility"`
}

type Authorization struct {
	// Signing key provider for validating JWT tokens
	JWTKeyProvider       JWTKeyProvider `yaml:"jwtKeyProvider"`
	PermissionsClaimName string         `yaml:"permissionsClaimName"`
	// Empty string for noopAuthorizer or "default" for defaultAuthorizer
	Authorizer string `yaml:"authorizer"`
	// Empty string for noopClaimMapper or "default" for defaultJWTClaimMapper
	ClaimMapper string `yaml:"claimMapper"`
	// Name of main auth header to pass to ClaimMapper (as `AuthToken`). Defaults to `authorization`.
	AuthHeaderName string `yaml:"authHeaderName"`
	// Name of extra auth header to pass to ClaimMapper (as `ExtraData`). Defaults to `authorization-extras`.
	AuthExtraHeaderName string `yaml:"authExtraHeaderName"`
}

type Cassandra struct {
	// Hosts is a csv of cassandra endpoints
	Hosts string `yaml:"hosts" validate:"nonzero"`
	// Port is the cassandra port used for connection by gocql client
	Port int `yaml:"port"`
	// User is the cassandra user used for authentication by gocql client
	User string `yaml:"user"`
	// Password is the cassandra password used for authentication by gocql client
	Password string `yaml:"password"`
	// AllowedAuthenticators is the optional list of authenticators the gocql client checks before approving the challenge request from the server.
	AllowedAuthenticators []string `yaml:"allowedAuthenticators"`
	// keyspace is the cassandra keyspace
	Keyspace string `yaml:"keyspace" validate:"nonzero"`
	// Datacenter is the data center filter arg for cassandra
	Datacenter string `yaml:"datacenter"`
	// MaxConns is the max number of connections to this datastore for a single keyspace
	MaxConns int `yaml:"maxConns"`
	// ConnectTimeout is a timeout for initial dial to cassandra server (default: 600 milliseconds)
	ConnectTimeout time.Duration `yaml:"connectTimeout"`
	// Timeout is a timeout for reads and, unless otherwise specified, writes. If not specified, ConnectTimeout is used.
	Timeout time.Duration `yaml:"timeout"`
	// WriteTimeout is a timeout for writing a query. If not specified, Timeout is used.
	WriteTimeout time.Duration `yaml:"writeTimeout"`
	// TLS configuration
	TLS *auth.TLS `yaml:"tls"`
	// Consistency configuration (defaults to LOCAL_QUORUM / LOCAL_SERIAL for all stores if this field not set)
	Consistency *CassandraStoreConsistency `yaml:"consistency"`
	// DisableInitialHostLookup instructs the gocql client to connect only using the supplied hosts
	DisableInitialHostLookup bool `yaml:"disableInitialHostLookup"`
	// AddressTranslator translates Cassandra IP addresses, used for cases when IP addresses gocql driver returns are not accessible from the server
	AddressTranslator *CassandraAddressTranslator `yaml:"addressTranslator"`
}

type CassandraAddressTranslator struct {
	// Translator defines name of translator implementation to use for Cassandra address translation
	Translator string `yaml:"translator"`
	// Options map of options for address translator implementation
	Options map[string]string `yaml:"options"`
}

type CassandraConsistencySettings struct {
	// Consistency sets the default consistency level. Values identical to gocql Consistency values. (defaults to LOCAL_QUORUM if not set).
	Consistency string `yaml:"consistency"`
	// SerialConsistency sets the consistency for the serial prtion of queries. Values identical to gocql SerialConsistency values. (defaults to LOCAL_SERIAL if not set)
	SerialConsistency string `yaml:"serialConsistency"`
}

type CassandraStoreConsistency struct {
	// Default defines the consistency level for ALL stores.
	// Defaults to LOCAL_QUORUM and LOCAL_SERIAL if not set
	Default *CassandraConsistencySettings `yaml:"default"`
}

type CertExpirationValidation struct {
	// Log warnings for certificates expiring during this time window from now
	WarningWindow time.Duration `yaml:"warningWindow"`
	// Log error for certificates expiring during this time window from now
	ErrorWindow time.Duration `yaml:"errorWindow"`
	// Interval between checks for certificate expiration
	CheckInterval time.Duration `yaml:"checkInterval"`
}

type ClientConnectionConfig struct {
	KeepAliveClientConfig *KeepAliveClientParameters `yaml:"keepAliveClientParameters"`
}

type ClientTLS struct {
	// DNS name to validate against for server to server connections.
	// Required when TLS is enabled in a multi-host cluster.
	// This name should be referenced by the certificate specified in the ServerTLS section.
	ServerName string `yaml:"serverName"`

	// If you want to verify the temporal server hostname and server cert, then you should turn this on
	// This option is basically equivalent to InSecureSkipVerify
	// See InSecureSkipVerify in http://golang.org/pkg/crypto/tls/ for more info
	DisableHostVerification bool `yaml:"disableHostVerification"`

	// Optional - A list of paths to files containing the PEM-encoded public key of the Certificate Authorities that are used to validate the server's TLS certificate
	// You cannot specify both RootCAFiles and RootCAData
	RootCAFiles []string `yaml:"rootCaFiles"`

	// Optional - A list of base64 PEM-encoded public keys of the Certificate Authorities that are used to validate the server's TLS certificate.
	// You cannot specify both RootCAFiles and RootCAData
	RootCAData []string `yaml:"rootCaData"`

	// Optional - Use TLS even is neither client certificate nor root CAs are configured
	// This is for non-mTLS cases when client validates serve against a set of trusted CA certificates configured in the environment
	ForceTLS bool `yaml:"forceTLS"`
}

type Config struct {
	// Global is process-wide service-related configuration
	Global Global `yaml:"global"`
	// Persistence contains the configuration for temporal datastores
	Persistence Persistence `yaml:"persistence"`
	// Log is the logging config
	Log log.Config `yaml:"log"`
	// ClusterMetadata is the config containing all valid clusters and active cluster
	ClusterMetadata *cluster.Config `yaml:"clusterMetadata"`
	// DCRedirectionPolicy contains the frontend datacenter redirection policy
	DCRedirectionPolicy DCRedirectionPolicy `yaml:"dcRedirectionPolicy"`
	// Services is a map of service name to service config items
	Services map[string]Service `yaml:"services"`
	// Archival is the config for archival
	Archival Archival `yaml:"archival"`
	// PublicClient is config for connecting to temporal frontend
	PublicClient PublicClient `yaml:"publicClient"`
	// DynamicConfigClient is the config for setting up the file based dynamic config client
	// Filepath should be relative to the root directory
	DynamicConfigClient *dynamicconfig.FileBasedClientConfig `yaml:"dynamicConfigClient"`
	// NamespaceDefaults is the default config for every namespace
	NamespaceDefaults NamespaceDefaults `yaml:"namespaceDefaults"`
	// ExporterConfig allows the specification of process-wide OTEL exporters
	ExporterConfig telemetry.ExportConfig `yaml:"otel"`
}

type CustomDatastoreConfig struct {
	// Name of the custom datastore
	Name string `yaml:"name"`
	// Options to be used by AbstractDatastoreFactory implementation
	Options map[string]any `yaml:"options"`
}

type DCRedirectionPolicy struct {
	Policy string `yaml:"policy"`
}

type DataStore struct {
	// FaultInjection contains the config for fault injector wrapper.
	FaultInjection *FaultInjection `yaml:"faultInjection"`
	// Cassandra contains the config for a cassandra datastore
	Cassandra *Cassandra `yaml:"cassandra"`
	// SQL contains the config for a SQL based datastore
	SQL *SQL `yaml:"sql"`
	// Custom contains the config for custom datastore implementation
	CustomDataStoreConfig *CustomDatastoreConfig `yaml:"customDatastore"`
	// ElasticSearch contains the config for a ElasticSearch datastore
	Elasticsearch *client.Config `yaml:"elasticsearch"`
}

type DataStoreName string

type FaultInjection struct {
	// Targets is a mapping of data store name to a targeted fault injection config for that data store.
	// Here is an example config for targeted fault injection. This config will inject errors into the
	// UpdateShard method of the ShardStore at a rate of 100%. No other methods will be affected.
	/*
		targets:
		  dataStores:
			ShardStore:
			  methods:
				UpdateShard:
				  seed: 42
				  errors:
					ShardOwnershipLostError: 1.0 # all UpdateShard calls will fail with ShardOwnershipLostError
	*/
	// This will cause the UpdateShard method of the ShardStore to always return ShardOwnershipLostError.
	// See config/development-cass-es-fi.yaml for a more detailed example.
	Targets FaultInjectionTargets `yaml:"targets"`
}

type FaultInjectionDataStoreConfig struct {
	// Methods is a map of data store method name to a fault injection config for that method.
	// We create an error generator that infers the method name from the call stack using reflection.
	// For example, if a test with targeted fault injection enabled calls ShardStore.UpdateShard, then
	// we fetch the error generator from this map using the key "UpdateShard".
	// The key is the name of the method to inject faults for.
	// The value is the config for that method.
	Methods map[string]FaultInjectionMethodConfig `yaml:"methods"`
}

type FaultInjectionMethodConfig struct {
	// Errors is a map of error type to probability of returning that error.
	// For example: `ShardOwnershipLostError: 0.1` will cause the method to return a ShardOwnershipLostError 10% of
	// the time.
	// The other 90% of the time, the method will call the underlying datastore.
	// If there are multiple errors for a method, the probability of each error is independent of the others.
	// For example, if there are two errors with probabilities 0.1 and 0.2, then the first error will be returned
	// 10% of the time, the second error will be returned 20% of the time,
	// and the underlying method will be called 70% of the time.
	Errors map[string]float64 `yaml:"errors"`

	// Seed is the seed for the random number generator used to sample faults from the Errors map. You can use this
	// to make the fault injection deterministic.
	// If the test config does not set this to a non-zero number, the fault injector will set it to the current time
	// in nanoseconds.
	Seed int64 `yaml:"seed"`
}

type FaultInjectionTargets struct {
	// DataStores is a map of datastore name to fault injection config.
	// Use this to configure fault injection for specific datastores. The key is the name of the datastore,
	// e.g. "ShardStore". See DataStoreName for the list of valid datastore names.
	DataStores map[DataStoreName]FaultInjectionDataStoreConfig `yaml:"dataStores"`
}

type FilestoreArchiver struct {
	FileMode string `yaml:"fileMode"`
	DirMode  string `yaml:"dirMode"`
}

type Global struct {
	// Membership is the ringpop related configuration
	Membership Membership `yaml:"membership"`
	// PProf is the PProf configuration
	PProf PProf `yaml:"pprof"`
	// TLS controls the communication encryption configuration
	TLS RootTLS `yaml:"tls"`
	// Metrics is the metrics subsystem configuration
	Metrics *metrics.Config `yaml:"metrics"`
	// Settings for authentication and authorization
	Authorization Authorization `yaml:"authorization"`
}

type GroupTLS struct {
	// Client handles client TLS settings
	Client ClientTLS `yaml:"client"`
	// Server handles the server (listener) TLS settings
	Server ServerTLS `yaml:"server"`

	// PerHostOverrides contains per-hostname TLS settings that
	// are used for external clients connecting to the Temporal Cluster on that
	// specific hostname. Host names are case insensitive. Optional. If not present,
	// uses configuration supplied by Server field.
	PerHostOverrides map[string]ServerTLS `yaml:"hostOverrides"`
}

type GstorageArchiver struct {
	CredentialsPath string `yaml:"credentialsPath"`
}

type HistoryArchival struct {
	// State is the state of history archival either: enabled, disabled, or paused
	State string `yaml:"state"`
	// EnableRead whether history can be read from archival
	EnableRead bool `yaml:"enableRead"`
	// Provider contains the config for all history archivers
	Provider *HistoryArchiverProvider `yaml:"provider"`
}

type HistoryArchivalNamespaceDefaults struct {
	// State is the namespace default state of history archival: enabled or disabled
	State string `yaml:"state"`
	// URI is the namespace default URI for history archiver
	URI string `yaml:"URI"`
}

type HistoryArchiverProvider struct {
	Filestore *FilestoreArchiver `yaml:"filestore"`
	Gstorage  *GstorageArchiver  `yaml:"gstorage"`
	S3store   *S3Archiver        `yaml:"s3store"`
}

type JWTKeyProvider struct {
	KeySourceURIs   []string      `yaml:"keySourceURIs"`
	RefreshInterval time.Duration `yaml:"refreshInterval"`
}

type KeepAliveClientParameters struct {
	Time                *time.Duration `yaml:"keepAliveTime"`
	Timeout             *time.Duration `yaml:"keepAliveTimeout"`
	PermitWithoutStream *bool          `yaml:"keepAlivePermitWithoutStream"`
}

type KeepAliveServerConfig struct {
	KeepAliveServerParameters  *KeepAliveServerParameters        `yaml:"keepAliveServerParameters"`
	KeepAliveEnforcementPolicy *KeepAliveServerEnforcementPolicy `yaml:"keepAliveEnforcementPolicy"`
}

type KeepAliveServerEnforcementPolicy struct {
	MinTime             *time.Duration `yaml:"minTime"`
	PermitWithoutStream *bool          `yaml:"permitWithoutStream"`
}

type KeepAliveServerParameters struct {
	MaxConnectionIdle     *time.Duration `yaml:"maxConnectionIdle"`
	MaxConnectionAge      *time.Duration `yaml:"maxConnectionAge"`
	MaxConnectionAgeGrace *time.Duration `yaml:"maxConnectionAgeGrace"`
	Time                  *time.Duration `yaml:"keepAliveTime"`
	Timeout               *time.Duration `yaml:"keepAliveTimeout"`
}

type Membership struct {
	// MaxJoinDuration is the max wait time to join the gossip ring
	MaxJoinDuration time.Duration `yaml:"maxJoinDuration"`
	// BroadcastAddress is used as the address that is communicated to remote nodes to connect on.
	// This is generally used when BindOnIP would be the same across several nodes (ie: `0.0.0.0` or `::`)
	// and for nat traversal scenarios. Check net.ParseIP for supported syntax
	BroadcastAddress string `yaml:"broadcastAddress"`
}

type NamespaceDefaults struct {
	// Archival is the default archival config for each namespace
	Archival ArchivalNamespaceDefaults `yaml:"archival"`
}

type PProf struct {
	// Port is the port on which the PProf will bind to
	Port int `yaml:"port"`
	// Host defaults to `localhost` but can be overriden
	// for instance in the case of dual stack IPv4/IPv6
	Host string `yaml:"host"`
}

type Persistence struct {
	// DefaultStore is the name of the default data store to use
	DefaultStore string `yaml:"defaultStore" validate:"nonzero"`
	// VisibilityStore is the name of the datastore to be used for visibility records
	VisibilityStore string `yaml:"visibilityStore"`
	// SecondaryVisibilityStore is the name of the secondary datastore to be used for visibility records
	SecondaryVisibilityStore string `yaml:"secondaryVisibilityStore"`
	// NumHistoryShards is the desired number of history shards. This config doesn't
	// belong here, needs refactoring
	NumHistoryShards int32 `yaml:"numHistoryShards" validate:"nonzero"`
	// DataStores contains the configuration for all datastores
	DataStores map[string]DataStore `yaml:"datastores"`
	// TransactionSizeLimit is the largest allowed transaction size
	TransactionSizeLimit dynamicconfig.IntPropertyFn `yaml:"-" json:"-"`
}

type PublicClient struct {
	// HostPort is the host port to connect on. Host can be DNS name. See the above
	// comment: in many situations you can leave this empty.
	HostPort string `yaml:"hostPort"`
	// HTTPHostPort is the HTTP host port to connect on. Host can be DNS name. See the above
	// comment: in many situations you can leave this empty.
	HTTPHostPort string `yaml:"httpHostPort"`
	// Force selection of either the "internode" or "frontend" TLS configs for these
	// connections (only those two strings are valid).
	ForceTLSConfig string `yaml:"forceTLSConfig"`
}

type RPC struct {
	// GRPCPort is the port on which gRPC will listen
	GRPCPort int `yaml:"grpcPort"`
	// Port used for membership listener
	MembershipPort int `yaml:"membershipPort"`
	// BindOnLocalHost is true if localhost is the bind address
	// if neither BindOnLocalHost nor BindOnIP are set then an
	// an attempt to discover an address is made
	BindOnLocalHost bool `yaml:"bindOnLocalHost"`
	// BindOnIP can be used to bind service on specific ip (eg. `0.0.0.0` or `::`)
	// check net.ParseIP for supported syntax
	// mutually exclusive with `BindOnLocalHost` option
	BindOnIP string `yaml:"bindOnIP"`
	// HTTPPort is the port on which HTTP will listen. If unset/0, HTTP will be
	// disabled. This setting only applies to the frontend service.
	HTTPPort int `yaml:"httpPort"`
	// HTTPAdditionalForwardedHeaders adds additional headers to the default set
	// forwarded from HTTP to gRPC. Any value with a trailing * will match the prefix before
	// the asterisk (eg. `x-internal-*`)
	HTTPAdditionalForwardedHeaders []string `yaml:"httpAdditionalForwardedHeaders"`
	// KeepAliveServerConfig keep alive configuration for the server
	KeepAliveServerConfig KeepAliveServerConfig `yaml:"keepAliveServerConfig"`
	// ClientConnectionConfig defines the connection config used by other services
	// when they create a gRPC client connection to this service.
	ClientConnectionConfig ClientConnectionConfig `yaml:"clientConnectionConfig"`
}

type ReplicationTaskProcessorConfig struct {
	NoTaskInitialWaitIntervalSecs int     `yaml:"noTaskInitialWaitIntervalSecs"`
	NoTaskWaitBackoffCoefficient  float64 `yaml:"noTaskWaitBackoffCoefficient"`
	NoTaskMaxWaitIntervalSecs     int     `yaml:"noTaskMaxWaitIntervalSecs"`
}

type Replicator struct{}

type RootTLS struct {
	// Internode controls backend service (history, matching, internal-frontend)
	// communication TLS settings.
	Internode GroupTLS `yaml:"internode"`
	// Frontend controls frontend server TLS settings. To control system worker -> frontend
	// TLS, use the SystemWorker field. (Frontend.Client is accepted for backwards
	// compatibility.)
	Frontend GroupTLS `yaml:"frontend"`
	// SystemWorker controls TLS setting for System Workers connecting to Frontend.
	SystemWorker WorkerTLS `yaml:"systemWorker"`
	// RemoteFrontendClients controls TLS setting for talking to remote cluster.
	RemoteClusters map[string]GroupTLS `yaml:"remoteClusters"`
	// ExpirationChecks defines settings for periodic checks for expiration of certificates
	ExpirationChecks CertExpirationValidation `yaml:"expirationChecks"`
	// Interval between refreshes of certificates loaded from files
	RefreshInterval time.Duration `yaml:"refreshInterval"`
}

type S3Archiver struct {
	Region           string  `yaml:"region"`
	Endpoint         *string `yaml:"endpoint"`
	S3ForcePathStyle bool    `yaml:"s3ForcePathStyle"`
	LogLevel         uint    `yaml:"logLevel"`
}

type SQL struct {
	// Connect is a function that returns a sql db connection. String based configuration is ignored if this is provided.
	Connect func(sqlConfig *SQL) (*sqlx.DB, error) `yaml:"-" json:"-"`
	// User is the username to be used for the conn
	User string `yaml:"user"`
	// Password is the password corresponding to the user name
	Password string `yaml:"password"`
	// PluginName is the name of SQL plugin
	PluginName string `yaml:"pluginName" validate:"nonzero"`
	// DatabaseName is the name of SQL database to connect to
	DatabaseName string `yaml:"databaseName" validate:"nonzero"`
	// ConnectAddr is the remote addr of the database
	ConnectAddr string `yaml:"connectAddr" validate:"nonzero"`
	// ConnectProtocol is the protocol that goes with the ConnectAddr ex - tcp, unix
	ConnectProtocol string `yaml:"connectProtocol" validate:"nonzero"`
	// ConnectAttributes is a set of key-value attributes to be sent as part of connect data_source_name url
	ConnectAttributes map[string]string `yaml:"connectAttributes"`
	// MaxConns the max number of connections to this datastore
	MaxConns int `yaml:"maxConns"`
	// MaxIdleConns is the max number of idle connections to this datastore
	MaxIdleConns int `yaml:"maxIdleConns"`
	// MaxConnLifetime is the maximum time a connection can be alive
	MaxConnLifetime time.Duration `yaml:"maxConnLifetime"`
	// EXPERIMENTAL - TaskScanPartitions is the number of partitions to sequentially scan during ListTaskQueue operations.
	// This is used for in a sharded sql database such as Vitess for heavy task workloads to minimize scatter gather.
	// The default value for this param is 1, and should not be configured without a thorough understanding of what this does.
	TaskScanPartitions int `yaml:"taskScanPartitions"`
	// TLS is the configuration for TLS connections
	TLS *auth.TLS `yaml:"tls"`
}

type ServerTLS struct {
	// The path to the file containing the PEM-encoded public key of the certificate to use.
	CertFile string `yaml:"certFile"`
	// The path to the file containing the PEM-encoded private key of the certificate to use.
	KeyFile string `yaml:"keyFile"`
	// A list of paths to files containing the PEM-encoded public key of the Certificate Authorities you wish to trust for client authentication.
	// This value is ignored if `requireClientAuth` is not enabled. Cannot specify both ClientCAFiles and ClientCAData
	ClientCAFiles []string `yaml:"clientCaFiles"`

	// Base64 equivalents of the above artifacts.
	// You cannot specify both a Data and a File for the same artifact (e.g. setting CertFile and CertData)
	CertData     string   `yaml:"certData"`
	KeyData      string   `yaml:"keyData"`
	ClientCAData []string `yaml:"clientCaData"`

	// Requires clients to authenticate with a certificate when connecting, otherwise known as mutual TLS.
	RequireClientAuth bool `yaml:"requireClientAuth"`
}

type Service struct {
	// RPC is the rpc configuration
	RPC RPC `yaml:"rpc"`
}

type ServicePortMap map[primitives.ServiceName]int

type VisibilityArchival struct {
	// State is the state of visibility archival either: enabled, disabled, or paused
	State string `yaml:"state"`
	// EnableRead whether visibility can be read from archival
	EnableRead bool `yaml:"enableRead"`
	// Provider contains the config for all visibility archivers
	Provider *VisibilityArchiverProvider `yaml:"provider"`
}

type VisibilityArchivalNamespaceDefaults struct {
	// State is the namespace default state of visibility archival: enabled or disabled
	State string `yaml:"state"`
	// URI is the namespace default URI for visibility archiver
	URI string `yaml:"URI"`
}

type VisibilityArchiverProvider struct {
	Filestore *FilestoreArchiver `yaml:"filestore"`
	S3store   *S3Archiver        `yaml:"s3store"`
	Gstorage  *GstorageArchiver  `yaml:"gstorage"`
}

type WorkerTLS struct {
	// The path to the file containing the PEM-encoded public key of the client certificate to use by system workers.
	CertFile string `yaml:"certFile"`
	// The path to the file containing the PEM-encoded private key of the client certificate to use by system workers.
	KeyFile string `yaml:"keyFile"`
	// Base64 equivalents of the above artifacts.
	// You cannot specify both a Data and a File for the same artifact (e.g. setting CertFile and CertData)
	CertData string `yaml:"certData"`
	KeyData  string `yaml:"keyData"`

	// Client TLS settings for system workers
	Client ClientTLS `yaml:"client"`
}