paths

type BasicLocalStorage struct {
	PathToJSON string
}

type BatchMeta struct {
	SupraSeal     bool
	BlockOffset   uint64
	NumInPipeline int

	BatchSectors int
}

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

type DefaultPartialFileHandler struct{}

type FetchHandler struct {
	Local interface {
		Store
		StashStore
	}
	PfHandler PartialFileHandler
}

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

type LocalStorage interface {
	GetStorage() (storiface.StorageConfig, error)
	SetStorage(func(*storiface.StorageConfig)) error

	Stat(path string) (fsutil.FsStat, error)

	// returns real disk usage for a file/directory
	// os.ErrNotExit when file doesn't exist
	DiskUsage(path string) (int64, error)
}

type PartialFileHandler interface {
	// OpenPartialFile opens and returns a partial file at the given path and also verifies it has the given
	// size
	OpenPartialFile(maxPieceSize abi.PaddedPieceSize, path string) (*partialfile.PartialFile, error)

	// HasAllocated returns true if the given partial file has an unsealed piece starting at the given offset with the given size.
	// returns false otherwise.
	HasAllocated(pf *partialfile.PartialFile, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (bool, error)

	// Reader returns a file from which we can read the unsealed piece in the partial file.
	Reader(pf *partialfile.PartialFile, offset storiface.PaddedByteIndex, size abi.PaddedPieceSize) (io.Reader, error)

	// Close closes the partial file
	Close(pf *partialfile.PartialFile) error
}

type PoRepVanillaParams struct {
	Sector   storiface.SectorRef
	Sealed   cid.Cid
	Unsealed cid.Cid
	Ticket   abi.SealRandomness
	Seed     abi.InteractiveSealRandomness
}

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

type SectorDeclaration struct {
	StorageID storiface.ID
	SectorID  abi.SectorID
	FileType  storiface.SectorFileType
	Primary   bool
}

type SectorIndex interface {
	StorageAttach(context.Context, storiface.StorageInfo, fsutil.FsStat) error
	StorageDetach(ctx context.Context, id storiface.ID, url string) error
	StorageInfo(context.Context, storiface.ID) (storiface.StorageInfo, error)
	StorageReportHealth(context.Context, storiface.ID, storiface.HealthReport) error

	StorageDeclareSector(ctx context.Context, storageID storiface.ID, s abi.SectorID, ft storiface.SectorFileType, primary bool) error
	StorageDropSector(ctx context.Context, storageID storiface.ID, s abi.SectorID, ft storiface.SectorFileType) error
	StorageFindSector(ctx context.Context, sector abi.SectorID, ft storiface.SectorFileType, ssize abi.SectorSize, allowFetch bool) ([]storiface.SectorStorageInfo, error)
	BatchStorageDeclareSectors(ctx context.Context, declarations []SectorDeclaration) error

	StorageBestAlloc(ctx context.Context, allocate storiface.SectorFileType, ssize abi.SectorSize, pathType storiface.PathType, miner abi.ActorID) ([]storiface.StorageInfo, error)

	// atomically acquire locks on all sector file types. close ctx to unlock
	StorageLock(ctx context.Context, sector abi.SectorID, read storiface.SectorFileType, write storiface.SectorFileType) error
	StorageTryLock(ctx context.Context, sector abi.SectorID, read storiface.SectorFileType, write storiface.SectorFileType) (bool, error)
	StorageGetLocks(ctx context.Context) (storiface.SectorLocks, error)

	StorageList(ctx context.Context) (map[storiface.ID][]storiface.Decl, error)
}

type SingleVanillaParams struct {
	Miner     abi.ActorID
	Sector    storiface.PostSectorChallenge
	ProofType abi.RegisteredPoStProof
}

type SnapVanillaParams struct {
	Sector storiface.SectorRef
}

type SpaceUseFunc func(ft storiface.SectorFileType, ssize abi.SectorSize) (uint64, error)

type StashStore interface {
	// StashCreate creates a new stash file with the specified maximum size.
	// It selects a sealing path with the most available space and creates a file
	// named [uuid].tmp in the stash directory.
	//
	// The provided writeFunc is called with an *os.File pointing to the newly
	// created stash file, allowing the caller to write data into it.
	//
	// Parameters:
	//  - ctx: Context for cancellation and timeout.
	//  - maxSize: The maximum size of the stash file in bytes.
	//  - writeFunc: A function that writes data to the stash file.
	//
	// Returns:
	//  - uuid.UUID: A unique identifier for the created stash.
	//  - error: An error if the stash could not be created.
	StashCreate(ctx context.Context, maxSize int64, writeFunc func(f *os.File) error) (uuid.UUID, error)

	// ServeAndRemove serves the stash file identified by the given UUID as an io.ReadCloser.
	// Once the stash has been fully read (i.e., the last byte has been read),
	// the stash file is automatically removed.
	// If the read is incomplete (e.g., due to an error or premature closure),
	// the stash file remains on disk.
	//
	// Parameters:
	//  - ctx: Context for cancellation and timeout.
	//  - id: The UUID of the stash to serve.
	//
	// Returns:
	//  - io.ReadCloser: A reader for the stash file.
	//  - error: An error if the stash could not be served.
	ServeAndRemove(ctx context.Context, id uuid.UUID) (io.ReadCloser, error)

	// StashRemove removes the stash file identified by the given UUID.
	//
	// Parameters:
	//  - ctx: Context for cancellation and timeout.
	//  - id: The UUID of the stash to remove.
	//
	// Returns:
	//  - error: An error if the stash could not be removed.
	StashRemove(ctx context.Context, id uuid.UUID) error

	// StashURL generates a URL for accessing the stash identified by the given UUID.
	//
	// Parameters:
	//  - id: The UUID of the stash.
	//
	// Returns:
	//  - url.URL: The URL where the stash can be accessed.
	//  - error: An error if the URL could not be generated.
	StashURL(id uuid.UUID) (url.URL, error)
}

type Store interface {
	AcquireSector(ctx context.Context, s storiface.SectorRef, existing storiface.SectorFileType, allocate storiface.SectorFileType, sealing storiface.PathType, op storiface.AcquireMode, opts ...storiface.AcquireOption) (paths storiface.SectorPaths, stores storiface.SectorPaths, err error)
	Remove(ctx context.Context, s abi.SectorID, types storiface.SectorFileType, force bool, keepIn []storiface.ID) error

	// like remove, but doesn't remove the primary sector copy, nor the last
	// non-primary copy if there no primary copies
	RemoveCopies(ctx context.Context, s abi.SectorID, types storiface.SectorFileType) error

	// move sectors into storage
	MoveStorage(ctx context.Context, s storiface.SectorRef, types storiface.SectorFileType, opts ...storiface.AcquireOption) error

	FsStat(ctx context.Context, id storiface.ID) (fsutil.FsStat, error)

	Reserve(ctx context.Context, sid storiface.SectorRef, ft storiface.SectorFileType, storageIDs storiface.SectorPaths, overheadTab map[storiface.SectorFileType]int, minFreePercentage float64) (func(), error)

	GenerateSingleVanillaProof(ctx context.Context, minerID abi.ActorID, si storiface.PostSectorChallenge, ppt abi.RegisteredPoStProof) ([]byte, error)
	GeneratePoRepVanillaProof(ctx context.Context, sr storiface.SectorRef, sealed, unsealed cid.Cid, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness) ([]byte, error)
	ReadSnapVanillaProof(ctx context.Context, sr storiface.SectorRef) ([]byte, error)
}

type URLs []string