v1alpha1

type AcknowledgementSetting struct {
	// Type represents how a batch of replication events is considered successfully replicated.
	// +kubebuilder:default:=ACK_ON_OPERATION_COMPLETE
	// +optional
	Type AcknowledgementType `json:"type,omitempty"`

	// Timeout represents the time in milliseconds the source cluster waits for the acknowledgement.
	// After timeout, the events will be resent.
	// +kubebuilder:default:=60000
	// +optional
	Timeout int32 `json:"timeout,omitempty"`
}

type AcknowledgementType string

type AdvancedNetwork struct {
	// +optional
	MemberServerSocketEndpointConfig ServerSocketEndpointConfig `json:"memberServerSocketEndpointConfig,omitempty"`

	// +optional
	ClientServerSocketEndpointConfig ServerSocketEndpointConfig `json:"clientServerSocketEndpointConfig,omitempty"`

	// +optional
	WAN []WANConfig `json:"wan,omitempty"`
}

type AgentConfiguration struct {
	// Repository to pull Hazelcast Platform Operator Agent(https://github.com/hazelcast/platform-operator-agent)
	// +kubebuilder:default:="docker.io/hazelcast/platform-operator-agent"
	// +optional
	Repository string `json:"repository,omitempty"`

	// Version of Hazelcast Platform Operator Agent.
	// +kubebuilder:default:="0.1.26"
	// +optional
	Version string `json:"version,omitempty"`

	// Compute Resources required by the Agent container.
	// +optional
	Resources *corev1.ResourceRequirements `json:"resources,omitempty"`
}

type AttributeConfig struct {
	// Name of the attribute https://docs.hazelcast.com/hazelcast/latest/query/predicate-overview#creating-custom-query-attributes
	// +required
	Name string `json:"name"`

	// Name of the extractor class https://docs.hazelcast.com/hazelcast/latest/query/predicate-overview#implementing-a-valueextractor
	// +required
	ExtractorClassName string `json:"extractorClassName"`
}

type BatchSetting struct {
	// Size represents the maximum batch size.
	// +kubebuilder:default:=500
	// +optional
	Size int32 `json:"size,omitempty"`

	// MaximumDelay represents the maximum delay in milliseconds.
	// If the batch size is not reached, the events will be sent after
	// the maximum delay.
	// +kubebuilder:default:=1000
	// +optional
	MaximumDelay int32 `json:"maximumDelay,omitempty"`
}

type BitmapIndexOptionsConfig struct {
	// +required
	UniqueKey string `json:"uniqueKey"`

	// +required
	UniqueKeyTransition UniqueKeyTransition `json:"uniqueKeyTransition"`
}

type BucketConfiguration struct {
	// secret is a deprecated alias for secretName.
	// +optional
	DeprecatedSecret string `json:"secret"`

	// Name of the secret with credentials for cloud providers.
	// +optional
	SecretName string `json:"secretName"`

	// URL of the bucket to download HotBackup folders.
	// AWS S3, GCP Bucket and Azure Blob storage buckets are supported.
	// Example bucket URIs:
	// - AWS S3     -> s3://bucket-name/path/to/folder
	// - GCP Bucket -> gs://bucket-name/path/to/folder
	// - Azure Blob -> azblob://bucket-name/path/to/folder
	// +kubebuilder:validation:MinLength:=6
	// +required
	BucketURI string `json:"bucketURI"`
}

type ByteOrder string

type CPSubsystem struct {
	// SessionTTLSeconds is the duration for a CP session to be kept alive after the last received heartbeat.
	// Must be greater than or equal to SessionHeartbeatIntervalSeconds and smaller than or equal to MissingCpMemberAutoRemovalSeconds.
	// +optional
	SessionTTLSeconds *int32 `json:"sessionTTLSeconds,omitempty"`

	// SessionHeartbeatIntervalSeconds Interval in seconds for the periodically committed CP session heartbeats.
	// Must be smaller than SessionTTLSeconds.
	// +optional
	SessionHeartbeatIntervalSeconds *int32 `json:"sessionHeartbeatIntervalSeconds,omitempty"`

	// MissingCpMemberAutoRemovalSeconds is the duration in seconds to wait before automatically removing a missing CP member from the CP Subsystem.
	MissingCpMemberAutoRemovalSeconds *int32 `json:"missingCpMemberAutoRemovalSeconds,omitempty"`

	// FailOnIndeterminateOperationState indicated whether CP Subsystem operations use at-least-once and at-most-once execution guarantees.
	// +optional
	FailOnIndeterminateOperationState *bool `json:"failOnIndeterminateOperationState,omitempty"`

	// DataLoadTimeoutSeconds is the timeout duration in seconds for CP members to restore their persisted data from disk
	// +kubebuilder:validation:Minimum:=1
	// +optional
	DataLoadTimeoutSeconds *int32 `json:"dataLoadTimeoutSeconds,omitempty"`

	// PVC is the configuration of PersistenceVolumeClaim.
	// +optional
	PVC *PvcConfiguration `json:"pvc,omitempty"`
}

type CRLister interface {
	GetItems() []client.Object
}

type Cache struct {
	metav1.TypeMeta `json:",inline"`
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// +required
	Spec CacheSpec `json:"spec"`
	// +optional
	Status CacheStatus `json:"status,omitempty"`
}

type CacheList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Cache `json:"items"`
}

type CacheSpec struct {
	DataStructureSpec `json:",inline"`

	// Class name of the key type
	// +optional
	KeyType string `json:"keyType,omitempty"`

	// Class name of the value type
	// +optional
	ValueType string `json:"valueType,omitempty"`

	// When enabled, cache data will be persisted.
	// +kubebuilder:default:=false
	// +optional
	PersistenceEnabled bool `json:"persistenceEnabled"`

	// InMemoryFormat specifies in which format data will be stored in your cache
	// +kubebuilder:default:=BINARY
	// +optional
	InMemoryFormat InMemoryFormatType `json:"inMemoryFormat,omitempty"`

	// EventJournal specifies event journal configuration of the Cache
	// +optional
	EventJournal *EventJournal `json:"eventJournal,omitempty"`
}

type CacheStatus struct {
	DataStructureStatus `json:",inline"`
}

type CapacityPolicyType string

type CollectionType string

