specs

type Appender interface {
	AppendFunc2(f DecoratorFunc, offset ...int)
	AppendDecorator2(f DecoratorDefinition, offset ...int)
}

type BarBaseConfiguration interface {
	ProgressConfiguration
	GetConfig() BarConfig
	GetWidth() uint
	GetPending() string
}

type BarBaseDefinition[T any] struct {
	ProgressDefinition[T]
	// contains filtered or unexported fields
}

type BarBaseInterface[V any] interface {
	ProgressInterface
	CompletedPercent
	Current() V
}

type BarBaseSpecification[T any] interface {
	ProgressSpecification[T]
	AppendCompleted(offset ...int) T
	PrependCompleted(offset ...int) T

	SetPending(m string) T
	SetWidth(w uint) T
	SetConfig(c BarConfig) T
	SetPredefined(i int) T
	SetBrackets(c Brackets) T
	SetBracketType(i int) T
	SetHead(c rune) T
	SetEmpty(c rune) T
	SetFill(c rune) T
	SetLeftEnd(c rune) T
	SetRightEnd(c rune) T
}

type BarConfig struct {
	// Fill is the default character representing completed progress
	Fill rune
	// Head is the default character that moves when progress is updated
	Head rune
	// Empty is the default character that represents the empty progress
	Empty rune
	// LeftEnd is the default character in the left most part of the progress indicator
	LeftEnd rune
	// RightEnd is the default character in the right most part of the progress indicator
	RightEnd rune
}

type BarConfiguration[T any] interface {
	BarBaseConfiguration
	GetTotal() int
}

type BarDefinition[T any] struct {
	BarBaseDefinition[T]
	// contains filtered or unexported fields
}

type BarInterface interface {
	BarBaseInterface[int]
	SetTotal(m int)

	Set(n int) bool
	Incr() bool
}

type BarSpecification[T any] interface {
	BarBaseSpecification[T]

	SetTotal(v int) T
}

type Brackets struct {
	// LeftEnd is the default character in the left most part of the progress indicator
	LeftEnd rune
	// RightEnd is the default character in the right most part of the progress indicator
	RightEnd rune
}

type CompletedPercent interface {
	CompletedPercent() float64
}

type Container = types.Container

type Cycle[T any] struct {
	// contains filtered or unexported fields
}

type DecoratorDefinition interface {
	CreateDecorator(e ElementState) types.Decorator
}

type DecoratorFunc = types.DecoratorFunc

type ElementConfiguration interface {
	// GetFinal gets a text message shown instead of the
	// text window after the action has been finished.
	GetFinal() string
	GetHideOnClose() bool
	GetHide() bool
}

type ElementDefinition[T any] struct {
	// contains filtered or unexported fields
}

type ElementInterface = types.Element

type ElementSpecification[T any] interface {
	// SetFinal sets a text message shown instead of the
	// text window after the action has been finished.
	SetFinal(string) T
	// HideOnClose will request to hide the element
	// when it is closed.
	HideOnClose(...bool) T

	// Hide will request to initially hide the element.
	Hide(...bool) T
}

type ElementState = types.ElementState

type EstimatedConfiguration interface {
	BarBaseConfiguration
	GetTotal() time.Duration
}

type EstimatedDefinition[T any] struct {
	BarBaseDefinition[T]
	// contains filtered or unexported fields
}

type EstimatedInterface interface {
	BarBaseInterface[time.Duration]

	Total() time.Duration
	TimeEstimated() time.Duration

	IsFinished() bool
	Set(n time.Duration) bool
}

type EstimatedSpecification[T any] interface {
	BarBaseSpecification[T]
	SetTotal(v time.Duration) T
}

type FollowupGapProvider interface {
	GetFollowUpGap() string
}

type GapProvider interface {
	GetGap() string
}

type GroupBaseConfiguration interface {
	GetFollowUpGap() string
	GetGap() string
	IsHideOnClose() bool
}

type GroupBaseDefinition[T any] struct {
	// contains filtered or unexported fields
}

type GroupBaseInterface interface {
	Container
	HideOnClose(b ...bool)
	Hide(b ...bool)
}

type GroupBaseSpecification[T any] interface {
	SetGap(string) T
	SetFollowUpGap(string) T
	HideOnClose(b ...bool) T
}

