otf

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

type AgentTokenRow struct {
	TokenID          pgtype.Text        `json:"token_id"`
	Token            pgtype.Text        `json:"token"`
	CreatedAt        pgtype.Timestamptz `json:"created_at"`
	Description      pgtype.Text        `json:"description"`
	OrganizationName pgtype.Text        `json:"organization_name"`
}

type AgentTokenService interface {
	CreateAgentToken(ctx context.Context, opts CreateAgentTokenOptions) (*AgentToken, error)
	// GetAgentToken retrieves AgentToken using its cryptographic
	// authentication token.
	GetAgentToken(ctx context.Context, token string) (*AgentToken, error)
	ListAgentTokens(ctx context.Context, organization string) ([]*AgentToken, error)
	DeleteAgentToken(ctx context.Context, id string) (*AgentToken, error)
}

type AgentTokenStore interface {
	CreateAgentToken(ctx context.Context, at *AgentToken) error
	// GetAgentTokenByID retrieves agent token using its ID.
	GetAgentTokenByID(ctx context.Context, id string) (*AgentToken, error)
	// GetAgentTokenByToken retrieves agent token using its cryptographic
	// authentication token.
	GetAgentTokenByToken(ctx context.Context, token string) (*AgentToken, error)
	ListAgentTokens(ctx context.Context, organization string) ([]*AgentToken, error)
	DeleteAgentToken(ctx context.Context, id string) error
}

type Application interface {
	// Tx provides a transaction within which to operate on the store.
	Tx(ctx context.Context, tx func(Application) error) error
	DB() DB
	OrganizationService
	WorkspaceService
	StateVersionService
	ConfigurationVersionService
	RunService
	EventService
	UserService
	SessionService
	RegistrySessionService
	TokenService
	TeamService
	AgentTokenService
	CurrentRunService
	VCSProviderService
	LockableApplication
	cloud.Service
	ModuleService
	ModuleVersionService
	HostnameService
	VariableService
	HookService
}

type Apply struct {
	// ResourcesReport is a report of applied resource changes
	*ResourceReport
	// contains filtered or unexported fields
}

type Cache interface {
	Get(key string) ([]byte, error)
	Set(key string, val []byte) error
}

type Change struct {
	Actions []ChangeAction
}

type ChangeAction string

type Chunk struct {
	// ID of run that generated the chunk
	RunID string `schema:"run_id,required"`
	// Phase that generated the chunk
	Phase PhaseType `schema:"phase,required"`
	// Position within logs.
	Offset int `schema:"offset,required"`
	// The chunk of logs
	Data []byte
}

type ChunkService interface {
	// GetChunk fetches a chunk.
	GetChunk(ctx context.Context, opts GetChunkOptions) (Chunk, error)
	// PutChunk uploads a chunk.
	PutChunk(ctx context.Context, chunk Chunk) error
}

type ChunkStore interface {
	// GetChunk fetches a chunk of logs.
	GetChunk(ctx context.Context, opts GetChunkOptions) (Chunk, error)
	// GetChunkByID fetches a specific chunk with the given ID.
	GetChunkByID(ctx context.Context, id int) (PersistedChunk, error)
	// PutChunk uploads a chunk, receiving back the chunk along with a unique
	// ID.
	PutChunk(ctx context.Context, chunk Chunk) (PersistedChunk, error)
}

type ConfigUploader interface {
	// Upload uploads the config tarball and returns a status indicating success
	// or failure.
	Upload(ctx context.Context, config []byte) (ConfigurationStatus, error)
	// SetErrored sets the config version status to 'errored' in the store.
	SetErrored(ctx context.Context) error
}

type ConfigurationSource string

type ConfigurationStatus string

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

type ConfigurationVersionCreateOptions struct {
	AutoQueueRuns *bool
	Speculative   *bool
	*IngressAttributes
}