type CompactSerializationConfig struct {

	// Serializers is the list of explicit serializers to be registered.
	// +optional
	Serializers []string `json:"serializers,omitempty"`

	// Classes is the list of class names for which a zero-config serializer will be registered, without implementing an explicit serializer.
	// +optional
	Classes []string `json:"classes,omitempty"`
}

type CronHotBackup struct {
	metav1.TypeMeta `json:",inline"`
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// +required
	Spec CronHotBackupSpec `json:"spec"`
	// +optional
	Status CronHotBackupStatus `json:"status,omitempty"`
}

type CronHotBackupList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []CronHotBackup `json:"items"`
}

type CronHotBackupSpec struct {
	// Schedule contains a crontab-like expression that defines the schedule in which HotBackup will be started.
	// If the Schedule is empty the HotBackup will start only once when applied.
	// ---
	// Several pre-defined schedules in place of a cron expression can be used.
	//	Entry                  | Description                                | Equivalent To
	//	-----                  | -----------                                | -------------
	//	@yearly (or @annually) | Run once a year, midnight, Jan. 1st        | 0 0 1 1 *
	//	@monthly               | Run once a month, midnight, first of month | 0 0 1 * *
	//	@weekly                | Run once a week, midnight between Sat/Sun  | 0 0 * * 0
	//	@daily (or @midnight)  | Run once a day, midnight                   | 0 0 * * *
	//	@hourly                | Run once an hour, beginning of hour        | 0 * * * *
	// +kubebuilder:validation:MinLength:=1
	// +required
	Schedule string `json:"schedule"`

	// Specifies the hot backup that will be created when executing a CronHotBackup.
	// +required
	HotBackupTemplate HotBackupTemplateSpec `json:"hotBackupTemplate"`

	// The number of successful finished hot backups to retain.
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:default:=5
	// +optional
	SuccessfulHotBackupsHistoryLimit *int32 `json:"successfulHotBackupsHistoryLimit,omitempty"`

	// The number of failed finished hot backups to retain.
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:default:=3
	// +optional
	FailedHotBackupsHistoryLimit *int32 `json:"failedHotBackupsHistoryLimit,omitempty"`

	// When true, CronHotBackup will stop creating HotBackup CRs until it is disabled
	// +kubebuilder:default:=false
	// +optional
	Suspend bool `json:"suspend"`
}

type CronHotBackupStatus struct{}

type DataRecoveryPolicyType string

type DataStructure interface {
	GetDSName() string
	GetHZResourceName() string
	GetStatus() *DataStructureStatus
	GetSpec() (string, error)
	SetSpec(string) error
	ValidateSpecCurrent(h *Hazelcast) error
	ValidateSpecUpdate() error
}

type DataStructureConfigState string

type DataStructureSpec struct {
	// Name of the data structure config to be created. If empty, CR name will be used.
	// It cannot be updated after the config is created successfully.
	// +optional
	Name string `json:"name,omitempty"`

	// HazelcastResourceName defines the name of the Hazelcast resource that this resource is
	// created for.
	// +kubebuilder:validation:MinLength:=1
	// +required
	HazelcastResourceName string `json:"hazelcastResourceName"`

	// Number of synchronous backups.
	// +kubebuilder:validation:Minimum:=0
	// +kubebuilder:validation:Maximum:=6
	// +kubebuilder:default:=1
	// +optional
	BackupCount *int32 `json:"backupCount,omitempty"`

	// Number of asynchronous backups.
	// +kubebuilder:validation:Minimum:=0
	// +kubebuilder:validation:Maximum:=6
	// +kubebuilder:default:=0
	// +optional
	AsyncBackupCount int32 `json:"asyncBackupCount"`
}

type DataStructureStatus struct {
	// State of the data structure
	// +optional
	State DataStructureConfigState `json:"state,omitempty"`
	// Message explaining the current state
	// +optional
	Message string `json:"message,omitempty"`
	// Holds status of data structure for each Hazelcast member
	// +optional
	MemberStatuses map[string]DataStructureConfigState `json:"memberStatuses,omitempty"`
}

type DurableExecutorServiceConfiguration struct {
	// The name of the executor service
	// +kubebuilder:default:="default"
	// +optional
	Name string `json:"name,omitempty"`

	// The number of executor threads per member.
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:default:=16
	// +optional
	PoolSize int32 `json:"poolSize,omitempty"`

	// Durability of the executor.
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:default:=1
	// +optional
	Durability int32 `json:"durability,omitempty"`

	// Capacity of the executor task per partition.
	// +kubebuilder:default:=100
	// +optional
	Capacity int32 `json:"capacity,omitempty"`
}

type EntryListenerConfiguration struct {
	// ClassName is the fully qualified name of the class that implements any of the Listener interface.
	// +kubebuilder:validation:MinLength:=1
	// +required
	ClassName string `json:"className"`

	// IncludeValues is an optional attribute that indicates whether the event will contain the map value.
	// Defaults to true.
	// +kubebuilder:default:=true
	// +optional
	IncludeValues *bool `json:"includeValues,omitempty"`

	// Local is an optional attribute that indicates whether the map on the local member can be listened to.
	// Defaults to false.
	// +kubebuilder:default:=false
	// +optional
	Local bool `json:"local"`
}

type EventJournal struct {
	// Capacity sets the capacity of the ringbuffer underlying the event journal.
	// +kubebuilder:default:=10000
	Capacity int32 `json:"capacity,omitempty"`
	// TimeToLiveSeconds indicates how long the items remain in the event journal before they are expired.
	// +kubebuilder:default:=0
	TimeToLiveSeconds int32 `json:"timeToLiveSeconds,omitempty"`
}

type EvictionConfig struct {
	// Eviction policy to be applied when map reaches its max size according to the max size policy.
	// +kubebuilder:default:="NONE"
	// +optional
	EvictionPolicy EvictionPolicyType `json:"evictionPolicy,omitempty"`

	// Max size of the map.
	// +kubebuilder:default:=0
	// +optional
	MaxSize int32 `json:"maxSize"`

	// Policy for deciding if the maxSize is reached.
	// +kubebuilder:default:="PER_NODE"
	// +optional
	MaxSizePolicy MaxSizePolicyType `json:"maxSizePolicy,omitempty"`
}

type EvictionPolicyType string

