controlplane

type APIError struct {
	// The name of the error.
	Name string
	// The error message.
	Message string
}

type BackupConfigSpec struct {
	// The repositories for this backup configuration.
	Repositories []*BackupRepositorySpec
	// The schedules for this backup configuration.
	Schedules []*BackupScheduleSpec
}

type BackupDatabaseNodePayload struct {
	// ID of the database to back up.
	DatabaseID Identifier
	// Name of the node to back up.
	NodeName string
	Options  *BackupOptions
	// Forcibly attempt backup even in unmodifiable state
	Force bool
}

type BackupDatabaseNodeResponse struct {
	// The task that will backup this database node.
	Task *Task
}

type BackupOptions struct {
	// The type of backup.
	Type string
	// Annotations for the backup.
	Annotations map[string]string
	// Options for the backup.
	BackupOptions map[string]string
}

type BackupRepositorySpec struct {
	// The unique identifier of this repository.
	ID *Identifier
	// The type of this repository.
	Type string
	// The S3 bucket name for this repository. Only applies when type = 's3'.
	S3Bucket *string
	// The region of the S3 bucket for this repository. Only applies when type =
	// 's3'.
	S3Region *string
	// The optional S3 endpoint for this repository. Only applies when type = 's3'.
	S3Endpoint *string
	// An optional AWS access key ID to use for this repository. If not provided,
	// pgbackrest will use the default credential provider chain. This field will
	// be excluded from the response of all endpoints. It can also be omitted from
	// update requests to keep the current value.
	S3Key *string
	// The corresponding secret for the AWS access key ID in s3_key. This field
	// will be excluded from the response of all endpoints. It can also be omitted
	// from update requests to keep the current value.
	S3KeySecret *string
	// The GCS bucket name for this repository. Only applies when type = 'gcs'.
	GcsBucket *string
	// The optional GCS endpoint for this repository. Only applies when type =
	// 'gcs'.
	GcsEndpoint *string
	// Optional base64-encoded private key data. If omitted, pgbackrest will use
	// the service account attached to the instance profile. This field will be
	// excluded from the response of all endpoints. It can also be omitted from
	// update requests to keep the current value.
	GcsKey *string
	// The Azure account name for this repository. Only applies when type = 'azure'.
	AzureAccount *string
	// The Azure container name for this repository. Only applies when type =
	// 'azure'.
	AzureContainer *string
	// The optional Azure endpoint for this repository. Only applies when type =
	// 'azure'.
	AzureEndpoint *string
	// The Azure storage account access key to use for this repository. This field
	// will be excluded from the response of all endpoints. It can also be omitted
	// from update requests to keep the current value.
	AzureKey *string
	// The count of full backups to retain or the time to retain full backups.
	RetentionFull *int
	// The type of measure used for retention_full.
	RetentionFullType *string
	// The base path within the repository to store backups. Required for type =
	// 'posix' and 'cifs'.
	BasePath *string
	// Additional options to apply to this repository.
	CustomOptions map[string]string
}

type BackupScheduleSpec struct {
	// The unique identifier for this backup schedule.
	ID string
	// The type of backup to take on this schedule.
	Type string
	// The cron expression for this schedule.
	CronExpression string
}

type CancelDatabaseTaskPayload struct {
	// ID of the database that owns the task.
	DatabaseID Identifier
	// ID of the task to cancel.
	TaskID Identifier
}