type ConfigurationVersionGetOptions struct {
	// ID of config version to retrieve
	ID *string

	// Get latest config version for this workspace ID
	WorkspaceID *string

	// A list of relations to include
	Include *string `schema:"include"`
}

type ConfigurationVersionList struct {
	*Pagination
	Items []*ConfigurationVersion
}

type ConfigurationVersionListOptions struct {
	// A list of relations to include
	Include *string `schema:"include"`

	ListOptions
}

type ConfigurationVersionResult struct {
	ConfigurationVersionID               pgtype.Text                                  `json:"configuration_version_id"`
	CreatedAt                            pgtype.Timestamptz                           `json:"created_at"`
	AutoQueueRuns                        bool                                         `json:"auto_queue_runs"`
	Source                               pgtype.Text                                  `json:"source"`
	Speculative                          bool                                         `json:"speculative"`
	Status                               pgtype.Text                                  `json:"status"`
	WorkspaceID                          pgtype.Text                                  `json:"workspace_id"`
	ConfigurationVersionStatusTimestamps []pggen.ConfigurationVersionStatusTimestamps `json:"configuration_version_status_timestamps"`
	IngressAttributes                    *pggen.IngressAttributes                     `json:"ingress_attributes"`
}

type ConfigurationVersionService interface {
	CreateConfigurationVersion(ctx context.Context, workspaceID string, opts ConfigurationVersionCreateOptions) (*ConfigurationVersion, error)
	// CloneConfigurationVersion creates a new configuration version using the
	// config tarball of an existing configuration version.
	CloneConfigurationVersion(ctx context.Context, cvID string, opts ConfigurationVersionCreateOptions) (*ConfigurationVersion, error)
	GetConfigurationVersion(ctx context.Context, id string) (*ConfigurationVersion, error)
	GetLatestConfigurationVersion(ctx context.Context, workspaceID string) (*ConfigurationVersion, error)
	ListConfigurationVersions(ctx context.Context, workspaceID string, opts ConfigurationVersionListOptions) (*ConfigurationVersionList, error)

	// Upload handles verification and upload of the config tarball, updating
	// the config version upon success or failure.
	UploadConfig(ctx context.Context, id string, config []byte) error

	// Download retrieves the config tarball for the given config version ID.
	DownloadConfig(ctx context.Context, id string) ([]byte, error)
}

type ConfigurationVersionStatusTimestamp struct {
	Status    ConfigurationStatus
	Timestamp time.Time
}

type ConfigurationVersionStore interface {
	// Creates a config version.
	CreateConfigurationVersion(ctx context.Context, cv *ConfigurationVersion) error
	// Get retrieves a config version.
	GetConfigurationVersion(ctx context.Context, opts ConfigurationVersionGetOptions) (*ConfigurationVersion, error)
	// GetConfig retrieves the config tarball for the given config version ID.
	GetConfig(ctx context.Context, id string) ([]byte, error)
	// List lists config versions for the given workspace.
	ListConfigurationVersions(ctx context.Context, workspaceID string, opts ConfigurationVersionListOptions) (*ConfigurationVersionList, error)
	// Delete deletes the config version from the store
	DeleteConfigurationVersion(ctx context.Context, id string) error
	// Upload uploads a config tarball for the given config version ID
	UploadConfigurationVersion(ctx context.Context, id string, fn func(cv *ConfigurationVersion, uploader ConfigUploader) error) error
}

type ConnectWorkspaceOptions struct {
	Identifier string `schema:"identifier,required"` // repo id: <owner>/<repo>
	ProviderID string `schema:"vcs_provider_id,required"`
	Cloud      string // cloud host of the repo
}

type CreateAgentTokenOptions struct {
	Organization string `schema:"organization_name,required"`
	Description  string `schema:"description,required"`
}

type CreateModuleOptions struct {
	Name         string
	Provider     string
	Organization *Organization
	Repo         *ModuleRepo
}

type CreateModuleVersionOptions struct {
	ModuleID string
	Version  string
}