type ExecutorServiceConfiguration struct {
	// The name of the executor service
	// +kubebuilder:default:="default"
	// +optional
	Name string `json:"name,omitempty"`

	// The number of executor threads per member.
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:default:=8
	// +optional
	PoolSize int32 `json:"poolSize,omitempty"`

	// Task queue capacity of the executor.
	// +kubebuilder:default:=0
	// +optional
	QueueCapacity int32 `json:"queueCapacity"`
}

type ExposeExternallyConfiguration struct {
	// Specifies how members are exposed.
	// Valid values are:
	// - "Smart" (default): each member pod is exposed with a separate external address
	// - "Unisocket": all member pods are exposed with one external address
	// +kubebuilder:default:="Smart"
	// +optional
	Type ExposeExternallyType `json:"type,omitempty"`

	// Type of the service used to discover Hazelcast cluster.
	// +kubebuilder:default:="LoadBalancer"
	// +optional
	DiscoveryServiceType corev1.ServiceType `json:"discoveryServiceType,omitempty"`

	// How each member is accessed from the external client.
	// Only available for "Smart" client and valid values are:
	// - "NodePortExternalIP" (default): each member is accessed by the NodePort service and the node external IP/hostname
	// - "NodePortNodeName": each member is accessed by the NodePort service and the node name
	// - "LoadBalancer": each member is accessed by the LoadBalancer service external address
	// +optional
	MemberAccess MemberAccess `json:"memberAccess,omitempty"`
}

type ExposeExternallyType string

type ExternalConnectivityConfiguration struct {
	// How Management Center is exposed.
	// Valid values are:
	// - "ClusterIP"
	// - "NodePort"
	// - "LoadBalancer" (default)
	// +kubebuilder:default:="LoadBalancer"
	// +optional
	Type ExternalConnectivityType `json:"type,omitempty"`

	// Ingress configuration of Management Center
	// +optional
	Ingress *ExternalConnectivityIngress `json:"ingress,omitempty"`

	// OpenShift Route configuration of Management Center
	// +optional
	Route *ExternalConnectivityRoute `json:"route,omitempty"`
}

type ExternalConnectivityIngress struct {
	// Hostname of Management Center exposed by Ingress.
	// Ingress controller will use this hostname to route inbound traffic.
	// +required
	Hostname string `json:"hostname"`

	// IngressClassName of the ingress object.
	// +optional
	IngressClassName string `json:"ingressClassName,omitempty"`

	// Annotations added to the ingress object.
	// +optional
	Annotations map[string]string `json:"annotations,omitempty"`

	// Path of the ingress rule.
	// +kubebuilder:default:="/"
	// +optional
	Path string `json:"path,omitempty"`
}

type ExternalConnectivityRoute struct {
	// Hostname of Management Center exposed by route.
	// Openshift routers will use this hostname to route inbound traffic.
	Hostname string `json:"hostname"`
}

type ExternalConnectivityType string

type FullBehaviorSetting string

type GCType string

type GlobalSerializer struct {

	// If set to true, will replace the internal Java serialization.
	// +optional
	OverrideJavaSerialization *bool `json:"overrideJavaSerialization,omitempty"`

	// Class name of the GlobalSerializer.
	// +required
	ClassName string `json:"className"`
}

type Hazelcast struct {
	metav1.TypeMeta `json:",inline"`
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// Initial values will be filled with its fields' default values.
	// +kubebuilder:default:={"repository" : "docker.io/hazelcast/hazelcast"}
	// +optional
	Spec HazelcastSpec `json:"spec,omitempty"`

	// +optional
	Status HazelcastStatus `json:"status,omitempty"`
}

type HazelcastClusterConfig struct {
	// Name of the Hazelcast cluster that Management Center will connect to, default is dev.
	// +kubebuilder:default:="dev"
	// +optional
	Name string `json:"name,omitempty"`

	// IP address or DNS name of the Hazelcast cluster.
	// If the cluster is exposed with a service name in a different namespace, use the following syntax "<service-name>.<service-namespace>".
	// +required
	Address string `json:"address"`

	// TLS client configuration.
	// +optional
	TLS *TLS `json:"tls,omitempty"`
}

type HazelcastClusterStatus struct {
	// ReadyMembers represents the number of members that are connected to cluster from the desired number of members
	// in the format <ready>/<desired>
	// +optional
	ReadyMembers string `json:"readyMembers,omitempty"`
}

type HazelcastEndpoint struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   HazelcastEndpointSpec   `json:"spec,omitempty"`
	Status HazelcastEndpointStatus `json:"status,omitempty"`
}

type HazelcastEndpointList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []HazelcastEndpoint `json:"items"`
}

type HazelcastEndpointSpec struct {
	// Type defines the endpoint connection. It is used to identify the target of the endpoint.
	// +required
	Type HazelcastEndpointType `json:"type"`

	// Port of the endpoint.
	// +required
	Port int32 `json:"port"`

	// HazelcastResourceName defines the name of the Hazelcast resource that this resource is
	// created for.
	// +kubebuilder:validation:MinLength:=1
	// +required
	HazelcastResourceName string `json:"hazelcastResourceName"`
}

type HazelcastEndpointStatus struct {
	// Address is the external address of the endpoint. It is taken from the corresponding service.
	// +optional
	Address string `json:"address,omitempty"`
}

type HazelcastEndpointType string

type HazelcastList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Hazelcast `json:"items"`
}

type HazelcastMemberStatus struct {
	// PodName is the name of the Hazelcast member pod.
	// +optional
	PodName string `json:"podName,omitempty"`

	// Uid is the unique member identifier within the cluster.
	// +optional
	Uid string `json:"uid,omitempty"`

	// Ip is the IP address of the member within the cluster.
	// +optional
	Ip string `json:"ip,omitempty"`

	// Version represents the Hazelcast version of the member.
	// +optional
	Version string `json:"version,omitempty"`

	// State represents the observed state of the member.
	// +optional
	State NodeState `json:"state,omitempty"`

	// Master flag is set to true if the member is master.
	// +optional
	Master bool `json:"master,omitempty"`

	// Lite is the flag that is true when the member is lite-member.
	// +optional
	Lite bool `json:"lite,omitempty"`

	// OwnedPartitions represents the partitions count on the member.
	// +optional
	OwnedPartitions int32 `json:"ownedPartitions,omitempty"`

	// Ready is the flag that is set to true when the member is successfully started,
	// connected to cluster and ready to accept connections.
	// +optional
	Ready bool `json:"connected"`

	// Message contains the optional message with the details of the cluster state.
	// +optional
	Message string `json:"message,omitempty"`

	// Reason contains the optional reason of member crash or restart.
	// +optional
	Reason string `json:"reason,omitempty"`

	// RestartCount is the number of times the member has been restarted.
	// +optional
	RestartCount int32 `json:"restartCount"`
}

