file

type AdaptiveTransferDefaults struct {
	MaxConcurrency int
	InitialTarget  int
}

type ByteOffset struct {
	PartSizes         []int64
	OverrideChunkSize int64
}

type Client struct {
	files_sdk.Config
}

type DeleteEmptySourceFolders struct {
	direction.Direction
	Config files_sdk.Config
}

type DeleteSource struct {
	direction.Direction
	Config files_sdk.Config
}

type DirEntryError struct {
	DirEntries []goFs.DirEntry
	// contains filtered or unexported fields
}

type DirectionalTransferStats struct {
	Upload   TransferStats
	Download TransferStats
}

type DownloadParts struct {
	context.CancelFunc
	context.Context

	fs.File
	fs.FileInfo
	lib.WriterAndAt

	CloseError error
	files_sdk.Config

	*sync.RWMutex
	// contains filtered or unexported fields
}

type DownloadStatus struct {
	fs.FS
	fs.FileInfo

	DownloadedBytes int64

	TmpPath     string
	Sync        bool
	NoOverwrite bool

	Mutex         *sync.RWMutex
	PreserveTimes bool

	status.Changes
	// contains filtered or unexported fields
}

type DownloadUri string

type DownloadUriValid struct {
	*url.URL
	time.Time
	Remaining time.Duration
}

type DownloadV2TargetClassifier func(downloadURI string) TransferV2TargetClass

type DownloaderParams struct {
	// Ignore gitignore formatted pattern
	Ignore []string
	// Include gitignore formatted pattern
	Include       []string
	RemotePath    string
	RemoteFile    files_sdk.File
	LocalPath     string
	TempPath      string // Folder path where the file(s) will be downloaded to before being moved to LocalPath. If not set, the file(s) will be downloaded directly to LocalPath.
	Sync          bool
	PreserveTimes bool
	NoOverwrite   bool
	// SyncAfterActions optionally run source cleanup/move actions after sync comparison.
	SyncAfterActions SyncAfterActions
	RetryPolicy
	*manager.Manager
	EventsReporter

	DryRun             bool
	PriorJobCheckpoint *JobDownloadCheckpoint
	ResumeTmpPath      string // Full path to the temp file from a prior paused download session.
	// AdaptiveConcurrency enables opt-in download V2 adaptive range concurrency.
	AdaptiveConcurrency bool
	// AdaptiveConcurrencyUseSDKDefaultCaps uses SDK V2 caps instead of treating an
	// explicitly supplied Manager as an isolation boundary.
	AdaptiveConcurrencyUseSDKDefaultCaps bool
	// AdaptiveDownloadV2TargetClassifier optionally overrides the SDK's download
	// V2 target classifier. Custom targets use default SDK transfer behavior but
	// keep separate adaptive manager cache entries and telemetry target labels.
	AdaptiveDownloadV2TargetClassifier DownloadV2TargetClassifier
	// AdaptiveDownloadV2TuningSet applies V2 tuning overrides below.
	// When false, V2 uses built-in defaults.
	AdaptiveDownloadV2TuningSet bool
	// AdaptiveDownloadV2Tuning holds opt-in V2 transfer tuning.
	AdaptiveDownloadV2Tuning UploadV2Tuning
	// ZipBatch controls batched small-file downloads through the ZIP download endpoint.
	ZipBatch ZipBatchParams
	// contains filtered or unexported fields
}

type Entity struct {
	fs.File
	fs.FS
	// contains filtered or unexported fields
}

type EventsReporter map[status.Status][]reporterSettings

type FS struct {
	files_sdk.Config
	context.Context
	Root string
	// contains filtered or unexported fields
}

type File struct {
	*files_sdk.File
	*FS
	ReadCloser lib.AtomicValue[io.ReadCloser]

	MaxConnections int

	SizeTrust
	// contains filtered or unexported fields
}

type IFile interface {
	SetStatus(status.Status, error)
	StatusChanges() status.Changes
	TransferBytes() int64
	IncrementTransferBytes(int64)
	File() filesSDK.File
	Size() int64
	Id() string
	LocalPath() string
	RemotePath() string
	Status() status.Status
	EndedAt() time.Time
	StartedAt() time.Time
	Err() error
	Job() *Job
}

