persistence

type ActivityInfo struct {
	Version                  int64
	ScheduleID               int64
	ScheduledEventBatchID    int64
	ScheduledEvent           *types.HistoryEvent
	ScheduledTime            time.Time
	StartedID                int64
	StartedEvent             *types.HistoryEvent
	StartedTime              time.Time
	DomainID                 string
	ActivityID               string
	RequestID                string
	Details                  []byte
	ScheduleToStartTimeout   int32
	ScheduleToCloseTimeout   int32
	StartToCloseTimeout      int32
	HeartbeatTimeout         int32
	CancelRequested          bool
	CancelRequestID          int64
	LastHeartBeatUpdatedTime time.Time
	TimerTaskStatus          int32
	// For retry
	Attempt            int32
	StartedIdentity    string
	TaskList           string
	TaskListKind       types.TaskListKind
	HasRetryPolicy     bool
	InitialInterval    int32
	BackoffCoefficient float64
	MaximumInterval    int32
	ExpirationTime     time.Time
	MaximumAttempts    int32
	NonRetriableErrors []string
	LastFailureReason  string
	LastWorkerIdentity string
	LastFailureDetails []byte
	// Not written to database - This is used only for deduping heartbeat timer creation
	LastHeartbeatTimeoutVisibilityInSeconds int64
}

type ActivityRetryTimerTask struct {
	WorkflowIdentifier
	TaskData
	EventID int64
	Attempt int64
}

type ActivityTask struct {
	WorkflowIdentifier
	TaskData
	TargetDomainID string
	TaskList       string
	ScheduleID     int64
}

type ActivityTimeoutTask struct {
	WorkflowIdentifier
	TaskData
	TimeoutType int
	EventID     int64
	Attempt     int64
}

type AppendHistoryNodesRequest struct {
	// true if this is the first append request to the branch
	IsNewBranch bool
	// the info for clean up data in background
	Info string
	// The branch to be appended
	BranchToken []byte
	// The batch of events to be appended. The first eventID will become the nodeID of this batch
	Events []*types.HistoryEvent
	// requested TransactionID for this write operation. For the same eventID, the node with larger TransactionID always wins
	TransactionID int64
	// optional binary encoding type
	Encoding constants.EncodingType
	// The shard to get history node data
	ShardID *int

	// DomainName to get metrics created with the domain
	DomainName string
}

type AppendHistoryNodesResponse struct {
	// The data blob that was persisted to database
	DataBlob DataBlob
}

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

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

type CancelExecutionTask struct {
	WorkflowIdentifier
	TaskData
	TargetDomainID          string
	TargetWorkflowID        string
	TargetRunID             string
	TargetChildWorkflowOnly bool
	InitiatedID             int64
}

type ChildExecutionInfo struct {
	Version               int64
	InitiatedID           int64
	InitiatedEventBatchID int64
	InitiatedEvent        *types.HistoryEvent
	StartedID             int64
	StartedWorkflowID     string
	StartedRunID          string
	StartedEvent          *types.HistoryEvent
	CreateRequestID       string
	DomainID              string
	DomainNameDEPRECATED  string // deprecated: please use DomainID field instead
	WorkflowTypeName      string
	ParentClosePolicy     types.ParentClosePolicy
}

type CloseExecutionTask struct {
	WorkflowIdentifier
	TaskData
}

type Closeable interface {
	Close()
}

type ClusterReplicationConfig struct {
	ClusterName string
}

type CompleteForkBranchRequest struct {
	// the new branch returned from ForkHistoryBranchRequest
	BranchToken []byte
	// true means the fork is success, will update the flag, otherwise will delete the new branch
	Success bool
	// The shard to update history branch data
	ShardID *int
}

type CompleteHistoryTaskRequest struct {
	TaskCategory HistoryTaskCategory
	TaskKey      HistoryTaskKey
}

type CompleteTaskRequest struct {
	TaskList   *TaskListInfo
	TaskID     int64
	DomainName string
}

type CompleteTasksLessThanRequest struct {
	DomainID     string
	TaskListName string
	TaskType     int
	TaskID       int64 // Tasks less than or equal to this ID will be completed
	Limit        int   // Limit on the max number of tasks that can be completed. Required param
	DomainName   string
}

type CompleteTasksLessThanResponse struct {
	TasksCompleted int
}

