persistence

type AddHistoryTasksRequest struct {
	ShardID int32
	RangeID int64

	NamespaceID string
	WorkflowID  string
	ArchetypeID chasm.ArchetypeID

	Tasks map[tasks.Category][]tasks.Task
}

type AppendHistoryNodesRequest struct {
	// The shard to get history node data
	ShardID int32
	// 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 []*historypb.HistoryEvent
	// TransactionID for events before these events. For events chaining
	PrevTransactionID int64
	// requested TransactionID for this write operation. For the same eventID, the node with larger TransactionID always wins
	TransactionID int64
}

type AppendHistoryNodesResponse struct {
	// the size of the event data that has been appended
	Size int
}

type AppendHistoryTimeoutError struct {
	Msg string
}

type AppendRawHistoryNodesRequest struct {
	// The shard to get history node data
	ShardID int32
	// 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
	History *commonpb.DataBlob
	// TransactionID for events before these events. For events chaining
	PrevTransactionID int64
	// requested TransactionID for this write operation. For the same eventID, the node with larger TransactionID always wins
	TransactionID int64
	// NodeID is the first event id.
	NodeID int64
}

type Archetype = chasm.Archetype

type AssertShardOwnershipRequest struct {
	ShardID int32
	RangeID int64
}

type Closeable interface {
	Close()
}

type ClusterMember struct {
	Role          ServiceType
	HostID        []byte
	RPCAddress    net.IP
	RPCPort       uint16
	SessionStart  time.Time
	LastHeartbeat time.Time
	RecordExpiry  time.Time
}

type ClusterMetadataManager interface {
	Closeable
	GetName() string
	GetClusterMembers(ctx context.Context, request *GetClusterMembersRequest) (*GetClusterMembersResponse, error)
	UpsertClusterMembership(ctx context.Context, request *UpsertClusterMembershipRequest) error
	PruneClusterMembership(ctx context.Context, request *PruneClusterMembershipRequest) error
	ListClusterMetadata(ctx context.Context, request *ListClusterMetadataRequest) (*ListClusterMetadataResponse, error)
	GetCurrentClusterMetadata(ctx context.Context) (*GetClusterMetadataResponse, error)
	GetClusterMetadata(ctx context.Context, request *GetClusterMetadataRequest) (*GetClusterMetadataResponse, error)
	SaveClusterMetadata(ctx context.Context, request *SaveClusterMetadataRequest) (bool, error)
	DeleteClusterMetadata(ctx context.Context, request *DeleteClusterMetadataRequest) error
}

type ClusterMetadataStore interface {
	Closeable
	GetName() string
	ListClusterMetadata(ctx context.Context, request *InternalListClusterMetadataRequest) (*InternalListClusterMetadataResponse, error)
	GetClusterMetadata(ctx context.Context, request *InternalGetClusterMetadataRequest) (*InternalGetClusterMetadataResponse, error)
	SaveClusterMetadata(ctx context.Context, request *InternalSaveClusterMetadataRequest) (bool, error)
	DeleteClusterMetadata(ctx context.Context, request *InternalDeleteClusterMetadataRequest) error
	// Membership APIs
	GetClusterMembers(ctx context.Context, request *GetClusterMembersRequest) (*GetClusterMembersResponse, error)
	UpsertClusterMembership(ctx context.Context, request *UpsertClusterMembershipRequest) error
	PruneClusterMembership(ctx context.Context, request *PruneClusterMembershipRequest) error
}

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 {
	ShardID      int32
	TaskCategory tasks.Category
	TaskKey      tasks.Key

	// BestEffort indicates that this request is a suggestion. System may choose to ignore it without error.
	BestEffort bool
}

type CompleteTasksLessThanRequest struct {
	NamespaceID        string
	TaskQueueName      string
	TaskType           enumspb.TaskQueueType
	ExclusiveMaxPass   int64 // If set, delete tasks less than <ExclusiveMaxPass, ExclusiveMaxTaskID>
	ExclusiveMaxTaskID int64 // Tasks less than this ID will be completed
	Subqueue           int
	Limit              int // Limit on the max number of tasks that can be completed. Required param
	// If set, only delete if the task queue's range id matches this value, otherwise return
	// ConditionFailedError. Only supported for fair (v2) task queues.
	ConditionRangeID int64
}

type ConditionFailedError struct {
	Msg string
}

type ConflictResolveWorkflowExecutionRequest struct {
	ShardID int32
	RangeID int64

	Mode ConflictResolveWorkflowMode

	ArchetypeID chasm.ArchetypeID

	// workflow to be resetted
	ResetWorkflowSnapshot WorkflowSnapshot
	ResetWorkflowEvents   []*WorkflowEvents

	// maybe new workflow
	NewWorkflowSnapshot *WorkflowSnapshot
	NewWorkflowEvents   []*WorkflowEvents

	// current workflow
	CurrentWorkflowMutation *WorkflowMutation
	CurrentWorkflowEvents   []*WorkflowEvents
}

type ConflictResolveWorkflowExecutionResponse struct {
	ResetMutableStateStats   MutableStateStatistics
	NewMutableStateStats     *MutableStateStatistics
	CurrentMutableStateStats *MutableStateStatistics
}

type ConflictResolveWorkflowMode int

type CountTaskQueuesByBuildIdRequest struct {
	NamespaceID string
	BuildID     string
}

type CreateNamespaceRequest struct {
	Namespace         *persistencespb.NamespaceDetail
	IsGlobalNamespace bool
}

type CreateNamespaceResponse struct {
	ID string
}

type CreateOrUpdateNexusEndpointRequest struct {
	LastKnownTableVersion int64
	Entry                 *persistencespb.NexusEndpointEntry
}

type CreateOrUpdateNexusEndpointResponse struct {
	Version int64
}