type Client struct {
	InitClusterEndpoint            goa.Endpoint
	JoinClusterEndpoint            goa.Endpoint
	GetJoinTokenEndpoint           goa.Endpoint
	GetJoinOptionsEndpoint         goa.Endpoint
	GetClusterEndpoint             goa.Endpoint
	ListHostsEndpoint              goa.Endpoint
	GetHostEndpoint                goa.Endpoint
	RemoveHostEndpoint             goa.Endpoint
	ListDatabasesEndpoint          goa.Endpoint
	CreateDatabaseEndpoint         goa.Endpoint
	GetDatabaseEndpoint            goa.Endpoint
	UpdateDatabaseEndpoint         goa.Endpoint
	DeleteDatabaseEndpoint         goa.Endpoint
	BackupDatabaseNodeEndpoint     goa.Endpoint
	SwitchoverDatabaseNodeEndpoint goa.Endpoint
	FailoverDatabaseNodeEndpoint   goa.Endpoint
	ListDatabaseTasksEndpoint      goa.Endpoint
	GetDatabaseTaskEndpoint        goa.Endpoint
	GetDatabaseTaskLogEndpoint     goa.Endpoint
	RestoreDatabaseEndpoint        goa.Endpoint
	GetVersionEndpoint             goa.Endpoint
	RestartInstanceEndpoint        goa.Endpoint
	StopInstanceEndpoint           goa.Endpoint
	StartInstanceEndpoint          goa.Endpoint
	CancelDatabaseTaskEndpoint     goa.Endpoint
}

type Cluster struct {
	// Unique identifier for the cluster.
	ID Identifier
	// Current status of the cluster.
	Status *ClusterStatus
	// All of the hosts in the cluster.
	Hosts []*Host
}

type ClusterCredentials struct {
	// The Etcd username for the new host.
	Username string
	// The Etcd password for the new host.
	Password string
	// The base64-encoded CA certificate for the cluster.
	CaCert string
	// The base64-encoded etcd client certificate for the new cluster member.
	ClientCert string
	// The base64-encoded etcd client key for the new cluster member.
	ClientKey string
	// The base64-encoded etcd server certificate for the new cluster member.
	ServerCert string
	// The base64-encoded etcd server key for the new cluster member.
	ServerKey string
}

type ClusterJoinOptions struct {
	// Connection information for the etcd cluster leader
	Leader *EtcdClusterMember
	// Credentials for the new host joining the cluster.
	Credentials *ClusterCredentials
}

type ClusterJoinRequest struct {
	// Token to join the cluster.
	Token string
	// The unique identifier for the host that's joining the cluster.
	HostID Identifier
	// The hostname of the host that's joining the cluster.
	Hostname string
	// The IPv4 address of the host that's joining the cluster.
	Ipv4Address string
	// True if the joining member is configured to run an embedded an etcd server.
	EmbeddedEtcdEnabled bool
}

type ClusterJoinToken struct {
	// Token to join an existing cluster.
	Token string
	// Existing server to join
	ServerURL string
}

type ClusterStatus struct {
	// The current state of the cluster.
	State string
}

type ComponentStatus struct {
	// Indicates if the component is healthy.
	Healthy bool
	// Error message from any errors that occurred during the health check.
	Error *string
	// Additional details about the component.
	Details map[string]any
}

type CreateDatabaseRequest struct {
	// Unique identifier for the database.
	ID *Identifier
	// Unique identifier for the databases's owner.
	TenantID *Identifier
	// The specification for the database.
	Spec *DatabaseSpec
}

type CreateDatabaseResponse struct {
	// The task that will create this database.
	Task *Task
	// The database being created.
	Database *Database
}

type Database struct {
	// Unique identifier for the database.
	ID Identifier
	// Unique identifier for the databases's owner.
	TenantID *Identifier
	// The time that the database was created.
	CreatedAt string
	// The time that the database was last updated.
	UpdatedAt string
	// Current state of the database.
	State string
	// All of the instances in the database.
	Instances InstanceCollection
	// The user-provided specification for the database.
	Spec *DatabaseSpec
}

type DatabaseCollection []*Database