type GroupConfiguration[E ProgressInterface] interface {
	GroupBaseConfiguration

	// GetProgress provides the main group progress indicator.
	GetProgress() GroupProgressElementDefinition[E]
}

type GroupDefinition[T any, E ProgressInterface] struct {
	GroupBaseDefinition[T]
	// contains filtered or unexported fields
}

type GroupInterface interface {
	Container
	ElementInterface
}

type GroupNotifier interface {
	Add(e ProgressInterface, o any)
	Done(e ProgressInterface, o any)
}

type GroupProgressElementDefinition[E ProgressInterface] interface {
	types.ElementDefinition[E]
	GetGroupNotifier() GroupNotifier
}

type GroupSpecification[T any] interface {
	GroupBaseSpecification[T]
}

type LineBarConfiguration[T any] interface {
	ProgressConfiguration
	IsResetOnFinished() bool
	GetPending() string
	GetTotal() T
}

type LineBarDefinition[T, V any] struct {
	ProgressDefinition[T]
	// contains filtered or unexported fields
}

type LineBarInterface interface {
	BarBaseInterface[int]
	SetTotal(m int)

	Set(n int) bool
	Incr() bool
}

type LineBarSpecification[T, V any] interface {
	ProgressSpecification[T]
	AppendCompleted(offset ...int) T
	PrependCompleted(offset ...int) T
	ResetOnFinished(b ...bool) T
	SetPending(m string) T
	SetTotal(v V) T
}

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

type NestedStepsConfiguration interface {
	GroupBaseConfiguration
	BarBaseConfiguration
	GetSteps() []NestedStep
	IsShowStepTitle() bool
}

type NestedStepsDefinition[T any] struct {
	BarBaseDefinition[T]
	GroupBaseDefinition[T]
	// contains filtered or unexported fields
}

type NestedStepsInterface interface {
	ProgressInterface
	Incr() (ElementInterface, error)
	Current() ElementInterface
}

type NestedStepsSpecification[T any] interface {
	BarBaseSpecification[T]
	GroupBaseSpecification[T]
	SetSteps(steps []NestedStep) T
	ShowStepTitle(b ...bool) T
}

type Phases interface {
	Incr()
	Get() ttycolors.String
}

type Prepender interface {
	PrependFunc2(f DecoratorFunc, offset ...int)
	PrependDecorator2(f DecoratorDefinition, offset ...int)
}

type ProgressConfiguration interface {
	ElementConfiguration
	GetTick() bool
	IsAutoClose() bool

	GetColor() ttycolors.Format
	GetProgressColor() ttycolors.Format
	GetPrependDecorators() []DecoratorDefinition
	GetAppendDecorators() []DecoratorDefinition
	GetMinVisualizationColumn() int
}

type ProgressDefinition[T any] struct {
	ElementDefinition[T]
	// contains filtered or unexported fields
}

type ProgressInterface = types.ProgressElement

type ProgressSpecification[T any] interface {
	ElementSpecification[T]

	// SetAutoClose enables/disabled automatic closeing
	// the element when Update indicates finished.
	SetAutoClose(b ...bool) T

	// SetColor set the color used for the progress line.
	SetColor(col ...ttycolors.FormatProvider) T

	// SetProgressColor set the color used for the progress visualization.
	SetProgressColor(col ...ttycolors.FormatProvider) T

	// SetDecoratorFormat set the output format for the next decorator.
	SetDecoratorFormat(col ...ttycolors.FormatProvider) T

	// SetMinVisualizationColumn sets the minimal column for the visualization,
	SetMinVisualizationColumn(int) T

	// AppendFunc adds a function providing some text appended
	// to the basic progress indicator.
	// If there are implicit settings, the offset can be used to
	// specify the index in the list of functions.
	AppendFunc(f DecoratorFunc, offset ...int) T

	// PrependFunc adds a function providing some text prepended
	// to the basic progress indicator.
	// If there are implicit settings, the offset can be used to
	// specify the index in the list of functions.
	PrependFunc(f DecoratorFunc, offset ...int) T

	// AppendDecorator adds a definition providing some text appended
	// to the basic progress indicator.
	// If there are implicit settings, the offset can be used to
	// specify the index in the list of functions.
	AppendDecorator(f DecoratorDefinition, offset ...int) T

	// PrependDecorator adds a definition providing some text prepended
	// to the basic progress indicator.
	// If there are implicit settings, the offset can be used to
	// specify the index in the list of functions.
	PrependDecorator(f DecoratorDefinition, offset ...int) T

	// AppendElapsed appends the elapsed time of the action
	// or the duration of the action if the element is already closed.
	AppendElapsed(offset ...int) T

	// PrependElapsed appends the elapsed time of the action
	// or the duration of the action if the element is already closed.
	PrependElapsed(offset ...int) T

	// AppendMessage appends text to the progress indicator.
	AppendMessage(m string, offset ...int) T

	// PrependMessage prepends text to the beginning of the indicator
	PrependMessage(m string, offset ...int) T
	// contains filtered or unexported methods
}