type CreateTeamOptions struct {
	Name         string `schema:"team_name,required"`
	Organization string `schema:"organization_name,required"`
}

type CreateVariableOptions struct {
	Key         *string
	Value       *string
	Description *string
	Category    *VariableCategory
	Sensitive   *bool
	HCL         *bool
}

type CreateWorkspaceOptions struct {
	AllowDestroyPlan           *bool
	AutoApply                  *bool
	Description                *string
	ExecutionMode              *ExecutionMode
	FileTriggersEnabled        *bool
	GlobalRemoteState          *bool
	MigrationEnvironment       *string
	Name                       *string `schema:"name,required"`
	QueueAllRuns               *bool
	SpeculativeEnabled         *bool
	SourceName                 *string
	SourceURL                  *string
	StructuredRunOutputEnabled *bool
	TerraformVersion           *string
	TriggerPrefixes            []string
	WorkingDirectory           *string
	Organization               *string `schema:"organization_name,required"`
	Repo                       *WorkspaceRepo
}

type CurrentRunService interface {
	// SetCurrentRun sets the ID of the latest run for a workspace.
	//
	// Take full run obj as param
	SetCurrentRun(ctx context.Context, workspaceID, runID string) (*Workspace, error)
}

type DB interface {
	Database

	Tx(ctx context.Context, tx func(DB) error) error
	// WaitAndLock obtains a DB with a session-level advisory lock.
	WaitAndLock(ctx context.Context, id int64, cb func(DB) error) error
	Close()
	UserStore
	TeamStore
	OrganizationStore
	WorkspaceStore
	RunStore
	SessionStore
	RegistrySessionStore
	StateVersionStore
	TokenStore
	ConfigurationVersionStore
	ChunkStore
	AgentTokenStore
	VCSProviderStore
	ModuleStore
	ModuleVersionStore
	VariableStore
}

type Database interface {
	pggen.Querier // generated SQL queries

	// Tx provides a transaction within which to operate on the store.
	Transaction(ctx context.Context, tx func(Database) error) error
	// WaitAndLock obtains a DB with a session-level advisory lock.
	WaitAndLock(ctx context.Context, id int64, cb func(DB) error) error
}

type DownloadModuleOptions struct {
	ModuleVersionID string
}

type Downloader interface {
	// Download version, return path.
	Download(ctx context.Context, version string, w io.Writer) (path string, err error)
}

type Entitlements struct {
	ID                    string
	Agents                bool
	AuditLogging          bool
	CostEstimation        bool
	Operations            bool
	PrivateModuleRegistry bool
	SSO                   bool
	Sentinel              bool
	StateStorage          bool
	Teams                 bool
	VCSIntegrations       bool
}

type Environment interface {
	// Path returns absolute root path
	Path() string
	// WorkingDir returns relative path for terraform operations
	WorkingDir() string
	// RunTerraform invokes a terraform command
	RunTerraform(cmd string, args ...string) error
	// RunCLI runs an arbitrary command
	RunCLI(name string, args ...string) error
	// RunFunc runs a go func with access to the env
	RunFunc(fn EnvironmentFunc) error
	// TerraformPath is the path to the terraform bin
	TerraformPath() string

	// All app services should be made available to the environment
	Application
	// For downloading TF CLI
	Downloader
	// Permits job to write to output that'll be shown to the user
	io.Writer
}

type EnvironmentFunc func(context.Context, Environment) error

type Event struct {
	Type    EventType
	Payload interface{}
}

type EventService interface {
	// Watch provides access to a stream of events. The WatchOptions filters
	// events. Context must be cancelled to close stream.
	//
	// TODO(@leg100): it would be clearer to the caller if the stream is closed by
	// returning a stream object with a Close() method. The calling code would
	// call Watch(), and then defer a Close(), which is more readable IMO.
	Watch(context.Context, WatchOptions) (<-chan Event, error)
	// WatchLogs provides access to a stream of phase logs. The WatchLogsOptions filters
	// events. Context must be cancelled to close stream.
	//
	// TODO(@leg100): it would be clearer to the caller if the stream is closed by
	// returning a stream object with a Close() method. The calling code would
	// call WatchLogs(), and then defer a Close(), which is more readable IMO.
	WatchLogs(context.Context, WatchLogsOptions) (<-chan Chunk, error)
}