type ConditionFailedError struct {
	Msg string
}

type ConfigStore interface {
	Closeable
	FetchConfig(ctx context.Context, configType ConfigType) (*InternalConfigStoreEntry, error)
	UpdateConfig(ctx context.Context, value *InternalConfigStoreEntry) error
}

type ConfigStoreManager interface {
	Closeable
	FetchDynamicConfig(ctx context.Context, cfgType ConfigType) (*FetchDynamicConfigResponse, error)
	UpdateDynamicConfig(ctx context.Context, request *UpdateDynamicConfigRequest, cfgType ConfigType) error
}

type ConfigType int

type ConflictResolveWorkflowExecutionRequest struct {
	RangeID int64

	Mode ConflictResolveWorkflowMode

	// workflow to be reset
	ResetWorkflowSnapshot WorkflowSnapshot

	// maybe new workflow
	NewWorkflowSnapshot *WorkflowSnapshot

	// current workflow
	CurrentWorkflowMutation *WorkflowMutation

	WorkflowRequestMode CreateWorkflowRequestMode

	Encoding constants.EncodingType // optional binary encoding type

	DomainName string
}

type ConflictResolveWorkflowExecutionResponse struct {
	MutableStateUpdateSessionStats *MutableStateUpdateSessionStats
}

type ConflictResolveWorkflowMode int

type CountWorkflowExecutionsRequest struct {
	DomainUUID string
	Domain     string // domain name is not persisted, but used as config filter key
	Query      string
}

type CountWorkflowExecutionsResponse struct {
	Count int64
}

type CreateDomainRequest struct {
	Info              *DomainInfo
	Config            *DomainConfig
	ReplicationConfig *DomainReplicationConfig
	IsGlobalDomain    bool
	ConfigVersion     int64
	FailoverVersion   int64
	LastUpdatedTime   int64
	CurrentTimeStamp  time.Time
}

type CreateDomainResponse struct {
	ID string
}

type CreateFailoverMarkersRequest struct {
	RangeID          int64
	Markers          []*FailoverMarkerTask
	CurrentTimeStamp time.Time
}

type CreateShardRequest struct {
	ShardInfo *ShardInfo
}

type CreateTaskInfo struct {
	Data   *TaskInfo
	TaskID int64
}

type CreateTasksRequest struct {
	TaskListInfo     *TaskListInfo
	Tasks            []*CreateTaskInfo
	DomainName       string
	CurrentTimeStamp time.Time
}

type CreateTasksResponse struct {
}

type CreateWorkflowExecutionRequest struct {
	RangeID int64

	Mode CreateWorkflowMode

	PreviousRunID            string
	PreviousLastWriteVersion int64

	NewWorkflowSnapshot WorkflowSnapshot

	WorkflowRequestMode CreateWorkflowRequestMode
	DomainName          string
}

type CreateWorkflowExecutionResponse struct {
	MutableStateUpdateSessionStats *MutableStateUpdateSessionStats
}

type CreateWorkflowMode int

type CreateWorkflowRequestMode int

type CrossClusterTaskInfo = TransferTaskInfo

type CurrentWorkflowConditionFailedError struct {
	Msg string
}

type CurrentWorkflowExecution struct {
	DomainID     string
	WorkflowID   string
	RunID        string
	State        int
	CurrentRunID string
}

type DBUnavailableError struct {
	Msg string
}

type DataBlob struct {
	Encoding constants.EncodingType
	Data     []byte
}

type DecisionTask struct {
	WorkflowIdentifier
	TaskData
	TargetDomainID string
	TaskList       string
	ScheduleID     int64
}

type DecisionTimeoutTask struct {
	WorkflowIdentifier
	TaskData
	EventID         int64
	ScheduleAttempt int64
	TimeoutType     int
}

type DeleteCurrentWorkflowExecutionRequest struct {
	DomainID   string
	WorkflowID string
	RunID      string
	DomainName string
}

type DeleteDomainByNameRequest struct {
	Name string
}

type DeleteDomainRequest struct {
	ID string
}

type DeleteHistoryBranchRequest struct {
	// branch to be deleted
	BranchToken []byte
	// The shard to delete history branch data
	ShardID *int
	// DomainName to generate metrics for Domain Cost Attribution
	DomainName string
}