type DatabaseNodeSpec struct {
	// The name of the database node.
	Name string
	// The IDs of the hosts that should run this node. When multiple hosts are
	// specified, one host will chosen as a primary, and the others will be read
	// replicas.
	HostIds []Identifier
	// The Postgres version for this node in 'major.minor' format. Overrides the
	// Postgres version set in the DatabaseSpec.
	PostgresVersion *string
	// The port used by the Postgres database for this node. Overrides the Postgres
	// port set in the DatabaseSpec.
	Port *int
	// The number of CPUs to allocate for the database on this node and to use for
	// tuning Postgres. It can include the SI suffix 'm', e.g. '500m' for 500
	// millicpus. Cannot allocate units smaller than 1m. Defaults to the number of
	// available CPUs on the host if 0 or unspecified. Cannot allocate more CPUs
	// than are available on the host. Whether this limit is enforced depends on
	// the orchestrator.
	Cpus *string
	// The amount of memory in SI or IEC notation to allocate for the database on
	// this node and to use for tuning Postgres. Defaults to the total available
	// memory on the host. Whether this limit is enforced depends on the
	// orchestrator.
	Memory *string
	// Additional postgresql.conf settings for this particular node. Will be merged
	// with the settings provided by control-plane.
	PostgresqlConf map[string]any
	// The backup configuration for this node. Overrides the backup configuration
	// set in the DatabaseSpec.
	BackupConfig *BackupConfigSpec
	// The restore configuration for this node. Overrides the restore configuration
	// set in the DatabaseSpec.
	RestoreConfig *RestoreConfigSpec
	// Orchestrator-specific configuration options.
	OrchestratorOpts *OrchestratorOpts
	// The name of the source node to use for sync. This is typically the node
	// (like 'n1') from which the data will be copied to initialize this new node.
	SourceNode *string
}

type DatabaseSpec struct {
	// The name of the Postgres database.
	DatabaseName string
	// The Postgres version in 'major.minor' format.
	PostgresVersion *string
	// The major version of the Spock extension.
	SpockVersion *string
	// The port used by the Postgres database. If the port is 0, each instance will
	// be assigned a random port. If the port is unspecified, the database will not
	// be exposed on any port, dependent on orchestrator support for that feature.
	Port *int
	// The number of CPUs to allocate for the database and to use for tuning
	// Postgres. Defaults to the number of available CPUs on the host. Can include
	// an SI suffix, e.g. '500m' for 500 millicpus. Whether this limit is enforced
	// depends on the orchestrator.
	Cpus *string
	// The amount of memory in SI or IEC notation to allocate for the database and
	// to use for tuning Postgres. Defaults to the total available memory on the
	// host. Whether this limit is enforced depends on the orchestrator.
	Memory *string
	// The Spock nodes for this database.
	Nodes []*DatabaseNodeSpec
	// The users to create for this database.
	DatabaseUsers []*DatabaseUserSpec
	// The backup configuration for this database.
	BackupConfig *BackupConfigSpec
	// The restore configuration for this database.
	RestoreConfig *RestoreConfigSpec
	// Additional postgresql.conf settings. Will be merged with the settings
	// provided by control-plane.
	PostgresqlConf map[string]any
	// Orchestrator-specific configuration options.
	OrchestratorOpts *OrchestratorOpts
}

type DatabaseUserSpec struct {
	// The username for this database user.
	Username string
	// The password for this database user. This field will be excluded from the
	// response of all endpoints. It can also be omitted from update requests to
	// keep the current value.
	Password *string
	// If true, this user will be granted database ownership.
	DbOwner *bool
	// The attributes to assign to this database user.
	Attributes []string
	// The roles to assign to this database user.
	Roles []string
}

type DeleteDatabasePayload struct {
	// ID of the database to delete.
	DatabaseID Identifier
	// Force deletion of a database even in an unmodifiable state
	Force bool
}

type DeleteDatabaseResponse struct {
	// The task that will delete this database.
	Task *Task
}

type Endpoints struct {
	InitCluster            goa.Endpoint
	JoinCluster            goa.Endpoint
	GetJoinToken           goa.Endpoint
	GetJoinOptions         goa.Endpoint
	GetCluster             goa.Endpoint
	ListHosts              goa.Endpoint
	GetHost                goa.Endpoint
	RemoveHost             goa.Endpoint
	ListDatabases          goa.Endpoint
	CreateDatabase         goa.Endpoint
	GetDatabase            goa.Endpoint
	UpdateDatabase         goa.Endpoint
	DeleteDatabase         goa.Endpoint
	BackupDatabaseNode     goa.Endpoint
	SwitchoverDatabaseNode goa.Endpoint
	FailoverDatabaseNode   goa.Endpoint
	ListDatabaseTasks      goa.Endpoint
	GetDatabaseTask        goa.Endpoint
	GetDatabaseTaskLog     goa.Endpoint
	RestoreDatabase        goa.Endpoint
	GetVersion             goa.Endpoint
	RestartInstance        goa.Endpoint
	StopInstance           goa.Endpoint
	StartInstance          goa.Endpoint
	CancelDatabaseTask     goa.Endpoint
}