type EventType string

type ExecutionMode string

type GetChunkOptions struct {
	RunID string    `schema:"run_id"`
	Phase PhaseType `schema:"phase"`
	// Limit is the size of the chunk to retrieve
	Limit int `schema:"limit"`
	// Offset is the position in the data from which to retrieve the chunk.
	Offset int `schema:"offset"`
}

type GetModuleOptions struct {
	Name         string
	Provider     string
	Organization string
}

type HookCallback func(ctx context.Context, tx Database, hookID uuid.UUID) error

type HookOptions struct {
	Identifier string
	Cloud      string

	HookCallback
	cloud.Client
}

type HookService interface {
	Hook(ctx context.Context, opts HookOptions) error
	Unhook(ctx context.Context, opts UnhookOptions) error
}

type HostnameService interface {
	Hostname() string
}

type Identity interface {
	// Human friendly identification of the entity.
	String() string
	// Uniquely identifies the entity.
	ID() string
}

type IngressAttributes struct {
	// ID     string
	Branch string
	// CloneURL          string
	// CommitMessage     string
	CommitSHA string
	// CommitURL         string
	// CompareURL        string
	Identifier      string
	IsPullRequest   bool
	OnDefaultBranch bool
}

type JobWriter struct {
	// ID of run to write logs on behalf of.
	ID string
	// run phase
	Phase PhaseType
	// LogService for uploading logs to server
	LogService

	logr.Logger
	// contains filtered or unexported fields
}

type ListModulesOptions struct {
	Organization string `schema:"organization_name,required"` // filter by organization name
}

type ListOptions struct {
	// The page number to request. The results vary based on the PageSize.
	PageNumber int `schema:"page[number],omitempty"`
	// The number of elements returned in a single page.
	PageSize int `schema:"page[size],omitempty"`
}

type LockableApplication interface {
	WithLock(ctx context.Context, id int64, cb func(Application) error) error
}

type LogService ChunkService

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

type ModuleDeleter interface {
	Delete(ctx context.Context, moduleID string) error
}

type ModuleList struct {
	*Pagination
	Items []*Module
}

type ModuleRepo struct {
	ProviderID string
	WebhookID  uuid.UUID
	Identifier string // identifier is <repo_owner>/<repo_name>
}

type ModuleRow struct {
	ModuleID     pgtype.Text            `json:"module_id"`
	CreatedAt    pgtype.Timestamptz     `json:"created_at"`
	UpdatedAt    pgtype.Timestamptz     `json:"updated_at"`
	Name         pgtype.Text            `json:"name"`
	Provider     pgtype.Text            `json:"provider"`
	Status       pgtype.Text            `json:"status"`
	Organization *pggen.Organizations   `json:"organization"`
	ModuleRepo   *pggen.ModuleRepos     `json:"module_repo"`
	Webhook      *pggen.Webhooks        `json:"webhook"`
	Versions     []pggen.ModuleVersions `json:"versions"`
}

type ModuleService interface {
	// PublishModule publishes a module from a VCS repository.
	PublishModule(context.Context, PublishModuleOptions) (*Module, error)
	// CreateModule creates a module without a connection to a VCS repository.
	CreateModule(context.Context, CreateModuleOptions) (*Module, error)
	UpdateModuleStatus(ctx context.Context, opts UpdateModuleStatusOptions) (*Module, error)
	ListModules(context.Context, ListModulesOptions) ([]*Module, error)
	GetModule(ctx context.Context, opts GetModuleOptions) (*Module, error)
	GetModuleByID(ctx context.Context, id string) (*Module, error)
	GetModuleByWebhookID(ctx context.Context, id uuid.UUID) (*Module, error)
	DeleteModule(ctx context.Context, id string) (*Module, error)
}