type DeleteHistoryEventTask struct {
	WorkflowIdentifier
	TaskData
}

type DeleteReplicationTaskFromDLQRequest struct {
	SourceClusterName string
	TaskID            int64
}

type DeleteTaskListRequest struct {
	DomainID     string
	DomainName   string
	TaskListName string
	TaskListType int
	RangeID      int64
}

type DeleteWorkflowExecutionRequest struct {
	DomainID   string
	WorkflowID string
	RunID      string
	DomainName string
}

type DomainConfig struct {
	// NOTE: this retention is in days, not in seconds
	Retention                int32
	EmitMetric               bool
	HistoryArchivalStatus    types.ArchivalStatus
	HistoryArchivalURI       string
	VisibilityArchivalStatus types.ArchivalStatus
	VisibilityArchivalURI    string
	BadBinaries              types.BadBinaries
	IsolationGroups          types.IsolationGroupConfiguration
	AsyncWorkflowConfig      types.AsyncWorkflowConfiguration
}

type DomainInfo struct {
	ID          string
	Name        string
	Status      int
	Description string
	OwnerEmail  string
	Data        map[string]string
}

type DomainManager interface {
	Closeable
	GetName() string
	CreateDomain(ctx context.Context, request *CreateDomainRequest) (*CreateDomainResponse, error)
	GetDomain(ctx context.Context, request *GetDomainRequest) (*GetDomainResponse, error)
	UpdateDomain(ctx context.Context, request *UpdateDomainRequest) error
	DeleteDomain(ctx context.Context, request *DeleteDomainRequest) error
	DeleteDomainByName(ctx context.Context, request *DeleteDomainByNameRequest) error
	ListDomains(ctx context.Context, request *ListDomainsRequest) (*ListDomainsResponse, error)
	GetMetadata(ctx context.Context) (*GetMetadataResponse, error)
}

type DomainReplicationConfig struct {
	Clusters []*ClusterReplicationConfig

	// ActiveClusterName is the name of the cluster that the domain is active in.
	// Applicable for active-passive domains.
	ActiveClusterName string

	// ActiveClusters is only applicable for active-active domains.
	// If this is set, ActiveClusterName is ignored.
	ActiveClusters *types.ActiveClusters
}

type DomainStore interface {
	Closeable
	GetName() string
	CreateDomain(ctx context.Context, request *InternalCreateDomainRequest) (*CreateDomainResponse, error)
	GetDomain(ctx context.Context, request *GetDomainRequest) (*InternalGetDomainResponse, error)
	UpdateDomain(ctx context.Context, request *InternalUpdateDomainRequest) error
	DeleteDomain(ctx context.Context, request *DeleteDomainRequest) error
	DeleteDomainByName(ctx context.Context, request *DeleteDomainByNameRequest) error
	ListDomains(ctx context.Context, request *ListDomainsRequest) (*InternalListDomainsResponse, error)
	GetMetadata(ctx context.Context) (*GetMetadataResponse, error)
}

type DuplicateRequestError struct {
	RequestType WorkflowRequestType
	RunID       string
}

type DynamicConfigSnapshot struct {
	Version int64
	Values  *types.DynamicConfigBlob
}

type DynamicConfiguration struct {
	EnableSQLAsyncTransaction                dynamicproperties.BoolPropertyFn
	EnableCassandraAllConsistencyLevelDelete dynamicproperties.BoolPropertyFn
	PersistenceSampleLoggingRate             dynamicproperties.IntPropertyFn
	EnableShardIDMetrics                     dynamicproperties.BoolPropertyFn
	EnableHistoryTaskDualWriteMode           dynamicproperties.BoolPropertyFn
	ReadNoSQLHistoryTaskFromDataBlob         dynamicproperties.BoolPropertyFn
	ReadNoSQLShardFromDataBlob               dynamicproperties.BoolPropertyFn
	SerializationEncoding                    dynamicproperties.StringPropertyFn
}

