s3iot

type BucketKeyer interface {
	BucketKey() (_, _ string)
}

type DefaultDownloadSlicerFactory struct {
	PartSize int64
}

type DefaultUploadSlicerFactory struct {
	PartSize       int64
	MaxUploadParts int
}

type DoneNotifier interface {
	// Done returns a channel which will be closed after complete.
	Done() <-chan struct{}
}

type DownloadContext interface {
	// Result reutrns the upload status or error.
	Status() (DownloadStatus, error)
	// Result reutrns the upload result or error.
	Result() (DownloadOutput, error)

	Pauser
	DoneNotifier
}

type DownloadInput struct {
	Bucket    *string
	Key       *string
	VersionID *string
}

type DownloadOutput struct {
	ContentType  *string
	ETag         *string
	LastModified *time.Time
	VersionID    *string
}

type DownloadSlicer interface {
	NextWriter() (io.WriterAt, contentrange.Range)
}

type DownloadSlicerFactory interface {
	New(io.WriterAt) DownloadSlicer
}

type DownloadStatus struct {
	Status
	DownloadOutput
}

type Downloader struct {
	UpDownloaderBase

	DownloadSlicerFactory DownloadSlicerFactory
}

type DownloaderOption interface {
	ApplyToDownloader(*Downloader)
}

type DownloaderOptionFn func(*Downloader)

type ErrorClassifier interface {
	IsRetryable(error) bool
	IsThrottle(error) (time.Duration, bool)
}

type ExponentialBackoffRetryerFactory struct {
	WaitBase time.Duration
	WaitMax  time.Duration
	RetryMax int
}

type NaiveErrorClassifier struct{}

type NoRetryerFactory struct{}

type PauseOnFailRetryerFactory struct {
	Base RetryerFactory
}

type Pauser interface {
	Pause()
	Resume()
}

type ReadInterceptor interface {
	Reader(io.ReadSeeker) io.ReadSeeker
}

type ReadInterceptorFactory interface {
	New() ReadInterceptor
}

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

type Retryer interface {
	OnFail(ctx context.Context, id int64, err error) bool
	OnSuccess(id int64)
}

type RetryerFactory interface {
	New(Pauser) Retryer
}

type RetryerHookFactory struct {
	Base    RetryerFactory
	OnError func(bucket, key string, err error)
}

type Status struct {
	Size          int64
	CompletedSize int64
	NumRetries    int
	Paused        bool
}

type UpDownloaderBase struct {
	API             s3api.UpDownloadAPI
	RetryerFactory  RetryerFactory
	ErrorClassifier ErrorClassifier
	ForcePause      bool
}

type UpDownloaderOption interface {
	UploaderOption
	DownloaderOption
}

type UpDownloaderOptionFn func(*UpDownloaderBase)

type UploadContext interface {
	// Result reutrns the upload status or error.
	Status() (UploadStatus, error)
	// Result reutrns the upload result or error.
	Result() (UploadOutput, error)

	Pauser
	DoneNotifier
}

type UploadInput struct {
	Bucket      *string
	Key         *string
	ACL         *string
	Body        io.Reader
	ContentType *string
}

type UploadOutput struct {
	VersionID *string
	ETag      *string
	Location  *string
}

type UploadSlicer interface {
	Len() int64
	NextReader() (io.ReadSeeker, func(), error)
}

type UploadSlicerFactory interface {
	New(io.Reader) (UploadSlicer, error)
}

type UploadStatus struct {
	Status

	UploadID string
}

type Uploader struct {
	UpDownloaderBase

	UploadSlicerFactory    UploadSlicerFactory
	ReadInterceptorFactory ReadInterceptorFactory
}

type UploaderOption interface {
	ApplyToUploader(*Uploader)
}

type UploaderOptionFn func(*Uploader)

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

type WaitReadInterceptorOption func(*WaitReadInterceptorFactory)