type HazelcastPersistenceConfiguration struct {
	// BaseDir is deprecated. Use restore.localConfig to restore from a local backup.
	// +optional
	DeprecatedBaseDir string `json:"baseDir"`

	// Configuration of the cluster recovery strategy.
	// +kubebuilder:default:="FullRecoveryOnly"
	// +optional
	ClusterDataRecoveryPolicy DataRecoveryPolicyType `json:"clusterDataRecoveryPolicy,omitempty"`

	// StartupAction represents the action triggered when the cluster starts to force the cluster startup.
	// +optional
	StartupAction PersistenceStartupAction `json:"startupAction,omitempty"`

	// DataRecoveryTimeout is timeout for each step of data recovery in seconds.
	// Maximum timeout is equal to DataRecoveryTimeout*2 (for each step: validation and data-load).
	// +optional
	DataRecoveryTimeout int32 `json:"dataRecoveryTimeout,omitempty"`

	// Configuration of PersistenceVolumeClaim.
	// +required
	PVC *PvcConfiguration `json:"pvc,omitempty"`

	// Restore configuration
	// +kubebuilder:default:={}
	// +optional
	Restore RestoreConfiguration `json:"restore,omitempty"`
}

type HazelcastSpec struct {
	// Number of Hazelcast members in the cluster.
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:default:=3
	// +optional
	ClusterSize *int32 `json:"clusterSize,omitempty"`

	// Repository to pull the Hazelcast Platform image from.
	// +kubebuilder:default:="docker.io/hazelcast/hazelcast"
	// +optional
	Repository string `json:"repository,omitempty"`

	// Version of Hazelcast Platform.
	// +kubebuilder:default:="5.4.0"
	// +optional
	Version string `json:"version,omitempty"`

	// Pull policy for the Hazelcast Platform image
	// +kubebuilder:default:="IfNotPresent"
	// +optional
	ImagePullPolicy corev1.PullPolicy `json:"imagePullPolicy,omitempty"`

	// Image pull secrets for the Hazelcast Platform image
	// +optional
	ImagePullSecrets []corev1.LocalObjectReference `json:"imagePullSecrets,omitempty"`

	// licenseKeySecret is a deprecated alias for licenseKeySecretName.
	// +optional
	DeprecatedLicenseKeySecret string `json:"licenseKeySecret,omitempty"`

	// Name of the secret with Hazelcast Enterprise License Key.
	// +optional
	LicenseKeySecretName string `json:"licenseKeySecretName,omitempty"`

	// Configuration to expose Hazelcast cluster to external clients.
	// +optional
	ExposeExternally *ExposeExternallyConfiguration `json:"exposeExternally,omitempty"`

	// Name of the Hazelcast cluster.
	// +kubebuilder:default:="dev"
	// +optional
	ClusterName string `json:"clusterName,omitempty"`

	// Scheduling details
	// +optional
	Scheduling *SchedulingConfiguration `json:"scheduling,omitempty"`

	// Compute Resources required by the Hazelcast container.
	// +optional
	Resources *corev1.ResourceRequirements `json:"resources,omitempty"`

	// Persistence configuration
	//+optional
	Persistence *HazelcastPersistenceConfiguration `json:"persistence,omitempty"`

	// B&R Agent configurations
	// +kubebuilder:default:={repository: "docker.io/hazelcast/platform-operator-agent", version: "0.1.26"}
	Agent AgentConfiguration `json:"agent,omitempty"`

	// Jet Engine configuration
	// +kubebuilder:default:={enabled: true, resourceUploadEnabled: false}
	// +optional
	JetEngineConfiguration *JetEngineConfiguration `json:"jet,omitempty"`

	// User Codes to Download into CLASSPATH
	// +optional
	UserCodeDeployment *UserCodeDeploymentConfig `json:"userCodeDeployment,omitempty"`

	// Java Executor Service configurations, see https://docs.hazelcast.com/hazelcast/latest/computing/executor-service
	// +optional
	ExecutorServices []ExecutorServiceConfiguration `json:"executorServices,omitempty"`

	// Durable Executor Service configurations, see https://docs.hazelcast.com/hazelcast/latest/computing/durable-executor-service
	// +optional
	DurableExecutorServices []DurableExecutorServiceConfiguration `json:"durableExecutorServices,omitempty"`

	// Scheduled Executor Service configurations, see https://docs.hazelcast.com/hazelcast/latest/computing/scheduled-executor-service
	// +optional
	ScheduledExecutorServices []ScheduledExecutorServiceConfiguration `json:"scheduledExecutorServices,omitempty"`

	// Hazelcast system properties, see https://docs.hazelcast.com/hazelcast/latest/system-properties
	// +optional
	Properties map[string]string `json:"properties,omitempty"`

	// Logging level for Hazelcast members
	// +kubebuilder:default:="INFO"
	// +optional
	LoggingLevel LoggingLevel `json:"loggingLevel,omitempty"`

	// Configuration to create clusters resilient to node and zone failures
	// +optional
	HighAvailabilityMode HighAvailabilityMode `json:"highAvailabilityMode,omitempty"`

	// Hazelcast JVM configuration
	// +optional
	JVM *JVMConfiguration `json:"jvm,omitempty"`

	// Hazelcast Native Memory (HD Memory) configuration
	// +optional
	NativeMemory *NativeMemoryConfiguration `json:"nativeMemory,omitempty"`

	// Hazelcast Advanced Network configuration
	// +optional
	AdvancedNetwork *AdvancedNetwork `json:"advancedNetwork,omitempty"`

	// Hazelcast Management Center Configuration
	// +optional
	ManagementCenterConfig *ManagementCenterConfig `json:"managementCenter,omitempty"`

	// Hazelcast TLS configuration
	// +optional
	TLS *TLS `json:"tls,omitempty"`

	// Hazelcast serialization configuration
	// +optional
	Serialization *SerializationConfig `json:"serialization,omitempty"`

	// Name of the ConfigMap with the Hazelcast custom configuration.
	// This configuration from the ConfigMap might be overridden by the Hazelcast CR configuration.
	// +optional
	CustomConfigCmName string `json:"customConfigCmName,omitempty"`

	// Hazelcast SQL configuration
	// +optional
	SQL *SQL `json:"sql,omitempty"`

	// Hazelcast LocalDevice configuration
	// +optional
	LocalDevices []LocalDeviceConfig `json:"localDevices,omitempty"`

	// Hazelcast Kubernetes resource annotations
	// +optional
	Annotations map[string]string `json:"annotations,omitempty"`

	// Hazelcast Kubernetes resource labels
	// +optional
	Labels map[string]string `json:"labels,omitempty"`

	// ServiceAccountName is the name of the ServiceAccount to use to run Hazelcast cluster.
	// More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/
	// +optional
	ServiceAccountName string `json:"serviceAccountName,omitempty"`

	// CPSubsystem is the configuration of the Hazelcast CP Subsystem.
	// +optional
	CPSubsystem *CPSubsystem `json:"cpSubsystem,omitempty"`
}