type EtcdClusterMember struct {
	// The name of the Etcd cluster member.
	Name string
	// The Etcd peer endpoint for this cluster member.
	PeerUrls []string
	// The Etcd client endpoint for this cluster member.
	ClientUrls []string
}

type ExtraNetworkSpec struct {
	// The name or ID of the network to connect to.
	ID string
	// Optional network-scoped aliases for the container.
	Aliases []string
	// Optional driver options for the network connection.
	DriverOpts map[string]string
}

type ExtraVolumesSpec struct {
	// The host path for the volume.
	HostPath string
	// The path inside the container where the volume will be mounted.
	DestinationPath string
}

type FailoverDatabaseNodeRequest struct {
	// ID of the database to perform the failover for.
	DatabaseID Identifier
	// Name of the node to initiate the failover from.
	NodeName string
	// Optional instance_id of the replica to promote. If omitted, a candidate will
	// be selected.
	CandidateInstanceID *string
	// If true, skip the health validations that prevent running failover on a
	// healthy cluster.
	SkipValidation bool
}

type FailoverDatabaseNodeResponse struct {
	// The task that will perform the failover.
	Task *Task
}

type GetDatabasePayload struct {
	// ID of the database to get.
	DatabaseID Identifier
}

type GetDatabaseTaskLogPayload struct {
	// ID of the database to get the task log for.
	DatabaseID Identifier
	// ID of the task to get the log for.
	TaskID string
	// ID of the entry to start from.
	AfterEntryID *string
	// Maximum number of entries to return.
	Limit *int
}

type GetDatabaseTaskPayload struct {
	// ID of the database the task belongs to.
	DatabaseID Identifier
	// ID of the task to get.
	TaskID string
}

type GetHostPayload struct {
	// ID of the host to get.
	HostID Identifier
}

type Host struct {
	// Unique identifier for the host.
	ID Identifier
	// The orchestrator used by this host.
	Orchestrator string
	// The data directory for the host.
	DataDir string
	// The cohort that this host belongs to.
	Cohort *HostCohort
	// The hostname of this host.
	Hostname string
	// The IPv4 address of this host.
	Ipv4Address string
	// The number of CPUs on this host.
	Cpus *int
	// The amount of memory available on this host.
	Memory *string
	// Current status of the host.
	Status *HostStatus
	// The default PgEdge version for this host.
	DefaultPgedgeVersion *PgEdgeVersion
	// The PgEdge versions supported by this host.
	SupportedPgedgeVersions []*PgEdgeVersion
}

type HostCohort struct {
	// The type of cohort that the host belongs to.
	Type string
	// The member ID of the host within the cohort.
	MemberID string
	// Indicates if the host is a control node in the cohort.
	ControlAvailable bool
}

type HostStatus struct {
	State string
	// The last time the host status was updated.
	UpdatedAt string
	// The status of each component of the host.
	Components map[string]*ComponentStatus
}

type Identifier string

type InitClusterRequest struct {
	// Optional id for the cluster, omit for default generated id
	ClusterID *Identifier
}

type Instance struct {
	// Unique identifier for the instance.
	ID string
	// The ID of the host this instance is running on.
	HostID string
	// The Spock node name for this instance.
	NodeName string
	// The time that the instance was created.
	CreatedAt string
	// The time that the instance was last modified.
	UpdatedAt string
	// The time that the instance status information was last updated.
	StatusUpdatedAt *string
	State           string
	// Connection information for the instance.
	ConnectionInfo *InstanceConnectionInfo
	// Postgres status information for the instance.
	Postgres *InstancePostgresStatus
	// Spock status information for the instance.
	Spock *InstanceSpockStatus
	// An error message if the instance is in an error state.
	Error *string
}

type InstanceCollection []*Instance

