registry

type Diff struct {
	Object   *ResourceWrapper
	Type     DiffType
	Fields   []string
	Critical bool
	// contains filtered or unexported fields
}

type DiffType int

type FieldInfo struct {
	Type  *FieldTypeInfo
	Value reflect.Value
}

type FieldProperties struct {
	Ignored  bool // ignore from state
	ForceNew bool // any change of this field forces new resource
	Computed bool // computed field disallows user input and is created by resource itself
	HardLink bool // dependencies of this field cannot be removed (propagates recreate)
}

type FieldTypeInfo struct {
	ReflectType reflect.StructField
	Properties  *FieldProperties
	Default     string
	DefaultSet  bool
}

type Options struct {
	Read            bool
	Destroy         bool
	AllowDuplicates bool
}

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

type Resource interface {
	GetName() string
	Registry() *Registry
	Diff() *Diff
	Wrapper() *ResourceWrapper
	SetState(ResourceState)
	State() ResourceState

	IsRegistered() bool

	IsNew() bool
	MarkAsNew()
	IsExisting() bool
	MarkAsExisting()
	IsDeleted() bool
	MarkAsDeleted()

	SkipState() bool
	// contains filtered or unexported methods
}

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

type ResourceBeforeDiffHook interface {
	BeforeDiff(ctx context.Context, meta interface{}) error
}

type ResourceCUD interface {
	Create(ctx context.Context, meta interface{}) error
	Update(ctx context.Context, meta interface{}) error
	Delete(ctx context.Context, meta interface{}) error
}

type ResourceCriticalChecker interface {
	IsCritical(t DiffType, fieldList []string) bool
}

type ResourceDiffCalculator interface {
	CalculateDiff(ctx context.Context, meta interface{}) (DiffType, error)
}

type ResourceID struct {
	ID        string `json:"id"`
	Namespace string `json:"namespace"`
	Type      string `json:"type"`
	Source    string `json:"source"`
	Partition string `json:"partition,omitempty"`
}

type ResourceIniter interface {
	Init(ctx context.Context, meta interface{}, opts *Options) error
}

type ResourceProcessor interface {
	Process(ctx context.Context, meta interface{}) error
}

type ResourceReader interface {
	Read(ctx context.Context, meta interface{}) error
}

type ResourceReference interface {
	ReferenceID() string
}

type ResourceSerialized struct {
	ResourceID
	IsNew        bool                   `json:"is_new,omitempty"`
	ReferenceID  string                 `json:"ref_id,omitempty"`
	Properties   map[string]interface{} `json:"properties,omitempty"`
	Dependencies []ResourceID           `json:"dependencies,omitempty"`
	DependedBy   []ResourceID           `json:"depended_by,omitempty"`
}

type ResourceState int

type ResourceTypeInfo struct {
	Type   reflect.Type
	Fields map[string]*FieldTypeInfo
}

type ResourceTypeVerbose interface {
	GetType() string
}

type ResourceWrapper struct {
	ResourceID

	Fields       map[string]*FieldInfo
	DependedBy   map[*ResourceWrapper]struct{}
	Dependencies map[*ResourceWrapper]struct{}
	Resource     Resource
	IsSkipped    bool
}