cumulus

type Account interface {
	fmt.Stringer
	InRegion(region string) RegionalAccount
	Name() string
	Fielder
	AccountInfoer
}

type AccountInfo interface {
	Common
	Account() Account
	Ctx() context.Context
	Name() string
	ID() string
}

type AccountInfoer interface {
	AccountInfos(context.Context) chan AccountInfo
}

type Accounts []Account

type Common interface {
	Fielder
	Sourcer
	Ctx() context.Context
}

type ErrorCollector struct {
	Error error
}

type ErrorHandler func(ctx context.Context, err error)

type FieldBuilder struct {
	Fields Fields
}

type FieldFilter interface {
	Accept(meta FieldMeta) bool
}

type FieldMeta struct {
	Kind          FieldType
	Name          string
	DefaultHidden bool
}

type FieldType int

type FieldValue struct {
	Values set.Set[string]
}

type Fielder interface {
	GetFields(builder IFieldBuilder)
}

type Fields map[FieldMeta]*FieldValue

type FieldsAccumulator struct {
	Lines []Fields
	// contains filtered or unexported fields
}

type ID string

type IFieldBuilder interface {
	Who(name, value string, options ...MetadataOption) *FieldBuilder
	What(name, value string, options ...MetadataOption) *FieldBuilder
	Where(name, value string, options ...MetadataOption) *FieldBuilder
	When(name string, t time.Time, options ...MetadataOption) *FieldBuilder
	How(name, value string, options ...MetadataOption) *FieldBuilder
	Why(name, value string, options ...MetadataOption) *FieldBuilder

	Tag(name, value string, options ...MetadataOption) *FieldBuilder

	GID(value string) *FieldBuilder
	Name(value string) *FieldBuilder
	Description(value string) *FieldBuilder
	Done()
}

type Instance interface {
	Common
	Id() ID
}

type Instancer interface {
	Instances(context.Context) chan Instance
}

type LineFilter func(fields Fields) bool

type MachineImage interface {
	Common
}

type MachineImager interface {
	MachineImages(context.Context) chan MachineImage
}

type MetadataOption func(meta FieldMeta) FieldMeta

type NameRecord interface {
	Common
	Ctx() context.Context
	Id() ID
}

type NameRecorder interface {
	NameRecords(context.Context) chan NameRecord
}

type Provider[T any] func(ctx context.Context) chan T

type ProviderMethod[T Fielder] func(p Provider[T], ctx context.Context) chan T

type RegionalAccount interface {
	Account
	Region() string
}

type RegionalAccounts []RegionalAccount

type Snapshot interface {
	Common
	Id() ID
	Delete(ctx context.Context, dryRun bool) error
}

type Snapshoter interface {
	Snapshots(context.Context) chan Snapshot
}

type Sourcer interface {
	Source() Fielder
}

type Subscription interface {
	Common
}

type Subscriptioner interface {
	Subscriptions(context.Context) chan Subscription
}

type Topic interface {
	Common
}

type Topicer interface {
	Topics(context.Context) chan Topic
}

type Volume interface {
	Common
}

type Volumer interface {
	Volumes(context.Context) chan Volume
}

type Zone interface {
	Common
	Ctx() context.Context
	Id() ID
}

type Zoner interface {
	Zones(context.Context) chan Zone
}