type InstanceConnectionInfo struct {
	// The hostname of the host that's running this instance.
	Hostname *string
	// The IPv4 address of the host that's running this instance.
	Ipv4Address *string
	// The host port that Postgres is listening on for this instance.
	Port *int
}

type InstancePostgresStatus struct {
	// The version of Postgres for this instance.
	Version      *string
	PatroniState *string
	Role         *string
	// True if this instance has a pending restart from a configuration change.
	PendingRestart *bool
	// True if Patroni is paused for this instance.
	PatroniPaused *bool
}

type InstanceSpockStatus struct {
	// The current spock.readonly setting.
	ReadOnly *string
	// The version of Spock for this instance.
	Version *string
	// Status information for this instance's Spock subscriptions.
	Subscriptions []*InstanceSubscription
}

type InstanceSubscription struct {
	// The Spock node name of the provider for this subscription.
	ProviderNode string
	// The name of the subscription.
	Name string
	// The current status of the subscription.
	Status string
}

type ListDatabaseTasksPayload struct {
	// ID of the database to list tasks for.
	DatabaseID Identifier
	// ID of the task to start from.
	AfterTaskID *string
	// Maximum number of tasks to return.
	Limit *int
	// Sort order for the tasks.
	SortOrder *string
}

type ListDatabaseTasksResponse struct {
	Tasks []*Task
}

type ListDatabasesResponse struct {
	Databases DatabaseCollection
}

type ListHostsResponse struct {
	// List of hosts in the cluster
	Hosts []*Host
}

type OrchestratorOpts struct {
	// Swarm-specific configuration.
	Swarm *SwarmOpts
}

type PgEdgeVersion struct {
	// The Postgres major and minor version.
	PostgresVersion string
	// The Spock major version.
	SpockVersion string
}

type RemoveHostPayload struct {
	// ID of the host to remove.
	HostID Identifier
	// Force removal even if instances exist or quorum would be violated. Use only
	// for disaster recovery when a host is permanently lost.
	Force bool
}

type RemoveHostResponse struct {
	// The tasks that will update databases affected by the host removal.
	UpdateDatabaseTasks []*Task
}

type RestartInstancePayload struct {
	// The ID of the database that owns the instance.
	DatabaseID Identifier
	// The ID of the instance to restart.
	InstanceID Identifier
	// The time at which the restart is scheduled.
	ScheduledAt *string
}

type RestartInstanceResponse struct {
	// Task representing the restart operation
	Task *Task
}

type RestoreConfigSpec struct {
	// The ID of the database to restore this database from.
	SourceDatabaseID Identifier
	// The name of the node to restore this database from.
	SourceNodeName string
	// The name of the database in this repository. The database will be renamed to
	// the database_name in the DatabaseSpec after it's restored.
	SourceDatabaseName string
	// The repository to restore this database from.
	Repository *RestoreRepositorySpec
	// Additional options to use when restoring this database. If omitted, the
	// database will be restored to the latest point in the given repository.
	RestoreOptions map[string]string
}

type RestoreDatabasePayload struct {
	// ID of the database to restore.
	DatabaseID Identifier
	Request    *RestoreDatabaseRequest
	// Force restoration of a database even in an unmodifiable state
	Force bool
}

type RestoreDatabaseRequest struct {
	// Configuration for the restore process.
	RestoreConfig *RestoreConfigSpec
	// The nodes to restore. Defaults to all nodes if empty or unspecified.
	TargetNodes []string
}

type RestoreDatabaseResponse struct {
	// The task that will restore this database.
	Task *Task
	// The tasks that will restore each database node.
	NodeTasks []*Task
	// The database being restored.
	Database *Database
}