type ModuleStatus string

type ModuleStore interface {
	CreateModule(context.Context, *Module) error
	UpdateModuleStatus(ctx context.Context, opts UpdateModuleStatusOptions) error
	ListModules(context.Context, ListModulesOptions) ([]*Module, error)
	GetModule(ctx context.Context, opts GetModuleOptions) (*Module, error)
	GetModuleByID(ctx context.Context, id string) (*Module, error)
	GetModuleByWebhookID(ctx context.Context, id uuid.UUID) (*Module, error)
	DeleteModule(ctx context.Context, id string) error
}

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

type ModuleVersionRow struct {
	ModuleVersionID pgtype.Text        `json:"module_version_id"`
	Version         pgtype.Text        `json:"version"`
	CreatedAt       pgtype.Timestamptz `json:"created_at"`
	UpdatedAt       pgtype.Timestamptz `json:"updated_at"`
	Status          pgtype.Text        `json:"status"`
	StatusError     pgtype.Text        `json:"status_error"`
	ModuleID        pgtype.Text        `json:"module_id"`
}

type ModuleVersionService interface {
	CreateModuleVersion(context.Context, CreateModuleVersionOptions) (*ModuleVersion, error)
	UploadModuleVersion(ctx context.Context, opts UploadModuleVersionOptions) (*ModuleVersion, error)
	DownloadModuleVersion(ctx context.Context, opts DownloadModuleOptions) ([]byte, error)
}

type ModuleVersionStatus string

type ModuleVersionStore interface {
	CreateModuleVersion(context.Context, *ModuleVersion) error
	UpdateModuleVersionStatus(ctx context.Context, opts UpdateModuleVersionStatusOptions) (*ModuleVersion, error)
	UploadModuleVersion(ctx context.Context, opts UploadModuleVersionOptions) error
	DownloadModuleVersion(ctx context.Context, opts DownloadModuleOptions) ([]byte, error)
}

type ModuleVersionUploader struct {
	Application
}

type NewSessionOption func(*Session)

type NewTeamOption func(*Team)

type NewTestModuleOption func(*Module)

type NewTestRegistrySessionOption func(*RegistrySession)

type NewTestWorkspaceOption func(*Workspace)

type NewUserOption func(*User)

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

type OrganizationAccess struct {
	ManageWorkspaces bool `schema:"manage_workspaces"` // admin access on all workspaces
	ManageVCS        bool `schema:"manage_vcs"`        // manage VCS providers
	ManageRegistry   bool `schema:"manage_registry"`   // manage module and provider registry
}

type OrganizationCreateOptions struct {
	Name            *string `schema:"name,required"`
	SessionRemember *int
	SessionTimeout  *int
}

type OrganizationList struct {
	*Pagination
	Items []*Organization
}

type OrganizationListOptions struct {
	ListOptions
}

type OrganizationService interface {
	CreateOrganization(ctx context.Context, opts OrganizationCreateOptions) (*Organization, error)
	EnsureCreatedOrganization(ctx context.Context, opts OrganizationCreateOptions) (*Organization, error)
	GetOrganization(ctx context.Context, name string) (*Organization, error)
	ListOrganizations(ctx context.Context, opts OrganizationListOptions) (*OrganizationList, error)
	UpdateOrganization(ctx context.Context, name string, opts *OrganizationUpdateOptions) (*Organization, error)
	DeleteOrganization(ctx context.Context, name string) error
	GetEntitlements(ctx context.Context, name string) (*Entitlements, error)
}

type OrganizationStore interface {
	CreateOrganization(ctx context.Context, org *Organization) error
	GetOrganization(ctx context.Context, name string) (*Organization, error)
	GetOrganizationByID(ctx context.Context, id string) (*Organization, error)
	ListOrganizations(ctx context.Context, opts OrganizationListOptions) (*OrganizationList, error)
	ListOrganizationsByUser(ctx context.Context, userID string) ([]*Organization, error)
	UpdateOrganization(ctx context.Context, name string, fn func(*Organization) error) (*Organization, error)
	DeleteOrganization(ctx context.Context, name string) error
	GetOrganizationNameByWorkspaceID(ctx context.Context, workspaceID string) (string, error)
}