type ExecutionManager interface {
	Closeable
	GetName() string
	GetShardID() int

	CreateWorkflowExecution(ctx context.Context, request *CreateWorkflowExecutionRequest) (*CreateWorkflowExecutionResponse, error)
	GetWorkflowExecution(ctx context.Context, request *GetWorkflowExecutionRequest) (*GetWorkflowExecutionResponse, error)
	UpdateWorkflowExecution(ctx context.Context, request *UpdateWorkflowExecutionRequest) (*UpdateWorkflowExecutionResponse, error)
	ConflictResolveWorkflowExecution(ctx context.Context, request *ConflictResolveWorkflowExecutionRequest) (*ConflictResolveWorkflowExecutionResponse, error)
	DeleteWorkflowExecution(ctx context.Context, request *DeleteWorkflowExecutionRequest) error
	DeleteCurrentWorkflowExecution(ctx context.Context, request *DeleteCurrentWorkflowExecutionRequest) error
	GetCurrentExecution(ctx context.Context, request *GetCurrentExecutionRequest) (*GetCurrentExecutionResponse, error)
	IsWorkflowExecutionExists(ctx context.Context, request *IsWorkflowExecutionExistsRequest) (*IsWorkflowExecutionExistsResponse, error)

	PutReplicationTaskToDLQ(ctx context.Context, request *PutReplicationTaskToDLQRequest) error
	GetReplicationTasksFromDLQ(ctx context.Context, request *GetReplicationTasksFromDLQRequest) (*GetHistoryTasksResponse, error)
	GetReplicationDLQSize(ctx context.Context, request *GetReplicationDLQSizeRequest) (*GetReplicationDLQSizeResponse, error)
	DeleteReplicationTaskFromDLQ(ctx context.Context, request *DeleteReplicationTaskFromDLQRequest) error
	RangeDeleteReplicationTaskFromDLQ(ctx context.Context, request *RangeDeleteReplicationTaskFromDLQRequest) (*RangeDeleteReplicationTaskFromDLQResponse, error)
	CreateFailoverMarkerTasks(ctx context.Context, request *CreateFailoverMarkersRequest) error

	GetHistoryTasks(ctx context.Context, request *GetHistoryTasksRequest) (*GetHistoryTasksResponse, error)
	CompleteHistoryTask(ctx context.Context, request *CompleteHistoryTaskRequest) error
	RangeCompleteHistoryTask(ctx context.Context, request *RangeCompleteHistoryTaskRequest) (*RangeCompleteHistoryTaskResponse, error)

	ListConcreteExecutions(ctx context.Context, request *ListConcreteExecutionsRequest) (*ListConcreteExecutionsResponse, error)
	ListCurrentExecutions(ctx context.Context, request *ListCurrentExecutionsRequest) (*ListCurrentExecutionsResponse, error)

	GetActiveClusterSelectionPolicy(ctx context.Context, domainID, wfID, rID string) (*types.ActiveClusterSelectionPolicy, error)
	DeleteActiveClusterSelectionPolicy(ctx context.Context, domainID, workflowID, runID string) error
}

type ExecutionManagerFactory interface {
	Closeable
	NewExecutionManager(shardID int) (ExecutionManager, error)
}

type ExecutionStats struct {
	HistorySize int64
}