type HazelcastStatus struct {
	// Number of Hazelcast members in the cluster.
	// +optional
	ClusterSize int32 `json:"clusterSize"`

	// Selector is a label selector used by HorizontalPodAutoscaler to autoscale Hazelcast resource.
	// +optional
	Selector string `json:"selector"`

	// Phase of the Hazelcast cluster
	// +optional
	Phase Phase `json:"phase,omitempty"`

	// Status of the Hazelcast cluster
	// +optional
	Cluster HazelcastClusterStatus `json:"hazelcastClusterStatus,omitempty"`

	// Message about the Hazelcast cluster state
	// +optional
	Message string `json:"message,omitempty"`

	// Status of Hazelcast members
	// +optional
	Members []HazelcastMemberStatus `json:"members,omitempty"`

	// Status of restore process of the Hazelcast cluster
	// +kubebuilder:default:={}
	// +optional
	Restore RestoreStatus `json:"restore,omitempty"`
}

type HighAvailabilityMode string

type HotBackup struct {
	metav1.TypeMeta `json:",inline"`
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// +required
	Spec HotBackupSpec `json:"spec"`
	// +optional
	Status HotBackupStatus `json:"status,omitempty"`
}

type HotBackupList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []HotBackup `json:"items"`
}

type HotBackupSpec struct {
	// HazelcastResourceName defines the name of the Hazelcast resource
	// +required
	HazelcastResourceName string `json:"hazelcastResourceName"`

	// URL of the bucket to download HotBackup folders.
	// AWS S3, GCP Bucket and Azure Blob storage buckets are supported.
	// Example bucket URIs:
	// - AWS S3     -> s3://bucket-name/path/to/folder
	// - GCP Bucket -> gs://bucket-name/path/to/folder
	// - Azure Blob -> azblob://bucket-name/path/to/folder
	// +optional
	BucketURI string `json:"bucketURI,omitempty"`

	// secret is a deprecated alias for secretName.
	// +optional
	DeprecatedSecret string `json:"secret,omitempty"`

	// Name of the secret with credentials for cloud providers.
	// +optional
	SecretName string `json:"secretName,omitempty"`
}

type HotBackupState string

type HotBackupStatus struct {
	// +optional
	State HotBackupState `json:"state,omitempty"`
	// +optional
	Message string `json:"message,omitempty"`
	// +optional
	BackupUUIDs []string `json:"backupUUIDs,omitempty"`
}

type HotBackupTemplateSpec struct {
	// Standard object's metadata of the hot backups created from this template.
	// +kubebuilder:validation:XPreserveUnknownFields
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// Specification of the desired behavior of the hot backup.
	// +required
	Spec HotBackupSpec `json:"spec"`
}

type InMemoryFormatType string

type IndexConfig struct {
	// Name of the index config.
	// +optional
	Name string `json:"name,omitempty"`

	// Type of the index. See https://docs.hazelcast.com/hazelcast/latest/query/indexing-maps#index-types
	// +required
	Type IndexType `json:"type"`

	// Attributes of the index.
	// +optional
	Attributes []string `json:"attributes,omitempty"`

	// Options for "BITMAP" index type. See https://docs.hazelcast.com/hazelcast/latest/query/indexing-maps#configuring-bitmap-indexes
	// +kubebuilder:default:={}
	// +optional
	BitmapIndexOptions *BitmapIndexOptionsConfig `json:"bitMapIndexOptions,omitempty"`
}

type IndexType string

type InitialModeType string

type JVMConfiguration struct {
	// Memory is a JVM memory configuration
	// +optional
	Memory *JVMMemoryConfiguration `json:"memory,omitempty"`

	// GC is for configuring JVM Garbage Collector
	// +optional
	GC *JVMGCConfiguration `json:"gc,omitempty"`

	// Args is for arbitrary JVM arguments
	// +optional
	Args []string `json:"args,omitempty"`
}

type JVMGCConfiguration struct {
	// Logging enables logging when set to true
	// +optional
	Logging *bool `json:"logging,omitempty"`

	// Collector is the Garbage Collector type
	// +optional
	Collector *GCType `json:"collector,omitempty"`
}

type JVMMemoryConfiguration struct {
	// InitialRAMPercentage configures JVM initial heap size
	// +optional
	InitialRAMPercentage *string `json:"initialRAMPercentage,omitempty"`

	// MinRAMPercentage sets the minimum heap size for a JVM
	// +optional
	MinRAMPercentage *string `json:"minRAMPercentage,omitempty"`

	// MaxRAMPercentage sets the maximum heap size for a JVM
	// +optional
	MaxRAMPercentage *string `json:"maxRAMPercentage,omitempty"`
}

type JavaSerializationFilter struct {

	// Java deserialization protection Blacklist.
	// +optional
	Blacklist *SerializationFilterList `json:"blacklist,omitempty"`

	// Java deserialization protection Whitelist.
	// +optional
	Whitelist *SerializationFilterList `json:"whitelist,omitempty"`
}