type OrganizationUpdateOptions struct {
	Name            *string
	SessionRemember *int
	SessionTimeout  *int
}

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

type PersistedChunk struct {
	// ChunkID uniquely identifies the chunk.
	ChunkID int
	Chunk
}

type Phase interface {
	// Run ID
	ID() string
	// phase type
	Phase() PhaseType
	// current phase status
	Status() PhaseStatus
	// Get job status timestamps
	StatusTimestamps() []PhaseStatusTimestamp
	// Lookup timestamp for status
	StatusTimestamp(PhaseStatus) (time.Time, error)
}

type PhaseFinishOptions struct {
	// Errored is true if the phase finished unsuccessfully.
	Errored bool `jsonapi:"attr,errored,omitempty"`
}

type PhaseSpec struct {
	RunID string
	Phase PhaseType
}

type PhaseStartOptions struct {
	AgentID string `jsonapi:"attr,agent-id,omitempty"`
}

type PhaseStatus string

type PhaseStatusTimestamp struct {
	Status    PhaseStatus
	Timestamp time.Time
}

type PhaseType string

type Plan struct {
	// report of planned resource changes
	*ResourceReport
	// contains filtered or unexported fields
}

type PlanFile struct {
	ResourceChanges []ResourceChange `json:"resource_changes"`
}

type PlanFormat string

type PubSubService interface {
	// Publish an event
	Publish(Event)
	// Subscribe creates a subscription to a stream of errors. Name is a
	// unique identifier describing the subscriber.
	Subscribe(ctx context.Context, name string) (<-chan Event, error)
}

type PublishModuleOptions struct {
	Identifier   string
	ProviderID   string
	Organization *Organization
}

type PutChunkOptions struct {
	// Start indicates this is the first chunk
	Start bool `schema:"start"`
	// End indicates this is the last and final chunk
	End bool `schema:"end"`
}

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

type RegistrySessionRow struct {
	Token            pgtype.Text        `json:"token"`
	Expiry           pgtype.Timestamptz `json:"expiry"`
	OrganizationName pgtype.Text        `json:"organization_name"`
}

type RegistrySessionService interface {
	CreateRegistrySession(ctx context.Context, organization string) (*RegistrySession, error)
	GetRegistrySession(ctx context.Context, token string) (*RegistrySession, error)
}

type RegistrySessionStore interface {
	CreateRegistrySession(ctx context.Context, session *RegistrySession) error
	GetRegistrySession(ctx context.Context, token string) (*RegistrySession, error)
}

type Reporter struct {
	Application
	logr.Logger
}

type ResourceChange struct {
	Change Change
}

type ResourceReport struct {
	Additions    int
	Changes      int
	Destructions int
}

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

type RunApplyOptions struct {
	// An optional comment about the run.
	Comment *string `json:"comment,omitempty"`
}

type RunCancelOptions struct {
	// An optional explanation for why the run was canceled.
	Comment *string `jsonapi:"attr,comment,omitempty"`
}

type RunCreateOptions struct {
	IsDestroy              *bool
	Refresh                *bool
	RefreshOnly            *bool
	Message                *string
	ConfigurationVersionID *string
	TargetAddrs            []string
	ReplaceAddrs           []string
	AutoApply              *bool
}

type RunDiscardOptions struct {
	// An optional explanation for why the run was discarded.
	Comment *string `jsonapi:"attr,comment,omitempty"`
}

type RunFactory struct {
	ConfigurationVersionService ConfigurationVersionService
	WorkspaceService            WorkspaceService
}