type CreateQueueRequest struct {
	QueueKey QueueKey
}

type CreateQueueResponse struct {
}

type CreateTaskQueueRequest struct {
	RangeID       int64
	TaskQueueInfo *persistencespb.TaskQueueInfo
}

type CreateTaskQueueResponse struct {
}

type CreateTasksRequest struct {
	TaskQueueInfo *PersistedTaskQueueInfo
	Tasks         []*persistencespb.AllocatedTaskInfo
	// If Subqueues is present, it should be the same size as Tasks and hold the subqueue
	// indexes that each task should be added to.
	Subqueues []int
	// UpdateMetadata controls whether the task queue metadata should be written
	// along with the tasks. When false, only the range ID check is performed
	// (for write fencing) without rewriting the metadata blob.
	UpdateMetadata bool
}

type CreateTasksResponse struct {
	UpdatedMetadata bool
}

type CreateWorkflowExecutionRequest struct {
	ShardID int32
	RangeID int64

	Mode CreateWorkflowMode

	PreviousRunID            string
	PreviousLastWriteVersion int64

	ArchetypeID chasm.ArchetypeID

	NewWorkflowSnapshot WorkflowSnapshot
	NewWorkflowEvents   []*WorkflowEvents
}

type CreateWorkflowExecutionResponse struct {
	NewMutableStateStats MutableStateStatistics
}

type CreateWorkflowMode int

type CurrentWorkflowConditionFailedError struct {
	Msg string
	// RequestIDs contains all request IDs associated with the workflow execution, ie., contain the
	// request ID that started the workflow execution as well as the request IDs that were attached
	// to the workflow execution when it was running.
	RequestIDs map[string]*persistencespb.RequestIDInfo
	RunID      string
	// FirstExecutionRunID is the run ID of the first execution in the continue-as-new chain.
	// May be empty on records written before this field was added to WorkflowExecutionState;
	// callers must not assume RunID in that case.
	FirstExecutionRunID string
	State               enumsspb.WorkflowExecutionState
	Status              enumspb.WorkflowExecutionStatus
	LastWriteVersion    int64
	StartTime           *time.Time
}

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

type DataStoreFactory interface {
	// Close closes the factory
	Close()
	// NewTaskStore returns a new task store
	NewTaskStore() (TaskStore, error)
	// NewFairTaskStore returns a new task store with fairness enabled
	NewFairTaskStore() (TaskStore, error)
	// NewShardStore returns a new shard store
	NewShardStore() (ShardStore, error)
	// NewMetadataStore returns a new metadata store
	NewMetadataStore() (MetadataStore, error)
	// NewExecutionStore returns a new execution store
	NewExecutionStore() (ExecutionStore, error)
	NewQueue(queueType QueueType) (Queue, error)
	NewQueueV2() (QueueV2, error)
	// NewClusterMetadataStore returns a new metadata store
	NewClusterMetadataStore() (ClusterMetadataStore, error)
	// NewNexusEndpointStore returns a new nexus service store
	NewNexusEndpointStore() (NexusEndpointStore, error)
}

type DeleteClusterMetadataRequest struct {
	ClusterName string
}

type DeleteCurrentWorkflowExecutionRequest struct {
	ShardID     int32
	NamespaceID string
	WorkflowID  string
	RunID       string
	ArchetypeID chasm.ArchetypeID
}

type DeleteHistoryBranchRequest struct {
	// The shard to delete history branch data
	ShardID int32
	// branch to be deleted
	BranchToken []byte
}

type DeleteNamespaceByNameRequest struct {
	Name string
}

type DeleteNamespaceRequest struct {
	ID string
}

type DeleteNexusEndpointRequest struct {
	LastKnownTableVersion int64
	ID                    string
}

type DeleteRange struct {
	InclusiveMessageRange
	NewMinMessageID  int64
	MessagesToDelete int64
}

type DeleteReplicationTaskFromDLQRequest struct {
	CompleteHistoryTaskRequest

	SourceClusterName string
}

type DeleteRequest struct {
	// LastIDToDeleteInclusive represents the maximum message ID that the user wants to delete, inclusive.
	LastIDToDeleteInclusive int64
	// ExistingMessageRange represents an inclusive range of the minimum message ID and the maximum message ID in the queue.
	ExistingMessageRange InclusiveMessageRange
}

type DeleteTaskQueueRequest struct {
	TaskQueue *TaskQueueKey
	RangeID   int64
}

type DeleteTasksRequest struct {
	QueueKey                    QueueKey
	InclusiveMaxMessageMetadata MessageMetadata
}

type DeleteTasksResponse struct {
	MessagesDeleted int64
}

type DeleteWorkflowExecutionRequest struct {
	ShardID     int32
	NamespaceID string
	WorkflowID  string
	RunID       string
	ArchetypeID chasm.ArchetypeID
}

type EnqueueTaskRequest struct {
	QueueType     QueueV2Type
	SourceCluster string
	TargetCluster string
	Task          tasks.Task
	// SourceShardID of the task in its original cluster. Note that tasks may move between clusters, so this shard
	// id may not be the same as the shard id of the task in the current cluster.
	SourceShardID int
}

type EnqueueTaskResponse struct {
	Metadata MessageMetadata
}

