namespace

type DynamicOptions interface {
	// Validate validates the options
	Validate() error

	// SetInstrumentOptions sets the instrumentation options
	SetInstrumentOptions(value instrument.Options) DynamicOptions

	// InstrumentOptions returns the instrumentation options
	InstrumentOptions() instrument.Options

	// SetConfigServiceClient sets the client of ConfigService
	SetConfigServiceClient(c client.Client) DynamicOptions

	// ConfigServiceClient returns the client of ConfigService
	ConfigServiceClient() client.Client

	// SetNamespaceRegistryKey sets the kv-store key used for the
	// NamespaceRegistry
	SetNamespaceRegistryKey(k string) DynamicOptions

	// NamespaceRegistryKey returns the kv-store key used for the
	// NamespaceRegistry
	NamespaceRegistryKey() string
}

type IndexConfiguration struct {
	Enabled   bool          `yaml:"enabled" validate:"nonzero"`
	BlockSize time.Duration `yaml:"blockSize" validate:"nonzero"`
}

type IndexOptions interface {
	// Equal returns true if the provide value is equal to this one.
	Equal(value IndexOptions) bool

	// SetEnabled sets whether indexing is enabled.
	SetEnabled(value bool) IndexOptions

	// Enabled returns whether indexing is enabled.
	Enabled() bool

	// SetBlockSize returns the block size.
	SetBlockSize(value time.Duration) IndexOptions

	// BlockSize returns the block size.
	BlockSize() time.Duration
}

type Initializer interface {
	// Init will return a new Registry
	Init() (Registry, error)
}

type Map interface {
	// Equal returns true if the provide value is equal to this one
	Equal(value Map) bool

	// Get gets the metadata for the provided namespace
	Get(ident.ID) (Metadata, error)

	// IDs returns the ID of known namespaces
	IDs() []ident.ID

	// Metadatas returns the metadata of known namespaces
	Metadatas() []Metadata
}

type MapConfiguration struct {
	Metadatas []MetadataConfiguration `yaml:"metadatas" validate:"nonzero"`
}

type Metadata interface {
	// Equal returns true if the provide value is equal to this one
	Equal(value Metadata) bool

	// ID is the ID of the namespace
	ID() ident.ID

	// Options is the namespace options
	Options() Options
}

type MetadataConfiguration struct {
	ID                string                  `yaml:"id" validate:"nonzero"`
	BootstrapEnabled  *bool                   `yaml:"bootstrapEnabled"`
	FlushEnabled      *bool                   `yaml:"flushEnabled"`
	WritesToCommitLog *bool                   `yaml:"writesToCommitLog"`
	CleanupEnabled    *bool                   `yaml:"cleanupEnabled"`
	RepairEnabled     *bool                   `yaml:"repairEnabled"`
	Retention         retention.Configuration `yaml:"retention" validate:"nonzero"`
	Index             IndexConfiguration      `yaml:"index"`
}

type MetadataMatcher interface {
	gomock.Matcher
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type Options interface {
	// Validate validates the options
	Validate() error

	// Equal returns true if the provide value is equal to this one
	Equal(value Options) bool

	// SetBootstrapEnabled sets whether this namespace requires bootstrapping
	SetBootstrapEnabled(value bool) Options

	// BootstrapEnabled returns whether this namespace requires bootstrapping
	BootstrapEnabled() bool

	// SetFlushEnabled sets whether the in-memory data for this namespace needs to be flushed
	SetFlushEnabled(value bool) Options

	// FlushEnabled returns whether the in-memory data for this namespace needs to be flushed
	FlushEnabled() bool

	// SetSnapshotEnabled sets whether the in-memory data for this namespace should be snapshotted regularly
	SetSnapshotEnabled(value bool) Options

	// SnapshotEnabled returns whether the in-memory data for this namespace should be snapshotted regularly
	SnapshotEnabled() bool

	// SetWritesToCommitLog sets whether writes for series in this namespace need to go to commit log
	SetWritesToCommitLog(value bool) Options

	// WritesToCommitLog returns whether writes for series in this namespace need to go to commit log
	WritesToCommitLog() bool

	// SetCleanupEnabled sets whether this namespace requires cleaning up fileset/snapshot files
	SetCleanupEnabled(value bool) Options

	// CleanupEnabled returns whether this namespace requires cleaning up fileset/snapshot files
	CleanupEnabled() bool

	// SetRepairEnabled sets whether the data for this namespace needs to be repaired
	SetRepairEnabled(value bool) Options

	// RepairEnabled returns whether the data for this namespace needs to be repaired
	RepairEnabled() bool

	// SetRetentionOptions sets the retention options for this namespace
	SetRetentionOptions(value retention.Options) Options

	// RetentionOptions returns the retention options for this namespace
	RetentionOptions() retention.Options

	// SetIndexOptions sets the IndexOptions.
	SetIndexOptions(value IndexOptions) Options

	// IndexOptions returns the IndexOptions.
	IndexOptions() IndexOptions
}

type Registry interface {
	// Watch for the Registry changes
	Watch() (Watch, error)

	// Close closes the registry
	Close() error
}

type Watch interface {
	// C is the notification channel for when a value becomes available
	C() <-chan struct{}

	// Get the current namespace map
	Get() Map

	// Close closes the watch
	Close() error
}