type JetEdgeDefaults struct {
	// Sets the capacity of processor-to-processor concurrent queues.
	// +optional
	QueueSize *int32 `json:"queueSize,omitempty"`

	// Limits the size of the packet in bytes.
	// +optional
	PacketSizeLimit *int32 `json:"packetSizeLimit,omitempty"`

	// Sets the scaling factor used by the adaptive receive window sizing function.
	// +optional
	ReceiveWindowMultiplier *int8 `json:"receiveWindowMultiplier,omitempty"`
}

type JetEngineConfiguration struct {
	// When false, disables Jet Engine.
	// +kubebuilder:default:=true
	// +optional
	Enabled *bool `json:"enabled,omitempty"`

	// When true, enables resource uploading for Jet jobs.
	// +kubebuilder:default:=false
	// +optional
	ResourceUploadEnabled bool `json:"resourceUploadEnabled"`

	// Configuration for downloading the JAR files be downloaded and accessible for the member.
	// These JAR files will not be placed in the CLASSPATH.
	// +optional
	RemoteFileConfiguration `json:",inline"`

	// Jet Instance Configuration
	// +kubebuilder:default:={}
	// +optional
	Instance *JetInstance `json:"instance,omitempty"`

	// Jet Edge Defaults Configuration
	// +kubebuilder:default:={}
	// +optional
	EdgeDefaults *JetEdgeDefaults `json:"edgeDefaults,omitempty"`
}

type JetInstance struct {
	// The number of threads Jet creates in its cooperative multithreading pool.
	// Its default value is the number of cores
	// +kubebuilder:validation:Minimum:=1
	// +optional
	CooperativeThreadCount *int32 `json:"cooperativeThreadCount,omitempty"`

	// The duration of the interval between flow-control packets.
	// +kubebuilder:default:=100
	// +optional
	FlowControlPeriodMillis int32 `json:"flowControlPeriodMillis,omitempty"`

	// The number of synchronous backups to configure on the IMap that Jet needs internally to store job metadata and snapshots.
	// +kubebuilder:default:=1
	// +kubebuilder:validation:Maximum:=6
	// +optional
	BackupCount int32 `json:"backupCount,omitempty"`

	// The delay after which the auto-scaled jobs restart if a new member joins the cluster.
	// +kubebuilder:default:=10000
	// +optional
	ScaleUpDelayMillis int32 `json:"scaleUpDelayMillis,omitempty"`

	// Specifies whether the Lossless Cluster Restart feature is enabled.
	// +kubebuilder:default:=false
	// +optional
	LosslessRestartEnabled bool `json:"losslessRestartEnabled"`

	// Specifies the maximum number of records that can be accumulated by any single processor instance.
	// Default value is Long.MAX_VALUE
	// +optional
	MaxProcessorAccumulatedRecords *int64 `json:"maxProcessorAccumulatedRecords,omitempty"`
}

type JetJob struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   JetJobSpec   `json:"spec,omitempty"`
	Status JetJobStatus `json:"status,omitempty"`
}

type JetJobList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []JetJob `json:"items"`
}

type JetJobSnapshot struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// +required
	Spec JetJobSnapshotSpec `json:"spec"`
	// +kubebuilder:default:={state: "Waiting"}
	// +optional
	Status JetJobSnapshotStatus `json:"status,omitempty"`
}

type JetJobSnapshotList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []JetJobSnapshot `json:"items"`
}

type JetJobSnapshotSpec struct {
	// Name of the exported snapshot
	// +optional
	Name string `json:"name,omitempty"`

	// CancelJob determines whether the job is canceled after exporting snapshot
	// +kubebuilder:default:=false
	// +optional
	CancelJob bool `json:"cancelJob"`

	// JetJobResourceName is the name of the JetJob CR where the Snapshot is exported from
	// +kubebuilder:validation:MinLength:=1
	// +required
	JetJobResourceName string `json:"jetJobResourceName"`
}

type JetJobSnapshotState string

type JetJobSnapshotStatus struct {
	// +optional
	State JetJobSnapshotState `json:"state"`

	// +optional
	Message string `json:"message,omitempty"`

	// +optional
	CreationTime *metav1.Time `json:"creationTime,omitempty"`
}

type JetJobSpec struct {
	// Name of the JetJob to be created. If empty, CR name will be used.
	// It cannot be updated after the config is created successfully.
	// +optional
	Name string `json:"name,omitempty"`

	// HazelcastResourceName defines the name of the Hazelcast resource that this resource is
	// created for.
	// +kubebuilder:validation:MinLength:=1
	// +required
	HazelcastResourceName string `json:"hazelcastResourceName"`

	// State is used to manage the job state.
	// +kubebuilder:default:=Running
	// +kubebuilder:validation:Enum=Running;Suspended;Canceled;Restarted
	// +required
	State JetJobState `json:"state"`

	// JarName specify the name of the Jar to run that is present on the member.
	// +kubebuilder:validation:MinLength:=1
	// +required
	JarName string `json:"jarName"`

	// MainClass is the name of the main class that will be run on the submitted job.
	// +optional
	MainClass string `json:"mainClass,omitempty"`

	// InitialSnapshotResourceName specify the name of the JetJobSnapshot object from which
	// the JetJob is initialized.
	// +optional
	InitialSnapshotResourceName string `json:"initialSnapshotResourceName,omitempty"`

	// Configuration for downloading the file from remote.
	// +optional
	JetRemoteFileConfiguration `json:",inline"`
}

type JetJobState string

type JetJobStatus struct {
	Id    int64             `json:"id"`
	Phase JetJobStatusPhase `json:"phase"`
	// +optional
	SubmissionTime *metav1.Time `json:"submissionTime,omitempty"`
	// +optional
	CompletionTime  *metav1.Time `json:"completionTime,omitempty"`
	FailureText     string       `json:"failureText,omitempty"`
	SuspensionCause string       `json:"suspensionCause,omitempty"`
}

type JetJobStatusPhase string

type JetRemoteFileConfiguration struct {
	// Bucket config from where the JAR files will be downloaded.
	// +optional
	BucketConfiguration *BucketConfiguration `json:"bucketConfig,omitempty"`

	// URL from where the file will be downloaded.
	// +optional
	RemoteURL string `json:"remoteURL,omitempty"`
}

