otf

type Apply struct {
	ID string

	gorm.Model

	ResourceAdditions    int
	ResourceChanges      int
	ResourceDestructions int
	Status               tfe.ApplyStatus
	StatusTimestamps     *tfe.ApplyStatusTimestamps

	// Logs is the blob ID for the log output from a terraform apply
	LogsBlobID string
}

type ApplyFinishOptions struct {
	// Type is a public field utilized by JSON:API to set the resource type via
	// the field tag.  It is not a user-defined value and does not need to be
	// set.  https://jsonapi.org/format/#crud-creating
	Type string `jsonapi:"primary,applies"`

	ResourceAdditions    int `jsonapi:"attr,resource-additions"`
	ResourceChanges      int `jsonapi:"attr,resource-changes"`
	ResourceDestructions int `jsonapi:"attr,resource-destructions"`
}

type ApplyService interface {
	Get(id string) (*Apply, error)
}

type BlobStore interface {
	// Get fetches a blob
	Get(string) ([]byte, error)

	// Get fetches a blob chunk
	GetChunk(string, GetChunkOptions) ([]byte, error)

	// Put uploads a blob
	Put(string, []byte) error

	// Put uploads a blob chunk
	PutChunk(string, []byte, PutChunkOptions) error
}

type Change struct {
	Actions []ChangeAction
}

type ChangeAction string

type ConfigurationVersion struct {
	ID string

	gorm.Model

	AutoQueueRuns    bool
	Error            string
	ErrorMessage     string
	Source           tfe.ConfigurationSource
	Speculative      bool
	Status           tfe.ConfigurationStatus
	StatusTimestamps *tfe.CVStatusTimestamps

	// BlobID is the ID of the blob containing the configuration
	BlobID string

	// Configuration Version belongs to a Workspace
	Workspace *Workspace
}

type ConfigurationVersionFactory struct {
	WorkspaceService WorkspaceService
}

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

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

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

type ConfigurationVersionListOptions struct {
	tfe.ListOptions

	// Filter by run statuses (with an implicit OR condition)
	Statuses []tfe.ConfigurationStatus

	// Filter by workspace ID
	WorkspaceID *string
}

type ConfigurationVersionService interface {
	Create(workspaceID string, opts *tfe.ConfigurationVersionCreateOptions) (*ConfigurationVersion, error)
	Get(id string) (*ConfigurationVersion, error)
	GetLatest(workspaceID string) (*ConfigurationVersion, error)
	List(workspaceID string, opts tfe.ConfigurationVersionListOptions) (*ConfigurationVersionList, error)
	Upload(id string, payload []byte) error
	Download(id string) ([]byte, error)
}

type ConfigurationVersionStore interface {
	Create(run *ConfigurationVersion) (*ConfigurationVersion, error)
	Get(opts ConfigurationVersionGetOptions) (*ConfigurationVersion, error)
	List(workspaceID string, opts ConfigurationVersionListOptions) (*ConfigurationVersionList, error)
	Update(id string, fn func(*ConfigurationVersion) error) (*ConfigurationVersion, error)
}

type Entitlements struct {
	*tfe.Entitlements
}

type ErrInvalidRunStatusTransition struct {
	From tfe.RunStatus
	To   tfe.RunStatus
}

type ErrJobAlreadyStarted error

type Event struct {
	Type    EventType
	Payload interface{}
}

type EventService interface {
	Publish(Event)
	Subscribe(id string) Subscription
}

type EventType string

type Executor struct {
	JobService

	RunService                  RunService
	ConfigurationVersionService ConfigurationVersionService
	StateVersionService         StateVersionService

	// Current working directory
	Path string

	// logger
	logr.Logger
	// contains filtered or unexported fields
}

type ExecutorFunc func(context.Context, *Executor) error

type GetChunkOptions struct {
	// The maximum number of bytes of logs to return to the client
	Limit int `schema:"limit"`

	// The start position in the logs from which to send to the client
	Offset int `schema:"offset"`
}

type Job interface {
	// GetID gets the ID of the job
	GetID() string
	// GetStatus gets the status of the job
	GetStatus() string
	// Do does the piece of work in an execution environment
	Do(*Executor) error
}

type JobFinishOptions struct {
	Errored bool
}

type JobLogsUploader interface {
	// UploadLogs uploads a chunk of output from the job.
	UploadLogs(id string, logs []byte, opts PutChunkOptions) error
}

type JobService interface {
	// Start is called by an agent when it starts a job. ErrJobAlreadyStarted
	// should be returned if another agent has already started it.
	Start(id string, opts JobStartOptions) (Job, error)
	// Finish is called by an agent when it finishes a job.
	Finish(id string, opts JobFinishOptions) (Job, error)

	JobLogsUploader
}

type JobStartOptions struct {
	AgentID string
}

type JobWriter struct {
	// JobLogsUploader uploads a chunk of logs to the server
	JobLogsUploader

	// ID of job
	ID string

	logr.Logger
}