type RunForceCancelOptions struct {
	// An optional comment explaining the reason for the force-cancel.
	Comment *string `jsonapi:"attr,comment,omitempty"`
}

type RunList struct {
	*Pagination
	Items []*Run
}

type RunListOptions struct {
	ListOptions
	// Filter by run statuses (with an implicit OR condition)
	Statuses []RunStatus `schema:"statuses,omitempty"`
	// Filter by workspace ID
	WorkspaceID *string `schema:"workspace_id,omitempty"`
	// Filter by organization name
	Organization *string `schema:"organization_name,omitempty"`
	// Filter by workspace name
	WorkspaceName *string `schema:"workspace_name,omitempty"`
	// Filter by speculative or non-speculative
	Speculative *bool `schema:"-"`
	// A list of relations to include. See available resources:
	// https://www.terraform.io/docs/cloud/api/run.html#available-related-resources
	Include *string `schema:"include,omitempty"`
}

type RunResult struct {
	RunID                  pgtype.Text                   `json:"run_id"`
	CreatedAt              pgtype.Timestamptz            `json:"created_at"`
	ForceCancelAvailableAt pgtype.Timestamptz            `json:"force_cancel_available_at"`
	IsDestroy              bool                          `json:"is_destroy"`
	PositionInQueue        int                           `json:"position_in_queue"`
	Refresh                bool                          `json:"refresh"`
	RefreshOnly            bool                          `json:"refresh_only"`
	Status                 pgtype.Text                   `json:"status"`
	PlanStatus             pgtype.Text                   `json:"plan_status"`
	ApplyStatus            pgtype.Text                   `json:"apply_status"`
	ReplaceAddrs           []string                      `json:"replace_addrs"`
	TargetAddrs            []string                      `json:"target_addrs"`
	AutoApply              bool                          `json:"auto_apply"`
	PlannedChanges         *pggen.Report                 `json:"planned_changes"`
	AppliedChanges         *pggen.Report                 `json:"applied_changes"`
	ConfigurationVersionID pgtype.Text                   `json:"configuration_version_id"`
	WorkspaceID            pgtype.Text                   `json:"workspace_id"`
	Speculative            bool                          `json:"speculative"`
	ExecutionMode          pgtype.Text                   `json:"execution_mode"`
	Latest                 bool                          `json:"latest"`
	OrganizationName       pgtype.Text                   `json:"organization_name"`
	IngressAttributes      *pggen.IngressAttributes      `json:"ingress_attributes"`
	RunStatusTimestamps    []pggen.RunStatusTimestamps   `json:"run_status_timestamps"`
	PlanStatusTimestamps   []pggen.PhaseStatusTimestamps `json:"plan_status_timestamps"`
	ApplyStatusTimestamps  []pggen.PhaseStatusTimestamps `json:"apply_status_timestamps"`
}