type RestoreRepositorySpec struct {
	// The unique identifier of this repository.
	ID *Identifier
	// The type of this repository.
	Type string
	// The S3 bucket name for this repository. Only applies when type = 's3'.
	S3Bucket *string
	// The region of the S3 bucket for this repository. Only applies when type =
	// 's3'.
	S3Region *string
	// The optional S3 endpoint for this repository. Only applies when type = 's3'.
	S3Endpoint *string
	// An optional AWS access key ID to use for this repository. If not provided,
	// pgbackrest will use the default credential provider chain.
	S3Key *string
	// The corresponding secret for the AWS access key ID in s3_key.
	S3KeySecret *string
	// The GCS bucket name for this repository. Only applies when type = 'gcs'.
	GcsBucket *string
	// The optional GCS endpoint for this repository. Only applies when type =
	// 'gcs'.
	GcsEndpoint *string
	// Optional base64-encoded private key data. If omitted, pgbackrest will use
	// the service account attached to the instance profile.
	GcsKey *string
	// The Azure account name for this repository. Only applies when type = 'azure'.
	AzureAccount *string
	// The Azure container name for this repository. Only applies when type =
	// 'azure'.
	AzureContainer *string
	// The optional Azure endpoint for this repository. Only applies when type =
	// 'azure'.
	AzureEndpoint *string
	// An optional Azure storage account access key to use for this repository. If
	// not provided, pgbackrest will use the VM's managed identity.
	AzureKey *string
	// The base path within the repository to store backups. Required for type =
	// 'posix' and 'cifs'.
	BasePath *string
	// Additional options to apply to this repository.
	CustomOptions map[string]string
}

type Service interface {
	// Initializes a new cluster.
	InitCluster(context.Context, *InitClusterRequest) (res *ClusterJoinToken, err error)
	// Joins this host to an existing cluster.
	JoinCluster(context.Context, *ClusterJoinToken) (err error)
	// Gets the join token for this cluster.
	GetJoinToken(context.Context) (res *ClusterJoinToken, err error)
	// Internal endpoint for other cluster members seeking to join this cluster.
	GetJoinOptions(context.Context, *ClusterJoinRequest) (res *ClusterJoinOptions, err error)
	// Returns information about the cluster.
	GetCluster(context.Context) (res *Cluster, err error)
	// Lists all hosts within the cluster.
	ListHosts(context.Context) (res *ListHostsResponse, err error)
	// Returns information about a particular host in the cluster.
	GetHost(context.Context, *GetHostPayload) (res *Host, err error)
	// Removes a host from the cluster.
	RemoveHost(context.Context, *RemoveHostPayload) (res *RemoveHostResponse, err error)
	// Lists all databases in the cluster.
	ListDatabases(context.Context) (res *ListDatabasesResponse, err error)
	// Creates a new database in the cluster.
	CreateDatabase(context.Context, *CreateDatabaseRequest) (res *CreateDatabaseResponse, err error)
	// Returns information about a particular database in the cluster.
	GetDatabase(context.Context, *GetDatabasePayload) (res *Database, err error)
	// Updates a database with the given specification.
	UpdateDatabase(context.Context, *UpdateDatabasePayload) (res *UpdateDatabaseResponse, err error)
	// Deletes a database from the cluster.
	DeleteDatabase(context.Context, *DeleteDatabasePayload) (res *DeleteDatabaseResponse, err error)
	// Initiates a backup for a database node.
	BackupDatabaseNode(context.Context, *BackupDatabaseNodePayload) (res *BackupDatabaseNodeResponse, err error)
	// Performs a planned switchover for a node's primary to a replica candidate.
	SwitchoverDatabaseNode(context.Context, *SwitchoverDatabaseNodePayload) (res *SwitchoverDatabaseNodeResponse, err error)
	// Performs a failover for a node to a replica candidate.
	FailoverDatabaseNode(context.Context, *FailoverDatabaseNodeRequest) (res *FailoverDatabaseNodeResponse, err error)
	// Lists all tasks for a database.
	ListDatabaseTasks(context.Context, *ListDatabaseTasksPayload) (res *ListDatabaseTasksResponse, err error)
	// Returns information about a particular task.
	GetDatabaseTask(context.Context, *GetDatabaseTaskPayload) (res *Task, err error)
	// Returns the log of a particular task for a database.
	GetDatabaseTaskLog(context.Context, *GetDatabaseTaskLogPayload) (res *TaskLog, err error)
	// Perform an in-place restore of one or more nodes using the given restore
	// configuration.
	RestoreDatabase(context.Context, *RestoreDatabasePayload) (res *RestoreDatabaseResponse, err error)
	// Returns version information for this Control Plane server.
	GetVersion(context.Context) (res *VersionInfo, err error)
	// Restarts a specific instance within a database. Supports immediate or
	// scheduled restarts.
	RestartInstance(context.Context, *RestartInstancePayload) (res *RestartInstanceResponse, err error)
	// Stops a specific instance within a database. Supports immediate stops.
	StopInstance(context.Context, *StopInstancePayload) (res *StopInstanceResponse, err error)
	// Starts a specific instance within a database. Supports immediate starts
	StartInstance(context.Context, *StartInstancePayload) (res *StartInstanceResponse, err error)
	// Cancels a running or pending task for a database.
	CancelDatabaseTask(context.Context, *CancelDatabaseTaskPayload) (res *Task, err error)
}