type Organization struct {
	ID string

	gorm.Model

	Name                   string
	CollaboratorAuthPolicy tfe.AuthPolicyType
	CostEstimationEnabled  bool
	Email                  string
	OwnersTeamSAMLRoleID   string
	Permissions            *tfe.OrganizationPermissions
	SAMLEnabled            bool
	SessionRemember        int
	SessionTimeout         int
	TrialExpiresAt         time.Time
	TwoFactorConformant    bool
}

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

type OrganizationService interface {
	Create(opts *tfe.OrganizationCreateOptions) (*Organization, error)
	Get(name string) (*Organization, error)
	List(opts tfe.OrganizationListOptions) (*OrganizationList, error)
	Update(name string, opts *tfe.OrganizationUpdateOptions) (*Organization, error)
	Delete(name string) error
	GetEntitlements(name string) (*Entitlements, error)
}

type OrganizationStore interface {
	Create(org *Organization) (*Organization, error)
	Get(name string) (*Organization, error)
	List(opts tfe.OrganizationListOptions) (*OrganizationList, error)
	Update(name string, fn func(*Organization) error) (*Organization, error)
	Delete(name string) error
}

type Phase interface {
	GetLogsBlobID() string
	Do(*Run, *Executor) error
}

type Plan struct {
	ID string

	gorm.Model

	ResourceAdditions    int
	ResourceChanges      int
	ResourceDestructions int
	Status               tfe.PlanStatus
	StatusTimestamps     *tfe.PlanStatusTimestamps

	// LogsBlobID is the blob ID for the log output from a terraform plan
	LogsBlobID string

	// PlanFileBlobID is the blob ID of the execution plan file in binary format
	PlanFileBlobID string

	// PlanJSONBlobID is the blob ID of the execution plan file in json format
	PlanJSONBlobID string
}

type PlanEnqueuer interface {
	EnqueuePlan(id string) error
}

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

type PlanFinishOptions struct {
	// Type is a public field utilized by JSON:API to set the resource type via
	// the field tag.  It is not a user-defined value and does not need to be
	// set.  https://jsonapi.org/format/#crud-creating
	Type string `jsonapi:"primary,plans"`

	ResourceAdditions    int `jsonapi:"attr,resource-additions"`
	ResourceChanges      int `jsonapi:"attr,resource-changes"`
	ResourceDestructions int `jsonapi:"attr,resource-destructions"`
}

type PlanService interface {
	Get(id string) (*Plan, error)
	GetPlanJSON(id string) ([]byte, error)
}

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

type Queue interface {
	Add(*Run) error
	Remove(*Run) error
}

type ResourceChange struct {
	Change Change
}

type Run struct {
	ID string

	gorm.Model

	ForceCancelAvailableAt time.Time
	IsDestroy              bool
	Message                string
	Permissions            *tfe.RunPermissions
	PositionInQueue        int
	Refresh                bool
	RefreshOnly            bool
	Status                 tfe.RunStatus
	StatusTimestamps       *tfe.RunStatusTimestamps
	ReplaceAddrs           []string
	TargetAddrs            []string

	// Relations
	Plan                 *Plan
	Apply                *Apply
	Workspace            *Workspace
	ConfigurationVersion *ConfigurationVersion
}

type RunFactory struct {
	ConfigurationVersionService ConfigurationVersionService
	WorkspaceService            WorkspaceService
}

type RunGetOptions struct {
	// ID of run to retrieve
	ID *string

	// Get run via apply ID
	ApplyID *string

	// Get run via plan ID
	PlanID *string
}

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

type RunListOptions struct {
	tfe.RunListOptions

	// Filter by run statuses (with an implicit OR condition)
	Statuses []tfe.RunStatus

	// Filter by workspace ID
	WorkspaceID *string
}

type RunService interface {
	Create(opts *tfe.RunCreateOptions) (*Run, error)
	Get(id string) (*Run, error)
	List(opts RunListOptions) (*RunList, error)
	Apply(id string, opts *tfe.RunApplyOptions) error
	Discard(id string, opts *tfe.RunDiscardOptions) error
	Cancel(id string, opts *tfe.RunCancelOptions) error
	ForceCancel(id string, opts *tfe.RunForceCancelOptions) error
	EnqueuePlan(id string) error
	GetPlanLogs(id string, opts GetChunkOptions) ([]byte, error)
	GetApplyLogs(id string, opts GetChunkOptions) ([]byte, error)
	GetPlanJSON(id string) ([]byte, error)
	GetPlanFile(id string) ([]byte, error)
	UploadPlan(runID string, plan []byte, json bool) error

	JobService
}

type RunStore interface {
	Create(run *Run) (*Run, error)
	Get(opts RunGetOptions) (*Run, error)
	List(opts RunListOptions) (*RunList, error)
	// TODO: add support for a special error type that tells update to skip
	// updates - useful when fn checks current fields and decides not to update
	Update(id string, fn func(*Run) error) (*Run, error)
}

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