type Info struct {
	files_sdk.File
	// contains filtered or unexported fields
}

type Iter struct {
	*folder.Iter
}

type Iterator func() (OffSet, Iterator, int)

type Job struct {
	Id string
	*timer.Timer
	Statuses  []IFile
	Direction direction.Direction

	LocalPath  string
	RemotePath string
	Sync       bool
	CodeStart  func()
	context.CancelFunc

	Params interface{}
	Client interface{}
	Config filesSDK.Config
	EventsReporter
	directory.Type
	*manager.Manager
	RetryPolicy    interface{}
	Ignore         *ignore.GitIgnore
	Include        *ignore.GitIgnore
	CompletedPaths map[string]struct{}
	Started        *lib.Signal
	Finished       *lib.Signal
	Canceled       *lib.Signal
	Scanning       *lib.Signal
	EndScanning    *lib.Signal
	retryablehttp.Logger
	RemoteFs fs.FS
	*lib.Meter
	// contains filtered or unexported fields
}

type JobDownloadCheckpoint struct {
	CompletedPaths []string
}

type JobFile struct {
	StatusName          string          `json:"status"`
	TransferBytes       int64           `json:"transferred_bytes"`
	Size                int64           `json:"size_bytes"`
	LocalPath           string          `json:"local_path"`
	RemotePath          string          `json:"remote_path"`
	CheckpointResumable UploadResumable `json:"-"`
	TmpPath             string          `json:"-"`
	EndedAt             time.Time       `json:"completed_at"`
	StartedAt           time.Time       `json:"started_at"`
	Err                 error           `json:"error"`
	Id                  string          `json:"-"`
	Attempts            int             `json:"attempts"`
	Mutex               *sync.RWMutex   `json:"-"`
	status.Status       `json:"-"`
	filesSDK.File       `json:"-"`
	*Job                `json:"-"`
}

type JobUploadCheckpoint struct {
	CompletedPaths []string
	PendingParts   map[string]UploadResumable // local path → partial upload
}

type Len interface {
	Len() int
}

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

type MoveSource struct {
	direction.Direction
	Path   string
	Config files_sdk.Config
}

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

type Part struct {
	OffSet
	files_sdk.EtagsParam

	context.Context
	context.CancelFunc
	*sync.RWMutex

	files_sdk.FileUploadPart
	ProxyReader
	// contains filtered or unexported fields
}

type PartRunnerReturn int

type Parts []*Part

type PossibleSize interface {
	PossibleSize() int64
}

type Progress func(int64)

type ProxyRead struct {
	io.Reader
	// contains filtered or unexported fields
}

type ProxyReader interface {
	io.ReadCloser
	Len() int
	BytesRead() int64
	ReadDuration() time.Duration
	Rewind() bool
}

type ProxyReaderAt struct {
	io.ReaderAt
	// contains filtered or unexported fields
}

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

type ReadAtLeastWrapper struct {
	io.ReadCloser
	io.Reader
}

type ReadDirFile struct {
	*File
	// contains filtered or unexported fields
}

type ReadWrapper struct {
	io.ReadCloser
	// contains filtered or unexported fields
}

type ReaderCloserDownloadStatus struct {
	*ReadWrapper

	UntrustedSizeRangeRequestSize
	// contains filtered or unexported fields
}

type ReaderRange interface {
	ReaderRange(off int64, end int64) (io.ReadCloser, error)
	goFs.File
}

type RecursiveItem struct {
	files_sdk.File
	// contains filtered or unexported fields
}

type Reporter func(JobFile)

type RetryPolicy struct {
	Type       RetryPolicyType
	RetryCount int
	Backoff    int
}

type RetryPolicyType string

type SizeTrust int

type Subscriptions struct {
	Started     chan time.Time
	Finished    chan time.Time
	Canceled    chan time.Time
	Scanning    chan time.Time
	EndScanning chan time.Time
}

