zfs

type CloneOptions struct {
	// Properties to be applied to the new dataset
	Properties map[string]string

	// Creates all the non-existing parent datasets. Datasets created in this manner are automatically mounted according
	// to the mountpoint property inherited from their parent. If the target filesystem or volume already exists,
	// the operation completes successfully.
	CreateParents bool
}

type CommandError struct {
	Err    error
	Debug  string
	Stderr string
}

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

type CreateFilesystemOptions struct {
	// Sets the specified properties as if the command zfs set property=value was invoked at the same time the dataset was created.
	Properties map[string]string

	// Creates all the non-existing parent datasets. Datasets created in this manner are automatically mounted according
	// to the mountpoint property inherited from their parent. Any property specified on the command line using the -o option
	// is ignored. If the target filesystem already exists, the operation completes successfully.
	CreateParents bool

	// Do a dry-run creation. No datasets will be created. This is useful in conjunction with the -v or -P flags
	// to validate properties that are passed via -o options and those implied by other options. The actual dataset creation
	// can still fail due to insufficient privileges or available capacity.
	DryRun bool

	// Do not mount the newly created file system.
	NoMount bool

	// Provide input to stdin, for instance for loading keys
	Stdin io.Reader
}

type CreateVolumeOptions struct {
	// Sets the specified properties as if the command zfs set property=value was invoked at the same time the dataset was created.
	Properties map[string]string

	// Creates all the non-existing parent datasets. Datasets created in this manner are automatically mounted according
	// to the mountpoint property inherited from their parent. Any property specified on the command line using the -o option
	// is ignored. If the target filesystem already exists, the operation completes successfully.
	CreateParents bool

	// Creates a sparse volume with no reservation.
	Sparse bool

	// Do a dry-run creation. No datasets will be created. This is useful in conjunction with the -v or -P flags
	// to validate properties that are passed via -o options and those implied by other options. The actual dataset creation
	// can still fail due to insufficient privileges or available capacity.
	DryRun bool

	// Provide input to stdin, for instance for loading keys
	Stdin io.Reader
}

type Dataset struct {
	Name          string            `json:"Name"`
	Type          DatasetType       `json:"Type"`
	Origin        string            `json:"Origin"`
	Used          uint64            `json:"Used"`
	Available     uint64            `json:"Available"`
	Mountpoint    string            `json:"Mountpoint"`
	Compression   string            `json:"Compression"`
	Written       uint64            `json:"Written"`
	Volsize       uint64            `json:"Volsize"`
	Logicalused   uint64            `json:"Logicalused"`
	Usedbydataset uint64            `json:"Usedbydataset"`
	Quota         uint64            `json:"Quota"`
	Refquota      uint64            `json:"Refquota"`
	Referenced    uint64            `json:"Referenced"`
	ExtraProps    map[string]string `json:"ExtraProps"`
}

type DatasetType string

type DestroyOptions struct {
	// Recursively destroy all children.
	Recursive bool

	// Recursively destroy all dependents, including cloned file systems outside the target hierarchy.
	RecursiveClones bool

	// Forcibly unmount file systems. This option has no effect on non-file systems or unmounted file systems.
	Force bool

	// Do a dry-run (no-op) deletion. No data will be deleted.
	DryRun bool

	// Only for snapshots. Destroy immediately. If a snapshot cannot be destroyed now, mark it for deferred destruction.
	Defer bool
}

type ListOptions struct {
	// ParentDataset filters by parent dataset, empty lists all
	ParentDataset string
	// DatasetType filters the results by type
	DatasetType DatasetType
	// ExtraProperties lists the properties to retrieve besides the ones in the Dataset struct (in the ExtraProps key)
	ExtraProperties []string
	// Recursive, if true will list all under the parent dataset
	Recursive bool
	// Depth specifies the depth to go below the parent dataset (or root if no parent)
	// Recursively display any children of the dataset, limiting the recursion to depth.
	// A depth of 1 will display only the dataset and its direct children.
	Depth int
	// FilterSelf: When true, it will filter out the parent dataset itself from the results
	FilterSelf bool
}

type LoadKeyOptions struct {
	// Recursively loads the keys for the specified filesystem and all descendent encryption roots.
	Recursive bool

	// Do a dry-run (no-op) load-key. This will cause zfs to simply check that the provided key is correct.
	// This command may be run even if the key is already loaded.
	DryRun bool

	// When the key is in a file, load it using this keylocation.
	// This is optional when the ZFS dataset already has this property set.
	KeyLocation string

	// Provide a reader to read the key from stdin
	KeyReader io.Reader
}