type StateOutput struct {
	Value string
	Type  string
}

type StateVersion struct {
	ID string

	gorm.Model

	Serial       int64
	VCSCommitSHA string
	VCSCommitURL string

	// BlobID is ID of the binary object containing the state
	BlobID string

	// State version belongs to a workspace
	Workspace *Workspace

	Outputs []*StateVersionOutput

	// State version has many outputs
	StateVersionOutputs []StateVersionOutput
}

type StateVersionFactory struct {
	WorkspaceService WorkspaceService
	BlobStore        BlobStore
}

type StateVersionGetOptions struct {
	// ID of state version to retrieve
	ID *string

	// Get current state version belonging to workspace with this ID
	WorkspaceID *string
}

type StateVersionList struct {
	*tfe.Pagination
	Items []*StateVersion
}

type StateVersionOutput struct {
	ID string

	gorm.Model

	Name      string
	Sensitive bool
	Type      string
	Value     string

	// StateVersionOutput belongs to State Version
	StateVersionID uint
}

type StateVersionOutputList []*StateVersionOutput

type StateVersionService interface {
	Create(workspaceID string, opts tfe.StateVersionCreateOptions) (*StateVersion, error)
	Current(workspaceID string) (*StateVersion, error)
	Get(id string) (*StateVersion, error)
	Download(id string) ([]byte, error)
	List(opts tfe.StateVersionListOptions) (*StateVersionList, error)
}

type StateVersionStore interface {
	Create(sv *StateVersion) (*StateVersion, error)
	Get(opts StateVersionGetOptions) (*StateVersion, error)
	List(opts tfe.StateVersionListOptions) (*StateVersionList, error)
}

type Subscription interface {
	// Event stream for all subscriber's event.
	C() <-chan Event

	// Closes the event stream channel and disconnects from the event service.
	Close() error
}

type Workspace struct {
	ID string

	gorm.Model

	AllowDestroyPlan           bool
	AutoApply                  bool
	CanQueueDestroyPlan        bool
	Description                string
	Environment                string
	ExecutionMode              string
	FileTriggersEnabled        bool
	GlobalRemoteState          bool
	Locked                     bool
	MigrationEnvironment       string
	Name                       string
	Permissions                *tfe.WorkspacePermissions
	QueueAllRuns               bool
	SpeculativeEnabled         bool
	SourceName                 string
	SourceURL                  string
	StructuredRunOutputEnabled bool
	TerraformVersion           string
	VCSRepo                    *tfe.VCSRepo
	WorkingDirectory           string
	ResourceCount              int
	ApplyDurationAverage       time.Duration
	PlanDurationAverage        time.Duration
	PolicyCheckFailures        int
	RunFailures                int
	RunsCount                  int

	TriggerPrefixes []string

	// Workspace belongs to an organization
	Organization *Organization
}

type WorkspaceList struct {
	*tfe.Pagination
	Items []*Workspace
}

type WorkspaceListOptions struct {
	// Pagination
	tfe.ListOptions

	// Optionally filter workspaces with name matching prefix
	Prefix *string `schema:"search[name],omitempty"`

	// OrganizationName filters workspaces by organization name
	OrganizationName *string

	// A list of relations to include. See available resources https://www.terraform.io/docs/cloud/api/workspaces.html#available-related-resources
	Include *string `schema:"include"`
}

type WorkspaceQueue struct {
	// Active is the currently active run.
	Active *Run
	// Pending is the list of pending runs waiting for the active run to
	// complete.
	Pending []*Run
	// PlanEnqueuer enqueues a plan onto the global queue
	PlanEnqueuer
}

type WorkspaceService interface {
	Create(org string, opts *tfe.WorkspaceCreateOptions) (*Workspace, error)
	Get(spec WorkspaceSpecifier) (*Workspace, error)
	List(opts WorkspaceListOptions) (*WorkspaceList, error)
	Update(spec WorkspaceSpecifier, opts *tfe.WorkspaceUpdateOptions) (*Workspace, error)
	Lock(id string, opts tfe.WorkspaceLockOptions) (*Workspace, error)
	Unlock(id string) (*Workspace, error)
	Delete(spec WorkspaceSpecifier) error
}

type WorkspaceSpecifier struct {
	// Specify workspace using its ID
	ID *string

	// Specify workspace using its name and organization
	Name             *string
	OrganizationName *string
}

type WorkspaceStore interface {
	Create(ws *Workspace) (*Workspace, error)
	Get(spec WorkspaceSpecifier) (*Workspace, error)
	List(opts WorkspaceListOptions) (*WorkspaceList, error)
	Update(spec WorkspaceSpecifier, fn func(*Workspace) error) (*Workspace, error)
	Delete(spec WorkspaceSpecifier) error
}