type ExecutionStore interface {
	Closeable
	GetName() string
	GetShardID() int
	// The below three APIs are related to serialization/deserialization
	GetWorkflowExecution(ctx context.Context, request *InternalGetWorkflowExecutionRequest) (*InternalGetWorkflowExecutionResponse, error)
	UpdateWorkflowExecution(ctx context.Context, request *InternalUpdateWorkflowExecutionRequest) error
	ConflictResolveWorkflowExecution(ctx context.Context, request *InternalConflictResolveWorkflowExecutionRequest) error

	CreateWorkflowExecution(ctx context.Context, request *InternalCreateWorkflowExecutionRequest) (*CreateWorkflowExecutionResponse, error)
	DeleteWorkflowExecution(ctx context.Context, request *DeleteWorkflowExecutionRequest) error
	DeleteCurrentWorkflowExecution(ctx context.Context, request *DeleteCurrentWorkflowExecutionRequest) error
	GetCurrentExecution(ctx context.Context, request *GetCurrentExecutionRequest) (*GetCurrentExecutionResponse, error)
	IsWorkflowExecutionExists(ctx context.Context, request *IsWorkflowExecutionExistsRequest) (*IsWorkflowExecutionExistsResponse, error)

	// Replication task related methods
	PutReplicationTaskToDLQ(ctx context.Context, request *InternalPutReplicationTaskToDLQRequest) error
	GetReplicationTasksFromDLQ(ctx context.Context, request *GetReplicationTasksFromDLQRequest) (*GetHistoryTasksResponse, error)
	GetReplicationDLQSize(ctx context.Context, request *GetReplicationDLQSizeRequest) (*GetReplicationDLQSizeResponse, error)
	DeleteReplicationTaskFromDLQ(ctx context.Context, request *DeleteReplicationTaskFromDLQRequest) error
	RangeDeleteReplicationTaskFromDLQ(ctx context.Context, request *RangeDeleteReplicationTaskFromDLQRequest) (*RangeDeleteReplicationTaskFromDLQResponse, error)
	CreateFailoverMarkerTasks(ctx context.Context, request *CreateFailoverMarkersRequest) error

	// History task related methods
	GetHistoryTasks(ctx context.Context, request *GetHistoryTasksRequest) (*GetHistoryTasksResponse, error)
	CompleteHistoryTask(ctx context.Context, request *CompleteHistoryTaskRequest) error
	RangeCompleteHistoryTask(ctx context.Context, request *RangeCompleteHistoryTaskRequest) (*RangeCompleteHistoryTaskResponse, error)

	// Scan related methods
	ListConcreteExecutions(ctx context.Context, request *ListConcreteExecutionsRequest) (*InternalListConcreteExecutionsResponse, error)
	ListCurrentExecutions(ctx context.Context, request *ListCurrentExecutionsRequest) (*ListCurrentExecutionsResponse, error)

	// Active cluster selection policy related methods
	GetActiveClusterSelectionPolicy(ctx context.Context, domainID, wfID, rID string) (*DataBlob, error)
	DeleteActiveClusterSelectionPolicy(ctx context.Context, domainID, wfID, rID string) error
}

type FailoverLevel struct {
	StartTime    time.Time
	MinLevel     HistoryTaskKey
	CurrentLevel HistoryTaskKey
	MaxLevel     HistoryTaskKey
	DomainIDs    map[string]struct{}
}

type FailoverMarkerTask struct {
	TaskData
	DomainID string
}

type FetchDynamicConfigResponse struct {
	Snapshot *DynamicConfigSnapshot
}

type ForkHistoryBranchRequest struct {
	// The base branch to fork from
	ForkBranchToken []byte
	// The nodeID to fork from, the new branch will start from ( inclusive ), the base branch will stop at(exclusive)
	// Application must provide a void forking nodeID, it must be a valid nodeID in that branch. A valid nodeID is the firstEventID of a valid batch of events.
	// And ForkNodeID > 1 because forking from 1 doesn't make any sense.
	ForkNodeID int64
	// the info for clean up data in background
	Info string
	// The shard to get history branch data
	ShardID *int
	// DomainName to create metrics for Domain Cost Attribution
	DomainName string
}

type ForkHistoryBranchResponse struct {
	// branchToken to represent the new branch
	NewBranchToken []byte
}

type GetAllHistoryTreeBranchesRequest struct {
	// pagination token
	NextPageToken []byte
	// maximum number of branches returned per page
	PageSize int
}

type GetAllHistoryTreeBranchesResponse struct {
	// pagination token
	NextPageToken []byte
	// all branches of all trees
	Branches []HistoryBranchDetail
}

type GetClosedWorkflowExecutionRequest struct {
	DomainUUID string
	Domain     string // domain name is not persisted, but used as config filter key
	Execution  types.WorkflowExecution
}

type GetClosedWorkflowExecutionResponse struct {
	Execution *types.WorkflowExecutionInfo
}

type GetCurrentExecutionRequest struct {
	DomainID   string
	WorkflowID string
	DomainName string
}

type GetCurrentExecutionResponse struct {
	StartRequestID   string
	RunID            string
	State            int
	CloseStatus      int
	LastWriteVersion int64
}

type GetDomainRequest struct {
	ID   string
	Name string
}

type GetDomainResponse struct {
	Info                        *DomainInfo
	Config                      *DomainConfig
	ReplicationConfig           *DomainReplicationConfig
	IsGlobalDomain              bool
	ConfigVersion               int64
	FailoverVersion             int64
	FailoverNotificationVersion int64
	PreviousFailoverVersion     int64
	FailoverEndTime             *int64
	LastUpdatedTime             int64
	NotificationVersion         int64
}