type SyncAfterActions struct {
	DeleteSourceFiles        bool
	DeleteSourceEmptyFolders bool
	// MoveSource is the destination path/root for moving synced source files after sync.
	MoveSource string
	// Log receives validation and cleanup action results. If nil, this helper cannot report those errors.
	Log func(status.Log, error)
}

type TransferStats = manager.TransferStats

type TransferV2TargetClass string

type UntrustedSize interface {
	UntrustedSize() bool
	SizeTrust() SizeTrust
	goFs.FileInfo
}

type UntrustedSizeRangeRequestSize struct {
	ExpectedSize int64
	SentSize     int64
	ReceivedSize int64
	Status       string
}

type UnwrappedError struct {
	OriginalError error
	// contains filtered or unexported fields
}

type UploadOption func(uploadIO) (uploadIO, error)

type UploadResumable struct {
	files_sdk.FileUploadPart
	Parts
	files_sdk.File
	TargetClass TransferV2TargetClass
}

type UploadStatus struct {
	Sync        bool
	NoOverwrite bool
	Uploader
	UploadResumable
	Mutex *sync.RWMutex

	status.Changes
	// contains filtered or unexported fields
}

type UploadV2TargetClassifier func(files_sdk.FileUploadPart) TransferV2TargetClass

type UploadV2Tuning struct {
	// InitialTarget is the starting adaptive concurrency target for all transfer targets.
	InitialTarget int
	// GrowthCeiling is the soft concurrency ceiling before throughput-guided probing.
	GrowthCeiling int
	// S3InitialTarget is the starting adaptive concurrency target for S3 uploads.
	S3InitialTarget int
	// S3AdaptiveFloor is the lowest adaptive target the S3 controller should shrink toward.
	S3AdaptiveFloor int
	// S3GrowEvery is the number of successful part samples required before a normal growth step.
	S3GrowEvery int
	// S3GrowStep is the number of additional concurrent part slots added during normal growth.
	S3GrowStep int
	// S3ThroughputWindow is the number of recent part samples used for throughput decisions.
	S3ThroughputWindow int
	// S3ThroughputMinGainPercent is the required throughput improvement for normal growth.
	S3ThroughputMinGainPercent int
	// S3ThroughputProbeMinWindows is the number of missed probe windows before backing off.
	S3ThroughputProbeMinWindows int
	// S3ThroughputProbeFloor is the fast-link target floor used when measured throughput is high.
	S3ThroughputProbeFloor int
	// S3ThroughputProbeFloorRateBytesPerSecond is the measured throughput required to use the probe floor.
	S3ThroughputProbeFloorRateBytesPerSecond int64
	// S3ThroughputProbePlateau is the target used as the first high-throughput probe plateau.
	S3ThroughputProbePlateau int
	// S3ThroughputShrinkPercent is the percent to shrink the target after throughput regression.
	S3ThroughputShrinkPercent int
	// S3ThroughputHoldWindows is the number of throughput windows to hold after a shrink.
	S3ThroughputHoldWindows int
	// S3ThroughputProbeMinGainPerTargetPercent is the minimum gain required per extra target above the plateau.
	S3ThroughputProbeMinGainPerTargetPercent float64
	// S3ThroughputProbeLossTolerancePercent is the tolerated throughput loss while probing above the plateau.
	S3ThroughputProbeLossTolerancePercent int
	// S3GrowthCeiling is the soft concurrency ceiling before large-workload probing unlocks higher targets.
	S3GrowthCeiling int
	// S3GrowthCeilingProbeBytes is the workload size required before probing above the soft ceiling.
	S3GrowthCeilingProbeBytes int64
	// S3GrowthCeilingProbeSuccesses is the successful part count required before probing above the soft ceiling.
	S3GrowthCeilingProbeSuccesses int
	// S3GrowthCeilingProbeRateBytesPerSecond is the throughput required before probing above the soft ceiling.
	S3GrowthCeilingProbeRateBytesPerSecond int64
	// S3LatencyQueueHigh is the observed queue/latency threshold that triggers backoff.
	S3LatencyQueueHigh float64
	// S3LatencyGrowthQueueHigh is the queue/latency threshold that suppresses further growth.
	S3LatencyGrowthQueueHigh float64
	// S3PartSizeMiB forces the known-size S3 part size in MiB. Zero uses the planner.
	S3PartSizeMiB int64
	// S3WorkloadBytes overrides the aggregate upload job size used by the workload-aware planner.
	S3WorkloadBytes int64
	// S3WorkloadTargetPartMultiplier sets desired planned parts per initial target for workload sizing.
	S3WorkloadTargetPartMultiplier int
	// S3WorkloadMinPartSizeMiB sets the minimum workload-tuned S3 part size in MiB.
	S3WorkloadMinPartSizeMiB int64
	// S3WorkloadScanWaitMillis is how long a job may wait for directory scanning before sizing from estimates.
	S3WorkloadScanWaitMillis int
}

