api

type Activity struct {
	ID int `jsonapi:"primary,activity"`

	// Standard fields
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`
	// Related fields
	// The object where this activity belongs
	// e.g if Type is "bb.issue.xxx", then this field refers to the corresponding issue's id.
	ContainerID int `jsonapi:"attr,containerId"`

	// Domain specific fields
	Type    ActivityType  `jsonapi:"attr,type"`
	Level   ActivityLevel `jsonapi:"attr,level"`
	Comment string        `jsonapi:"attr,comment"`
	Payload string        `jsonapi:"attr,payload"`
}

type ActivityCreate struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	CreatorID int

	// Domain specific fields
	ContainerID int          `jsonapi:"attr,containerId"`
	Type        ActivityType `jsonapi:"attr,type"`
	Level       ActivityLevel
	Comment     string `jsonapi:"attr,comment"`
	Payload     string `jsonapi:"attr,payload"`
}

type ActivityDelete struct {
	ID int

	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	DeleterID int
}

type ActivityFind struct {
	ID *int

	// Domain specific fields
	CreatorID   *int
	Type        *string
	Level       *ActivityLevel
	ContainerID *int
	Limit       *int
}

type ActivityIssueCommentCreatePayload struct {
	// Used by inbox to display info without paying the join cost
	IssueName string `json:"issueName"`
}

type ActivityIssueCreatePayload struct {
	// Used by inbox to display info without paying the join cost
	IssueName string `json:"issueName"`
}

type ActivityIssueFieldUpdatePayload struct {
	FieldID  IssueFieldID `json:"fieldId"`
	OldValue string       `json:"oldValue,omitempty"`
	NewValue string       `json:"newValue,omitempty"`
	// Used by inbox to display info without paying the join cost
	IssueName string `json:"issueName"`
}

type ActivityIssueStatusUpdatePayload struct {
	OldStatus IssueStatus `json:"oldStatus,omitempty"`
	NewStatus IssueStatus `json:"newStatus,omitempty"`
	// Used by inbox to display info without paying the join cost
	IssueName string `json:"issueName"`
}

type ActivityLevel string

type ActivityMemberActivateDeactivatePayload struct {
	PrincipalID    int    `json:"principalId"`
	PrincipalName  string `json:"principalName"`
	PrincipalEmail string `json:"principalEmail"`
	Role           Role   `json:"role"`
}

type ActivityMemberCreatePayload struct {
	PrincipalID    int          `json:"principalId"`
	PrincipalName  string       `json:"principalName"`
	PrincipalEmail string       `json:"principalEmail"`
	MemberStatus   MemberStatus `json:"memberStatus"`
	Role           Role         `json:"role"`
}

type ActivityMemberRoleUpdatePayload struct {
	PrincipalID    int    `json:"principalId"`
	PrincipalName  string `json:"principalName"`
	PrincipalEmail string `json:"principalEmail"`
	OldRole        Role   `json:"oldRole"`
	NewRole        Role   `json:"newRole"`
}

type ActivityPatch struct {
	ID int `jsonapi:"primary,activityPatch"`

	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	UpdaterID int

	// Domain specific fields
	Comment *string `jsonapi:"attr,comment"`
}

type ActivityPipelineTaskEarliestAllowedTimeUpdatePayload struct {
	TaskID               int   `json:"taskId"`
	OldEarliestAllowedTs int64 `json:"oldEarliestAllowedTs,omitempty"`
	NewEarliestAllowedTs int64 `json:"newEarliestAllowedTs,omitempty"`
	// Used by inbox to display info without paying the join cost
	IssueName string `json:"issueName"`
	TaskName  string `json:"taskName"`
}

type ActivityPipelineTaskFileCommitPayload struct {
	TaskID             int    `json:"taskId"`
	VCSInstanceURL     string `json:"vcsInstanceUrl,omitempty"`
	RepositoryFullPath string `json:"repositoryFullPath,omitempty"`
	Branch             string `json:"branch,omitempty"`
	FilePath           string `json:"filePath,omitempty"`
	CommitID           string `json:"commitId,omitempty"`
}

type ActivityPipelineTaskStatementUpdatePayload struct {
	TaskID       int    `json:"taskId"`
	OldStatement string `json:"oldStatement,omitempty"`
	NewStatement string `json:"newStatement,omitempty"`
	// Used by inbox to display info without paying the join cost
	IssueName string `json:"issueName"`
	TaskName  string `json:"taskName"`
}

type ActivityPipelineTaskStatusUpdatePayload struct {
	TaskID    int        `json:"taskId"`
	OldStatus TaskStatus `json:"oldStatus,omitempty"`
	NewStatus TaskStatus `json:"newStatus,omitempty"`
	// Used by inbox to display info without paying the join cost
	IssueName string `json:"issueName"`
	TaskName  string `json:"taskName"`
}

type ActivityProjectDatabaseTransferPayload struct {
	DatabaseID int `json:"databaseId,omitempty"`
	// Used by activity table to display info without paying the join cost
	DatabaseName string `json:"databaseName,omitempty"`
}

type ActivityProjectRepositoryPushPayload struct {
	VCSPushEvent vcs.PushEvent `json:"pushEvent"`
	// Used by activity table to display info without paying the join cost
	// IssueID/IssueName only exist if the push event leads to the issue creation.
	IssueID   int    `json:"issueId,omitempty"`
	IssueName string `json:"issueName,omitempty"`
}

type ActivitySQLEditorQueryPayload struct {
	// Used by activity table to display info without paying the join cost
	Statement    string `json:"statement"`
	DurationNs   int64  `json:"durationNs"`
	InstanceName string `json:"instanceName"`
	DatabaseName string `json:"databaseName"`
	Error        string `json:"error"`
}

type ActivityService interface {
	CreateActivity(ctx context.Context, create *ActivityCreate) (*Activity, error)
	FindActivityList(ctx context.Context, find *ActivityFind) ([]*Activity, error)
	FindActivity(ctx context.Context, find *ActivityFind) (*Activity, error)
	PatchActivity(ctx context.Context, patch *ActivityPatch) (*Activity, error)
	DeleteActivity(ctx context.Context, delete *ActivityDelete) error
}

type ActivityType string

type Anomaly struct {
	ID int `jsonapi:"primary,anomaly"`

	// Standard fields
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Related fields
	InstanceID int `jsonapi:"attr,instanceId"`
	// Instance anomaly doesn't have databaseID
	DatabaseID *int `jsonapi:"attr,databaseId"`

	// Domain specific fields
	Type AnomalyType `jsonapi:"attr,type"`
	// Calculated field derived from type
	Severity AnomalySeverity `jsonapi:"attr,severity"`
	Payload  string          `jsonapi:"attr,payload"`
}

type AnomalyArchive struct {
	InstanceID *int
	DatabaseID *int
	Type       AnomalyType
}

type AnomalyDatabaseBackupMissingPayload struct {
	ExpectedBackupSchedule BackupPlanPolicySchedule `json:"expectedSchedule,omitempty"`
	// Time of last successful backup created
	LastBackupTs int64 `json:"lastBackupTs,omitempty"`
}

type AnomalyDatabaseBackupPolicyViolationPayload struct {
	EnvironmentID          int                      `json:"environmentId,omitempty"`
	ExpectedBackupSchedule BackupPlanPolicySchedule `json:"expectedSchedule,omitempty"`
	ActualBackupSchedule   BackupPlanPolicySchedule `json:"actualSchedule,omitempty"`
}

type AnomalyDatabaseConnectionPayload struct {
	// Connection failure detail
	Detail string `json:"detail,omitempty"`
}

type AnomalyDatabaseSchemaDriftPayload struct {
	// The schema version corresponds to the expected schema
	Version string `json:"version,omitempty"`
	// The expected latest schema stored in the migration history table
	Expect string `json:"expect,omitempty"`
	// The actual schema dumped from the database
	Actual string `json:"actual,omitempty"`
}

type AnomalyFind struct {
	// Standard fields
	RowStatus *RowStatus

	// Related fields
	InstanceID *int
	DatabaseID *int
	Type       *AnomalyType
	// Only applicable if InstanceID is specified, if true, then we only return instance anomaly (database_id is NULL)
	InstanceOnly bool
}

type AnomalyInstanceConnectionPayload struct {
	// Connection failure detail
	Detail string `json:"detail,omitempty"`
}

type AnomalyService interface {
	// UpsertActiveAnomaly would update the existing active anomaly if both database id and type match, otherwise create a new one.
	UpsertActiveAnomaly(ctx context.Context, upsert *AnomalyUpsert) (*Anomaly, error)
	FindAnomalyList(ctx context.Context, find *AnomalyFind) ([]*Anomaly, error)
	ArchiveAnomaly(ctx context.Context, archive *AnomalyArchive) error
}

type AnomalySeverity string

type AnomalyType string

type AnomalyUpsert struct {
	// Standard fields
	CreatorID int

	// Related fields
	InstanceID int
	DatabaseID *int

	// Domain specific fields
	Type    AnomalyType `jsonapi:"attr,type"`
	Payload string      `jsonapi:"attr,payload"`
}

type AuthProvider struct {
	Type          vcs.Type `jsonapi:"attr,type"`
	Name          string   `jsonapi:"attr,name"`
	InstanceURL   string   `jsonapi:"attr,instanceUrl"`
	ApplicationID string   `jsonapi:"attr,applicationId"`
	// Secret will be used for OAuth on the client side when user choose to login via Gitlab
	Secret string `jsonapi:"attr,secret"`
}

type Backup struct {
	ID int `jsonapi:"primary,backup"`

	// Standard fields
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Related fields
	DatabaseID int `jsonapi:"attr,databaseId"`

	// Domain specific fields
	Name           string               `jsonapi:"attr,name"`
	Status         BackupStatus         `jsonapi:"attr,status"`
	Type           BackupType           `jsonapi:"attr,type"`
	StorageBackend BackupStorageBackend `jsonapi:"attr,storageBackend"`
	// Upon taking the database backup, we will also record the current migration history version if exists.
	// And when restoring the backup, we will record this in the migration history.
	MigrationHistoryVersion string `jsonapi:"attr,migrationHistoryVersion"`
	Path                    string `jsonapi:"attr,path"`
	Comment                 string `jsonapi:"attr,comment"`
}

type BackupCreate struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	CreatorID int

	// Related fields
	DatabaseID int `jsonapi:"attr,databaseId"`

	// Domain specific fields
	Name                    string               `jsonapi:"attr,name"`
	Type                    BackupType           `jsonapi:"attr,type"`
	StorageBackend          BackupStorageBackend `jsonapi:"attr,storageBackend"`
	MigrationHistoryVersion string
	Path                    string
}

type BackupFind struct {
	ID *int

	// Related fields
	DatabaseID *int

	// Domain specific fields
	Name   *string
	Status *BackupStatus
}

type BackupPatch struct {
	ID int

	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	UpdaterID int

	// Domain specific fields
	Status  string
	Comment string
}

type BackupPlanPolicy struct {
	Schedule BackupPlanPolicySchedule `json:"schedule"`
}

type BackupPlanPolicySchedule string

type BackupService interface {
	CreateBackup(ctx context.Context, create *BackupCreate) (*Backup, error)
	FindBackup(ctx context.Context, find *BackupFind) (*Backup, error)
	// Returns backup list in updated_ts descending order.
	FindBackupList(ctx context.Context, find *BackupFind) ([]*Backup, error)
	PatchBackup(ctx context.Context, patch *BackupPatch) (*Backup, error)
	FindBackupSetting(ctx context.Context, find *BackupSettingFind) (*BackupSetting, error)
	UpsertBackupSetting(ctx context.Context, upsert *BackupSettingUpsert) (*BackupSetting, error)
	UpsertBackupSettingTx(ctx context.Context, tx *sql.Tx, upsert *BackupSettingUpsert) (*BackupSetting, error)
	FindBackupSettingsMatch(ctx context.Context, match *BackupSettingsMatch) ([]*BackupSetting, error)
}

type BackupSetting struct {
	ID int `jsonapi:"primary,backupSetting"`

	// Standard fields
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Related fields
	DatabaseID int `jsonapi:"attr,databaseId"`
	// Do not return this to the client since the client always has the database context and fetching the
	// database object and all its own related objects is a bit expensive.
	Database *Database

	// Domain specific fields
	Enabled   bool `jsonapi:"attr,enabled"`
	Hour      int  `jsonapi:"attr,hour"`
	DayOfWeek int  `jsonapi:"attr,dayOfWeek"`
	// HookURL is the callback url to be requested (using HTTP GET) after a successful backup.
	HookURL string `jsonapi:"attr,hookUrl"`
}

type BackupSettingFind struct {
	ID *int

	// Related fields
	DatabaseID *int
}

type BackupSettingUpsert struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	// CreatorID is the ID of the creator.
	UpdaterID int

	// Related fields
	DatabaseID    int `jsonapi:"attr,databaseId"`
	EnvironmentID int

	// Domain specific fields
	Enabled   bool   `jsonapi:"attr,enabled"`
	Hour      int    `jsonapi:"attr,hour"`
	DayOfWeek int    `jsonapi:"attr,dayOfWeek"`
	HookURL   string `jsonapi:"attr,hookUrl"`
}

type BackupSettingsMatch struct {
	Hour      int
	DayOfWeek int
}

type BackupStatus string

type BackupStorageBackend string

type BackupType string

type Bookmark struct {
	ID int `jsonapi:"primary,bookmark"`

	// Standard fields
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Domain specific fields
	Name string `jsonapi:"attr,name"`
	Link string `jsonapi:"attr,link"`
}

type BookmarkCreate struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	CreatorID int

	// Domain specific fields
	Name string `jsonapi:"attr,name"`
	Link string `jsonapi:"attr,link"`
}

type BookmarkDelete struct {
	ID int

	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	DeleterID int
}

type BookmarkFind struct {
	ID *int

	// Standard fields
	CreatorID *int
}

type BookmarkService interface {
	CreateBookmark(ctx context.Context, create *BookmarkCreate) (*Bookmark, error)
	FindBookmarkList(ctx context.Context, find *BookmarkFind) ([]*Bookmark, error)
	FindBookmark(ctx context.Context, find *BookmarkFind) (*Bookmark, error)
	DeleteBookmark(ctx context.Context, delete *BookmarkDelete) error
}

type CacheNamespace string

type CacheService interface {
	FindCache(namespace CacheNamespace, id int, entry interface{}) (bool, error)
	UpsertCache(namespace CacheNamespace, id int, entry interface{}) error
}

type Column struct {
	ID int `jsonapi:"primary,column"`

	// Standard fields
	CreatorID int
	CreatedTs int64 `json:"createdTs"`
	UpdaterID int
	UpdatedTs int64 `json:"updatedTs"`

	// Related fields
	DatabaseID int
	TableID    int

	// Domain specific fields
	Name         string  `json:"name"`
	Position     int     `json:"position"`
	Default      *string `json:"default"`
	Nullable     bool    `json:"nullable"`
	Type         string  `json:"type"`
	CharacterSet string  `json:"characterSet"`
	Collation    string  `json:"collation"`
	Comment      string  `json:"comment"`
}

type ColumnCreate struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	CreatorID int

	// Related fields
	DatabaseID int
	TableID    int

	// Domain specific fields
	Name         string
	Position     int
	Default      *string
	Nullable     bool
	Type         string
	CharacterSet string
	Collation    string
	Comment      string
}

type ColumnFind struct {
	ID *int

	// Related fields
	DatabaseID *int
	TableID    *int

	// Domain specific fields
	Name *string
}

type ColumnPatch struct {
	ID int

	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	UpdaterID int
}

type ColumnService interface {
	CreateColumn(ctx context.Context, create *ColumnCreate) (*Column, error)
	FindColumnList(ctx context.Context, find *ColumnFind) ([]*Column, error)
	FindColumn(ctx context.Context, find *ColumnFind) (*Column, error)
	PatchColumn(ctx context.Context, patch *ColumnPatch) (*Column, error)
}

type ConnectionInfo struct {
	Engine           db.Type `jsonapi:"attr,engine"`
	Host             string  `jsonapi:"attr,host"`
	Port             string  `jsonapi:"attr,port"`
	Username         string  `jsonapi:"attr,username"`
	Password         string  `jsonapi:"attr,password"`
	UseEmptyPassword bool    `jsonapi:"attr,useEmptyPassword"`
	InstanceID       *int    `jsonapi:"attr,instanceId"`
}

type CreateDatabaseContext struct {
	// InstanceID is the ID of an instance.
	InstanceID int `json:"instanceId"`
	// DatabaseName is the name of the database.
	DatabaseName string `json:"databaseName"`
	// CharacterSet is the character set of the database.
	CharacterSet string `json:"characterSet"`
	// Collation is the collation of the database.
	Collation string `json:"collation"`
	// BackupID is the ID of the backup.
	BackupID int `json:"backupId"`
	// Labels is a json-encoded string from a list of DatabaseLabel.
	// See definition in api.Database.
	Labels string `jsonapi:"attr,labels,omitempty"`
}

type DataSource struct {
	ID int `jsonapi:"primary,dataSource"`

	// Standard fields
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Related fields
	// Just returns InstanceID and DatabaseID otherwise would cause circular dependency.
	InstanceID int `jsonapi:"attr,instanceId"`
	DatabaseID int `jsonapi:"attr,databaseId"`

	// Domain specific fields
	Name     string         `jsonapi:"attr,name"`
	Type     DataSourceType `jsonapi:"attr,type"`
	Username string         `jsonapi:"attr,username"`
	Password string         `jsonapi:"attr,password"`
}

type DataSourceCreate struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	CreatorID int

	// Related fields
	InstanceID int `jsonapi:"attr,instanceId"`
	DatabaseID int `jsonapi:"attr,databaseId"`

	// Domain specific fields
	Name     string         `jsonapi:"attr,name"`
	Type     DataSourceType `jsonapi:"attr,type"`
	Username string         `jsonapi:"attr,username"`
	Password string         `jsonapi:"attr,password"`
}

type DataSourceFind struct {
	ID *int

	// Related fields
	InstanceID *int
	DatabaseID *int

	// Domain specific fields
	Type *DataSourceType
}

type DataSourcePatch struct {
	ID int

	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	UpdaterID int

	// Domain specific fields
	Username         *string `jsonapi:"attr,username"`
	Password         *string `jsonapi:"attr,password"`
	UseEmptyPassword *bool   `jsonapi:"attr,useEmptyPassword"`
}

type DataSourceService interface {
	CreateDataSource(ctx context.Context, create *DataSourceCreate) (*DataSource, error)
	// This is specifically used to create data source when creating the instance.
	CreateDataSourceTx(ctx context.Context, tx *sql.Tx, create *DataSourceCreate) (*DataSource, error)
	FindDataSourceList(ctx context.Context, find *DataSourceFind) ([]*DataSource, error)
	FindDataSource(ctx context.Context, find *DataSourceFind) (*DataSource, error)
	PatchDataSource(ctx context.Context, patch *DataSourcePatch) (*DataSource, error)
}

type DataSourceType string

type Database struct {
	ID int `jsonapi:"primary,database"`

	// Standard fields
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Related fields
	ProjectID      int           `jsonapi:"attr,projectId"`
	Project        *Project      `jsonapi:"relation,project"`
	InstanceID     int           `jsonapi:"attr,instanceId"`
	Instance       *Instance     `jsonapi:"relation,instance"`
	DataSourceList []*DataSource `jsonapi:"relation,dataSource"`
	SourceBackupID int
	SourceBackup   *Backup `jsonapi:"relation,sourceBackup"`
	// Anomalies are stored in a separate table, but just return here for convenience
	AnomalyList []*Anomaly `jsonapi:"relation,anomaly"`

	// Domain specific fields
	Name                 string     `jsonapi:"attr,name"`
	CharacterSet         string     `jsonapi:"attr,characterSet"`
	Collation            string     `jsonapi:"attr,collation"`
	SchemaVersion        string     `jsonapi:"attr,schemaVersion"`
	SyncStatus           SyncStatus `jsonapi:"attr,syncStatus"`
	LastSuccessfulSyncTs int64      `jsonapi:"attr,lastSuccessfulSyncTs"`
	// Labels is a json-encoded string from a list of DatabaseLabel,
	// e.g. "[{"key":"bb.location","value":"earth"},{"key":"bb.tenant","value":"bytebase"}]".
	Labels string `jsonapi:"attr,labels,omitempty"`
}

type DatabaseCreate struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	CreatorID int

	// Related fields
	ProjectID     int `jsonapi:"attr,projectId"`
	InstanceID    int `jsonapi:"attr,instanceId"`
	EnvironmentID int

	// Domain specific fields
	Name         string `jsonapi:"attr,name"`
	CharacterSet string `jsonapi:"attr,characterSet"`
	Collation    string `jsonapi:"attr,collation"`
	IssueID      int    `jsonapi:"attr,issueId"`
	// Labels is a json-encoded string from a list of DatabaseLabel,
	// e.g. "[{"key":"bb.location","value":"earth"},{"key":"bb.tenant","value":"bytebase"}]".
	Labels        *string `jsonapi:"attr,labels"`
	SchemaVersion string
}

type DatabaseFind struct {
	ID *int

	// Related fields
	InstanceID *int
	ProjectID  *int

	// Domain specific fields
	Name               *string
	IncludeAllDatabase bool
}

type DatabaseLabel struct {
	ID int `json:"-"`

	// Standard fields
	RowStatus RowStatus  `json:"-"`
	CreatorID int        `json:"-"`
	Creator   *Principal `json:"-"`
	CreatedTs int64      `json:"-"`
	UpdaterID int        `json:"-"`
	Updater   *Principal `json:"-"`
	UpdatedTs int64      `json:"-"`

	// Related fields
	DatabaseID int    `json:"-"`
	Key        string `json:"key"`

	// Domain specific fields
	Value string `json:"value"`
}

type DatabaseLabelFind struct {
	// Standard fields
	ID        *int
	RowStatus *RowStatus

	// Related fields
	DatabaseID *int
}

type DatabaseLabelUpsert struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	UpdaterID int
	RowStatus RowStatus

	// Related fields
	DatabaseID int
	Key        string

	// Domain specific fields
	Value string
}

type DatabasePatch struct {
	ID int

	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	UpdaterID int

	// Related fields
	ProjectID      *int `jsonapi:"attr,projectId"`
	SourceBackupID *int

	// Labels is a json-encoded string from a list of DatabaseLabel,
	// e.g. "[{"key":"bb.location","value":"earth"},{"key":"bb.tenant","value":"bytebase"}]".
	Labels *string `jsonapi:"attr,labels"`

	// Domain specific fields
	SchemaVersion        *string
	SyncStatus           *SyncStatus
	LastSuccessfulSyncTs *int64
}

type DatabaseService interface {
	CreateDatabase(ctx context.Context, create *DatabaseCreate) (*Database, error)
	// This is specifically used to create the * database when creating the instance.
	CreateDatabaseTx(ctx context.Context, tx *sql.Tx, create *DatabaseCreate) (*Database, error)
	FindDatabaseList(ctx context.Context, find *DatabaseFind) ([]*Database, error)
	FindDatabase(ctx context.Context, find *DatabaseFind) (*Database, error)
	PatchDatabase(ctx context.Context, patch *DatabasePatch) (*Database, error)
}

type Debug struct {
	IsDebug bool `jsonapi:"attr,isDebug"`
}

type DebugPatch struct {
	IsDebug bool `jsonapi:"attr,isDebug"`
}

type Deployment struct {
	Name string          `json:"name"`
	Spec *DeploymentSpec `json:"spec"`
}

type DeploymentConfig struct {
	ID int `jsonapi:"primary,deploymentConfig"`

	// Standard fields
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Related fields
	ProjectID int
	Project   *Project `jsonapi:"relation,project"`

	// Domain specific fields
	Name string `jsonapi:"attr,name"`
	// Payload encapsulates DeploymentSchedule in json string format. We use json instead jsonapi because this configuration isn't queryable as HTTP format.
	Payload string `jsonapi:"attr,payload"`
}

type DeploymentConfigFind struct {
	ID *int

	// Related fields
	ProjectID *int
}

type DeploymentConfigService interface {
	// FindDeploymentConfig finds the deployment configuration in a project.
	FindDeploymentConfig(ctx context.Context, find *DeploymentConfigFind) (*DeploymentConfig, error)
	// UpsertDeploymentConfig upserts a deployment configuration to a project.
	UpsertDeploymentConfig(ctx context.Context, upsert *DeploymentConfigUpsert) (*DeploymentConfig, error)
}

type DeploymentConfigUpsert struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	// CreatorID is the ID of the creator.
	UpdaterID int

	// Related fields
	ProjectID int

	// Domain specific fields
	Name string `jsonapi:"attr,name"`
	// Payload is a json serialization of DeploymentSchedule.
	Payload string `jsonapi:"attr,payload"`
}

type DeploymentSchedule struct {
	Deployments []*Deployment `json:"deployments"`
}

type DeploymentSpec struct {
	Selector *LabelSelector `json:"selector"`
}

type Environment struct {
	ID int `jsonapi:"primary,environment"`

	// Standard fields
	RowStatus RowStatus `jsonapi:"attr,rowStatus"`
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Domain specific fields
	Name  string `jsonapi:"attr,name"`
	Order int    `jsonapi:"attr,order"`
}

type EnvironmentCreate struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	CreatorID int

	// Domain specific fields
	Name string `jsonapi:"attr,name"`
}

type EnvironmentDelete struct {
	ID int

	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	DeleterID int
}

type EnvironmentFind struct {
	ID *int

	// Standard fields
	RowStatus *RowStatus
}

type EnvironmentPatch struct {
	ID int `jsonapi:"primary,environmentPatch"`

	// Standard fields
	RowStatus *string `jsonapi:"attr,rowStatus"`
	// Value is assigned from the jwt subject field passed by the client.
	UpdaterID int

	// Domain specific fields
	Name  *string `jsonapi:"attr,name"`
	Order *int    `jsonapi:"attr,order"`
}

type EnvironmentService interface {
	CreateEnvironment(ctx context.Context, create *EnvironmentCreate) (*Environment, error)
	FindEnvironmentList(ctx context.Context, find *EnvironmentFind) ([]*Environment, error)
	FindEnvironment(ctx context.Context, find *EnvironmentFind) (*Environment, error)
	PatchEnvironment(ctx context.Context, patch *EnvironmentPatch) (*Environment, error)
}

type FeatureType string

type GitlabLogin struct {
	InstanceURL   string `jsonapi:"attr,instanceUrl"`
	ApplicationID string `jsonapi:"attr,applicationId"`
	Secret        string `jsonapi:"attr,secret"`
	AccessToken   string `jsonapi:"attr,accessToken"`
}

type Inbox struct {
	ID int `jsonapi:"primary,inbox"`

	// Domain specific fields
	ReceiverID int         `jsonapi:"attr,receiverId"`
	Activity   *Activity   `jsonapi:"relation,activity"`
	Status     InboxStatus `jsonapi:"attr,status"`
}

type InboxCreate struct {
	// Domain specific fields
	ReceiverID int
	ActivityID int
}

type InboxFind struct {
	ID *int

	// Domain specific fields
	ReceiverID *int
	// If specified, then it will only fetch "UNREAD" item or "READ" item whose activity created after "CreatedAfterTs"
	ReadCreatedAfterTs *int64
}

type InboxPatch struct {
	ID int

	// Domain specific fields
	Status InboxStatus `jsonapi:"attr,status"`
}

type InboxService interface {
	CreateInbox(ctx context.Context, create *InboxCreate) (*Inbox, error)
	// Find the inbox list and return most recent created item first.
	FindInboxList(ctx context.Context, find *InboxFind) ([]*Inbox, error)
	FindInbox(ctx context.Context, find *InboxFind) (*Inbox, error)
	PatchInbox(ctx context.Context, patch *InboxPatch) (*Inbox, error)
	FindInboxSummary(ctx context.Context, principalID int) (*InboxSummary, error)
}

type InboxStatus string

type InboxSummary struct {
	HasUnread      bool `json:"hasUnread"`
	HasUnreadError bool `json:"hasUnreadError"`
}

type Index struct {
	ID int `jsonapi:"primary,index"`

	// Standard fields
	CreatorID int
	CreatedTs int64 `json:"createdTs"`
	UpdaterID int
	UpdatedTs int64 `json:"updatedTs"`

	// Related fields
	DatabaseID int
	TableID    int

	// Domain specific fields
	Name       string `json:"name"`
	Expression string `json:"expression"`
	Position   int    `json:"position"`
	Type       string `json:"type"`
	Unique     bool   `json:"unique"`
	Visible    bool   `json:"visible"`
	Comment    string `json:"comment"`
}

type IndexCreate struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	CreatorID int

	// Related fields
	DatabaseID int
	TableID    int

	// Domain specific fields
	Name       string
	Expression string
	Position   int
	Type       string
	Unique     bool
	Visible    bool
	Comment    string
}

type IndexFind struct {
	ID *int

	// Related fields
	DatabaseID *int
	TableID    *int

	// Domain specific fields
	Name       *string
	Expression *string
}

type IndexService interface {
	CreateIndex(ctx context.Context, create *IndexCreate) (*Index, error)
	FindIndexList(ctx context.Context, find *IndexFind) ([]*Index, error)
	FindIndex(ctx context.Context, find *IndexFind) (*Index, error)
}

type Instance struct {
	ID int `jsonapi:"primary,instance"`

	// Standard fields
	RowStatus RowStatus `jsonapi:"attr,rowStatus"`
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Related fields
	EnvironmentID int
	Environment   *Environment `jsonapi:"relation,environment"`
	// Anomalies are stored in a separate table, but just return here for convenience
	AnomalyList    []*Anomaly    `jsonapi:"relation,anomalyList"`
	DataSourceList []*DataSource `jsonapi:"relation,dataSourceList"`

	// Domain specific fields
	Name          string  `jsonapi:"attr,name"`
	Engine        db.Type `jsonapi:"attr,engine"`
	EngineVersion string  `jsonapi:"attr,engineVersion"`
	ExternalLink  string  `jsonapi:"attr,externalLink"`
	Host          string  `jsonapi:"attr,host"`
	Port          string  `jsonapi:"attr,port"`
	Username      string  `jsonapi:"attr,username"`
	// Password is not returned to the client
	Password string
}

type InstanceCreate struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	CreatorID int

	// Related fields
	EnvironmentID int `jsonapi:"attr,environmentId"`

	// Domain specific fields
	Name         string  `jsonapi:"attr,name"`
	Engine       db.Type `jsonapi:"attr,engine"`
	ExternalLink string  `jsonapi:"attr,externalLink"`
	Host         string  `jsonapi:"attr,host"`
	Port         string  `jsonapi:"attr,port"`
	Username     string  `jsonapi:"attr,username"`
	Password     string  `jsonapi:"attr,password"`
}

type InstanceFind struct {
	ID *int

	// Standard fields
	RowStatus *RowStatus
}

type InstanceMigration struct {
	Status InstanceMigrationSchemaStatus `jsonapi:"attr,status"`
	Error  string                        `jsonapi:"attr,error"`
}

type InstanceMigrationSchemaStatus string

type InstancePatch struct {
	ID int `jsonapi:"primary,instancePatch"`

	// Standard fields
	RowStatus *string `jsonapi:"attr,rowStatus"`
	// Value is assigned from the jwt subject field passed by the client.
	UpdaterID int

	// Domain specific fields
	Name             *string `jsonapi:"attr,name"`
	EngineVersion    *string
	ExternalLink     *string `jsonapi:"attr,externalLink"`
	Host             *string `jsonapi:"attr,host"`
	Port             *string `jsonapi:"attr,port"`
	Username         *string `jsonapi:"attr,username"`
	Password         *string `jsonapi:"attr,password"`
	UseEmptyPassword bool    `jsonapi:"attr,useEmptyPassword"`
}

type InstanceService interface {
	// CreateInstance should also create the * database and the admin data source.
	CreateInstance(ctx context.Context, create *InstanceCreate) (*Instance, error)
	FindInstanceList(ctx context.Context, find *InstanceFind) ([]*Instance, error)
	FindInstance(ctx context.Context, find *InstanceFind) (*Instance, error)
	CountInstance(ctx context.Context, find *InstanceFind) (int, error)
	PatchInstance(ctx context.Context, patch *InstancePatch) (*Instance, error)
}

type InstanceUser struct {
	ID int `jsonapi:"primary,instanceUser"`

	// Related fields
	InstanceID int `jsonapi:"attr,instanceId"`

	// Domain specific fields
	Name  string `jsonapi:"attr,name"`
	Grant string `jsonapi:"attr,grant"`
}

type InstanceUserDelete struct {
	ID int
}

type InstanceUserFind struct {
	InstanceID int
}

type InstanceUserService interface {
	// UpsertInstanceUser would update the existing user if name matches.
	UpsertInstanceUser(ctx context.Context, upsert *InstanceUserUpsert) (*InstanceUser, error)
	FindInstanceUserList(ctx context.Context, find *InstanceUserFind) ([]*InstanceUser, error)
	DeleteInstanceUser(ctx context.Context, delete *InstanceUserDelete) error
}

type InstanceUserUpsert struct {
	// Standard fields
	CreatorID int

	// Related fields
	InstanceID int

	// Domain specific fields
	Name  string `jsonapi:"attr,name"`
	Grant string `jsonapi:"attr,grant"`
}

type Issue struct {
	ID int `jsonapi:"primary,issue"`

	// Standard fields
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Related fields
	ProjectID  int
	Project    *Project `jsonapi:"relation,project"`
	PipelineID int
	Pipeline   *Pipeline `jsonapi:"relation,pipeline"`

	// Domain specific fields
	Name           string       `jsonapi:"attr,name"`
	Status         IssueStatus  `jsonapi:"attr,status"`
	Type           IssueType    `jsonapi:"attr,type"`
	Description    string       `jsonapi:"attr,description"`
	AssigneeID     int          `jsonapi:"attr,assigneeId"`
	Assignee       *Principal   `jsonapi:"relation,assignee"`
	SubscriberList []*Principal `jsonapi:"relation,subscriberList"`
	Payload        string       `jsonapi:"attr,payload"`
}

type IssueCreate struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	CreatorID int

	// Related fields
	ProjectID  int `jsonapi:"attr,projectId"`
	PipelineID int
	Pipeline   PipelineCreate `jsonapi:"attr,pipeline"`

	// Domain specific fields
	Name             string    `jsonapi:"attr,name"`
	Type             IssueType `jsonapi:"attr,type"`
	Description      string    `jsonapi:"attr,description"`
	AssigneeID       int       `jsonapi:"attr,assigneeId"`
	SubscriberIDList []int     `jsonapi:"attr,subscriberIdList"`
	Payload          string    `jsonapi:"attr,payload"`
	// CreateContext is used to create the issue pipeline and not persisted.
	// The context format depends on the issue type. For example, create database issue corresponds to CreateDatabaseContext.
	// This consolidates the pipeline generation to backend because both frontend and VCS pipeline could create issues and
	// we want the complexity resides in the backend.
	CreateContext string `jsonapi:"attr,createContext"`

	// ValidateOnly validates the request and previews the review, but does not actually post it.
	ValidateOnly bool `jsonapi:"attr,validateOnly"`
}

type IssueFieldID string

type IssueFind struct {
	ID *int

	// Related fields
	ProjectID *int

	// Domain specific fields
	PipelineID *int
	// Find issue where principalID is either creator, assignee or subscriber
	PrincipalID *int
	StatusList  *[]IssueStatus
	// If specified, then it will only fetch "Limit" most recently updated issues
	Limit *int
}

type IssuePatch struct {
	ID int `jsonapi:"primary,issuePatch"`

	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	UpdaterID int

	// Domain specific fields
	Name *string `jsonapi:"attr,name"`
	// Status is only set manually via IssueStatusPatch
	Status      *IssueStatus
	Description *string `jsonapi:"attr,description"`
	AssigneeID  *int    `jsonapi:"attr,assigneeId"`
	Payload     *string `jsonapi:"attr,payload"`
}

type IssueService interface {
	CreateIssue(ctx context.Context, create *IssueCreate) (*Issue, error)
	FindIssueList(ctx context.Context, find *IssueFind) ([]*Issue, error)
	FindIssue(ctx context.Context, find *IssueFind) (*Issue, error)
	PatchIssue(ctx context.Context, patch *IssuePatch) (*Issue, error)
}

type IssueStatus string

type IssueStatusPatch struct {
	ID int `jsonapi:"primary,issueStatusPatch"`

	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	UpdaterID int

	// Domain specific fields
	Status  IssueStatus `jsonapi:"attr,status"`
	Comment string      `jsonapi:"attr,comment"`
}

type IssueSubscriber struct {
	// Domain specific fields
	IssueID      int `jsonapi:"attr,issueId"`
	SubscriberID int
	Subscriber   *Principal `jsonapi:"relation,subscriber"`
}

type IssueSubscriberCreate struct {
	// Domain specific fields
	IssueID      int
	SubscriberID int `jsonapi:"attr,subscriberId"`
}

type IssueSubscriberDelete struct {
	// Domain specific fields
	IssueID      int
	SubscriberID int
}

type IssueSubscriberFind struct {
	// Domain specific fields
	IssueID      *int
	SubscriberID *int
}

type IssueSubscriberService interface {
	CreateIssueSubscriber(ctx context.Context, create *IssueSubscriberCreate) (*IssueSubscriber, error)
	FindIssueSubscriberList(ctx context.Context, find *IssueSubscriberFind) ([]*IssueSubscriber, error)
	DeleteIssueSubscriber(ctx context.Context, delete *IssueSubscriberDelete) error
}

type IssueType string

type LabelKey struct {
	ID int `jsonapi:"primary,labelKey"`

	// Standard fields
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Domain specific fields
	// bb.environment is a reserved key and identically mapped from environments. It has zero ID and its values are immutable.
	Key       string   `jsonapi:"attr,key"`
	ValueList []string `jsonapi:"attr,valueList"`
}

type LabelKeyFind struct {
	// RowStatus is the row status filter.
	RowStatus *RowStatus
}

type LabelKeyPatch struct {
	ID int

	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	// CreatorID is the ID of the creator.
	UpdaterID int

	// Domain specific fields
	ValueList []string `jsonapi:"attr,valueList"`
}

type LabelSelector struct {
	// MatchExpressions is a list of label selector requirements. The requirements are ANDed.
	MatchExpressions []*LabelSelectorRequirement `json:"matchExpressions"`
}

type LabelSelectorRequirement struct {
	// Key is the label key that the selector applies to.
	Key string `json:"key"`

	// Operator represents a key's relationship to a set of values.
	Operator OperatorType `json:"operator"`

	// Values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
	Values []string `json:"values"`
}

type LabelService interface {
	// FindLabelKeyList finds all available keys for labels.
	FindLabelKeyList(ctx context.Context, find *LabelKeyFind) ([]*LabelKey, error)
	// PatchLabelKey patches a label key.
	PatchLabelKey(ctx context.Context, patch *LabelKeyPatch) (*LabelKey, error)
	// FindDatabaseLabelList finds all database labels matching the conditions, ascending by key.
	FindDatabaseLabelList(ctx context.Context, find *DatabaseLabelFind) ([]*DatabaseLabel, error)
	// SetDatabaseLabelList sets a database's labels to new labels.
	SetDatabaseLabelList(ctx context.Context, labels []*DatabaseLabel, databaseID int, updaterID int) ([]*DatabaseLabel, error)
}

type Login struct {
	// Domain specific fields
	Email    string `jsonapi:"attr,email"`
	Password string `jsonapi:"attr,password"`
}

type Member struct {
	ID int `jsonapi:"primary,member"`

	// Standard fields
	RowStatus RowStatus `jsonapi:"attr,rowStatus"`
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Domain specific fields
	Status      MemberStatus `jsonapi:"attr,status"`
	Role        Role         `jsonapi:"attr,role"`
	PrincipalID int
	Principal   *Principal `jsonapi:"relation,principal"`
}

type MemberCreate struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	CreatorID int

	// Domain specific fields
	Status      MemberStatus `jsonapi:"attr,status"`
	Role        Role         `jsonapi:"attr,role"`
	PrincipalID int          `jsonapi:"attr,principalId"`
}

type MemberFind struct {
	ID *int

	// Domain specific fields
	PrincipalID *int
	Role        *Role
}

type MemberPatch struct {
	ID int

	// Standard fields
	RowStatus *string `jsonapi:"attr,rowStatus"`
	// Value is assigned from the jwt subject field passed by the client.
	UpdaterID int

	// Domain specific fields
	Role *string `jsonapi:"attr,role"`
}

type MemberService interface {
	CreateMember(ctx context.Context, create *MemberCreate) (*Member, error)
	FindMemberList(ctx context.Context, find *MemberFind) ([]*Member, error)
	FindMember(ctx context.Context, find *MemberFind) (*Member, error)
	PatchMember(ctx context.Context, patch *MemberPatch) (*Member, error)
}

type MemberStatus string

type MigrationHistory struct {
	ID int `jsonapi:"primary,migrationHistory"`

	// Standard fields
	Creator   string `jsonapi:"attr,creator"`
	CreatedTs int64  `jsonapi:"attr,createdTs"`
	Updater   string `jsonapi:"attr,updater"`
	UpdatedTs int64  `jsonapi:"attr,updatedTs"`

	// Domain specific fields
	ReleaseVersion      string             `jsonapi:"attr,releaseVersion"`
	Database            string             `jsonapi:"attr,database"`
	Source              db.MigrationSource `jsonapi:"attr,source"`
	Type                db.MigrationType   `jsonapi:"attr,type"`
	Status              db.MigrationStatus `jsonapi:"attr,status"`
	Version             string             `jsonapi:"attr,version"`
	Description         string             `jsonapi:"attr,description"`
	Statement           string             `jsonapi:"attr,statement"`
	Schema              string             `jsonapi:"attr,schema"`
	SchemaPrev          string             `jsonapi:"attr,schemaPrev"`
	ExecutionDurationNs int64              `jsonapi:"attr,executionDurationNs"`
	// This is a string instead of int as the issue id may come from other issue tracking system in the future
	IssueID string `jsonapi:"attr,issueId"`
	Payload string `jsonapi:"attr,payload"`
}

type OperatorType string

type Pipeline struct {
	ID int `jsonapi:"primary,pipeline"`

	// Standard fields
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Related fields
	StageList []*Stage `jsonapi:"relation,stage"`

	// Domain specific fields
	Name   string         `jsonapi:"attr,name"`
	Status PipelineStatus `jsonapi:"attr,status"`
}

type PipelineApprovalPolicy struct {
	Value PipelineApprovalValue `json:"value"`
}

type PipelineApprovalValue string

type PipelineCreate struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	CreatorID int

	// Related fields
	StageList []StageCreate `jsonapi:"attr,stageList"`

	// Domain specific fields
	Name string `jsonapi:"attr,name"`
}

type PipelineFind struct {
	ID *int

	// Domain specific fields
	Status *PipelineStatus
}

type PipelinePatch struct {
	ID int `jsonapi:"primary,pipelinePatch"`

	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	UpdaterID int

	// Domain specific fields
	Status *PipelineStatus `jsonapi:"attr,status"`
}

type PipelineService interface {
	CreatePipeline(ctx context.Context, create *PipelineCreate) (*Pipeline, error)
	FindPipelineList(ctx context.Context, find *PipelineFind) ([]*Pipeline, error)
	FindPipeline(ctx context.Context, find *PipelineFind) (*Pipeline, error)
	PatchPipeline(ctx context.Context, patch *PipelinePatch) (*Pipeline, error)
}

type PipelineStatus string

type Plan struct {
	Type PlanType `jsonapi:"attr,type"`
}

type PlanPatch struct {
	Type PlanType `jsonapi:"attr,type"`
}

type PlanType int

type Policy struct {
	ID int `jsonapi:"primary,policy"`

	// Standard fields
	RowStatus RowStatus `jsonapi:"attr,rowStatus"`
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Related fields
	EnvironmentID int
	Environment   *Environment `jsonapi:"relation,environment"`

	// Domain specific fields
	Type    PolicyType `jsonapi:"attr,type"`
	Payload string     `jsonapi:"attr,payload"`
}

type PolicyFind struct {
	ID *int

	// Related fields
	EnvironmentID *int

	// Domain specific fields
	Type *PolicyType `jsonapi:"attr,type"`
}

type PolicyService interface {
	FindPolicy(ctx context.Context, find *PolicyFind) (*Policy, error)
	UpsertPolicy(ctx context.Context, upsert *PolicyUpsert) (*Policy, error)
	GetBackupPlanPolicy(ctx context.Context, environmentID int) (*BackupPlanPolicy, error)
	GetPipelineApprovalPolicy(ctx context.Context, environmentID int) (*PipelineApprovalPolicy, error)
}

type PolicyType string

type PolicyUpsert struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	// CreatorID is the ID of the creator.
	UpdaterID int

	// Related fields
	EnvironmentID int

	// Domain specific fields
	Type    PolicyType
	Payload string `jsonapi:"attr,payload"`
}

type Principal struct {
	ID int `jsonapi:"primary,principal"`

	// Standard fields
	CreatorID int   `jsonapi:"attr,creatorId"`
	CreatedTs int64 `jsonapi:"attr,createdTs"`
	UpdaterID int   `jsonapi:"attr,updaterId"`
	UpdatedTs int64 `jsonapi:"attr,updatedTs"`

	// Domain specific fields
	Type  PrincipalType `jsonapi:"attr,type"`
	Name  string        `jsonapi:"attr,name"`
	Email string        `jsonapi:"attr,email"`
	// Do not return to the client
	PasswordHash string
	// Role is stored in the member table, but we include it when returning the principal.
	// This simplifies the client code where it won't require order depenendency to fetch the related member info first.
	Role Role `jsonapi:"attr,role"`
}

type PrincipalAuthProvider string

type PrincipalCreate struct {
	// Standard fields
	// For signup, value is SYSTEM_BOT_ID
	// For invite, value is assigned from the jwt subject field passed by the client.
	CreatorID int

	// Domain specific fields
	Type         PrincipalType
	Name         string `jsonapi:"attr,name"`
	Email        string `jsonapi:"attr,email"`
	Password     string `jsonapi:"attr,password"`
	PasswordHash string
}

type PrincipalFind struct {
	ID *int

	// Domain specific fields
	Email *string
}

type PrincipalPatch struct {
	ID int

	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	UpdaterID int

	// Domain specific fields
	Name         *string `jsonapi:"attr,name"`
	Password     *string `jsonapi:"attr,password"`
	PasswordHash *string
}

type PrincipalService interface {
	CreatePrincipal(ctx context.Context, create *PrincipalCreate) (*Principal, error)
	FindPrincipalList(ctx context.Context) ([]*Principal, error)
	FindPrincipal(ctx context.Context, find *PrincipalFind) (*Principal, error)
	PatchPrincipal(ctx context.Context, patch *PrincipalPatch) (*Principal, error)
}

type PrincipalType string

type Project struct {
	ID int `jsonapi:"primary,project"`

	// Standard fields
	RowStatus RowStatus `jsonapi:"attr,rowStatus"`
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Related fields
	ProjectMemberList []*ProjectMember `jsonapi:"relation,projectMember"`

	// Domain specific fields
	Name         string              `jsonapi:"attr,name"`
	Key          string              `jsonapi:"attr,key"`
	WorkflowType ProjectWorkflowType `jsonapi:"attr,workflowType"`
	Visibility   ProjectVisibility   `jsonapi:"attr,visibility"`
	TenantMode   ProjectTenantMode   `jsonapi:"attr,tenantMode"`
	// DBNameTemplate is only used when a project is in tenant mode.
	// Empty value means {{DB_NAME}}.
	DBNameTemplate string              `jsonapi:"attr,dbNameTemplate"`
	RoleProvider   ProjectRoleProvider `jsonapi:"attr,roleProvider"`
}

type ProjectCreate struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	CreatorID int

	// Domain specific fields
	Name           string              `jsonapi:"attr,name"`
	Key            string              `jsonapi:"attr,key"`
	TenantMode     ProjectTenantMode   `jsonapi:"attr,tenantMode"`
	DBNameTemplate string              `jsonapi:"attr,dbNameTemplate"`
	RoleProvider   ProjectRoleProvider `jsonapi:"attr,roleProvider"`
}

type ProjectFind struct {
	ID *int

	// Standard fields
	RowStatus *RowStatus

	// Domain specific fields
	// If present, will only find project containing PrincipalID as an active member
	PrincipalID *int
}

type ProjectMember struct {
	ID int `jsonapi:"primary,projectMember"`

	// Standard fields
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Related fields
	// Just returns ProjectID otherwise would cause circular dependency.
	ProjectID int `jsonapi:"attr,projectId"`

	// Domain specific fields
	Role         string `jsonapi:"attr,role"`
	PrincipalID  int
	Principal    *Principal          `jsonapi:"relation,principal"`
	RoleProvider ProjectRoleProvider `jsonapi:"attr,roleProvider"`
	Payload      string              `jsonapi:"attr,payload"`
}

type ProjectMemberBatchUpdate struct {
	ID int

	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	UpdaterID int

	// All the Member to be update should have the same role provider as this field
	RoleProvider ProjectRoleProvider
	List         []*ProjectMemberCreate
}

type ProjectMemberCreate struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	CreatorID int

	// Related fields
	ProjectID int

	// Domain specific fields
	Role         common.ProjectRole  `jsonapi:"attr,role"`
	PrincipalID  int                 `jsonapi:"attr,principalId"`
	RoleProvider ProjectRoleProvider `jsonapi:"attr,roleProvider"`
	Payload      string              `jsonapi:"attr,payload"`
}

type ProjectMemberDelete struct {
	ID int

	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	DeleterID int
}

type ProjectMemberFind struct {
	ID *int

	// Related fields
	ProjectID    *int
	RoleProvider *ProjectRoleProvider
}

type ProjectMemberPatch struct {
	ID int

	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	UpdaterID int

	// Domain specific fields
	Role         *string `jsonapi:"attr,role"`
	RoleProvider *string `jsonapi:"attr,roleProvider"`
	Payload      *string `jsonapi:"attr,payload"`
}

type ProjectMemberService interface {
	CreateProjectMember(ctx context.Context, create *ProjectMemberCreate) (*ProjectMember, error)
	FindProjectMemberList(ctx context.Context, find *ProjectMemberFind) ([]*ProjectMember, error)
	FindProjectMember(ctx context.Context, find *ProjectMemberFind) (*ProjectMember, error)
	PatchProjectMember(ctx context.Context, patch *ProjectMemberPatch) (*ProjectMember, error)
	DeleteProjectMember(ctx context.Context, delete *ProjectMemberDelete) error
	BatchUpdateProjectMember(ctx context.Context, set *ProjectMemberBatchUpdate) (createdMember, deletedMember []*ProjectMember, err error)
}

type ProjectPatch struct {
	ID int `jsonapi:"primary,projectPatch"`

	// Standard fields
	RowStatus *string `jsonapi:"attr,rowStatus"`
	// Value is assigned from the jwt subject field passed by the client.
	UpdaterID int

	// Domain specific fields
	Name         *string              `jsonapi:"attr,name"`
	Key          *string              `jsonapi:"attr,key"`
	WorkflowType *ProjectWorkflowType `jsonapi:"attr,workflowType"`
	RoleProvider *string              `jsonapi:"attr,roleProvider"`
}

type ProjectRaw struct {
	ID int

	// Standard fields
	RowStatus RowStatus
	CreatorID int
	CreatedTs int64
	UpdaterID int
	UpdatedTs int64

	// Domain specific fields
	Name           string
	Key            string
	WorkflowType   ProjectWorkflowType
	Visibility     ProjectVisibility
	TenantMode     ProjectTenantMode
	DBNameTemplate string
	RoleProvider   ProjectRoleProvider
}

type ProjectRoleProvider string

type ProjectRoleProviderPayload struct {
	VCSRole    string `json:"vcsRole"`
	LastSyncTs int64  `json:"lastSyncTs"`
}

type ProjectService interface {
	CreateProject(ctx context.Context, create *ProjectCreate) (*ProjectRaw, error)
	FindProjectList(ctx context.Context, find *ProjectFind) ([]*ProjectRaw, error)
	FindProject(ctx context.Context, find *ProjectFind) (*ProjectRaw, error)
	PatchProject(ctx context.Context, patch *ProjectPatch) (*ProjectRaw, error)
	// This is specifically used to update the ProjectWorkflowType when linking/unlinking the repository.
	PatchProjectTx(ctx context.Context, tx *sql.Tx, patch *ProjectPatch) (*ProjectRaw, error)
}

type ProjectTenantMode string

type ProjectVisibility string

type ProjectWebhook struct {
	ID int `jsonapi:"primary,projectWebhookMember"`

	// Standard fields
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Related fields
	// Just returns ProjectID since it always operates within the project context
	ProjectID int `jsonapi:"attr,projecId"`

	// Domain specific fields
	Type         string   `jsonapi:"attr,type"`
	Name         string   `jsonapi:"attr,name"`
	URL          string   `jsonapi:"attr,url"`
	ActivityList []string `jsonapi:"attr,activityList"`
}

type ProjectWebhookCreate struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	CreatorID int

	// Related fields
	ProjectID int

	// Domain specific fields
	Type         string   `jsonapi:"attr,type"`
	Name         string   `jsonapi:"attr,name"`
	URL          string   `jsonapi:"attr,url"`
	ActivityList []string `jsonapi:"attr,activityList"`
}

type ProjectWebhookDelete struct {
	ID int

	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	DeleterID int
}

type ProjectWebhookFind struct {
	ID *int

	// Related fields
	ProjectID    *int
	ActivityType *ActivityType
}

type ProjectWebhookPatch struct {
	ID int

	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	UpdaterID int

	// Domain specific fields
	Name         *string `jsonapi:"attr,name"`
	URL          *string `jsonapi:"attr,url"`
	ActivityList *string `jsonapi:"attr,activityList"`
}

type ProjectWebhookService interface {
	CreateProjectWebhook(ctx context.Context, create *ProjectWebhookCreate) (*ProjectWebhook, error)
	FindProjectWebhookList(ctx context.Context, find *ProjectWebhookFind) ([]*ProjectWebhook, error)
	FindProjectWebhook(ctx context.Context, find *ProjectWebhookFind) (*ProjectWebhook, error)
	PatchProjectWebhook(ctx context.Context, patch *ProjectWebhookPatch) (*ProjectWebhook, error)
	DeleteProjectWebhook(ctx context.Context, delete *ProjectWebhookDelete) error
}

type ProjectWebhookTestResult struct {
	Error string `jsonapi:"attr,error"`
}

type ProjectWorkflowType string

type Repository struct {
	ID int `jsonapi:"primary,repository"`

	// Standard fields
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Related fields
	VCSID     int
	VCS       *VCS `jsonapi:"relation,vcs"`
	ProjectID int
	Project   *Project `jsonapi:"relation,project"`

	// Domain specific fields
	Name          string `jsonapi:"attr,name"`
	FullPath      string `jsonapi:"attr,fullPath"`
	WebURL        string `jsonapi:"attr,webUrl"`
	BranchFilter  string `jsonapi:"attr,branchFilter"`
	BaseDirectory string `jsonapi:"attr,baseDirectory"`
	// The file path template for matching the committed migration script.
	FilePathTemplate string `jsonapi:"attr,filePathTemplate"`
	// The file path template for storing the latest schema auto-generated by Bytebase after migration.
	// If empty, then Bytebase won't auto generate it.
	SchemaPathTemplate string `jsonapi:"attr,schemaPathTemplate"`
	ExternalID         string `jsonapi:"attr,externalId"`
	ExternalWebhookID  string
	WebhookURLHost     string
	WebhookEndpointID  string
	WebhookSecretToken string
	// These will be exclusively used on the server side and we don't return it to the client.
	AccessToken  string
	ExpiresTs    int64
	RefreshToken string
}

type RepositoryCreate struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	CreatorID int

	// Related fields
	VCSID     int `jsonapi:"attr,vcsId"`
	ProjectID int

	// Domain specific fields
	Name               string `jsonapi:"attr,name"`
	FullPath           string `jsonapi:"attr,fullPath"`
	WebURL             string `jsonapi:"attr,webUrl"`
	BranchFilter       string `jsonapi:"attr,branchFilter"`
	BaseDirectory      string `jsonapi:"attr,baseDirectory"`
	FilePathTemplate   string `jsonapi:"attr,filePathTemplate"`
	SchemaPathTemplate string `jsonapi:"attr,schemaPathTemplate"`
	ExternalID         string `jsonapi:"attr,externalId"`
	// Token belonged by the user linking the project to the VCS repository. We store this token together
	// with the refresh token in the new repository record so we can use it to call VCS API on
	// behalf of that user to perform tasks like webhook CRUD later.
	AccessToken        string `jsonapi:"attr,accessToken"`
	ExpiresTs          int64  `jsonapi:"attr,expiresTs"`
	RefreshToken       string `jsonapi:"attr,refreshToken"`
	ExternalWebhookID  string
	WebhookURLHost     string
	WebhookEndpointID  string
	WebhookSecretToken string
}

type RepositoryDelete struct {
	// Related fields
	// When deleting the repository, we need to update the corresponding project workflow type to "UI",
	// thus we use ProjectID here.
	ProjectID int

	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	DeleterID int
}

type RepositoryFind struct {
	ID *int

	// Related fields
	VCSID     *int
	ProjectID *int

	// Domain specific fields
	WebhookEndpointID *string
}

type RepositoryPatch struct {
	ID int `jsonapi:"primary,repositoryPatch"`

	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	UpdaterID int

	// Domain specific fields
	BranchFilter       *string `jsonapi:"attr,branchFilter"`
	BaseDirectory      *string `jsonapi:"attr,baseDirectory"`
	FilePathTemplate   *string `jsonapi:"attr,filePathTemplate"`
	SchemaPathTemplate *string `jsonapi:"attr,schemaPathTemplate"`
	AccessToken        *string
	ExpiresTs          *int64
	RefreshToken       *string
}

type RepositoryService interface {
	CreateRepository(ctx context.Context, create *RepositoryCreate) (*Repository, error)
	FindRepositoryList(ctx context.Context, find *RepositoryFind) ([]*Repository, error)
	FindRepository(ctx context.Context, find *RepositoryFind) (*Repository, error)
	PatchRepository(ctx context.Context, patch *RepositoryPatch) (*Repository, error)
	DeleteRepository(ctx context.Context, delete *RepositoryDelete) error
}

type Role string

type RowStatus string

type SQLExecute struct {
	InstanceID int `jsonapi:"attr,instanceId"`
	// For engines like MySQL, databaseName can be empty.
	DatabaseName string `jsonapi:"attr,databaseName"`
	Statement    string `jsonapi:"attr,statement"`
	// For now, Readonly must be true
	Readonly bool `jsonapi:"attr,readonly"`
	// The maximum row count returned, only applicable to SELECT query.
	// Not enforced if limit <= 0.
	Limit int `jsonapi:"attr,limit"`
}

type SQLResultSet struct {
	// A list of rows marshalled into a JSON.
	Data string `jsonapi:"attr,data"`
	// SQL operation may fail for connection issue and there is no proper http status code for it, so we return error in the response body.
	Error string `jsonapi:"attr,error"`
}

type SQLService interface {
	Ping(ctx context.Context, config *ConnectionInfo) (*SQLResultSet, error)
}

type SQLSyncSchema struct {
	InstanceID int `jsonapi:"attr,instanceId"`
}

type ServerInfo struct {
	Version        string `json:"version"`
	Readonly       bool   `json:"readonly"`
	Demo           bool   `json:"demo"`
	Host           string `json:"host"`
	Port           string `json:"port"`
	NeedAdminSetup bool   `json:"needAdminSetup"`
	StartedTs      int64  `json:"startedTs"`
}

type Setting struct {
	ID int `jsonapi:"primary,setting"`

	// Standard fields
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Domain specific fields
	Name        SettingName `jsonapi:"attr,name"`
	Value       string      `jsonapi:"attr,value"`
	Description string      `jsonapi:"attr,description"`
}

type SettingCreate struct {
	CreatorID   int
	Name        SettingName
	Value       string
	Description string
}

type SettingFind struct {
	Name *SettingName
}

type SettingName string

type SettingPatch struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	UpdaterID int

	Name  SettingName
	Value string `jsonapi:"attr,value"`
}

type SettingService interface {
	// Creates new setting and returns if not exist, returns the existing one otherwise.
	CreateSettingIfNotExist(ctx context.Context, create *SettingCreate) (*Setting, error)
	FindSettingList(ctx context.Context, find *SettingFind) ([]*Setting, error)
	FindSetting(ctx context.Context, find *SettingFind) (*Setting, error)
	PatchSetting(ctx context.Context, patch *SettingPatch) (*Setting, error)
}

type Sheet struct {
	ID int `jsonapi:"primary,sheet"`

	// Standard fields
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Related fields
	ProjectID int      `jsonapi:"attr,projectId"`
	Project   *Project `jsonapi:"relation,project"`
	// The DatabaseID is optional.
	// If not NULL, the sheet ProjectID should always be equal to the id of the database related project.
	// A project must remove all linked sheets for a particular database before that database can be transferred to a different project.
	DatabaseID *int      `jsonapi:"attr,databaseId"`
	Database   *Database `jsonapi:"relation,database"`

	// Domain specific fields
	Name       string          `jsonapi:"attr,name"`
	Statement  string          `jsonapi:"attr,statement"`
	Visibility SheetVisibility `jsonapi:"attr,visibility"`
}

type SheetCreate struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	CreatorID int

	// Related fields
	ProjectID  int  `jsonapi:"attr,projectId"`
	DatabaseID *int `jsonapi:"attr,databaseId"`

	// Domain specific fields
	Name       string          `jsonapi:"attr,name"`
	Statement  string          `jsonapi:"attr,statement"`
	Visibility SheetVisibility `jsonapi:"attr,visibility"`
}

type SheetDelete struct {
	ID int

	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	DeleterID int
}

type SheetFind struct {
	// Standard fields
	ID        *int
	RowStatus *RowStatus
	// Value is assigned from the jwt subject field passed by the client.
	CreatorID *int

	// Related fields
	ProjectID *int
	// Query all related sheets with databaseId can be used for database transfer checking.
	DatabaseID *int

	// Domain fields
	Visibility *SheetVisibility
}

type SheetPatch struct {
	ID int `jsonapi:"primary,sheetPatch"`

	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	UpdaterID int

	// Related fields
	ProjectID  int  `jsonapi:"attr,projectId"`
	DatabaseID *int `jsonapi:"attr,databaseId"`

	// Domain specific fields
	Name       *string `jsonapi:"attr,name"`
	Statement  *string `jsonapi:"attr,statement"`
	Visibility *string `jsonapi:"attr,visibility"`
}

type SheetService interface {
	CreateSheet(ctx context.Context, create *SheetCreate) (*Sheet, error)
	PatchSheet(ctx context.Context, patch *SheetPatch) (*Sheet, error)
	FindSheetList(ctx context.Context, find *SheetFind) ([]*Sheet, error)
	FindSheet(ctx context.Context, find *SheetFind) (*Sheet, error)
	DeleteSheet(ctx context.Context, delete *SheetDelete) error
}

type SheetVisibility string

type Signup struct {
	// Domain specific fields
	Name     string `jsonapi:"attr,name"`
	Email    string `jsonapi:"attr,email"`
	Password string `jsonapi:"attr,password"`
}

type Stage struct {
	ID int `jsonapi:"primary,stage"`

	// Standard fields
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Related fields
	// Just returns PipelineID otherwise would cause circular dependency.
	PipelineID    int `jsonapi:"attr,pipelineId"`
	EnvironmentID int
	Environment   *Environment `jsonapi:"relation,environment"`
	TaskList      []*Task      `jsonapi:"relation,task"`

	// Domain specific fields
	Name string `jsonapi:"attr,name"`
}

type StageCreate struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	CreatorID int

	// Related fields
	EnvironmentID int `jsonapi:"attr,environmentId"`
	PipelineID    int
	TaskList      []TaskCreate `jsonapi:"attr,taskList"`

	// Domain specific fields
	Name string `jsonapi:"attr,name"`
}

type StageFind struct {
	ID *int

	// Related fields
	PipelineID *int
}

type StageService interface {
	CreateStage(ctx context.Context, create *StageCreate) (*Stage, error)
	FindStageList(ctx context.Context, find *StageFind) ([]*Stage, error)
	FindStage(ctx context.Context, find *StageFind) (*Stage, error)
}

type SyncStatus string

type Table struct {
	ID int `jsonapi:"primary,table"`

	// Standard fields
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Related fields
	DatabaseID int
	Database   *Database `jsonapi:"relation,database"`

	// Domain specific fields
	Name          string    `jsonapi:"attr,name"`
	Type          string    `jsonapi:"attr,type"`
	Engine        string    `jsonapi:"attr,engine"`
	Collation     string    `jsonapi:"attr,collation"`
	RowCount      int64     `jsonapi:"attr,rowCount"`
	DataSize      int64     `jsonapi:"attr,dataSize"`
	IndexSize     int64     `jsonapi:"attr,indexSize"`
	DataFree      int64     `jsonapi:"attr,dataFree"`
	CreateOptions string    `jsonapi:"attr,createOptions"`
	Comment       string    `jsonapi:"attr,comment"`
	ColumnList    []*Column `jsonapi:"attr,columnList"`
	IndexList     []*Index  `jsonapi:"attr,indexList"`
}

type TableCreate struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	CreatorID int
	CreatedTs int64
	UpdatedTs int64

	// Related fields
	DatabaseID int

	// Domain specific fields
	Name          string
	Type          string
	Engine        string
	Collation     string
	RowCount      int64
	DataSize      int64
	IndexSize     int64
	DataFree      int64
	CreateOptions string
	Comment       string
}

type TableDelete struct {
	// Related fields
	DatabaseID int
}

type TableFind struct {
	ID *int

	// Related fields
	DatabaseID *int

	// Domain specific fields
	Name *string
}

type TableService interface {
	CreateTable(ctx context.Context, create *TableCreate) (*Table, error)
	FindTableList(ctx context.Context, find *TableFind) ([]*Table, error)
	FindTable(ctx context.Context, find *TableFind) (*Table, error)
	DeleteTable(ctx context.Context, delete *TableDelete) error
}

type Task struct {
	ID int `jsonapi:"primary,task"`

	// Standard fields
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Related fields
	// Just returns PipelineID and StageID otherwise would cause circular dependency.
	PipelineID int `jsonapi:"attr,pipelineId"`
	StageID    int `jsonapi:"attr,stageId"`
	InstanceID int
	Instance   *Instance `jsonapi:"relation,instance"`
	// Could be empty for creating database task when the task isn't yet completed successfully.
	DatabaseID       *int
	Database         *Database       `jsonapi:"relation,database"`
	TaskRunList      []*TaskRun      `jsonapi:"relation,taskRun"`
	TaskCheckRunList []*TaskCheckRun `jsonapi:"relation,taskCheckRun"`

	// Domain specific fields
	Name              string     `jsonapi:"attr,name"`
	Status            TaskStatus `jsonapi:"attr,status"`
	Type              TaskType   `jsonapi:"attr,type"`
	Payload           string     `jsonapi:"attr,payload"`
	EarliestAllowedTs int64      `jsonapi:"attr,earliestAllowedTs"`
}

type TaskCheckDatabaseStatementAdvisePayload struct {
	Statement string  `json:"statement,omitempty"`
	DbType    db.Type `json:"dbType,omitempty"`
	Charset   string  `json:"charset,omitempty"`
	Collation string  `json:"collation,omitempty"`
}

type TaskCheckEarliestAllowedTimePayload struct {
	EarliestAllowedTs int64 `json:"earliestAllowedTs,omitempty"`
}

type TaskCheckResult struct {
	Status  TaskCheckStatus `json:"status,omitempty"`
	Code    common.Code     `json:"code,omitempty"`
	Title   string          `json:"title,omitempty"`
	Content string          `json:"content,omitempty"`
}

type TaskCheckRun struct {
	ID int `jsonapi:"primary,taskCheckRun"`

	// Standard fields
	CreatorID int
	Creator   *Principal `jsonapi:"relation,creator"`
	CreatedTs int64      `jsonapi:"attr,createdTs"`
	UpdaterID int
	Updater   *Principal `jsonapi:"relation,updater"`
	UpdatedTs int64      `jsonapi:"attr,updatedTs"`

	// Related fields
	TaskID int `jsonapi:"attr,taskId"`

	// Domain specific fields
	Status  TaskCheckRunStatus `jsonapi:"attr,status"`
	Type    TaskCheckType      `jsonapi:"attr,type"`
	Code    common.Code        `jsonapi:"attr,code"`
	Comment string             `jsonapi:"attr,comment"`
	Result  string             `jsonapi:"attr,result"`
	Payload string             `jsonapi:"attr,payload"`
}

type TaskCheckRunCreate struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	CreatorID int

	// Related fields
	TaskID int

	// Domain specific fields
	Type    TaskCheckType `jsonapi:"attr,type"`
	Comment string        `jsonapi:"attr,comment"`
	Payload string        `jsonapi:"attr,payload"`

	// If true, then we will skip creating the task check run if there has already been a DONE check run
	// for this (TaskID, Type) pair. The check is done at the store layer so that we can wrap it in the
	// same transaction.
	// This is NOT persisted into the db
	SkipIfAlreadyTerminated bool
}

type TaskCheckRunFind struct {
	ID *int

	// Related fields
	TaskID *int
	Type   *TaskCheckType

	// Domain specific fields
	StatusList *[]TaskCheckRunStatus
	// If true, only returns the latest
	Latest bool
}

type TaskCheckRunResultPayload struct {
	Detail     string            `json:"detail,omitempty"`
	ResultList []TaskCheckResult `json:"resultList,omitempty"`
}

type TaskCheckRunService interface {
	// For a particular task and a particular check type, we only create a new TaskCheckRun if matches all conditions below:
	// 1. There is no existing RUNNING check run. If this is the case, then returns that RUNNING check run.
	// 2. If SkipIfAlreadyTerminated is false, or if SkipIfAlreadyTerminated is true and there is no DONE/FAILED/CANCELED check run. If this is the case,
	//    then returns that terminated check run.
	CreateTaskCheckRunIfNeeded(ctx context.Context, create *TaskCheckRunCreate) (*TaskCheckRun, error)
	FindTaskCheckRunList(ctx context.Context, find *TaskCheckRunFind) ([]*TaskCheckRun, error)
	FindTaskCheckRunListTx(ctx context.Context, tx *sql.Tx, find *TaskCheckRunFind) ([]*TaskCheckRun, error)
	PatchTaskCheckRunStatus(ctx context.Context, patch *TaskCheckRunStatusPatch) (*TaskCheckRun, error)
}

type TaskCheckRunStatus string

type TaskCheckRunStatusPatch struct {
	ID *int

	// Standard fields
	UpdaterID int

	// Domain specific fields
	Status TaskCheckRunStatus
	Code   common.Code
	Result string
}

type TaskCheckStatus string

type TaskCheckType string

type TaskCreate struct {
	// Standard fields
	// Value is assigned from the jwt subject field passed by the client.
	CreatorID int

	// Related fields
	PipelineID int
	StageID    int
	InstanceID int `jsonapi:"attr,instanceId"`
	// Tasks like creating database may not have database.
	DatabaseID *int `jsonapi:"attr,databaseId"`

	// Domain specific fields
	Name   string     `jsonapi:"attr,name"`
	Status TaskStatus `jsonapi:"attr,status"`
	Type   TaskType   `jsonapi:"attr,type"`
	// Payload is derived from fields below it
	Payload           string
	EarliestAllowedTs int64  `jsonapi:"attr,earliestAllowedTs"`
	Statement         string `jsonapi:"attr,statement"`
	DatabaseName      string `jsonapi:"attr,databaseName"`
	CharacterSet      string `jsonapi:"attr,characterSet"`
	Collation         string `jsonapi:"attr,collation"`
	Labels            string `jsonapi:"attr,labels"`
	BackupID          *int   `jsonapi:"attr,backupId"`
	VCSPushEvent      *vcs.PushEvent
	MigrationType     db.MigrationType `jsonapi:"attr,migrationType"`
}

type TaskDatabaseBackupPayload struct {
	BackupID int `json:"backupId,omitempty"`
}

type TaskDatabaseCreatePayload struct {
	// The project owning the database.
	ProjectID     int    `json:"projectId,omitempty"`
	DatabaseName  string `json:"databaseName,omitempty"`
	Statement     string `json:"statement,omitempty"`
	CharacterSet  string `json:"character,omitempty"`
	Collation     string `json:"collation,omitempty"`
	Labels        string `json:"labels,omitempty"`
	SchemaVersion string `json:"schemaVersion,omitempty"`
}

type TaskDatabaseDataUpdatePayload struct {
	Statement     string         `json:"statement,omitempty"`
	SchemaVersion string         `json:"schemaVersion,omitempty"`
	VCSPushEvent  *vcs.PushEvent `json:"pushEvent,omitempty"`
}

type TaskDatabaseRestorePayload struct {
	// The database name we restore to. When we restore a backup to a new database, we only have the database name
	// and don't have the database id upon constructing the task yet.
	DatabaseName string `json:"databaseName,omitempty"`
	BackupID     int    `json:"backupId,omitempty"`
}

type TaskDatabaseSchemaUpdatePayload struct {
	MigrationType db.MigrationType `json:"migrationType,omitempty"`
	Statement     string           `json:"statement,omitempty"`
	SchemaVersion string           `json:"schemaVersion,omitempty"`
	VCSPushEvent  *vcs.PushEvent   `json:"pushEvent,omitempty"`
}

type TaskFind struct {
	ID *int

	// Related fields
	PipelineID *int
	StageID    *int

	// Domain specific fields
	StatusList *[]TaskStatus
}