type GetHistoryTasksRequest struct {
	TaskCategory        HistoryTaskCategory
	InclusiveMinTaskKey HistoryTaskKey
	ExclusiveMaxTaskKey HistoryTaskKey
	PageSize            int
	NextPageToken       []byte
}

type GetHistoryTasksResponse struct {
	Tasks         []Task
	NextPageToken []byte
}

type GetHistoryTreeRequest struct {
	// A UUID of a tree
	TreeID string
	// Get data from this shard
	ShardID *int
	// optional: can provide treeID via branchToken if treeID is empty
	BranchToken []byte
	// DomainName to create metrics
	DomainName string
}

type GetHistoryTreeResponse struct {
	// all branches of a tree
	Branches []*workflow.HistoryBranch
}

type GetMetadataResponse struct {
	NotificationVersion int64
}

type GetOrphanTasksRequest struct {
	Limit int
}

type GetOrphanTasksResponse struct {
	Tasks []*TaskKey
}

type GetReplicationDLQSizeRequest struct {
	SourceClusterName string
}

type GetReplicationDLQSizeResponse struct {
	Size int64
}

type GetReplicationTasksFromDLQRequest struct {
	SourceClusterName string
	ReadLevel         int64
	MaxReadLevel      int64
	BatchSize         int
	NextPageToken     []byte
}

type GetShardRequest struct {
	ShardID int
}

type GetShardResponse struct {
	ShardInfo *ShardInfo
}

type GetTaskListRequest struct {
	DomainID   string
	DomainName string
	TaskList   string
	TaskType   int
}

type GetTaskListResponse struct {
	TaskListInfo *TaskListInfo
}

type GetTaskListSizeRequest struct {
	DomainID     string
	DomainName   string
	TaskListName string
	TaskListType int
	AckLevel     int64
}

type GetTaskListSizeResponse struct {
	Size int64
}

type GetTasksRequest struct {
	DomainID     string
	TaskList     string
	TaskType     int
	ReadLevel    int64  // range exclusive
	MaxReadLevel *int64 // optional: range inclusive when specified
	BatchSize    int
	DomainName   string
}

type GetTasksResponse struct {
	Tasks []*TaskInfo
}

type GetWorkflowExecutionRequest struct {
	DomainID   string
	Execution  types.WorkflowExecution
	DomainName string
	RangeID    int64
}

type GetWorkflowExecutionResponse struct {
	State             *WorkflowMutableState
	MutableStateStats *MutableStateStats
}

type HistoryBranchDetail struct {
	TreeID   string
	BranchID string
	ForkTime time.Time
	Info     string
}

type HistoryManager interface {
	Closeable
	GetName() string

	// AppendHistoryNodes add(or override) a batch of nodes to a history branch
	AppendHistoryNodes(ctx context.Context, request *AppendHistoryNodesRequest) (*AppendHistoryNodesResponse, error)
	// ReadHistoryBranch returns history node data for a branch
	ReadHistoryBranch(ctx context.Context, request *ReadHistoryBranchRequest) (*ReadHistoryBranchResponse, error)
	// ReadHistoryBranchByBatch returns history node data for a branch ByBatch
	ReadHistoryBranchByBatch(ctx context.Context, request *ReadHistoryBranchRequest) (*ReadHistoryBranchByBatchResponse, error)
	// ReadRawHistoryBranch returns history node raw data for a branch ByBatch
	// NOTE: this API should only be used by 3+DC
	ReadRawHistoryBranch(ctx context.Context, request *ReadHistoryBranchRequest) (*ReadRawHistoryBranchResponse, error)
	// ForkHistoryBranch forks a new branch from an old branch
	ForkHistoryBranch(ctx context.Context, request *ForkHistoryBranchRequest) (*ForkHistoryBranchResponse, error)
	// DeleteHistoryBranch removes a branch
	// If this is the last branch to delete, it will also remove the root node
	DeleteHistoryBranch(ctx context.Context, request *DeleteHistoryBranchRequest) error
	// GetHistoryTree returns all branch information of a tree
	GetHistoryTree(ctx context.Context, request *GetHistoryTreeRequest) (*GetHistoryTreeResponse, error)
	// GetAllHistoryTreeBranches returns all branches of all trees
	GetAllHistoryTreeBranches(ctx context.Context, request *GetAllHistoryTreeBranchesRequest) (*GetAllHistoryTreeBranchesResponse, error)
}