type RunService interface {
	// Create a new run with the given options.
	CreateRun(ctx context.Context, workspaceID string, opts RunCreateOptions) (*Run, error)
	// Get retrieves a run with the given ID.
	GetRun(ctx context.Context, id string) (*Run, error)
	// List lists runs according to the given options.
	ListRuns(ctx context.Context, opts RunListOptions) (*RunList, error)
	// Delete deletes a run with the given ID.
	DeleteRun(ctx context.Context, id string) error
	// EnqueuePlan enqueues a plan
	EnqueuePlan(ctx context.Context, id string) (*Run, error)
	// Apply a run with the given ID.
	//
	// TODO: return run
	ApplyRun(ctx context.Context, id string, opts RunApplyOptions) error
	// Discard discards a run with the given ID.
	//
	// TODO: return run
	DiscardRun(ctx context.Context, id string, opts RunDiscardOptions) error
	// Cancel run.
	//
	// TODO: return run
	CancelRun(ctx context.Context, id string, opts RunCancelOptions) error
	// Forcefully cancel a run.
	//
	// TODO: return run
	ForceCancelRun(ctx context.Context, id string, opts RunForceCancelOptions) error
	// Start a run phase.
	StartPhase(ctx context.Context, id string, phase PhaseType, opts PhaseStartOptions) (*Run, error)
	// Finish a run phase.
	FinishPhase(ctx context.Context, id string, phase PhaseType, opts PhaseFinishOptions) (*Run, error)
	// GetPlanFile retrieves a run's plan file with the requested format.
	GetPlanFile(ctx context.Context, id string, format PlanFormat) ([]byte, error)
	// UploadPlanFile saves a run's plan file with the requested format.
	UploadPlanFile(ctx context.Context, id string, plan []byte, format PlanFormat) error
	// GetLockFile retrieves a run's lock file (.terraform.lock.hcl)
	GetLockFile(ctx context.Context, id string) ([]byte, error)
	// UploadLockFile saves a run's lock file (.terraform.lock.hcl)
	UploadLockFile(ctx context.Context, id string, lockFile []byte) error
	// Read and write logs for run phases.
	LogService
	// Tail logs of a run phase
	Tail(ctx context.Context, opts GetChunkOptions) (<-chan Chunk, error)
	// StartRun creates and starts a run.
	StartRun(ctx context.Context, workspaceID string, opts ConfigurationVersionCreateOptions) (*Run, error)
}

type RunStarter struct {
	Application
}

type RunStatus string

type RunStatusTimestamp struct {
	Status    RunStatus
	Timestamp time.Time
}

type RunStore interface {
	CreateRun(ctx context.Context, run *Run) error
	GetRun(ctx context.Context, id string) (*Run, error)
	SetPlanFile(ctx context.Context, id string, file []byte, format PlanFormat) error
	GetPlanFile(ctx context.Context, id string, format PlanFormat) ([]byte, error)
	SetLockFile(ctx context.Context, id string, file []byte) error
	GetLockFile(ctx context.Context, id string) ([]byte, error)
	ListRuns(ctx context.Context, opts RunListOptions) (*RunList, error)
	// UpdateStatus updates the run's status, providing a func with which to
	// perform updates in a transaction.
	UpdateStatus(ctx context.Context, id string, fn func(*Run) error) (*Run, error)
	CreatePlanReport(ctx context.Context, id string, report ResourceReport) error
	CreateApplyReport(ctx context.Context, id string, report ResourceReport) error
	DeleteRun(ctx context.Context, id string) error
}

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

type SessionResult struct {
	Token     pgtype.Text        `json:"token"`
	CreatedAt pgtype.Timestamptz `json:"created_at"`
	Address   pgtype.Text        `json:"address"`
	Expiry    pgtype.Timestamptz `json:"expiry"`
	UserID    pgtype.Text        `json:"user_id"`
}

type SessionService interface {
	// CreateSession creates a user session.
	CreateSession(ctx context.Context, userID, address string) (*Session, error)
	// GetSession retrieves a session using its token.
	GetSessionByToken(ctx context.Context, token string) (*Session, error)
	// ListSessions lists current sessions for a user
	ListSessions(ctx context.Context, userID string) ([]*Session, error)
	// DeleteSession deletes the session with the given token
	DeleteSession(ctx context.Context, token string) error
}

type SessionStore interface {
	// CreateSession persists a new session to the store.
	CreateSession(ctx context.Context, session *Session) error
	// GetSession retrieves a session using its token.
	GetSessionByToken(ctx context.Context, token string) (*Session, error)
	// ListSessions lists current sessions for a user
	ListSessions(ctx context.Context, userID string) ([]*Session, error)
	// DeleteSession deletes a session
	DeleteSession(ctx context.Context, token string) error
}

type SortedModuleVersions []*ModuleVersion

type State struct {
	Version int
	Serial  int64
	Lineage string
	Outputs map[string]StateOutput
}

type StateCreateOptions struct {
	Version *int
	Serial  *int64
	Lineage *string
}

type StateOutput struct {
	Name      string
	Value     string
	Type      string
	Sensitive bool
}

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