type LDAPProvider struct {
	// URL of your LDAP server, including schema (ldap://) and port.
	// +required
	URL string `json:"url"`

	// CredentialsSecretName is the name of the secret that contains username and password of a user that has admin privileges on the LDAP server.
	// The username must be the DN of the user. It is used to connect to the server when authenticating users.
	// +required
	CredentialsSecretName string `json:"credentialsSecretName"`

	// DN to be used for searching users.
	// +required
	UserDN string `json:"userDN"`

	// DN to be used for searching groups.
	// +required
	GroupDN string `json:"groupDN"`

	// Members of these groups and its nested groups have admin privileges on the Management Center.
	// +kubebuilder:validation:MinItems:=1
	AdminGroups []string `json:"adminGroups"`

	// Members of these groups and its nested groups have read and write privileges on the Management Center.
	// +kubebuilder:validation:MinItems:=1
	UserGroups []string `json:"userGroups"`

	// Members of these groups and its nested groups have only read privilege on the Management Center.
	// +kubebuilder:validation:MinItems:=1
	ReadonlyUserGroups []string `json:"readonlyUserGroups"`

	// Members of these groups and its nested groups have the privilege to see only the metrics on the Management Center.
	// +kubebuilder:validation:MinItems:=1
	MetricsOnlyGroups []string `json:"metricsOnlyGroups"`

	// LDAP search filter expression to search for the users.
	// For example, uid={0} searches for a username that matches with the uid attribute.
	// +required
	UserSearchFilter string `json:"userSearchFilter"`

	// LDAP search filter expression to search for the groups.
	// For example, uniquemember={0} searches for a group that matches with the uniquemember attribute.
	// +required
	GroupSearchFilter string `json:"groupSearchFilter"`

	// NestedGroupSearch enables searching for nested LDAP groups.
	// +kubebuilder:default:=false
	NestedGroupSearch bool `json:"nestedGroupSearch"`
}

type LocalDeviceConfig struct {
	// Name represents the name of the local device
	// +required
	Name string `json:"name"`

	// BlockSize defines Device block/sector size in bytes.
	// +kubebuilder:validation:Minimum=512
	// +kubebuilder:default:=4096
	// +optional
	BlockSize *int32 `json:"blockSize,omitempty"`

	// ReadIOThreadCount is Read IO thread count.
	// +kubebuilder:validation:Minimum:=1
	// +kubebuilder:default:=4
	// +optional
	ReadIOThreadCount *int32 `json:"readIOThreadCount,omitempty"`

	// WriteIOThreadCount is Write IO thread count.
	// +kubebuilder:validation:Minimum:=1
	// +kubebuilder:default:=4
	// +optional
	WriteIOThreadCount *int32 `json:"writeIOThreadCount,omitempty"`

	// Configuration of PersistenceVolumeClaim.
	// +required
	PVC *PvcConfiguration `json:"pvc,omitempty"`
}

type LoggingLevel string

type MCJVMConfiguration struct {
	// Args is for arbitrary JVM arguments
	// +optional
	Args []string `json:"args,omitempty"`
}

type MCPersistenceConfiguration struct {
	// When true, MC will use a PersistentVolumeClaim to store data.
	// +kubebuilder:default:=true
	// +optional
	Enabled *bool `json:"enabled,omitempty"`

	// Name of the PersistentVolumeClaim MC will use for persistence. If not empty,
	// MC will use the existing claim instead of creating a new one.
	// +optional
	ExistingVolumeClaimName string `json:"existingVolumeClaimName,omitempty"`

	// StorageClass from which PersistentVolumeClaim will be created.
	// +optional
	StorageClass *string `json:"storageClass,omitempty"`

	// Size of the created PersistentVolumeClaim.
	// +kubebuilder:default:="10Gi"
	// +optional
	Size *resource.Quantity `json:"size,omitempty"`
}

type MCPhase string

type ManagementCenter struct {
	metav1.TypeMeta `json:",inline"`
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// Initial values will be filled with its fields' default values.
	// +kubebuilder:default:={"repository" : "docker.io/hazelcast/management-center"}
	// +optional
	Spec ManagementCenterSpec `json:"spec,omitempty"`

	// +optional
	Status ManagementCenterStatus `json:"status,omitempty"`
}

type ManagementCenterConfig struct {
	// Allows you to execute scripts that can automate interactions with the cluster.
	// +kubebuilder:default:=false
	// +optional
	ScriptingEnabled bool `json:"scriptingEnabled,omitempty"`

	// Allows you to execute commands from a built-in console in the user interface.
	// +kubebuilder:default:=false
	// +optional
	ConsoleEnabled bool `json:"consoleEnabled,omitempty"`

	// Allows you to access contents of Hazelcast data structures via SQL Browser or Map Browser.
	// +kubebuilder:default:=false
	// +optional
	DataAccessEnabled bool `json:"dataAccessEnabled,omitempty"`
}

type ManagementCenterList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ManagementCenter `json:"items"`
}

type ManagementCenterSpec struct {
	// Repository to pull the Management Center image from.
	// +kubebuilder:default:="docker.io/hazelcast/management-center"
	// +optional
	Repository string `json:"repository,omitempty"`

	// Version of Management Center.
	// +kubebuilder:default:="5.4.0"
	// +optional
	Version string `json:"version,omitempty"`

	// Pull policy for the Management Center image
	// +kubebuilder:default:="IfNotPresent"
	// +optional
	ImagePullPolicy corev1.PullPolicy `json:"imagePullPolicy,omitempty"`

	// Image pull secrets for the Management Center image
	// +optional
	ImagePullSecrets []corev1.LocalObjectReference `json:"imagePullSecrets,omitempty"`

	// licenseKeySecret is a deprecated alias for licenseKeySecretName.
	// +optional
	DeprecatedLicenseKeySecret string `json:"licenseKeySecret,omitempty"`

	// Name of the secret with Hazelcast Enterprise License Key.
	// +optional
	LicenseKeySecretName string `json:"licenseKeySecretName,omitempty"`

	// Connection configuration for the Hazelcast clusters that Management Center will monitor.
	// +optional
	HazelcastClusters []HazelcastClusterConfig `json:"hazelcastClusters,omitempty"`

	// Configuration to expose Management Center to outside.
	// +kubebuilder:default:={type: "LoadBalancer"}
	// +optional
	ExternalConnectivity *ExternalConnectivityConfiguration `json:"externalConnectivity,omitempty"`

	// Configuration for Management Center persistence.
	// +kubebuilder:default:={enabled: true, size: "10Gi"}
	// +optional
	Persistence *MCPersistenceConfiguration `json:"persistence,omitempty"`

	// Scheduling details
	// +kubebuilder:default:={}
	// +optional
	Scheduling *SchedulingConfiguration `json:"scheduling,omitempty"`

	// Compute Resources required by the MC container.
	// +kubebuilder:default:={}
	// +optional
	Resources *corev1.ResourceRequirements `json:"resources,omitempty"`

	// ManagementCenter JVM configuration
	// +optional
	JVM *MCJVMConfiguration `json:"jvm,omitempty"`

	// SecurityProviders to authenticate users in Management Center
	// +optional
	SecurityProviders *SecurityProviders `json:"securityProvider,omitempty"`

	// ManagementCenter Kubernetes resource annotations
	// +optional
	Annotations map[string]string `json:"annotations,omitempty"`

	// ManagementCenter Kubernetes resource labels
	// +optional
	Labels map[string]string `json:"labels,omitempty"`
}