type HistoryReplicationTask struct {
	WorkflowIdentifier
	TaskData
	FirstEventID      int64
	NextEventID       int64
	BranchToken       []byte
	NewRunBranchToken []byte
}

type HistoryStore interface {
	Closeable
	GetName() string

	// AppendHistoryNodes add(or override) a node to a history branch
	AppendHistoryNodes(ctx context.Context, request *InternalAppendHistoryNodesRequest) error
	// ReadHistoryBranch returns history node data for a branch
	ReadHistoryBranch(ctx context.Context, request *InternalReadHistoryBranchRequest) (*InternalReadHistoryBranchResponse, error)
	// ForkHistoryBranch forks a new branch from a old branch
	ForkHistoryBranch(ctx context.Context, request *InternalForkHistoryBranchRequest) (*InternalForkHistoryBranchResponse, error)
	// DeleteHistoryBranch removes a branch
	DeleteHistoryBranch(ctx context.Context, request *InternalDeleteHistoryBranchRequest) error
	// GetHistoryTree returns all branch information of a tree
	GetHistoryTree(ctx context.Context, request *InternalGetHistoryTreeRequest) (*InternalGetHistoryTreeResponse, error)
	// GetAllHistoryTreeBranches returns all branches of all trees
	GetAllHistoryTreeBranches(ctx context.Context, request *GetAllHistoryTreeBranchesRequest) (*GetAllHistoryTreeBranchesResponse, error)
}

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

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

type InternalActivityInfo struct {
	Version                  int64
	ScheduleID               int64
	ScheduledEventBatchID    int64
	ScheduledEvent           *DataBlob
	ScheduledTime            time.Time
	StartedID                int64
	StartedEvent             *DataBlob
	StartedTime              time.Time
	ActivityID               string
	RequestID                string
	Details                  []byte
	ScheduleToStartTimeout   time.Duration
	ScheduleToCloseTimeout   time.Duration
	StartToCloseTimeout      time.Duration
	HeartbeatTimeout         time.Duration
	CancelRequested          bool
	CancelRequestID          int64
	LastHeartBeatUpdatedTime time.Time
	TimerTaskStatus          int32
	// For retry
	Attempt            int32
	DomainID           string
	StartedIdentity    string
	TaskList           string
	TaskListKind       types.TaskListKind
	HasRetryPolicy     bool
	InitialInterval    time.Duration
	BackoffCoefficient float64
	MaximumInterval    time.Duration
	ExpirationTime     time.Time
	MaximumAttempts    int32
	NonRetriableErrors []string
	LastFailureReason  string
	LastWorkerIdentity string
	LastFailureDetails []byte
	// Not written to database - This is used only for deduping heartbeat timer creation
	LastHeartbeatTimeoutVisibilityInSeconds int64
}

type InternalAppendHistoryEventsRequest struct {
	DomainID          string
	Execution         workflow.WorkflowExecution
	FirstEventID      int64
	EventBatchVersion int64
	RangeID           int64
	TransactionID     int64
	Events            *DataBlob
	Overwrite         bool
}

type InternalAppendHistoryNodesRequest struct {
	// True if it is the first append request to the branch
	IsNewBranch bool
	// The info for clean up data in background
	Info string
	// The branch to be appended
	BranchInfo types.HistoryBranch
	// The first eventID becomes the nodeID to be appended
	NodeID int64
	// The events to be appended
	Events *DataBlob
	// Requested TransactionID for conditional update
	TransactionID int64
	// Used in sharded data stores to identify which shard to use
	ShardID int

	CurrentTimeStamp time.Time
}

type InternalChildExecutionInfo struct {
	Version               int64
	InitiatedID           int64
	InitiatedEventBatchID int64
	InitiatedEvent        *DataBlob
	StartedID             int64
	StartedWorkflowID     string
	StartedRunID          string
	StartedEvent          *DataBlob
	CreateRequestID       string
	DomainID              string
	DomainNameDEPRECATED  string // deprecated: use DomainID field
	WorkflowTypeName      string
	ParentClosePolicy     types.ParentClosePolicy
}