type Uploader interface {
	UploadWithResume(...UploadOption) (UploadResumable, error)
	Find(files_sdk.FileFindParams, ...files_sdk.RequestResponseOption) (files_sdk.File, error)
	CreateFolder(files_sdk.FolderCreateParams, ...files_sdk.RequestResponseOption) (files_sdk.File, error)
}

type UploaderParams struct {
	// Ignore gitignore formatted pattern
	Ignore []string
	// Include gitignore formatted pattern
	Include []string
	// Sync compare destination and only upload if different or non-existent.
	Sync bool
	// LocalPaths files or directories to upload.
	LocalPaths []string
	// LocalPath a file or directory to recursively upload.
	LocalPath string
	// RemotePath destination path for files.com, formatted `/` path separator.
	RemotePath string
	// DryRun see what files would be uploaded.
	DryRun bool
	// NoOverwrite do not overwrite existing files.
	NoOverwrite bool
	// SyncAfterActions optionally run source cleanup/move actions after sync comparison.
	SyncAfterActions SyncAfterActions
	// PriorResumable restores mid-upload state so the upload continues from where it left off.
	PriorResumable UploadResumable
	// PriorJobCheckpoint restores folder-level upload state on resume.
	PriorJobCheckpoint *JobUploadCheckpoint
	// RetryPolicy config for retrying errored uploads.
	RetryPolicy
	// EventsReporter log file events
	EventsReporter
	// Manager limit concurrency
	*manager.Manager
	*Job

	PreserveTimes bool
	// AdaptiveConcurrency explicitly opts this upload job into the upload V2
	// engine. Existing SDK callers remain on the V1 path unless this is true.
	// Any configured concurrent connection limit is used as a maximum cap, not
	// a fixed target.
	AdaptiveConcurrency bool
	// AdaptiveConcurrencyUseSDKDefaultCaps keeps SDK V2 concurrency caps and
	// shared adaptive learning when Manager is present only for job scheduling.
	// When false and Manager is provided, V2 treats that Manager as an explicit
	// isolated cap.
	AdaptiveConcurrencyUseSDKDefaultCaps bool
	// AdaptiveUploadV2TargetClassifier optionally overrides the SDK's upload V2
	// target classifier. Custom targets use default SDK transfer behavior but
	// keep separate adaptive manager cache entries and telemetry target labels.
	AdaptiveUploadV2TargetClassifier UploadV2TargetClassifier
	// AdaptiveUploadReadyRunwaySet applies the ready-runway values below. When
	// false, V2 uses its built-in defaults.
	AdaptiveUploadReadyRunwaySet bool
	// AdaptiveUploadReadyRunwayParts controls how many upload parts V2 may
	// prepare ahead of admitted HTTP concurrency. Zero disables the runway.
	AdaptiveUploadReadyRunwayParts int
	// AdaptiveUploadReadyRunwayBytes caps the extra queued bytes for prepared
	// runway parts. Zero leaves queued runway bytes uncapped.
	AdaptiveUploadReadyRunwayBytes int64
	// AdaptiveUploadV2TuningSet applies V2 tuning overrides below.
	// When false, V2 uses built-in defaults.
	AdaptiveUploadV2TuningSet bool
	// AdaptiveUploadV2Tuning holds opt-in V2 transfer tuning.
	AdaptiveUploadV2Tuning UploadV2Tuning
	// contains filtered or unexported fields
}