type ExecutionManager interface {
	Closeable
	GetName() string
	GetHistoryBranchUtil() HistoryBranchUtil

	CreateWorkflowExecution(ctx context.Context, request *CreateWorkflowExecutionRequest) (*CreateWorkflowExecutionResponse, 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)
	GetWorkflowExecution(ctx context.Context, request *GetWorkflowExecutionRequest) (*GetWorkflowExecutionResponse, error)
	SetWorkflowExecution(ctx context.Context, request *SetWorkflowExecutionRequest) (*SetWorkflowExecutionResponse, error)

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

	AddHistoryTasks(ctx context.Context, request *AddHistoryTasksRequest) error
	GetHistoryTasks(ctx context.Context, request *GetHistoryTasksRequest) (*GetHistoryTasksResponse, error)
	CompleteHistoryTask(ctx context.Context, request *CompleteHistoryTaskRequest) error
	RangeCompleteHistoryTasks(ctx context.Context, request *RangeCompleteHistoryTasksRequest) error

	PutReplicationTaskToDLQ(ctx context.Context, request *PutReplicationTaskToDLQRequest) error
	GetReplicationTasksFromDLQ(ctx context.Context, request *GetReplicationTasksFromDLQRequest) (*GetHistoryTasksResponse, error)
	DeleteReplicationTaskFromDLQ(ctx context.Context, request *DeleteReplicationTaskFromDLQRequest) error
	RangeDeleteReplicationTaskFromDLQ(ctx context.Context, request *RangeDeleteReplicationTaskFromDLQRequest) error
	IsReplicationDLQEmpty(ctx context.Context, request *GetReplicationTasksFromDLQRequest) (bool, error)

	// AppendHistoryNodes add a node to history node table
	AppendHistoryNodes(ctx context.Context, request *AppendHistoryNodesRequest) (*AppendHistoryNodesResponse, error)
	// AppendRawHistoryNodes add a node of raw histories to history node table
	AppendRawHistoryNodes(ctx context.Context, request *AppendRawHistoryNodesRequest) (*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)
	// ReadHistoryBranchReverse returns history node data for a branch
	ReadHistoryBranchReverse(ctx context.Context, request *ReadHistoryBranchReverseRequest) (*ReadHistoryBranchReverseResponse, 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 a 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
	// TrimHistoryBranch validate & trim a history branch
	TrimHistoryBranch(ctx context.Context, request *TrimHistoryBranchRequest) (*TrimHistoryBranchResponse, error)
	// GetAllHistoryTreeBranches returns all branches of all trees
	GetAllHistoryTreeBranches(ctx context.Context, request *GetAllHistoryTreeBranchesRequest) (*GetAllHistoryTreeBranchesResponse, error)
}

type ExecutionStore interface {
	Closeable
	GetName() string
	GetHistoryBranchUtil() HistoryBranchUtil

	// The below three APIs are related to serialization/deserialization
	CreateWorkflowExecution(ctx context.Context, request *InternalCreateWorkflowExecutionRequest) (*InternalCreateWorkflowExecutionResponse, error)
	UpdateWorkflowExecution(ctx context.Context, request *InternalUpdateWorkflowExecutionRequest) error
	ConflictResolveWorkflowExecution(ctx context.Context, request *InternalConflictResolveWorkflowExecutionRequest) error

	DeleteWorkflowExecution(ctx context.Context, request *DeleteWorkflowExecutionRequest) error
	DeleteCurrentWorkflowExecution(ctx context.Context, request *DeleteCurrentWorkflowExecutionRequest) error
	GetCurrentExecution(ctx context.Context, request *GetCurrentExecutionRequest) (*InternalGetCurrentExecutionResponse, error)
	GetWorkflowExecution(ctx context.Context, request *GetWorkflowExecutionRequest) (*InternalGetWorkflowExecutionResponse, error)
	SetWorkflowExecution(ctx context.Context, request *InternalSetWorkflowExecutionRequest) error

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

	AddHistoryTasks(ctx context.Context, request *InternalAddHistoryTasksRequest) error
	GetHistoryTasks(ctx context.Context, request *GetHistoryTasksRequest) (*InternalGetHistoryTasksResponse, error)
	CompleteHistoryTask(ctx context.Context, request *CompleteHistoryTaskRequest) error
	RangeCompleteHistoryTasks(ctx context.Context, request *RangeCompleteHistoryTasksRequest) error

	PutReplicationTaskToDLQ(ctx context.Context, request *PutReplicationTaskToDLQRequest) error
	GetReplicationTasksFromDLQ(ctx context.Context, request *GetReplicationTasksFromDLQRequest) (*InternalGetReplicationTasksFromDLQResponse, error)
	DeleteReplicationTaskFromDLQ(ctx context.Context, request *DeleteReplicationTaskFromDLQRequest) error
	RangeDeleteReplicationTaskFromDLQ(ctx context.Context, request *RangeDeleteReplicationTaskFromDLQRequest) error
	IsReplicationDLQEmpty(ctx context.Context, request *GetReplicationTasksFromDLQRequest) (bool, error)

	// AppendHistoryNodes add a node to history node table
	AppendHistoryNodes(ctx context.Context, request *InternalAppendHistoryNodesRequest) error
	// DeleteHistoryNodes delete a node from history node table
	DeleteHistoryNodes(ctx context.Context, request *InternalDeleteHistoryNodesRequest) 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) error
	// DeleteHistoryBranch removes a branch
	DeleteHistoryBranch(ctx context.Context, request *InternalDeleteHistoryBranchRequest) error
	// GetHistoryTreeContainingBranch returns all branch information of the tree containing the specified branch
	GetHistoryTreeContainingBranch(ctx context.Context, request *InternalGetHistoryTreeContainingBranchRequest) (*InternalGetHistoryTreeContainingBranchResponse, error)
	// GetAllHistoryTreeBranches returns all branches of all trees.
	// Note that branches may be skipped or duplicated across pages if there are branches created or deleted while
	// paginating through results.
	GetAllHistoryTreeBranches(ctx context.Context, request *GetAllHistoryTreeBranchesRequest) (*InternalGetAllHistoryTreeBranchesResponse, error)
}

type FairTaskManager TaskManager

