lib

type AdaptiveConcurrencyConfig struct {
	MaxConcurrency                         int
	InitialTarget                          int
	MinTarget                              int
	GrowthCeiling                          int
	GrowthCeilingProbeBytes                int64
	GrowthCeilingProbeSuccesses            int
	GrowthCeilingProbeRate                 float64
	ThroughputFloor                        int
	GrowEvery                              int
	GrowStep                               int
	SqrtGrowth                             bool
	FailureShrinkPercent                   int
	BackPressureShrinkPercent              int
	BackPressurePause                      time.Duration
	ThroughputWindow                       int
	ThroughputMinGainPercent               int
	ThroughputShrinkPercent                int
	ThroughputHoldWindows                  int
	ThroughputProbeMinWindows              int
	ThroughputProbeFloor                   int
	ThroughputProbeFloorRate               float64
	ThroughputProbePlateauTarget           int
	ThroughputProbeMinGainPerTargetPercent float64
	ThroughputProbeLossTolerancePercent    int
	LatencyFloor                           int
	LatencyShrinkPercent                   int
	LatencyQueueHigh                       float64
	LatencyGrowthQueueHigh                 float64
}

type AdaptiveConcurrencyDefaults struct {
	MaxConcurrency int
	InitialTarget  int
}

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

type AdaptiveConcurrencyManagerWithSample interface {
	ConcurrencyManager
	DoneWithSample(AdaptiveConcurrencySample)
}

type AdaptiveConcurrencySample struct {
	Success      bool
	Duration     time.Duration
	Bytes        int64
	StatusCode   int
	BackPressure bool
	RetryAfter   time.Duration
}

type AdaptiveConcurrencySnapshot struct {
	Target                                  int
	Max                                     int
	GrowthCeiling                           int
	GrowthCeilingUnlocked                   bool
	GrowthCeilingProbeSuccessThreshold      int
	Running                                 int
	PeakTarget                              int
	PeakRunning                             int
	SuccessTotal                            int
	FailureTotal                            int
	GrowTotal                               int
	ShrinkTotal                             int
	BackPressureTotal                       int
	RetryAfterTotal                         int
	ThroughputBackoffTotal                  int
	ThroughputProbeMissTotal                int
	ThroughputProbeEfficiencyMissTotal      int
	LatencyBackoffTotal                     int
	LatencyGrowthSuppressionTotal           int
	BytesTotal                              int64
	AverageDuration                         time.Duration
	LastThroughputBytesPerSecond            float64
	BestThroughputBytesPerSecond            float64
	LastThroughputProbeGainPercent          float64
	LastThroughputProbeTargetDelta          int
	LastThroughputProbeGainPerTargetPercent float64
	LastQueueEstimate                       float64
	MinDurationPerByte                      float64
	LastDurationPerByte                     float64
}

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

type AtomicValue[T comparable] struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type Cmd interface {
	SetOut(io.Writer)
	SetErr(newErr io.Writer)
	Run() error
	Args() []string
}

type ConcurrencyManager interface {
	// Wait until a slot is available for the new goroutine.
	Wait()

	// Done Mark a goroutine as finished
	Done()

	// WaitAllDone Wait for all goroutines are done
	WaitAllDone()

	// RunningCount Returns the number of goroutines which are running
	RunningCount() int

	// WaitWithContext Acquires a semaphore to allow a new goroutine to run or returns false if the context is done
	WaitWithContext(ctx context.Context) bool

	// WaitForADone Blocks until at least one goroutine has completed.
	WaitForADone() bool

	// WaitForADoneWithContext blocks until at least one goroutine has completed or returns false if the context is done.
	WaitForADoneWithContext(ctx context.Context) bool
}

type ConcurrencyManagerWithSubWorker interface {
	ConcurrencyManager
	NewSubWorker() ConcurrencyManager
}

type Conn struct {
	net.Conn

	sync.Once
	// contains filtered or unexported fields
}

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

type DecimalOverride struct {
	Key     string // JSON and query key shared by both fields
	Field   string // Go name of the float64 field; the text field is Field + "Decimal"
	Float   *float64
	Decimal **string
}

type DirEntry struct {
	fs.DirEntry
	fs.FileInfo
	// contains filtered or unexported fields
}

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