type InternalCompleteForkBranchRequest struct {
	// branch to be updated
	BranchInfo workflow.HistoryBranch
	// whether fork is successful
	Success bool
	// Used in sharded data stores to identify which shard to use
	ShardID int
}

type InternalConfigStoreEntry struct {
	RowType   int
	Version   int64
	Timestamp time.Time
	Values    *DataBlob
}

type InternalConflictResolveWorkflowExecutionRequest struct {
	RangeID int64

	Mode ConflictResolveWorkflowMode

	// workflow to be resetted
	ResetWorkflowSnapshot InternalWorkflowSnapshot

	// maybe new workflow
	NewWorkflowSnapshot *InternalWorkflowSnapshot

	// current workflow
	CurrentWorkflowMutation *InternalWorkflowMutation

	WorkflowRequestMode CreateWorkflowRequestMode

	CurrentTimeStamp time.Time
}

type InternalCreateDomainRequest struct {
	Info              *DomainInfo
	Config            *InternalDomainConfig
	ReplicationConfig *InternalDomainReplicationConfig
	IsGlobalDomain    bool
	ConfigVersion     int64
	FailoverVersion   int64
	LastUpdatedTime   time.Time
	CurrentTimeStamp  time.Time
}

type InternalCreateShardRequest struct {
	ShardInfo        *InternalShardInfo
	CurrentTimeStamp time.Time
}

type InternalCreateWorkflowExecutionRequest struct {
	RangeID int64

	Mode CreateWorkflowMode

	PreviousRunID            string
	PreviousLastWriteVersion int64

	NewWorkflowSnapshot InternalWorkflowSnapshot

	WorkflowRequestMode CreateWorkflowRequestMode

	CurrentTimeStamp time.Time
}

type InternalDeleteHistoryBranchRequest struct {
	// branch to be deleted
	BranchInfo types.HistoryBranch
	// Used in sharded data stores to identify which shard to use
	ShardID int
}

type InternalDomainConfig struct {
	Retention                time.Duration
	EmitMetric               bool                 // deprecated
	ArchivalBucket           string               // deprecated
	ArchivalStatus           types.ArchivalStatus // deprecated
	HistoryArchivalStatus    types.ArchivalStatus
	HistoryArchivalURI       string
	VisibilityArchivalStatus types.ArchivalStatus
	VisibilityArchivalURI    string
	BadBinaries              *DataBlob
	IsolationGroups          *DataBlob
	AsyncWorkflowsConfig     *DataBlob
}

type InternalDomainReplicationConfig struct {
	Clusters             []*ClusterReplicationConfig
	ActiveClusterName    string
	ActiveClustersConfig *DataBlob
}

type InternalForkHistoryBranchRequest struct {
	// The base branch to fork from
	ForkBranchInfo types.HistoryBranch
	// The nodeID to fork from, the new branch will start from ( inclusive ), the base branch will stop at(exclusive)
	ForkNodeID int64
	// branchID of the new branch
	NewBranchID string
	// the info for clean up data in background
	Info string
	// Used in sharded data stores to identify which shard to use
	ShardID int

	CurrentTimeStamp time.Time
}

type InternalForkHistoryBranchResponse struct {
	// branchInfo to represent the new branch
	NewBranchInfo types.HistoryBranch
}

type InternalGetClosedWorkflowExecutionRequest struct {
	DomainUUID string
	Domain     string // domain name is not persisted, but used as config filter key
	Execution  types.WorkflowExecution
}

type InternalGetClosedWorkflowExecutionResponse struct {
	Execution *InternalVisibilityWorkflowExecutionInfo
}

type InternalGetDomainResponse struct {
	Info                        *DomainInfo
	Config                      *InternalDomainConfig
	ReplicationConfig           *InternalDomainReplicationConfig
	IsGlobalDomain              bool
	ConfigVersion               int64
	FailoverVersion             int64
	FailoverNotificationVersion int64
	PreviousFailoverVersion     int64
	FailoverEndTime             *time.Time
	LastUpdatedTime             time.Time
	NotificationVersion         int64
}

type InternalGetHistoryTreeRequest struct {
	// A UUID of a tree
	TreeID string
	// Get data from this shard
	ShardID *int
	// optional: can provide treeID via branchToken if treeID is empty
	BranchToken []byte
}