type WritableFile struct {
	*Client
	*FS

	*bytes.Buffer
	// contains filtered or unexported fields
}

type ZipBatchExtractionMode string

type ZipBatchParams struct {
	// Disabled turns ZIP batching off entirely.
	Disabled bool
	// Extraction selects spool or stream extraction. Empty uses the SDK default.
	Extraction ZipBatchExtractionMode
	// EligibleSize is the exclusive per-file size ceiling for ZIP batching. Zero uses the SDK default.
	EligibleSize int64
	// MinFiles is the number of eligible small files required before ZIP batching engages. Zero uses the SDK default.
	MinFiles int
	// MaxFiles is the maximum dynamic or pinned file count in one ZIP batch. Zero uses the SDK default.
	MaxFiles int
	// BatchSize pins the number of files per ZIP batch. Zero uses dynamic growth.
	BatchSize int
	// MaxBytes is the maximum listed file bytes in one ZIP batch. Zero uses the SDK default.
	MaxBytes int64
	// ConcurrentBatches is the maximum number of ZIP streams in flight. Zero uses the SDK default.
	ConcurrentBatches int
	// MinAdvantage is the required ZIP/per-file speedup before committing to ZIP batching. Zero uses the SDK default; negative disables probing and batches unconditionally after MinFiles.
	MinAdvantage float64
	// ReprobeInterval is the delay before re-testing ZIP after a dissolve verdict. Zero uses the SDK default; negative disables re-probing.
	ReprobeInterval time.Duration
}

type ZipBatchStatsSnapshot struct {
	// BatchesDispatched is the number of ZIP batches admitted for download.
	BatchesDispatched int64
	// BatchFiles is the number of files originally assigned to dispatched ZIP batches.
	BatchFiles int64
	// BatchesDissolved is the number of below-gate or below-MinFiles remainders sent to per-file downloads.
	BatchesDissolved int64
	// DissolvedFiles is the number of files in dissolved batches.
	DissolvedFiles int64
	// CreateRequests is the number of ZIP create POST requests, including 422 shrink retries.
	CreateRequests int64
	// StreamAttempts is the number of ZIP stream download attempts.
	StreamAttempts int64
	// StreamFailures is the number of corrupt or failed ZIP stream attempts.
	StreamFailures int64
	// CleanFinalized is the number of files finalized from clean ZIP extraction.
	CleanFinalized int64
	// SalvageFinalized is the number of files finalized from corrupt-spool salvage.
	SalvageFinalized int64
	// FallbackCreateError is the number of files falling back after ZIP create failures.
	FallbackCreateError int64
	// FallbackTripwire is the number of files falling back after correctness tripwires.
	FallbackTripwire int64
	// FallbackRetriesExhausted is the number of files falling back after ZIP retries are exhausted.
	FallbackRetriesExhausted int64
	// FallbackMissingEntry is the number of files falling back because the ZIP omitted expected entries.
	FallbackMissingEntry int64
	// ProbeZipFiles is the number of probe files routed through ZIP batches.
	ProbeZipFiles int64
	// ProbePerFileFiles is the number of probe files routed through per-file downloads.
	ProbePerFileFiles int64
	// ProbeZipRateMilli is measured ZIP probe throughput in files/sec multiplied by 1000.
	ProbeZipRateMilli int64
	// ProbePerFileRateMilli is measured per-file probe throughput in files/sec multiplied by 1000.
	ProbePerFileRateMilli int64
	// ProbeBaselineWindows is the number of per-file windows used for the latest probe baseline.
	ProbeBaselineWindows int64
	// ProbeDecision is none, committed, or dissolved.
	ProbeDecision string
	// CircuitBreakerTrips is the number of times ZIP batching was disabled after repeated retry-exhausted batches.
	CircuitBreakerTrips int64
	// Reprobes is the number of scheduled ZIP re-probe attempts after a dissolve verdict.
	Reprobes int64
}