type ScrollingSpinnerConfiguration = SpinnerConfiguration

type ScrollingSpinnerDefinition[T any] struct {
	ProgressDefinition[T]
	// contains filtered or unexported fields
}

type ScrollingSpinnerInterface interface {
	ProgressInterface
}

type ScrollingSpinnerSpecification[T any] interface {
	ProgressSpecification[T]
	SetDone(string) T
}

type Self[T any] interface {
	Self() T
}

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

type SpinnerConfiguration interface {
	ProgressConfiguration
	GetPending() string
	GetDone() string
	GetSpeed() int
	GetPhases() Phases
}

type SpinnerDefinition[T any] struct {
	ProgressDefinition[T]
	// contains filtered or unexported fields
}

type SpinnerInterface interface {
	ProgressInterface
}

type SpinnerSpecification[T any] interface {
	ProgressSpecification[T]
	SetPredefined(i int) T
	SetSpeed(v int) T
	SetSimplePhases(p ...string) T
	SetFormattedPhases(p ...ttycolors.String) T
	SetPhases(p Phases) T
	SetDone(string) T
}

type StepsConfiguration interface {
	BarConfiguration[time.Duration]
	GetSteps() []string
}

type StepsDefinition[T any] struct {
	BarBaseDefinition[T]
	// contains filtered or unexported fields
}

type StepsInterface interface {
	BarInterface
	GetCurrentStep() string
}

type StepsSpecification[T any] interface {
	BarBaseSpecification[T]
	SetSteps(steps []string) T
	AppendStep() T
	PrependStep() T
}

type TextConfiguration interface {
	ElementConfiguration
	TitleLineProvider
	GapProvider
	FollowupGapProvider
	ViewFormatProvider
	TitleFormatProvider
	GetView() int
	GetAuto() bool
}

type TextDefinition[T any] struct {
	ElementDefinition[T]
	// contains filtered or unexported fields
}

type TextInterface interface {
	ElementInterface
	io.Writer
}

type TextSpecification[T any] interface {
	ElementSpecification[T]
	SetGap(v string) T

	// SetFollowUpGap provides a prefix for the second and following lines.
	// It could be used together with SetTitleLine.
	SetFollowUpGap(v string) T
	SetTitleLine(v string) T
	SetViewFormat(f ...ttycolors.FormatProvider) T
	SetTitleFormat(f ...ttycolors.FormatProvider) T
	SetAuto(b ...bool) T
	SetView(int) T
}

type TextSpinnerConfiguration interface {
	SpinnerConfiguration
	FollowupGapProvider
	ViewFormatProvider
	GetView() int
}

type TextSpinnerDefinition[T any] struct {
	SpinnerDefinition[T]
	// contains filtered or unexported fields
}

type TextSpinnerInterface interface {
	SpinnerInterface
	TextInterface
}

type TextSpinnerSpecification[T any] interface {
	SpinnerSpecification[T]
	SetView(view int) T
	SetFollowUpGap(gap string) T
	SetViewFormat(f ...ttycolors.FormatProvider) T
}

type TitleFormatProvider interface {
	GetTitleFormat() ttycolors.Format
}

type TitleLineProvider interface {
	GetTitleLine() string
}

type VariableProvider interface {
	GetVariable(name string) any
}

type ViewFormatProvider interface {
	GetViewFormat() ttycolors.Format
}

type VoidGroupNotifier struct{}