type ForkHistoryBranchRequest struct {
	// The shard to get history branch data
	ShardID int32
	// The namespace performing the fork
	NamespaceID string
	// 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 new run ID
	NewRunID 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 GetClusterMembersRequest struct {
	LastHeartbeatWithin time.Duration
	RPCAddressEquals    net.IP
	HostIDEquals        []byte
	RoleEquals          ServiceType
	SessionStartedAfter time.Time
	NextPageToken       []byte
	PageSize            int
}

type GetClusterMembersResponse struct {
	ActiveMembers []*ClusterMember
	NextPageToken []byte
}

type GetClusterMetadataRequest struct {
	ClusterName string
}

type GetClusterMetadataResponse struct {
	*persistencespb.ClusterMetadata
	Version int64
}

type GetCurrentExecutionRequest struct {
	ShardID     int32
	NamespaceID string
	WorkflowID  string
	ArchetypeID chasm.ArchetypeID
}

type GetCurrentExecutionResponse struct {
	StartRequestID string
	RunID          string
	State          enumsspb.WorkflowExecutionState
	Status         enumspb.WorkflowExecutionStatus
}

type GetHistoryTasksRequest struct {
	ShardID             int32
	TaskCategory        tasks.Category
	InclusiveMinTaskKey tasks.Key
	ExclusiveMaxTaskKey tasks.Key
	BatchSize           int
	NextPageToken       []byte
}

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

type GetMetadataResponse struct {
	NotificationVersion int64
}

type GetNamespaceRequest struct {
	ID   string
	Name string
}

type GetNamespaceResponse struct {
	Namespace           *persistencespb.NamespaceDetail
	IsGlobalNamespace   bool
	NotificationVersion int64
}

type GetNexusEndpointRequest struct {
	ID string
}

type GetOrCreateShardRequest struct {
	ShardID          int32
	InitialShardInfo *persistencespb.ShardInfo // optional, zero value will be used if missing
	LifecycleContext context.Context           // cancelled when shard is unloaded
}

type GetOrCreateShardResponse struct {
	ShardInfo *persistencespb.ShardInfo
}

type GetReplicationTasksFromDLQRequest struct {
	GetHistoryTasksRequest

	SourceClusterName string
}

type GetReplicationTasksRequest struct {
	ShardID       int32
	MinTaskID     int64
	MaxTaskID     int64
	BatchSize     int
	NextPageToken []byte
}

type GetTaskQueueRequest struct {
	NamespaceID string
	TaskQueue   string
	TaskType    enumspb.TaskQueueType
}

type GetTaskQueueResponse struct {
	RangeID       int64
	TaskQueueInfo *persistencespb.TaskQueueInfo
}

type GetTaskQueueUserDataRequest struct {
	NamespaceID string
	TaskQueue   string
}

type GetTaskQueueUserDataResponse struct {
	UserData *persistencespb.VersionedTaskQueueUserData
}

type GetTaskQueuesByBuildIdRequest struct {
	NamespaceID string
	BuildID     string
}

type GetTasksRequest struct {
	NamespaceID string
	TaskQueue   string
	TaskType    enumspb.TaskQueueType
	// If InclusiveMinPass is set, return tasks greater or equal to <InclusiveMinPass,
	// InclusiveMinTaskID> with no upper bound. InclusiveMinPass must be >= 1 for fair task
	// manager and must be 0 for classic task manager.
	InclusiveMinPass   int64
	InclusiveMinTaskID int64
	ExclusiveMaxTaskID int64
	Subqueue           int
	PageSize           int
	UseLimit           bool // If true, use LIMIT in the query
	NextPageToken      []byte
}

type GetTasksResponse struct {
	Tasks         []*persistencespb.AllocatedTaskInfo
	NextPageToken []byte
}

type GetWorkflowExecutionRequest struct {
	ShardID     int32
	NamespaceID string
	WorkflowID  string
	RunID       string
	ArchetypeID chasm.ArchetypeID
}

type GetWorkflowExecutionResponse struct {
	State             *persistencespb.WorkflowMutableState
	DBRecordVersion   int64
	MutableStateStats MutableStateStatistics
}

type HealthSignalAggregator interface {
	Record(callerSegment int32, latency time.Duration, err error)
	AverageLatency() float64
	LatencyQuantile(quantile float64) float64
	ErrorRatio() float64
	Start()
	Stop()
}

type HistoryBranchDetail struct {
	BranchInfo *persistencespb.HistoryBranch
	ForkTime   *timestamppb.Timestamp
	Info       string
}

type HistoryBranchUtil interface {
	NewHistoryBranch(
		namespaceID string,
		workflowID string,
		runID string,
		treeID string,
		branchID *string,
		ancestors []*persistencespb.HistoryBranchRange,
		runTimeout time.Duration,
		executionTimeout time.Duration,
		retentionDuration time.Duration,
	) ([]byte, error)
	// ParseHistoryBranchInfo parses the history branch for branch information
	ParseHistoryBranchInfo(
		branchToken []byte,
	) (*persistencespb.HistoryBranch, error)
	// UpdateHistoryBranchInfo updates the history branch with branch information
	UpdateHistoryBranchInfo(
		branchToken []byte,
		branchInfo *persistencespb.HistoryBranch,
		runID string,
	) ([]byte, error)
}

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

type HistoryStatistics struct {
	SizeDiff  int
	CountDiff int
}

type HistoryTask struct {
	MessageMetadata MessageMetadata
	Task            tasks.Task
}

type HistoryTaskQueueManager interface {
	Closeable
	EnqueueTask(ctx context.Context, request *EnqueueTaskRequest) (*EnqueueTaskResponse, error)
	ReadRawTasks(
		ctx context.Context,
		request *ReadRawTasksRequest,
	) (*ReadRawTasksResponse, error)
	ReadTasks(ctx context.Context, request *ReadTasksRequest) (*ReadTasksResponse, error)
	// CreateQueue must return an ErrQueueAlreadyExists if the queue already exists.
	CreateQueue(ctx context.Context, request *CreateQueueRequest) (*CreateQueueResponse, error)
	DeleteTasks(ctx context.Context, request *DeleteTasksRequest) (*DeleteTasksResponse, error)
	ListQueues(ctx context.Context, request *ListQueuesRequest) (*ListQueuesResponse, error)
}

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

type InclusiveMessageRange struct {
	MinMessageID int64
	MaxMessageID int64
}

type InternalAddHistoryTasksRequest struct {
	ShardID int32
	RangeID int64

	NamespaceID string
	WorkflowID  string
	ArchetypeID chasm.ArchetypeID

	Tasks map[tasks.Category][]InternalHistoryTask `json:",omitempty"`
}

type InternalAppendHistoryNodesRequest struct {
	// The raw branch token
	BranchToken []byte
	// 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 *persistencespb.HistoryBranch
	// Serialized TreeInfo
	TreeInfo *commonpb.DataBlob
	// The history node
	Node InternalHistoryNode
	// Used in sharded data stores to identify which shard to use
	ShardID int32
}

type InternalChasmNode struct {
	Metadata *commonpb.DataBlob
	Data     *commonpb.DataBlob

	// Only set when Cassandra is used as the persistence layer. When set, Metadata
	// and Data will be unset. *No* code outside of the ExecutionManager or Cassandra
	// store should reference this field.
	//
	// As an optimization to avoid an extra encode/deocde step, the Cassandra version
	// is encoded in a single blob up-front.
	CassandraBlob *commonpb.DataBlob
}

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

type InternalConflictResolveWorkflowExecutionRequest struct {
	ShardID int32
	RangeID int64

	Mode ConflictResolveWorkflowMode

	ArchetypeID chasm.ArchetypeID

	// workflow to be resetted
	ResetWorkflowSnapshot        InternalWorkflowSnapshot
	ResetWorkflowEventsNewEvents []*InternalAppendHistoryNodesRequest `json:",omitempty"`
	// maybe new workflow
	NewWorkflowSnapshot        *InternalWorkflowSnapshot
	NewWorkflowEventsNewEvents []*InternalAppendHistoryNodesRequest `json:",omitempty"`

	// current workflow
	CurrentWorkflowMutation        *InternalWorkflowMutation
	CurrentWorkflowEventsNewEvents []*InternalAppendHistoryNodesRequest `json:",omitempty"`
}

type InternalCreateNamespaceRequest struct {
	ID        string
	Name      string
	Namespace *commonpb.DataBlob
	IsGlobal  bool
}

type InternalCreateOrUpdateNexusEndpointRequest struct {
	LastKnownTableVersion int64
	Endpoint              InternalNexusEndpoint
}

type InternalCreateQueueRequest struct {
	QueueType QueueV2Type
	QueueName string
}

type InternalCreateQueueResponse struct {
}

type InternalCreateTask struct {
	TaskPass   int64
	TaskId     int64
	ExpiryTime *timestamppb.Timestamp
	Task       *commonpb.DataBlob
	Subqueue   int
}

type InternalCreateTaskQueueRequest struct {
	NamespaceID   string
	TaskQueue     string
	TaskType      enumspb.TaskQueueType
	RangeID       int64
	TaskQueueInfo *commonpb.DataBlob

	TaskQueueKind enumspb.TaskQueueKind
	ExpiryTime    *timestamppb.Timestamp
}

type InternalCreateTasksRequest struct {
	NamespaceID    string
	TaskQueue      string
	TaskType       enumspb.TaskQueueType
	RangeID        int64
	TaskQueueInfo  *commonpb.DataBlob
	Tasks          []*InternalCreateTask `json:",omitempty"`
	UpdateMetadata bool
}

type InternalCreateWorkflowExecutionRequest struct {
	ShardID int32
	RangeID int64

	Mode CreateWorkflowMode

	PreviousRunID            string
	PreviousLastWriteVersion int64

	ArchetypeID chasm.ArchetypeID

	NewWorkflowSnapshot  InternalWorkflowSnapshot
	NewWorkflowNewEvents []*InternalAppendHistoryNodesRequest `json:",omitempty"`
}

type InternalCreateWorkflowExecutionResponse struct {
}

type InternalDeleteClusterMetadataRequest struct {
	ClusterName string
}

type InternalDeleteHistoryBranchRange struct {
	BranchId    string
	BeginNodeId int64 // delete nodes with ID >= BeginNodeId
}

type InternalDeleteHistoryBranchRequest struct {
	// The raw branch token
	BranchToken []byte
	// The branch
	BranchInfo *persistencespb.HistoryBranch
	// Used in sharded data stores to identify which shard to use
	ShardID int32
	// branch ranges is used to delete range of history nodes from target branch and it ancestors.
	BranchRanges []InternalDeleteHistoryBranchRange `json:",omitempty"`
}

type InternalDeleteHistoryNodesRequest struct {
	// The raw branch token
	BranchToken []byte
	// Used in sharded data stores to identify which shard to use
	ShardID int32
	// The branch to be appended
	BranchInfo *persistencespb.HistoryBranch
	// node ID of the history node
	NodeID int64
	// transaction ID of the history node
	TransactionID int64
}

type InternalEnqueueMessageRequest struct {
	QueueType QueueV2Type
	QueueName string
	Blob      *commonpb.DataBlob
}

type InternalEnqueueMessageResponse struct {
	Metadata MessageMetadata
}

type InternalForkHistoryBranchRequest struct {
	// The new branch token to fork to
	NewBranchToken []byte
	// The base branch to fork from
	ForkBranchInfo *persistencespb.HistoryBranch
	// Serialized TreeInfo
	TreeInfo *commonpb.DataBlob
	// 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 int32
}

type InternalGetAllHistoryTreeBranchesResponse struct {
	// pagination token
	NextPageToken []byte
	// all branches of all trees
	Branches []InternalHistoryBranchDetail `json:",omitempty"`
}

type InternalGetClusterMetadataRequest struct {
	ClusterName string
}

type InternalGetClusterMetadataResponse struct {
	// Serialized MutableCusterMetadata.
	ClusterMetadata *commonpb.DataBlob
	Version         int64
}

type InternalGetCurrentExecutionResponse struct {
	RunID          string
	ExecutionState *persistencespb.WorkflowExecutionState
}

type InternalGetHistoryTaskResponse struct {
	InternalHistoryTask
}

type InternalGetHistoryTasksResponse struct {
	Tasks         []InternalHistoryTask `json:",omitempty"`
	NextPageToken []byte
}

type InternalGetHistoryTreeContainingBranchRequest struct {
	// The raw branch token
	BranchToken []byte
	// Get data from this shard
	ShardID int32
}

type InternalGetHistoryTreeContainingBranchResponse struct {
	// TreeInfos
	TreeInfos []*commonpb.DataBlob `json:",omitempty"`
}

type InternalGetNamespaceResponse struct {
	Namespace           *commonpb.DataBlob
	IsGlobal            bool
	NotificationVersion int64
}

type InternalGetOrCreateShardRequest struct {
	ShardID          int32
	CreateShardInfo  func() (rangeID int64, shardInfo *commonpb.DataBlob, err error) `json:"-"` // cannot be serialized otherwise
	LifecycleContext context.Context                                                 // cancelled when shard is unloaded
}

type InternalGetOrCreateShardResponse struct {
	ShardInfo *commonpb.DataBlob
}

type InternalGetReplicationTasksFromDLQResponse = InternalGetHistoryTasksResponse

type InternalGetTaskQueueRequest struct {
	NamespaceID string
	TaskQueue   string
	TaskType    enumspb.TaskQueueType
}

type InternalGetTaskQueueResponse struct {
	RangeID       int64
	TaskQueueInfo *commonpb.DataBlob
}

type InternalGetTaskQueueUserDataResponse struct {
	Version  int64
	UserData *commonpb.DataBlob
}

type InternalGetTasksResponse struct {
	Tasks         []*commonpb.DataBlob `json:",omitempty"`
	NextPageToken []byte
}

type InternalGetWorkflowExecutionResponse struct {
	State           *InternalWorkflowMutableState
	DBRecordVersion int64
}

type InternalHistoryBranchDetail struct {
	TreeID   string
	BranchID string
	Encoding string
	Data     []byte // HistoryTreeInfo blob
}

type InternalHistoryNode struct {
	// The first eventID becomes the nodeID to be appended
	NodeID int64
	// requested TransactionID for this write operation. For the same eventID, the node with larger TransactionID always wins
	TransactionID int64
	// TransactionID for events before these events. For events chaining
	PrevTransactionID int64
	// The events to be appended
	Events *commonpb.DataBlob
}

type InternalHistoryTask struct {
	Key  tasks.Key
	Blob *commonpb.DataBlob
}

type InternalListClusterMetadataRequest struct {
	PageSize      int
	NextPageToken []byte
}

type InternalListClusterMetadataResponse struct {
	ClusterMetadata []*InternalGetClusterMetadataResponse `json:",omitempty"`
	NextPageToken   []byte
}

type InternalListConcreteExecutionsResponse struct {
	States        []*InternalWorkflowMutableState `json:",omitempty"`
	NextPageToken []byte
}

type InternalListNamespacesRequest struct {
	PageSize      int
	NextPageToken []byte
}

type InternalListNamespacesResponse struct {
	Namespaces    []*InternalGetNamespaceResponse `json:",omitempty"`
	NextPageToken []byte
}

type InternalListNexusEndpointsResponse struct {
	TableVersion  int64
	NextPageToken []byte
	Endpoints     []InternalNexusEndpoint `json:",omitempty"`
}

type InternalListQueuesRequest struct {
	QueueType     QueueV2Type
	PageSize      int
	NextPageToken []byte
}

type InternalListQueuesResponse struct {
	Queues        []QueueInfo `json:",omitempty"`
	NextPageToken []byte
}

type InternalListTaskQueueItem struct {
	TaskQueue *commonpb.DataBlob // serialized PersistedTaskQueueInfo
	RangeID   int64
}

type InternalListTaskQueueResponse struct {
	Items         []*InternalListTaskQueueItem `json:",omitempty"`
	NextPageToken []byte
}

type InternalListTaskQueueUserDataEntriesResponse struct {
	NextPageToken []byte
	Entries       []InternalTaskQueueUserDataEntry `json:",omitempty"`
}

type InternalNexusEndpoint struct {
	ID      string
	Version int64
	Data    *commonpb.DataBlob
}

type InternalQueueMetadata struct {
	Blob    *commonpb.DataBlob
	Version int64
}

type InternalRangeDeleteMessagesRequest struct {
	QueueType                   QueueV2Type
	QueueName                   string
	InclusiveMaxMessageMetadata MessageMetadata
}

type InternalRangeDeleteMessagesResponse struct {
	MessagesDeleted int64
}

type InternalReadHistoryBranchRequest struct {
	// The raw branch token
	BranchToken []byte
	// The branch range to be read
	BranchID string
	// Get the history nodes from MinNodeID. Inclusive.
	MinNodeID int64
	// Get the history nodes upto MaxNodeID.  Exclusive.
	MaxNodeID int64
	// passing thru for pagination
	PageSize int
	// Pagination token
	NextPageToken []byte
	// Used in sharded data stores to identify which shard to use
	ShardID int32
	// whether to only return metadata, excluding node content
	MetadataOnly bool
	// whether we iterate in reverse order
	ReverseOrder bool
}

type InternalReadHistoryBranchResponse struct {
	// History nodes
	Nodes []InternalHistoryNode `json:",omitempty"`
	// Pagination token
	NextPageToken []byte
}

type InternalReadMessagesRequest struct {
	QueueType     QueueV2Type
	QueueName     string
	PageSize      int
	NextPageToken []byte
}

type InternalReadMessagesResponse struct {
	Messages      []QueueV2Message `json:",omitempty"`
	NextPageToken []byte
}

type InternalRenameNamespaceRequest struct {
	*InternalUpdateNamespaceRequest
	PreviousName string
}

type InternalSaveClusterMetadataRequest struct {
	ClusterName string
	// Serialized MutableCusterMetadata.
	ClusterMetadata *commonpb.DataBlob
	Version         int64
}

type InternalSetWorkflowExecutionRequest struct {
	ShardID int32
	RangeID int64

	ArchetypeID chasm.ArchetypeID

	SetWorkflowSnapshot InternalWorkflowSnapshot
}

type InternalSingleTaskQueueUserDataUpdate struct {
	Version  int64
	UserData *commonpb.DataBlob
	// Used to build an index of build_id to task_queues
	BuildIdsAdded   []string `json:",omitempty"`
	BuildIdsRemoved []string `json:",omitempty"`
	Applied         *bool
	Conflicting     *bool
}

type InternalTaskQueueUserDataEntry struct {
	TaskQueue string
	Data      *commonpb.DataBlob
	Version   int64
}

type InternalUpdateNamespaceRequest struct {
	Id                  string
	Name                string
	Namespace           *commonpb.DataBlob
	NotificationVersion int64
	IsGlobal            bool
}

type InternalUpdateShardRequest struct {
	ShardID         int32
	RangeID         int64
	Owner           string
	ShardInfo       *commonpb.DataBlob
	PreviousRangeID int64
}

type InternalUpdateTaskQueueRequest struct {
	NamespaceID   string
	TaskQueue     string
	TaskType      enumspb.TaskQueueType
	RangeID       int64
	TaskQueueInfo *commonpb.DataBlob

	TaskQueueKind enumspb.TaskQueueKind
	ExpiryTime    *timestamppb.Timestamp

	PrevRangeID int64
}

type InternalUpdateTaskQueueUserDataRequest struct {
	NamespaceID string
	Updates     map[string]*InternalSingleTaskQueueUserDataUpdate // key is task queue name
}

type InternalUpdateWorkflowExecutionRequest struct {
	ShardID int32
	RangeID int64

	Mode UpdateWorkflowMode

	ArchetypeID chasm.ArchetypeID

	UpdateWorkflowMutation  InternalWorkflowMutation
	UpdateWorkflowNewEvents []*InternalAppendHistoryNodesRequest `json:",omitempty"`
	NewWorkflowSnapshot     *InternalWorkflowSnapshot
	NewWorkflowNewEvents    []*InternalAppendHistoryNodesRequest `json:",omitempty"`
}

type InternalUpsertClusterMembershipRequest struct {
	ClusterMember
	RecordExpiry time.Time
}

type InternalWorkflowMutableState struct {
	ActivityInfos       map[int64]*commonpb.DataBlob  `json:",omitempty"` // ActivityInfo
	TimerInfos          map[string]*commonpb.DataBlob `json:",omitempty"` // TimerInfo
	ChildExecutionInfos map[int64]*commonpb.DataBlob  `json:",omitempty"` // ChildExecutionInfo
	RequestCancelInfos  map[int64]*commonpb.DataBlob  `json:",omitempty"` // RequestCancelInfo
	SignalInfos         map[int64]*commonpb.DataBlob  `json:",omitempty"` // SignalInfo
	ChasmNodes          map[string]InternalChasmNode  `json:",omitempty"` // persistencespb.ChasmNode
	SignalRequestedIDs  []string                      `json:",omitempty"`
	ExecutionInfo       *commonpb.DataBlob            // WorkflowExecutionInfo
	ExecutionState      *commonpb.DataBlob            // WorkflowExecutionState
	NextEventID         int64
	BufferedEvents      []*commonpb.DataBlob `json:",omitempty"`
	Checksum            *commonpb.DataBlob   // persistencespb.Checksum
	DBRecordVersion     int64
}

type InternalWorkflowMutation struct {
	// TODO: properly set this on call sites
	NamespaceID string
	WorkflowID  string
	RunID       string

	ExecutionInfo      *persistencespb.WorkflowExecutionInfo
	ExecutionInfoBlob  *commonpb.DataBlob `json:"-"` // redundant in JSON
	ExecutionState     *persistencespb.WorkflowExecutionState
	ExecutionStateBlob *commonpb.DataBlob `json:"-"` // redundant in JSON
	NextEventID        int64
	StartVersion       int64
	LastWriteVersion   int64
	DBRecordVersion    int64

	UpsertActivityInfos       map[int64]*commonpb.DataBlob  `json:",omitempty"`
	DeleteActivityInfos       map[int64]struct{}            `json:",omitempty"`
	UpsertTimerInfos          map[string]*commonpb.DataBlob `json:",omitempty"`
	DeleteTimerInfos          map[string]struct{}           `json:",omitempty"`
	UpsertChildExecutionInfos map[int64]*commonpb.DataBlob  `json:",omitempty"`
	DeleteChildExecutionInfos map[int64]struct{}            `json:",omitempty"`
	UpsertRequestCancelInfos  map[int64]*commonpb.DataBlob  `json:",omitempty"`
	DeleteRequestCancelInfos  map[int64]struct{}            `json:",omitempty"`
	UpsertSignalInfos         map[int64]*commonpb.DataBlob  `json:",omitempty"`
	DeleteSignalInfos         map[int64]struct{}            `json:",omitempty"`
	UpsertChasmNodes          map[string]InternalChasmNode  `json:",omitempty"`
	DeleteChasmNodes          map[string]struct{}           `json:",omitempty"`
	UpsertSignalRequestedIDs  map[string]struct{}           `json:",omitempty"`
	DeleteSignalRequestedIDs  map[string]struct{}           `json:",omitempty"`
	NewBufferedEvents         *commonpb.DataBlob
	ClearBufferedEvents       bool

	Tasks map[tasks.Category][]InternalHistoryTask `json:",omitempty"`

	Condition int64

	Checksum *commonpb.DataBlob
}

type InternalWorkflowSnapshot struct {
	// TODO: properly set this on call sites
	NamespaceID string
	WorkflowID  string
	RunID       string

	ExecutionInfo      *persistencespb.WorkflowExecutionInfo
	ExecutionInfoBlob  *commonpb.DataBlob `json:"-"` // redundant in JSON
	ExecutionState     *persistencespb.WorkflowExecutionState
	ExecutionStateBlob *commonpb.DataBlob `json:"-"` // redundant in JSON
	StartVersion       int64
	LastWriteVersion   int64
	NextEventID        int64
	DBRecordVersion    int64

	ActivityInfos       map[int64]*commonpb.DataBlob  `json:",omitempty"`
	TimerInfos          map[string]*commonpb.DataBlob `json:",omitempty"`
	ChildExecutionInfos map[int64]*commonpb.DataBlob  `json:",omitempty"`
	RequestCancelInfos  map[int64]*commonpb.DataBlob  `json:",omitempty"`
	SignalInfos         map[int64]*commonpb.DataBlob  `json:",omitempty"`
	ChasmNodes          map[string]InternalChasmNode  `json:",omitempty"`
	SignalRequestedIDs  map[string]struct{}           `json:",omitempty"`

	Tasks map[tasks.Category][]InternalHistoryTask `json:",omitempty"`

	Condition int64

	Checksum *commonpb.DataBlob
}

type InvalidPersistenceRequestError struct {
	Msg string
}

type ListClusterMetadataRequest struct {
	PageSize      int
	NextPageToken []byte
}

type ListClusterMetadataResponse struct {
	ClusterMetadata []*GetClusterMetadataResponse
	NextPageToken   []byte
}

type ListConcreteExecutionsRequest struct {
	ShardID   int32
	PageSize  int
	PageToken []byte
}

type ListConcreteExecutionsResponse struct {
	States    []*persistencespb.WorkflowMutableState
	PageToken []byte
}

type ListNamespacesRequest struct {
	PageSize       int
	NextPageToken  []byte
	IncludeDeleted bool
}

type ListNamespacesResponse struct {
	Namespaces    []*GetNamespaceResponse
	NextPageToken []byte
}

type ListNexusEndpointsRequest struct {
	LastKnownTableVersion int64
	NextPageToken         []byte
	PageSize              int
}

type ListNexusEndpointsResponse struct {
	TableVersion  int64
	NextPageToken []byte
	Entries       []*persistencespb.NexusEndpointEntry
}

type ListQueuesRequest struct {
	QueueType     QueueV2Type
	PageSize      int
	NextPageToken []byte
}

type ListQueuesResponse struct {
	Queues        []QueueInfo
	NextPageToken []byte
}

type ListTaskQueueRequest struct {
	PageSize  int
	PageToken []byte
}

type ListTaskQueueResponse struct {
	Items         []*PersistedTaskQueueInfo
	NextPageToken []byte
}

type ListTaskQueueUserDataEntriesRequest struct {
	NamespaceID   string
	PageSize      int
	NextPageToken []byte
}

type ListTaskQueueUserDataEntriesResponse struct {
	NextPageToken []byte
	Entries       []*TaskQueueUserDataEntry
}

type MessageMetadata struct {
	ID int64
}

type MetadataManager interface {
	Closeable
	GetName() string
	CreateNamespace(ctx context.Context, request *CreateNamespaceRequest) (*CreateNamespaceResponse, error)
	GetNamespace(ctx context.Context, request *GetNamespaceRequest) (*GetNamespaceResponse, error)
	UpdateNamespace(ctx context.Context, request *UpdateNamespaceRequest) error
	RenameNamespace(ctx context.Context, request *RenameNamespaceRequest) error
	DeleteNamespace(ctx context.Context, request *DeleteNamespaceRequest) error
	DeleteNamespaceByName(ctx context.Context, request *DeleteNamespaceByNameRequest) error
	ListNamespaces(ctx context.Context, request *ListNamespacesRequest) (*ListNamespacesResponse, error)
	GetMetadata(ctx context.Context) (*GetMetadataResponse, error)
	InitializeSystemNamespaces(ctx context.Context, currentClusterName string) error
	WatchNamespaces(ctx context.Context) (<-chan *NamespaceWatchEvent, error)
}

type MetadataStore interface {
	Closeable
	GetName() string
	CreateNamespace(ctx context.Context, request *InternalCreateNamespaceRequest) (*CreateNamespaceResponse, error)
	GetNamespace(ctx context.Context, request *GetNamespaceRequest) (*InternalGetNamespaceResponse, error)
	UpdateNamespace(ctx context.Context, request *InternalUpdateNamespaceRequest) error
	RenameNamespace(ctx context.Context, request *InternalRenameNamespaceRequest) error
	DeleteNamespace(ctx context.Context, request *DeleteNamespaceRequest) error
	DeleteNamespaceByName(ctx context.Context, request *DeleteNamespaceByNameRequest) error
	ListNamespaces(ctx context.Context, request *InternalListNamespacesRequest) (*InternalListNamespacesResponse, error)
	GetMetadata(ctx context.Context) (*GetMetadataResponse, error)
}

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

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

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

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

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

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

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

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

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

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

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

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