@helia/unixfs 1.0.5 → 1.2.0

package/src/commands/rm.ts

@@ -1,4 +1,4 @@
-import type { Blockstore } from 'interface-blockstore'
+import type { Blocks } from '@helia/interface/blocks'
 import type { CID } from 'multiformats/cid'
 import type { RmOptions } from '../index.js'
 import mergeOpts from 'merge-options'
@@ -15,7 +15,7 @@ const defaultOptions: RmOptions = {
   shardSplitThresholdBytes: SHARD_SPLIT_THRESHOLD_BYTES
 }
 
-export async function rm (target: CID, name: string, blockstore: Blockstore, options: Partial<RmOptions> = {}): Promise<CID> {
+export async function rm (target: CID, name: string, blockstore: Blocks, options: Partial<RmOptions> = {}): Promise<CID> {
   const opts: RmOptions = mergeOptions(defaultOptions, options)
 
   if (name.includes('/')) {

package/src/commands/stat.ts

@@ -10,7 +10,7 @@ import type { AbortOptions } from '@libp2p/interfaces'
 import type { Mtime } from 'ipfs-unixfs'
 import { resolve } from './utils/resolve.js'
 import * as raw from 'multiformats/codecs/raw'
-import type { Blockstore } from 'interface-blockstore'
+import type { Blocks } from '@helia/interface/blocks'
 
 const mergeOptions = mergeOpts.bind({ ignoreUndefined: true })
 const log = logger('helia:unixfs:stat')
@@ -19,7 +19,7 @@ const defaultOptions: StatOptions = {
 
 }
 
-export async function stat (cid: CID, blockstore: Blockstore, options: Partial<StatOptions> = {}): Promise<UnixFSStats> {
+export async function stat (cid: CID, blockstore: Blocks, options: Partial<StatOptions> = {}): Promise<UnixFSStats> {
   const opts: StatOptions = mergeOptions(defaultOptions, options)
   const resolved = await resolve(cid, options.path, blockstore, opts)
 
@@ -93,7 +93,7 @@ interface InspectDagResults {
   blocks: number
 }
 
-async function inspectDag (cid: CID, blockstore: Blockstore, options: AbortOptions): Promise<InspectDagResults> {
+async function inspectDag (cid: CID, blockstore: Blocks, options: AbortOptions): Promise<InspectDagResults> {
   const results = {
     localFileSize: 0,
     localDagSize: 0,

package/src/commands/touch.ts

@@ -10,7 +10,7 @@ import * as dagPB from '@ipld/dag-pb'
 import type { PBNode, PBLink } from '@ipld/dag-pb'
 import { importer } from 'ipfs-unixfs-importer'
 import { persist } from './utils/persist.js'
-import type { Blockstore } from 'interface-blockstore'
+import type { Blocks } from '@helia/interface/blocks'
 import last from 'it-last'
 import { sha256 } from 'multiformats/hashes/sha2'
 import { resolve, updatePathCids } from './utils/resolve.js'
@@ -25,7 +25,7 @@ const defaultOptions: TouchOptions = {
   shardSplitThresholdBytes: SHARD_SPLIT_THRESHOLD_BYTES
 }
 
-export async function touch (cid: CID, blockstore: Blockstore, options: Partial<TouchOptions> = {}): Promise<CID> {
+export async function touch (cid: CID, blockstore: Blocks, options: Partial<TouchOptions> = {}): Promise<CID> {
   const opts: TouchOptions = mergeOptions(defaultOptions, options)
   const resolved = await resolve(cid, opts.path, blockstore, opts)
   const mtime = opts.mtime ?? {
@@ -67,6 +67,7 @@ export async function touch (cid: CID, blockstore: Blockstore, options: Partial<
           }
         }
       },
+      // @ts-expect-error blockstore types are incompatible
       (source) => importer(source, blockstore, {
         ...opts,
         dagBuilder: async function * (source, block) {

package/src/commands/utils/add-link.ts

@@ -14,7 +14,7 @@ import { AlreadyExistsError, InvalidParametersError, InvalidPBNodeError } from '
 import type { ImportResult } from 'ipfs-unixfs-importer'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { Directory } from './cid-to-directory.js'
-import type { Blockstore } from 'interface-blockstore'
+import type { Blocks } from '@helia/interface/blocks'
 import { isOverShardThreshold } from './is-over-shard-threshold.js'
 import { hamtBucketBits, hamtHashFn } from './hamt-constants.js'
 // @ts-expect-error no types
@@ -35,7 +35,7 @@ export interface AddLinkOptions extends AbortOptions {
   cidVersion: Version
 }
 
-export async function addLink (parent: Directory, child: Required<PBLink>, blockstore: Blockstore, options: AddLinkOptions): Promise<AddLinkResult> {
+export async function addLink (parent: Directory, child: Required<PBLink>, blockstore: Blocks, options: AddLinkOptions): Promise<AddLinkResult> {
   if (parent.node.Data == null) {
     throw new InvalidParametersError('Invalid parent passed to addLink')
   }
@@ -63,7 +63,7 @@ export async function addLink (parent: Directory, child: Required<PBLink>, block
   return result
 }
 
-const convertToShardedDirectory = async (parent: Directory, blockstore: Blockstore): Promise<ImportResult> => {
+const convertToShardedDirectory = async (parent: Directory, blockstore: Blocks): Promise<ImportResult> => {
   if (parent.node.Data == null) {
     throw new InvalidParametersError('Invalid parent passed to convertToShardedDirectory')
   }
@@ -85,7 +85,7 @@ const convertToShardedDirectory = async (parent: Directory, blockstore: Blocksto
   return result
 }
 
-const addToDirectory = async (parent: Directory, child: PBLink, blockstore: Blockstore, options: AddLinkOptions): Promise<AddLinkResult> => {
+const addToDirectory = async (parent: Directory, child: PBLink, blockstore: Blocks, options: AddLinkOptions): Promise<AddLinkResult> => {
   // Remove existing link if it exists
   const parentLinks = parent.node.Links.filter((link) => {
     const matches = link.Name === child.Name
@@ -137,7 +137,7 @@ const addToDirectory = async (parent: Directory, child: PBLink, blockstore: Bloc
   }
 }
 
-const addToShardedDirectory = async (parent: Directory, child: Required<PBLink>, blockstore: Blockstore, options: AddLinkOptions): Promise<AddLinkResult> => {
+const addToShardedDirectory = async (parent: Directory, child: Required<PBLink>, blockstore: Blocks, options: AddLinkOptions): Promise<AddLinkResult> => {
   const { path, hash } = await recreateShardedDirectory(parent.cid, child.Name, blockstore, options)
   const finalSegment = path[path.length - 1]
 

package/src/commands/utils/cid-to-directory.ts

@@ -1,7 +1,7 @@
 import { exporter, ExporterOptions } from 'ipfs-unixfs-exporter'
 import type { CID } from 'multiformats/cid'
 import type { PBNode } from '@ipld/dag-pb'
-import type { Blockstore } from 'interface-blockstore'
+import type { Blocks } from '@helia/interface/blocks'
 import { NotADirectoryError } from './errors.js'
 
 export interface Directory {
@@ -9,7 +9,7 @@ export interface Directory {
   node: PBNode
 }
 
-export async function cidToDirectory (cid: CID, blockstore: Blockstore, options: ExporterOptions = {}): Promise<Directory> {
+export async function cidToDirectory (cid: CID, blockstore: Blocks, options: ExporterOptions = {}): Promise<Directory> {
   const entry = await exporter(cid, blockstore, options)
 
   if (entry.type !== 'directory') {

package/src/commands/utils/cid-to-pblink.ts

@@ -3,9 +3,9 @@ import type { CID } from 'multiformats/cid'
 import { NotUnixFSError } from './errors.js'
 import * as dagPb from '@ipld/dag-pb'
 import type { PBNode, PBLink } from '@ipld/dag-pb'
-import type { Blockstore } from 'interface-blockstore'
+import type { Blocks } from '@helia/interface/blocks'
 
-export async function cidToPBLink (cid: CID, name: string, blockstore: Blockstore, options?: ExporterOptions): Promise<Required<PBLink>> {
+export async function cidToPBLink (cid: CID, name: string, blockstore: Blocks, options?: ExporterOptions): Promise<Required<PBLink>> {
   const sourceEntry = await exporter(cid, blockstore, options)
 
   if (sourceEntry.type !== 'directory' && sourceEntry.type !== 'file' && sourceEntry.type !== 'raw') {

package/src/commands/utils/dir-sharded.ts

@@ -8,7 +8,7 @@ import {
 } from './hamt-constants.js'
 import { CID } from 'multiformats/cid'
 import type { Mtime } from 'ipfs-unixfs'
-import type { Blockstore } from 'interface-blockstore'
+import type { Blocks } from '@helia/interface/blocks'
 
 interface InProgressImportResult extends ImportResult {
   single?: boolean
@@ -69,7 +69,7 @@ abstract class Dir {
   abstract put (name: string, value: InProgressImportResult | Dir): Promise<void>
   abstract get (name: string): Promise<InProgressImportResult | Dir | undefined>
   abstract eachChildSeries (): AsyncIterable<{ key: string, child: InProgressImportResult | Dir }>
-  abstract flush (blockstore: Blockstore): AsyncGenerator<ImportResult>
+  abstract flush (blockstore: Blocks): AsyncGenerator<ImportResult>
   abstract estimateNodeSize (): number
   abstract childCount (): number
 }
@@ -129,7 +129,7 @@ export class DirSharded extends Dir {
     return this.nodeSize
   }
 
-  async * flush (blockstore: Blockstore): AsyncGenerator<ImportResult> {
+  async * flush (blockstore: Blocks): AsyncGenerator<ImportResult> {
     for await (const entry of flush(this._bucket, blockstore, this, this.options)) {
       yield {
         ...entry,
@@ -139,7 +139,7 @@ export class DirSharded extends Dir {
   }
 }
 
-async function * flush (bucket: Bucket<Dir | InProgressImportResult>, blockstore: Blockstore, shardRoot: DirSharded | null, options: PersistOptions): AsyncIterable<ImportResult> {
+async function * flush (bucket: Bucket<Dir | InProgressImportResult>, blockstore: Blocks, shardRoot: DirSharded | null, options: PersistOptions): AsyncIterable<ImportResult> {
   const children = bucket._children
   const links: PBLink[] = []
   let childrenSize = 0n

package/src/commands/utils/hamt-utils.ts

@@ -9,7 +9,7 @@ import {
   hamtHashFn,
   hamtBucketBits
 } from './hamt-constants.js'
-import type { Blockstore } from 'interface-blockstore'
+import type { Blocks } from '@helia/interface/blocks'
 import type { Mtime } from 'ipfs-unixfs'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { ImportResult } from 'ipfs-unixfs-importer'
@@ -40,7 +40,7 @@ export interface CreateShardOptions {
   cidVersion: Version
 }
 
-export const createShard = async (blockstore: Blockstore, contents: Array<{ name: string, size: bigint, cid: CID }>, options: CreateShardOptions): Promise<ImportResult> => {
+export const createShard = async (blockstore: Blocks, contents: Array<{ name: string, size: bigint, cid: CID }>, options: CreateShardOptions): Promise<ImportResult> => {
   const shard = new DirSharded({
     root: true,
     dir: true,
@@ -75,7 +75,7 @@ export interface HAMTPath {
   node: dagPB.PBNode
 }
 
-export const updateShardedDirectory = async (path: HAMTPath[], blockstore: Blockstore, options: PersistOptions): Promise<{ cid: CID, node: dagPB.PBNode }> => {
+export const updateShardedDirectory = async (path: HAMTPath[], blockstore: Blocks, options: PersistOptions): Promise<{ cid: CID, node: dagPB.PBNode }> => {
   // persist any metadata on the shard root
   const shardRoot = UnixFS.unmarshal(path[0].node.Data ?? new Uint8Array(0))
 
@@ -142,7 +142,7 @@ export const updateShardedDirectory = async (path: HAMTPath[], blockstore: Block
   return { cid, node }
 }
 
-export const recreateShardedDirectory = async (cid: CID, fileName: string, blockstore: Blockstore, options: AbortOptions): Promise<{ path: HAMTPath[], hash: InfiniteHash }> => {
+export const recreateShardedDirectory = async (cid: CID, fileName: string, blockstore: Blocks, options: AbortOptions): Promise<{ path: HAMTPath[], hash: InfiniteHash }> => {
   const wrapped = wrapHash(hamtHashFn)
   const hash = wrapped(uint8ArrayFromString(fileName))
   const path: HAMTPath[] = []

package/src/commands/utils/is-over-shard-threshold.ts

@@ -1,5 +1,5 @@
 import type { PBNode } from '@ipld/dag-pb'
-import type { Blockstore } from 'interface-blockstore'
+import type { Blocks } from '@helia/interface/blocks'
 import { UnixFS } from 'ipfs-unixfs'
 import * as dagPb from '@ipld/dag-pb'
 import { CID_V0, CID_V1 } from './dir-sharded.js'
@@ -10,7 +10,7 @@ import { CID_V0, CID_V1 } from './dir-sharded.js'
  *
  * If the node is a hamt sharded directory the calculation is based on if it was a regular directory.
  */
-export async function isOverShardThreshold (node: PBNode, blockstore: Blockstore, threshold: number): Promise<boolean> {
+export async function isOverShardThreshold (node: PBNode, blockstore: Blocks, threshold: number): Promise<boolean> {
   if (node.Data == null) {
     throw new Error('DagPB node had no data')
   }
@@ -42,7 +42,7 @@ function estimateNodeSize (node: PBNode): number {
   return size
 }
 
-async function estimateShardSize (node: PBNode, current: number, max: number, blockstore: Blockstore): Promise<number> {
+async function estimateShardSize (node: PBNode, current: number, max: number, blockstore: Blocks): Promise<number> {
   if (current > max) {
     return max
   }

package/src/commands/utils/persist.ts

@@ -1,7 +1,7 @@
 import { CID } from 'multiformats/cid'
 import * as dagPb from '@ipld/dag-pb'
 import { sha256 } from 'multiformats/hashes/sha2'
-import type { Blockstore } from 'ipfs-unixfs-importer'
+import type { Blocks } from '@helia/interface/blocks'
 import type { BlockCodec } from 'multiformats/codecs/interface'
 import type { Version as CIDVersion } from 'multiformats/cid'
 
@@ -11,7 +11,9 @@ export interface PersistOptions {
   signal?: AbortSignal
 }
 
-export const persist = async (buffer: Uint8Array, blockstore: Blockstore, options: PersistOptions): Promise<CID> => {
+type PutStore = Pick<Blocks, 'put'>
+
+export const persist = async (buffer: Uint8Array, blockstore: PutStore, options: PersistOptions): Promise<CID> => {
   if (options.codec == null) {
     options.codec = dagPb
   }
@@ -20,6 +22,7 @@ export const persist = async (buffer: Uint8Array, blockstore: Blockstore, option
   const cid = CID.create(options.cidVersion, options.codec.code, multihash)
 
   await blockstore.put(cid, buffer, {
+    ...options,
     signal: options.signal
   })
 

package/src/commands/utils/remove-link.ts

@@ -9,7 +9,7 @@ import {
   updateShardedDirectory
 } from './hamt-utils.js'
 import type { PBNode } from '@ipld/dag-pb'
-import type { Blockstore } from 'interface-blockstore'
+import type { Blocks } from '@helia/interface/blocks'
 import type { Directory } from './cid-to-directory.js'
 import type { AbortOptions } from '@libp2p/interfaces'
 import { InvalidParametersError, InvalidPBNodeError } from './errors.js'
@@ -29,7 +29,7 @@ export interface RemoveLinkResult {
   cid: CID
 }
 
-export async function removeLink (parent: Directory, name: string, blockstore: Blockstore, options: RmLinkOptions): Promise<RemoveLinkResult> {
+export async function removeLink (parent: Directory, name: string, blockstore: Blocks, options: RmLinkOptions): Promise<RemoveLinkResult> {
   if (parent.node.Data == null) {
     throw new InvalidPBNodeError('Parent node had no data')
   }
@@ -55,7 +55,7 @@ export async function removeLink (parent: Directory, name: string, blockstore: B
   return await removeFromDirectory(parent, name, blockstore, options)
 }
 
-const removeFromDirectory = async (parent: Directory, name: string, blockstore: Blockstore, options: AbortOptions): Promise<RemoveLinkResult> => {
+const removeFromDirectory = async (parent: Directory, name: string, blockstore: Blocks, options: AbortOptions): Promise<RemoveLinkResult> => {
   // Remove existing link if it exists
   parent.node.Links = parent.node.Links.filter((link) => {
     return link.Name !== name
@@ -75,7 +75,7 @@ const removeFromDirectory = async (parent: Directory, name: string, blockstore:
   }
 }
 
-const removeFromShardedDirectory = async (parent: Directory, name: string, blockstore: Blockstore, options: UpdateHamtDirectoryOptions): Promise<{ cid: CID, node: PBNode }> => {
+const removeFromShardedDirectory = async (parent: Directory, name: string, blockstore: Blocks, options: UpdateHamtDirectoryOptions): Promise<{ cid: CID, node: PBNode }> => {
   const { path } = await recreateShardedDirectory(parent.cid, name, blockstore, options)
   const finalSegment = path[path.length - 1]
 
@@ -132,7 +132,7 @@ const removeFromShardedDirectory = async (parent: Directory, name: string, block
   return await updateShardedDirectory(path, blockstore, options)
 }
 
-const convertToFlatDirectory = async (parent: Directory, blockstore: Blockstore, options: RmLinkOptions): Promise<RemoveLinkResult> => {
+const convertToFlatDirectory = async (parent: Directory, blockstore: Blocks, options: RmLinkOptions): Promise<RemoveLinkResult> => {
   if (parent.node.Data == null) {
     throw new InvalidParametersError('Invalid parent passed to convertToFlatDirectory')
   }

package/src/commands/utils/resolve.ts

@@ -6,7 +6,7 @@ import { DoesNotExistError, InvalidParametersError } from './errors.js'
 import { addLink } from './add-link.js'
 import { cidToDirectory } from './cid-to-directory.js'
 import { cidToPBLink } from './cid-to-pblink.js'
-import type { Blockstore } from 'interface-blockstore'
+import type { Blocks } from '@helia/interface/blocks'
 
 const log = logger('helia:unixfs:components:utils:resolve')
 
@@ -32,7 +32,7 @@ export interface ResolveResult {
   segments?: Segment[]
 }
 
-export async function resolve (cid: CID, path: string | undefined, blockstore: Blockstore, options: AbortOptions): Promise<ResolveResult> {
+export async function resolve (cid: CID, path: string | undefined, blockstore: Blocks, options: AbortOptions): Promise<ResolveResult> {
   if (path == null || path === '') {
     return { cid }
   }
@@ -101,7 +101,7 @@ export interface UpdatePathCidsOptions extends AbortOptions {
  * Where we have descended into a DAG to update a child node, ascend up the DAG creating
  * new hashes and blocks for the changed content
  */
-export async function updatePathCids (cid: CID, result: ResolveResult, blockstore: Blockstore, options: UpdatePathCidsOptions): Promise<CID> {
+export async function updatePathCids (cid: CID, result: ResolveResult, blockstore: Blocks, options: UpdatePathCidsOptions): Promise<CID> {
   if (result.segments == null || result.segments.length === 0) {
     return cid
   }

package/src/index.ts

@@ -32,7 +32,7 @@
  */
 
 import type { CID, Version } from 'multiformats/cid'
-import type { Blockstore } from 'interface-blockstore'
+import type { Blocks, GetBlockProgressEvents, PutBlockProgressEvents } from '@helia/interface/blocks'
 import type { AbortOptions } from '@libp2p/interfaces'
 import { addAll, addBytes, addByteStream, addDirectory, addFile } from './commands/add.js'
 import { cat } from './commands/cat.js'
@@ -43,18 +43,29 @@ import { rm } from './commands/rm.js'
 import { stat } from './commands/stat.js'
 import { touch } from './commands/touch.js'
 import { chmod } from './commands/chmod.js'
-import type { UnixFSEntry } from 'ipfs-unixfs-exporter'
+import type { ExporterProgressEvents, UnixFSEntry } from 'ipfs-unixfs-exporter'
 import { ls } from './commands/ls.js'
-import type { ByteStream, DirectoryCandidate, FileCandidate, ImportCandidateStream, ImporterOptions, ImportResult } from 'ipfs-unixfs-importer'
+import type { ByteStream, DirectoryCandidate, FileCandidate, ImportCandidateStream, ImporterOptions, ImporterProgressEvents, ImportResult } from 'ipfs-unixfs-importer'
+import type { ProgressOptions } from 'progress-events'
 
 export interface UnixFSComponents {
-  blockstore: Blockstore
+  blockstore: Blocks
 }
 
+export type AddEvents = PutBlockProgressEvents
+| ImporterProgressEvents
+
+export interface AddOptions extends AbortOptions, Omit<ImporterOptions, 'onProgress'>, ProgressOptions<AddEvents> {
+
+}
+
+export type GetEvents = GetBlockProgressEvents
+| ExporterProgressEvents
+
 /**
  * Options to pass to the cat command
  */
-export interface CatOptions extends AbortOptions {
+export interface CatOptions extends AbortOptions, ProgressOptions<GetEvents> {
   /**
    * Start reading the file at this offset
    */
@@ -74,7 +85,7 @@ export interface CatOptions extends AbortOptions {
 /**
  * Options to pass to the chmod command
  */
-export interface ChmodOptions extends AbortOptions {
+export interface ChmodOptions extends AbortOptions, ProgressOptions<GetEvents | PutBlockProgressEvents> {
   /**
    * If the target of the operation is a directory and this is true,
    * apply the new mode to all directory contents
@@ -96,7 +107,7 @@ export interface ChmodOptions extends AbortOptions {
 /**
  * Options to pass to the cp command
  */
-export interface CpOptions extends AbortOptions {
+export interface CpOptions extends AbortOptions, ProgressOptions<GetEvents | PutBlockProgressEvents> {
   /**
    * If true, allow overwriting existing directory entries (default: false)
    */
@@ -112,7 +123,7 @@ export interface CpOptions extends AbortOptions {
 /**
  * Options to pass to the ls command
  */
-export interface LsOptions extends AbortOptions {
+export interface LsOptions extends AbortOptions, ProgressOptions<GetEvents> {
   /**
    * Optional path to list subdirectory contents if the target CID resolves to
    * a directory
@@ -133,7 +144,7 @@ export interface LsOptions extends AbortOptions {
 /**
  * Options to pass to the mkdir command
  */
-export interface MkdirOptions extends AbortOptions {
+export interface MkdirOptions extends AbortOptions, ProgressOptions<GetEvents | PutBlockProgressEvents> {
   /**
    * The CID version to create the new directory with - defaults to the same
    * version as the containing directory
@@ -165,7 +176,7 @@ export interface MkdirOptions extends AbortOptions {
 /**
  * Options to pass to the rm command
  */
-export interface RmOptions extends AbortOptions {
+export interface RmOptions extends AbortOptions, ProgressOptions<GetEvents | PutBlockProgressEvents> {
   /**
    * DAGs with a root block larger than this value will be sharded. Blocks
    * smaller than this value will be regular UnixFS directories.
@@ -176,7 +187,7 @@ export interface RmOptions extends AbortOptions {
 /**
  * Options to pass to the stat command
  */
-export interface StatOptions extends AbortOptions {
+export interface StatOptions extends AbortOptions, ProgressOptions<GetEvents> {
   /**
    * An optional path to allow statting paths inside directories
    */
@@ -243,7 +254,7 @@ export interface UnixFSStats {
 /**
  * Options to pass to the touch command
  */
-export interface TouchOptions extends AbortOptions {
+export interface TouchOptions extends AbortOptions, ProgressOptions<GetEvents | PutBlockProgressEvents> {
   /**
    * Optional mtime to set on the DAG root, defaults to the current time
    */
@@ -292,7 +303,7 @@ export interface UnixFS {
    * }
    * ```
    */
-  addAll: (source: ImportCandidateStream, options?: Partial<ImporterOptions>) => AsyncIterable<ImportResult>
+  addAll: (source: ImportCandidateStream, options?: Partial<AddOptions>) => AsyncIterable<ImportResult>
 
   /**
    * Add a single `Uint8Array` to your Helia node as a file.
@@ -305,7 +316,7 @@ export interface UnixFS {
    * console.info(cid)
    * ```
    */
-  addBytes: (bytes: Uint8Array, options?: Partial<ImporterOptions>) => Promise<CID>
+  addBytes: (bytes: Uint8Array, options?: Partial<AddOptions>) => Promise<CID>
 
   /**
    * Add a stream of `Uint8Array` to your Helia node as a file.
@@ -321,7 +332,7 @@ export interface UnixFS {
    * console.info(cid)
    * ```
    */
-  addByteStream: (bytes: ByteStream, options?: Partial<ImporterOptions>) => Promise<CID>
+  addByteStream: (bytes: ByteStream, options?: Partial<AddOptions>) => Promise<CID>
 
   /**
    * Add a file to your Helia node with optional metadata.
@@ -342,7 +353,7 @@ export interface UnixFS {
    * console.info(cid)
    * ```
    */
-  addFile: (file: FileCandidate, options?: Partial<ImporterOptions>) => Promise<CID>
+  addFile: (file: FileCandidate, options?: Partial<AddOptions>) => Promise<CID>
 
   /**
    * Add a directory to your Helia node.
@@ -355,7 +366,7 @@ export interface UnixFS {
    * console.info(cid)
    * ```
    */
-  addDirectory: (dir?: Partial<DirectoryCandidate>, options?: Partial<ImporterOptions>) => Promise<CID>
+  addDirectory: (dir?: Partial<DirectoryCandidate>, options?: Partial<AddOptions>) => Promise<CID>
 
   /**
    * Retrieve the contents of a file from your Helia node.
@@ -489,23 +500,23 @@ class DefaultUnixFS implements UnixFS {
     this.components = components
   }
 
-  async * addAll (source: ImportCandidateStream, options: Partial<ImporterOptions> = {}): AsyncIterable<ImportResult> {
+  async * addAll (source: ImportCandidateStream, options: Partial<AddOptions> = {}): AsyncIterable<ImportResult> {
     yield * addAll(source, this.components.blockstore, options)
   }
 
-  async addBytes (bytes: Uint8Array, options: Partial<ImporterOptions> = {}): Promise<CID> {
+  async addBytes (bytes: Uint8Array, options: Partial<AddOptions> = {}): Promise<CID> {
     return await addBytes(bytes, this.components.blockstore, options)
   }
 
-  async addByteStream (bytes: ByteStream, options: Partial<ImporterOptions> = {}): Promise<CID> {
+  async addByteStream (bytes: ByteStream, options: Partial<AddOptions> = {}): Promise<CID> {
     return await addByteStream(bytes, this.components.blockstore, options)
   }
 
-  async addFile (file: FileCandidate, options: Partial<ImporterOptions> = {}): Promise<CID> {
+  async addFile (file: FileCandidate, options: Partial<AddOptions> = {}): Promise<CID> {
     return await addFile(file, this.components.blockstore, options)
   }
 
-  async addDirectory (dir: Partial<DirectoryCandidate> = {}, options: Partial<ImporterOptions> = {}): Promise<CID> {
+  async addDirectory (dir: Partial<DirectoryCandidate> = {}, options: Partial<AddOptions> = {}): Promise<CID> {
     return await addDirectory(dir, this.components.blockstore, options)
   }
 
@@ -545,6 +556,6 @@ class DefaultUnixFS implements UnixFS {
 /**
  * Create a {@link UnixFS} instance for use with {@link https://github.com/ipfs/helia Helia}
  */
-export function unixfs (helia: { blockstore: Blockstore }): UnixFS {
+export function unixfs (helia: { blockstore: Blocks }): UnixFS {
   return new DefaultUnixFS(helia)
 }