type StartInstancePayload struct {
	// The ID of the database that owns the instance.
	DatabaseID Identifier
	// The ID of the instance to start.
	InstanceID Identifier
	// Force starting an instance even if database in an unmodifiable state
	Force bool
}

type StartInstanceResponse struct {
	// Task representing the start operation
	Task *Task
}

type StopInstancePayload struct {
	// The ID of the database that owns the instance.
	DatabaseID Identifier
	// The ID of the instance to stop.
	InstanceID Identifier
	// Force stopping an instance even if database in an unmodifiable state
	Force bool
}

type StopInstanceResponse struct {
	// Task representing the stop operation
	Task *Task
}

type SwarmOpts struct {
	// A list of extra volumes to mount. Each entry defines a host and container
	// path.
	ExtraVolumes []*ExtraVolumesSpec
	// A list of additional Docker Swarm networks to attach containers in this
	// database to.
	ExtraNetworks []*ExtraNetworkSpec
	// Arbitrary labels to apply to the Docker Swarm service
	ExtraLabels map[string]string
}

type SwitchoverDatabaseNodePayload struct {
	// ID of the database to operate on.
	DatabaseID Identifier
	// Name of the node to operate on.
	NodeName string
	// Optional instance_id for the replica candidate.
	CandidateInstanceID *string
	// Optional scheduled time (ISO8601) for the switchover. If absent switchover
	// happens immediately.
	ScheduledAt *string
}

type SwitchoverDatabaseNodeResponse struct {
	// The task that will perform the switchover.
	Task *Task
}

type Task struct {
	// The parent task ID of the task.
	ParentID *string
	// The database ID of the task.
	DatabaseID string
	// The name of the node that the task is operating on.
	NodeName *string
	// The ID of the instance that the task is operating on.
	InstanceID *string
	// The ID of the host that the task is running on.
	HostID *string
	// The unique ID of the task.
	TaskID string
	// The time when the task was created.
	CreatedAt string
	// The time when the task was completed.
	CompletedAt *string
	// The type of the task.
	Type string
	// The status of the task.
	Status string
	// The error message if the task failed.
	Error *string
}

type TaskLog struct {
	// The database ID of the task log.
	DatabaseID string
	// The unique ID of the task log.
	TaskID string
	// The status of the task.
	TaskStatus string
	// The ID of the last entry in the task log.
	LastEntryID *string
	// Entries in the task log.
	Entries []*TaskLogEntry
}

type TaskLogEntry struct {
	// The timestamp of the log entry.
	Timestamp string
	// The log message.
	Message string
	// Additional fields for the log entry.
	Fields map[string]any
}

type UpdateDatabasePayload struct {
	// ID of the database to update.
	DatabaseID Identifier
	// Force update the database even if the spec is the same.
	ForceUpdate bool
	Request     *UpdateDatabaseRequest
}

type UpdateDatabaseRequest struct {
	// Unique identifier for the databases's owner.
	TenantID *Identifier
	// The specification for the database.
	Spec *DatabaseSpec
}

type UpdateDatabaseResponse struct {
	// The task that will update this database.
	Task *Task
	// The database being updated.
	Database *Database
}

type VersionInfo struct {
	// The version of the API server.
	Version string
	// The VCS revision of the API server.
	Revision string
	// The timestamp associated with the revision.
	RevisionTime string
	// The CPU architecture of the API server.
	Arch string
}