type ExeCmd struct {
	*exec.Cmd
}

type ExportValues struct {
	url.Values
}

type FSWithContext interface {
	WithContext(ctx context.Context) fs.FS
}

type FileWithContext interface {
	WithContext(ctx context.Context) fs.File
}

type IsDir interface {
	IsDir() bool
}

type IterChan[T any] struct {
	Send      chan T
	SendError chan error

	Error atomic.Value
	Start func(*IterChan[T])
	context.Context
	Stop context.CancelFunc
	// contains filtered or unexported fields
}

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

type LeveledLogger interface {
	Error(string, ...any)
	Warn(string, ...any)
	Info(string, ...any)
	Debug(string, ...any)
	Trace(string, ...any)
}

type LocalFileSystem struct{}

type Logger interface {
	Printf(string, ...any)
}

type Map[T any] struct {
	sync.Map
}

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

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

type NullLogger struct{}

type Params struct {
	Params interface{}
}

type Path struct {
	Path      string
	Separator string
}

type PathSpecArgs struct {
	Src           string
	Dest          string
	PreserveTimes bool
}

type PathSpecEntry struct {
	Dir bool

	Preexisting bool
	Mtime       time.Time
	// contains filtered or unexported fields
}

type PathSpecTest struct {
	Name string
	Args PathSpecArgs
	Dest []PathSpecEntry
	Src  []PathSpecEntry
}

type ProgressWriter struct {
	WriterAndAt
	ProgressWatcher func(int64)
}

type Queue[T any] struct {
	*sync.RWMutex
	// contains filtered or unexported fields
}

type ReadWriteFs interface {
	WritableFs
	fs.FS
}

type ReaderAtCloser interface {
	io.ReaderAt
	io.ReadCloser
}

type Resource struct {
	Path   string
	Params interface{}
	Method string
	Entity UnmarshalJSON
}

type ResourceOut struct {
	Resource
	Values
}

type ResponseError struct {
	StatusCode int

	Response *http.Response
	// contains filtered or unexported fields
}

type S3Error struct {
	XMLName   xml.Name `xml:"Error"`
	Code      string   `xml:"Code"`
	Message   string   `xml:"Message"`
	HostId    string   `xml:"HostId"`
	RequestId string   `xml:"RequestId"`
}

type S3ErrorClassification struct {
	Class     string
	Message   string
	Retryable bool
}

type Signal struct {
	C chan bool
}

type StatefulDirectory interface {
	Chdir(string) error
	Getwd() (string, error)
}

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

type Transport struct {
	*http.Transport
	*net.Dialer
	// contains filtered or unexported fields
}

type UnmarshalJSON interface {
	UnmarshalJSON(data []byte) error
}

type UploadRetryAttempt struct {
	StatusCode int
	Retryable  bool
	RetryAfter time.Duration
	Err        error
}

type Values interface {
	ToValues() (url.Values, error)
	ToJSON() (io.Reader, error)
}

type Walk[T any] struct {
	fs.FS
	Queue[string]
	IterChan[T]
	ConcurrencyManager ConcurrencyManagerWithSubWorker
	// Root is the directory to walk. An empty Root walks the contents of the
	// filesystem root without emitting the root itself; "." or a named Root also
	// emits the root directory when ListDirectories is set.
	Root            string
	WalkFile        func(d fs.DirEntry, path string, err error) (T, error)
	ListDirectories bool
}

type WithContextReader interface {
	WithContext(context.Context) interface{}
	io.Reader
}

type WithContextReaderAt interface {
	WithContext(context.Context) interface{}
	io.ReaderAt
}

type WritableFs interface {
	MkdirAll(string, fs.FileMode) error
	MkdirTemp(dir, pattern string) (string, error)
	TempDir() string
	Create(string) (io.WriteCloser, error)
	RemoveAll(string) error
	Remove(string) error
	PathSeparator() string
	PathJoin(...string) string
	RelPath(parent, child string) (string, error)
	SplitPath(path string) (string, string)
	Chtimes(name string, atime time.Time, mtime time.Time) error
}

type WriterAndAt interface {
	io.WriterAt
	io.Writer
	io.Closer
}