type MountOptions struct {
	// Perform an overlay mount. Allows mounting in non-empty mountpoint.
	OverlayMount bool

	// An optional, comma-separated list of mount options to use temporarily for the duration of the mount.
	Options []string

	// Load keys for encrypted filesystems as they are being mounted. This is equivalent to executing zfs load-key
	// on each encryption root before mounting it. Note that if a filesystem has keylocation=prompt, this will cause
	// the terminal to interactively block after asking for the key.
	LoadKeys bool
}

type ProgressCallback func(bytes int64)

type ReceiveOptions struct {
	// Whether the received snapshot should be resumable on interrupions, or be thrown away
	Resumable bool

	// Properties to be applied to the dataset
	Properties map[string]string

	// EnableCompression enables zstd decompression
	EnableDecompression bool
}

type RenameOptions struct {
	// Creates all the nonexistent parent datasets. Datasets created in this manner are automatically mounted
	// according to the mountpoint property inherited from their parent.
	CreateParent bool

	// Recursively rename the snapshots of all descendent datasets. Snapshots are the only dataset that can
	// be renamed recursively.
	Recursive bool

	// Do not remount file systems during rename. If a file system's mountpoint property is set to legacy or none,
	// the file system is not unmounted even if this option is not given.
	NoMount bool

	// Force unmount any file systems that need to be unmounted in the process. This flag has no effect if used together
	// with the no mount flag.
	Force bool
}

type ResumableStreamError struct {
	CommandError

	ReceiveResumeToken string
}

type ResumeSendOptions struct {
	// When set, uses a rate-limiter to limit the flow to this amount of bytes per second
	BytesPerSecond int64
	// CompressionLevel is the level of zstd compression, zero for off
	CompressionLevel zstd.EncoderLevel
}

type RollbackOptions struct {
	// Destroy any snapshots and bookmarks more recent than the one specified.
	DestroyMoreRecent bool

	// Destroy any more recent snapshots and bookmarks, as well as any clones of those snapshots.
	DestroyMoreRecentClones bool

	// Used with the DestroyMoreRecentClones option to force an unmount of any clone file systems that are to be destroyed.
	Force bool
}

type SendOptions struct {
	// For encrypted datasets, send data exactly as it exists on disk. This allows backups to
	//           be taken even if encryption keys are not currently loaded. The backup may then be
	//           received on an untrusted machine since that machine will not have the encryption keys
	//           to read the protected data or alter it without being detected. Upon being received,
	//           the dataset will have the same encryption keys as it did on the send side, although
	//           the keylocation property will be defaulted to prompt if not otherwise provided. For
	//           unencrypted datasets, this flag will be equivalent to -Lec.  Note that if you do not
	//           use this flag for sending encrypted datasets, data will be sent unencrypted and may be
	//           re-encrypted with a different encryption key on the receiving system, which will
	//           disable the ability to do a raw send to that system for incrementals.
	Raw bool
	// Include the dataset's properties in the stream.  This flag is implicit when -R is
	//           specified.  The receiving system must also support this feature. Sends of encrypted
	//           datasets must use -w when using this flag.
	IncludeProperties bool
	// Generate an incremental stream from the first snapshot (the incremental source) to the
	//           second snapshot (the incremental target).  The incremental source can be specified as
	//           the last component of the snapshot name (the @ character and following) and it is
	//           assumed to be from the same file system as the incremental target.
	//
	//           If the destination is a clone, the source may be the origin snapshot, which must be
	//           fully specified (for example, pool/fs@origin, not just @origin).
	IncrementalBase *Dataset
	// When set, uses a rate-limiter to limit the flow to this amount of bytes per second
	BytesPerSecond int64
	// CompressionLevel is the level of zstd compression, 0 for off
	CompressionLevel zstd.EncoderLevel
}

type SnapshotOptions struct {
	// Sets the specified properties on the snapshot.
	Properties map[string]string

	// Recursively create snapshots of all descendent datasets.
	Recursive bool
}

type UnloadKeyOptions struct {
	// Recursively loads the keys for the specified filesystem and all descendent encryption roots.
	Recursive bool
}

type UnmountOptions struct {
	// Forcefully unmount the file system, even if it is currently in use.
	Force bool

	// Unload keys for any encryption roots unmounted by this command.
	UnloadKeys bool
}