state

type AlreadyExistsError struct {
	Idx string
}

type DirHandleFieldIndexer struct {
	Field string
}

type DocumentStore struct {

	// TimeProvider provides current time (for mocking time.Now in tests)
	TimeProvider func() time.Time
	// contains filtered or unexported fields
}

type InstalledProviders map[tfaddr.Provider]*version.Version

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

type LocalSchemaSource struct {
	ModulePath string
}

type Module struct {
	Path string

	ModManifest      *datadir.ModuleManifest
	ModManifestErr   error
	ModManifestState op.OpState

	TerraformVersion      *version.Version
	TerraformVersionErr   error
	TerraformVersionState op.OpState

	InstalledProviders InstalledProviders

	ProviderSchemaErr   error
	ProviderSchemaState op.OpState

	RefTargets      reference.Targets
	RefTargetsErr   error
	RefTargetsState op.OpState

	RefOrigins      reference.Origins
	RefOriginsErr   error
	RefOriginsState op.OpState

	VarsRefOrigins      reference.Origins
	VarsRefOriginsErr   error
	VarsRefOriginsState op.OpState

	ParsedModuleFiles  ast.ModFiles
	ParsedVarsFiles    ast.VarsFiles
	ModuleParsingErr   error
	VarsParsingErr     error
	ModuleParsingState op.OpState
	VarsParsingState   op.OpState

	Meta      ModuleMetadata
	MetaErr   error
	MetaState op.OpState

	ModuleDiagnostics ast.ModDiags
	VarsDiagnostics   ast.VarsDiags
}

type ModuleCallReader interface {
	ModuleCalls(modPath string) (tfmod.ModuleCalls, error)
	ModuleMeta(modPath string) (*tfmod.Meta, error)
}

type ModuleChangeBatch struct {
	DirHandle       document.DirHandle
	FirstChangeTime time.Time
	IsDirOpen       bool
	Changes         ModuleChanges
}

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

type ModuleChanges struct {
	// IsRemoval indicates whether this batch represents removal of a module
	IsRemoval bool

	CoreRequirements     bool
	Backend              bool
	ProviderRequirements bool
	TerraformVersion     bool
	InstalledProviders   bool
	Diagnostics          bool
	ReferenceOrigins     bool
	ReferenceTargets     bool
}

type ModuleIds struct {
	Path string
	ID   string
}

type ModuleLookupFunc func(string) (*Module, error)

type ModuleMetadata struct {
	CoreRequirements     version.Constraints
	Backend              *tfmod.Backend
	ProviderReferences   map[tfmod.ProviderRef]tfaddr.Provider
	ProviderRequirements tfmod.ProviderRequirements
	Variables            map[string]tfmod.Variable
	Outputs              map[string]tfmod.Output
	Filenames            []string
	ModuleCalls          map[string]tfmod.DeclaredModuleCall
}

type ModuleNotFoundError struct {
	Path string
}

type ModuleReader interface {
	CallersOfModule(modPath string) ([]*Module, error)
	ModuleByPath(modPath string) (*Module, error)
	List() ([]*Module, error)
}

type ModuleStore struct {
	Changes *ModuleChangeStore

	// TimeProvider provides current time (for mocking time.Now in tests)
	TimeProvider func() time.Time
	// contains filtered or unexported fields
}

type NoSchemaError struct{}

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

type PathState uint

type PreloadedSchemaSource struct {
}

type ProviderIds struct {
	Address tfaddr.Provider
	ID      string
}

type ProviderSchema struct {
	Address tfaddr.Provider
	Version *version.Version
	Source  SchemaSource

	Schema *tfschema.ProviderSchema
}

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

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

type ScheduledJob struct {
	job.ID
	job.Job
	IsDirOpen bool
	State     State

	// JobErr contains error when job finishes (State = StateDone)
	JobErr error
	// DeferredJobIDs contains IDs of any deferred jobs
	// set when job finishes (State = StateDone)
	DeferredJobIDs job.IDs
}

type SchemaReader interface {
	ProviderSchema(modPath string, addr tfaddr.Provider, vc version.Constraints) (*tfschema.ProviderSchema, error)
}

type SchemaSource interface {
	String() string
	// contains filtered or unexported methods
}

type State uint

type StateStore struct {
	DocumentStore   *DocumentStore
	JobStore        *JobStore
	Modules         *ModuleStore
	ProviderSchemas *ProviderSchemaStore
	WalkerPaths     *WalkerPathStore
	// contains filtered or unexported fields
}

type StringerFieldIndexer struct {
	Field string
}

type TimeFieldIndex struct {
	Field string
}

type VersionFieldIndexer struct {
	Field string
}

type WalkerPath struct {
	Dir       document.DirHandle
	IsDirOpen bool
	State     PathState
}

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