type ManagementCenterStatus struct {
	// Phase of the Management Center
	// +optional
	Phase MCPhase `json:"phase,omitempty"`

	// Configured is a flag that indicates if the configuration step has successfully passed
	// +optional
	Configured bool `json:"configured"`

	// Message about the Management Center state
	// +optional
	Message string `json:"message,omitempty"`

	// External addresses of the Management Center instance
	// +optional
	ExternalAddresses string `json:"externalAddresses,omitempty"`
}

type Map struct {
	metav1.TypeMeta `json:",inline"`
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// +required
	Spec MapSpec `json:"spec"`
	// +optional
	Status MapStatus `json:"status,omitempty"`
}

type MapConfigState string

type MapList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Map `json:"items"`
}

type MapSpec struct {
	DataStructureSpec `json:",inline"`

	// Maximum time in seconds for each entry to stay in the map.
	// If it is not 0, entries that are older than this time and not updated for this time are evicted automatically.
	// It can be updated.
	// +kubebuilder:default:=0
	// +optional
	TimeToLiveSeconds int32 `json:"timeToLiveSeconds"`

	// Maximum time in seconds for each entry to stay idle in the map.
	// Entries that are idle for more than this time are evicted automatically.
	// It can be updated.
	// +kubebuilder:default:=0
	// +optional
	MaxIdleSeconds int32 `json:"maxIdleSeconds"`

	// Configuration for removing data from the map when it reaches its max size.
	// It can be updated.
	// +kubebuilder:default:={maxSize: 0, evictionPolicy: NONE, maxSizePolicy: PER_NODE}
	// +optional
	Eviction EvictionConfig `json:"eviction,omitempty"`

	// Indexes to be created for the map data.
	// You can learn more at https://docs.hazelcast.com/hazelcast/latest/query/indexing-maps.
	// It cannot be updated after map config is created successfully.
	// +optional
	Indexes []IndexConfig `json:"indexes,omitempty"`

	// Attributes to be used with Predicates API.
	// You can learn more at https://docs.hazelcast.com/hazelcast/latest/query/predicate-overview#creating-custom-query-attributes
	// +optional
	Attributes []AttributeConfig `json:"attributes,omitempty"`

	// When enabled, map data will be persisted.
	// It cannot be updated after map config is created successfully.
	// +kubebuilder:default:=false
	// +optional
	PersistenceEnabled bool `json:"persistenceEnabled"`

	// Configuration options when you want to load/store the map entries
	// from/to a persistent data store such as a relational database
	// You can learn more at https://docs.hazelcast.com/hazelcast/latest/data-structures/working-with-external-data
	// +optional
	MapStore *MapStoreConfig `json:"mapStore,omitempty"`

	// InMemoryFormat specifies in which format data will be stored in your map
	// +kubebuilder:default:=BINARY
	// +optional
	InMemoryFormat InMemoryFormatType `json:"inMemoryFormat,omitempty"`

	// EntryListeners contains the configuration for the map-level or entry-based events listeners
	// provided by the Hazelcast’s eventing framework.
	// You can learn more at https://docs.hazelcast.com/hazelcast/latest/events/object-events.
	// +optional
	EntryListeners []EntryListenerConfiguration `json:"entryListeners,omitempty"`

	// InMemoryFormat specifies near cache configuration for map
	// +optional
	NearCache *NearCache `json:"nearCache"`

	// EventJournal specifies event journal configuration of the Map
	// +optional
	EventJournal *EventJournal `json:"eventJournal,omitempty"`

	// TieredStore enables the Hazelcast's Tiered-Store feature for the Map
	// +optional
	TieredStore *TieredStore `json:"tieredStore,omitempty"`

	// MerkleTree defines the configuration for the Merkle tree data structure.
	// +optional
	MerkleTree *MerkleTreeConfig `json:"merkleTree,omitempty"`
}

type MapStatus struct {
	// +optional
	State MapConfigState `json:"state,omitempty"`
	// +optional
	Message string `json:"message,omitempty"`
	// +optional
	MemberStatuses map[string]MapConfigState `json:"memberStatuses,omitempty"`
}

type MapStoreConfig struct {
	// Sets the initial entry loading mode.
	// +kubebuilder:default:=LAZY
	// +optional
	InitialMode InitialModeType `json:"initialMode,omitempty"`

	// Name of your class implementing MapLoader and/or MapStore interface.
	// +required
	ClassName string `json:"className"`

	// Number of seconds to delay the storing of entries.
	// +kubebuilder:default:0
	// +optional
	WriteDelaySeconds int32 `json:"writeDelaySeconds"`

	// Used to create batches when writing to map store.
	// +kubebuilder:default:=1
	// +kubebuilder:validation:Minimum=1
	// +optional
	WriteBatchSize int32 `json:"writeBatchSize,omitempty"`

	// It is meaningful if you are using write behind in MapStore. When it is set to true,
	// only the latest store operation on a key during the write-delay-seconds will be
	// reflected to MapStore.
	// +kubebuilder:default:=true
	// +optional
	WriteCoealescing *bool `json:"writeCoalescing,omitempty"`

	// Properties can be used for giving information to the MapStore implementation
	// +optional
	PropertiesSecretName string `json:"propertiesSecretName,omitempty"`
}

type MaxSizePolicyType string

type MemberAccess string