@ethersphere/bee-js 8.3.1 → 9.0.2

package/dist/types/types/index.d.ts

@@ -1,32 +1,21 @@
-import type { Identifier, SingleOwnerChunk } from '../chunk/soc';
+import { Optional } from 'cafe-utility';
+import type { SingleOwnerChunk } from '../chunk/soc';
 import type { FeedUploadOptions } from '../feed';
-import type { FeedType } from '../feed/type';
-import type { FeedUpdateOptions, FetchFeedUpdateResponse } from '../modules/feed';
-import type { Bytes } from '../utils/bytes';
+import type { FeedPayloadResult, FeedReferenceResult, FeedUpdateOptions } from '../modules/feed';
+import { Bytes } from '../utils/bytes';
+import { Duration } from '../utils/duration';
 import type { BeeError } from '../utils/error';
-import type { EthAddress, HexEthAddress } from '../utils/eth';
-import type { HexString } from '../utils/hex';
+import { Size } from '../utils/size';
+import { BatchId, EthAddress, Identifier, PrivateKey, PublicKey, Reference, Topic, TransactionId } from '../utils/typed-bytes';
 export * from './debug';
-export declare const SPAN_SIZE = 8;
 export declare const SECTION_SIZE = 32;
 export declare const BRANCHES = 128;
 export declare const CHUNK_SIZE: number;
-export declare const ADDRESS_HEX_LENGTH = 64;
-export declare const PSS_TARGET_HEX_LENGTH_MAX = 6;
-export declare const PUBKEY_HEX_LENGTH = 66;
-export declare const BATCH_ID_HEX_LENGTH = 64;
-export declare const REFERENCE_HEX_LENGTH = 64;
-export declare const ENCRYPTED_REFERENCE_HEX_LENGTH = 128;
-export declare const REFERENCE_BYTES_LENGTH = 32;
-export declare const ENCRYPTED_REFERENCE_BYTES_LENGTH = 64;
+export declare const PSS_TARGET_HEX_LENGTH_MAX = 4;
 /**
  * Minimal depth that can be used for creation of postage batch
  */
 export declare const STAMPS_DEPTH_MIN = 17;
-/**
- * Minimal amount that can be used for creation of postage batch
- */
-export declare const STAMPS_AMOUNT_MIN: number;
 /**
  * Maximal depth that can be used for creation of postage batch
  */
@@ -34,50 +23,20 @@ export declare const STAMPS_DEPTH_MAX = 255;
 export declare const TAGS_LIMIT_MIN = 1;
 export declare const TAGS_LIMIT_MAX = 1000;
 export declare const FEED_INDEX_HEX_LENGTH = 16;
-/**
- * Generic reference that can be either non-encrypted reference which is a hex string of length 64 or encrypted
- * reference which is a hex string of length 128.
- *
- * Encrypted reference consists of two parts. The reference address itself (like non-encrypted reference) and decryption key.
- *
- * @see [Bee docs - Store with Encryption](https://docs.ethswarm.org/docs/develop/access-the-swarm/store-with-encryption)
- */
-export type Reference = HexString<typeof REFERENCE_HEX_LENGTH> | HexString<typeof ENCRYPTED_REFERENCE_HEX_LENGTH>;
-/**
- * Type that represents either Swarm's reference in hex string or ESN domain (something.eth).
- */
-export type ReferenceOrEns = Reference | string;
-/**
- * Type that represents either Swarm's reference in hex string, ESN domain (something.eth) or CID using one of the Swarm's codecs.
- */
-export type ReferenceCidOrEns = ReferenceOrEns | string;
-export type PlainBytesReference = Bytes<typeof REFERENCE_BYTES_LENGTH>;
-export type EncryptedBytesReference = Bytes<typeof ENCRYPTED_REFERENCE_BYTES_LENGTH>;
-export type BytesReference = PlainBytesReference | EncryptedBytesReference;
-export type PublicKey = HexString<typeof PUBKEY_HEX_LENGTH>;
-export type Address = HexString<typeof ADDRESS_HEX_LENGTH>;
-/**
- * BatchId is result of keccak256 hash so 64 hex string without prefix.
- */
-export type BatchId = HexString<typeof BATCH_ID_HEX_LENGTH>;
-/**
- * AddressPrefix is an HexString of length equal or smaller then ADDRESS_HEX_LENGTH.
- * It represents PSS Address Prefix that is used to define address neighborhood that will receive the PSS message.
- */
-export type AddressPrefix = HexString;
 export type BeeRequestOptions = {
     baseURL?: string;
-    timeout?: number | false;
+    timeout?: number;
     headers?: Record<string, string>;
     onRequest?: (request: BeeRequest) => void;
-    httpAgent?: any;
-    httpsAgent?: any;
+    httpAgent?: unknown;
+    httpsAgent?: unknown;
+    endlesslyRetry?: boolean;
 };
 export interface BeeOptions extends BeeRequestOptions {
     /**
      * Signer object or private key of the Signer in form of either hex string or Uint8Array that will be default signer for the instance.
      */
-    signer?: Signer | Uint8Array | string;
+    signer?: PrivateKey | Uint8Array | string;
 }
 export interface GranteesResult {
     status: number;
@@ -88,15 +47,7 @@ export interface GranteesResult {
 export interface GetGranteesResult {
     status: number;
     statusText: string;
-    data: string[];
-}
-export interface UploadResultWithCid extends UploadResult {
-    /**
-     * Function that converts the reference into Swarm CIDs
-     *
-     * @throws TypeError if the reference is encrypted reference (eq. 128 chars long) which is not supported in CID
-     */
-    cid: () => string;
+    grantees: PublicKey[];
 }
 /**
  * Result of upload calls.
@@ -113,13 +64,14 @@ export interface UploadResult {
     /**
      * History address of the uploaded data with ACT.
      */
-    historyAddress: string;
+    historyAddress: Optional<Reference>;
 }
 export interface UploadOptions {
     /**
      * If set to true, an ACT will be created for the uploaded data.
      */
     act?: boolean;
+    actHistoryAddress?: Reference | Uint8Array | string;
     /**
      * Will pin the data locally in the Bee node as well.
      *
@@ -168,7 +120,7 @@ export declare enum RedundancyLevel {
     INSANE = 3,
     PARANOID = 4
 }
-export interface UploadRedundancyOptions {
+export interface RedundantUploadOptions extends UploadOptions {
     redundancyLevel?: RedundancyLevel;
 }
 /**
@@ -187,7 +139,7 @@ export declare enum RedundancyStrategy {
     PROX = 2,
     RACE = 3
 }
-export interface DownloadRedundancyOptions {
+export interface DownloadOptions {
     /**
      * Specify the retrieve strategy on redundant data.
      */
@@ -200,6 +152,9 @@ export interface DownloadRedundancyOptions {
      * Specify the timeout for chunk retrieval. The default is 30 seconds.
      */
     timeoutMs?: number;
+    actPublisher?: PublicKey | Uint8Array | string;
+    actHistoryAddress?: Reference | Uint8Array | string;
+    actTimestamp?: string | number;
 }
 export interface FileUploadOptions extends UploadOptions {
     /**
@@ -214,6 +169,7 @@ export interface FileUploadOptions extends UploadOptions {
      * @see [Bee API reference - `POST /bzz`](https://docs.ethswarm.org/api/#tag/BZZ/paths/~1bzz/post)
      */
     contentType?: string;
+    redundancyLevel?: RedundancyLevel;
 }
 export interface CollectionUploadOptions extends UploadOptions {
     /**
@@ -230,6 +186,7 @@ export interface CollectionUploadOptions extends UploadOptions {
      * @see [Bee API reference - `POST /bzz`](https://docs.ethswarm.org/api/#tag/BZZ/paths/~1bzz/post)
      */
     errorDocument?: string;
+    redundancyLevel?: RedundancyLevel;
 }
 export interface UploadHeaders {
     'swarm-act'?: string;
@@ -244,37 +201,13 @@ export interface UploadHeaders {
  * @see [Bee docs - Syncing / Tags](https://docs.ethswarm.org/docs/develop/access-the-swarm/syncing)
  */
 export interface Tag {
-    /**
-     * Number of chunks created by the splitter.
-     */
     split: number;
-    /**
-     * Number of chunks that are already uploaded with same reference and same postage batch. These don't need to be synced again.
-     */
     seen: number;
-    /**
-     * Number of chunks that were stored locally as they lie in the uploader node's neighborhood. This is only applicable for full nodes.
-     */
     stored: number;
-    /**
-     * Number of chunks sent on the network to peers as a part of the upload. Chunks could be sent multiple times because of failures or replication.
-     */
     sent: number;
-    /**
-     * Number of chunks that were pushed with a valid receipt. The receipt will also show if they were stored at the correct depth.
-     */
     synced: number;
-    /**
-     * Unique identifier
-     */
     uid: number;
-    /**
-     * Swarm hash of the uploaded data
-     */
     address: string;
-    /**
-     * When the upload process started
-     */
     startedAt: string;
 }
 export interface AllTagsOptions {
@@ -290,7 +223,7 @@ export interface FileData<T> extends FileHeaders {
     data: T;
 }
 export interface Pin {
-    reference: string;
+    reference: Reference;
 }
 export interface ReferenceInformation {
     contentLength: number;
@@ -310,7 +243,7 @@ export interface Data extends Uint8Array {
     /**
      * Converts the binary data into hex-string.
      */
-    hex(): HexString;
+    hex(): string;
     /**
      * Converts the binary data into string which is then parsed into JSON.
      */
@@ -330,16 +263,20 @@ export interface CollectionEntry {
  */
 export type Collection = Array<CollectionEntry>;
 export interface PssSubscription {
-    readonly topic: string;
+    readonly topic: Topic;
     cancel: () => void;
 }
 export interface PssMessageHandler {
-    onMessage: (message: Data, subscription: PssSubscription) => void;
+    onMessage: (message: Bytes, subscription: PssSubscription) => void;
     onError: (error: BeeError, subscription: PssSubscription) => void;
 }
-export interface BeeGenericResponse {
-    message: string;
-    code: number;
+export interface GsocSubscription {
+    readonly address: EthAddress;
+    cancel: () => void;
+}
+export interface GsocMessageHandler {
+    onMessage: (message: Bytes, subscription: GsocSubscription) => void;
+    onError: (error: BeeError, subscription: GsocSubscription) => void;
 }
 export interface ReferenceResponse {
     reference: Reference;
@@ -358,53 +295,24 @@ export interface BeeResponse {
     statusText?: string;
     request: BeeRequest;
 }
-/*********************************************************
- * Writers and Readers interfaces
- */
-export declare const TOPIC_BYTES_LENGTH = 32;
-export declare const TOPIC_HEX_LENGTH = 64;
-/**
- * Hex string of length 64 chars without prefix that specifies topics for feed.
- */
-export type Topic = HexString<typeof TOPIC_HEX_LENGTH>;
-/**
- * Result of upload calls.
- */
-export interface FeedManifestResult {
-    /**
-     * Reference of the uploaded data
-     */
-    reference: Reference;
-    /**
-     * Function that converts the reference into Swarm Feed CID.
-     */
-    cid: () => string;
-}
 /**
  * FeedReader is an interface for downloading feed updates
  */
 export interface FeedReader {
-    readonly type: FeedType;
-    readonly owner: HexEthAddress;
+    readonly owner: EthAddress;
     readonly topic: Topic;
     /**
-     * Download the latest feed update
+     * @deprecated Use `downloadReference` or `downloadPayload` instead to disambiguate how the data should be interpreted.
      */
-    download(options?: FeedUpdateOptions): Promise<FetchFeedUpdateResponse>;
-}
-export interface JsonFeedOptions {
+    download(options?: FeedUpdateOptions): Promise<FeedPayloadResult>;
     /**
-     * Valid only for `get` action, where either this `address` or `signer` has
-     * to be specified.
+     * Downloads the feed update (latest if no index is specified) and returns it as a reference.
      */
-    address?: EthAddress | Uint8Array | string;
+    downloadReference(options?: FeedUpdateOptions): Promise<FeedReferenceResult>;
     /**
-     * Custom Signer object or private key in either binary or hex form.
-     * This required for `set` action, and optional for `get` although
-     * if not specified for `get` then `address` option has to be specified.
+     * Downloads the feed update (latest if no index is specified) and returns it as a payload.
      */
-    signer?: Signer | Uint8Array | string;
-    type?: FeedType;
+    downloadPayload(options?: FeedUpdateOptions): Promise<FeedPayloadResult>;
 }
 /**
  * FeedWriter is an interface for updating feeds
@@ -413,25 +321,29 @@ export interface FeedWriter extends FeedReader {
     /**
      * Upload a new feed update
      *
+     * @deprecated Use `uploadReference` or `uploadPayload` instead to disambiguate how the data should be interpreted.
+     *
      * @param postageBatchId Postage BatchId to be used to upload the data with
      * @param reference The reference to be stored in the new update
      * @param options   Additional options like `at`
      *
      * @returns UpdateResult that points at Single Owner Chunk that contains the new update and pointer to the updated chunk reference.
      */
-    upload(postageBatchId: string | BatchId, reference: BytesReference | Reference, options?: FeedUploadOptions): Promise<UploadResult>;
+    upload(postageBatchId: string | BatchId, reference: Reference | string | Uint8Array, options?: FeedUploadOptions): Promise<UploadResult>;
+    uploadReference(postageBatchId: string | BatchId, reference: Reference | string | Uint8Array, options?: FeedUploadOptions): Promise<UploadResult>;
+    uploadPayload(postageBatchId: string | BatchId, payload: Uint8Array | string, options?: FeedUploadOptions): Promise<UploadResult>;
 }
 /**
  * Interface for downloading single owner chunks
  */
 export interface SOCReader {
-    readonly owner: HexEthAddress;
+    readonly owner: EthAddress;
     /**
      * Downloads a single owner chunk
      *
      * @param identifier  The identifier of the chunk
      */
-    download: (identifier: Identifier) => Promise<SingleOwnerChunk>;
+    download: (identifier: Identifier | Uint8Array | string) => Promise<SingleOwnerChunk>;
 }
 /**
  * Interface for downloading and uploading single owner chunks
@@ -444,26 +356,60 @@ export interface SOCWriter extends SOCReader {
      * @param data        The chunk payload data
      * @param options     Upload options
      */
-    upload: (stamp: BatchId | Uint8Array | string, identifier: Identifier, data: Uint8Array, options?: UploadOptions) => Promise<UploadResult>;
+    upload: (stamp: BatchId | Uint8Array | string, identifier: Identifier | Uint8Array | string, data: Uint8Array, options?: UploadOptions) => Promise<UploadResult>;
+}
+export interface GlobalPostageBatch {
+    batchID: BatchId;
+    value: NumberString;
+    start: number;
+    owner: EthAddress;
+    depth: number;
+    bucketDepth: number;
+    immutable: boolean;
+    batchTTL: number;
 }
-/**
- * Interface representing Postage stamp batch.
- */
 export interface PostageBatch {
     batchID: BatchId;
+    /**
+     * Represents how much of the batch is used up.
+     *
+     * Max utilization = `2 ** (depth - bucketDepth)`
+     *
+     * Since the smallest depth is 17, and one batch has 65,536 buckets, and one chunk is 4,096 bytes,
+     * the 512MB theoretical max size for the smallest stamp comes from `2 * 65536 * 4096 = 512MB`
+     */
     utilization: number;
     usable: boolean;
-    label: '' | string;
+    label: string;
     depth: number;
-    amount: string;
+    amount: NumberString;
     bucketDepth: number;
     blockNumber: number;
     immutableFlag: boolean;
     /**
-     * The time (in seconds) remaining until the batch expires; -1 signals that the batch never expires; 0 signals that the batch has already expired.
+     * Estimated time until the batch expires
      */
-    batchTTL: number;
-    exists: boolean;
+    duration: Duration;
+    /**
+     * A floating point number from 0 to 1, where 0 is no usage, 1 is full usage.
+     */
+    usage: number;
+    /**
+     * Human readable usage text, like "50%" or "100%", no fractions
+     */
+    usageText: string;
+    /**
+     * Effective size
+     */
+    size: Size;
+    /**
+     * Estimated remaining size
+     */
+    remainingSize: Size;
+    /**
+     * Theoretical size in bytes
+     */
+    theoreticalSize: Size;
 }
 export interface BatchBucket {
     bucketID: number;
@@ -473,12 +419,11 @@ export interface PostageBatchBuckets {
     depth: number;
     bucketDepth: number;
     bucketUpperBound: number;
-    buckets?: BatchBucket[];
+    buckets: BatchBucket[];
 }
-export type TransactionHash = BrandedString<'TransactionHash'>;
 export interface TransactionInfo {
-    transactionHash: TransactionHash;
-    to: HexEthAddress;
+    transactionHash: TransactionId;
+    to: string;
     nonce: number;
     gasPrice: NumberString;
     gasLimit: number;
@@ -498,7 +443,10 @@ export interface PostageBatchOptions {
     /**
      * Sets gas price in Wei for the transaction that creates the postage batch
      */
-    gasPrice?: NumberString;
+    gasPrice?: NumberString | string | bigint;
+    /**
+     * Controls whether data can be overwritten that was uploaded with this postage batch.
+     */
     immutableFlag?: boolean;
     /**
      * The returned Promise will await until the purchased Postage Batch is usable.
@@ -523,61 +471,12 @@ export interface Envelope {
     timestamp: Uint8Array;
     signature: Uint8Array;
 }
+export interface EnvelopeWithBatchId extends Envelope {
+    batchId: BatchId;
+}
 /**
  * With this type a number should be represented in a string
  */
-export type NumberString = FlavoredType<string, 'NumberString'>;
-/*********************************************************
- * Ethereum compatible signing interfaces and definitions
- */
-export declare const SIGNATURE_HEX_LENGTH = 130;
-export declare const SIGNATURE_BYTES_LENGTH = 65;
-export type Signature = Bytes<typeof SIGNATURE_BYTES_LENGTH>;
-export type PrivateKeyBytes = Bytes<32>;
-/**
- * Signing function that takes digest in Uint8Array  to be signed that has helpers to convert it
- * conveniently into other types like hex-string (non prefix).
- * Result of the signing can be returned either in Uint8Array or hex string form.
- *
- * @see Data
- */
-type SyncSigner = (digest: Data) => Signature | HexString<typeof SIGNATURE_HEX_LENGTH> | string;
-type AsyncSigner = (digest: Data) => Promise<Signature | HexString<typeof SIGNATURE_HEX_LENGTH> | string>;
-/**
- * Interface for implementing Ethereum compatible signing.
- *
- * In order to be compatible with Ethereum and its signing method `personal_sign`, the data
- * that are passed to sign() function should be prefixed with: `\x19Ethereum Signed Message:\n${data.length}`, hashed
- * and only then signed.
- * If you are wrapping another signer tool/library (like Metamask or some other Ethereum wallet), you might not have
- * to do this prefixing manually if you use the `personal_sign` method. Check documentation of the tool!
- * If you are writing your own storage for keys, then you have to prefix the data manually otherwise the Bee node
- * will reject the chunks signed by you!
- *
- * For example see the hashWithEthereumPrefix() function.
- *
- * @property sign     The sign function that can be sync or async. This function takes non-prefixed data. See above.
- * @property address  The ethereum address of the signer in bytes.
- * @see hashWithEthereumPrefix
- */
-export type Signer = {
-    sign: SyncSigner | AsyncSigner;
-    address: EthAddress;
+export type NumberString = string & {
+    __numberString: never;
 };
-/**
- * These type are used to create new nominal types
- *
- * See https://spin.atomicobject.com/2018/01/15/typescript-flexible-nominal-typing/
- */
-export type BrandedType<Type, Name> = Type & {
-    __tag__: Name;
-};
-export type BrandedString<Name> = BrandedType<string, Name>;
-export type FlavoredType<Type, Name> = Type & {
-    __tag__?: Name;
-};
-export type AnyJson = boolean | number | string | null | JsonArray | JsonMap;
-interface JsonMap {
-    [key: string]: AnyJson;
-}
-type JsonArray = Array<AnyJson>;

package/dist/types/utils/bytes.d.ts

@@ -1,91 +1,17 @@
-/**
- * Helper type for dealing with fixed size byte arrays.
- *
- * It changes the type of `length` property of `Uint8Array` to the
- * generic `Length` type parameter which is runtime compatible with
- * the original, because it extends from the `number` type.
- */
-import { Data } from '../types';
-export interface Bytes<Length extends number> extends Uint8Array {
-    readonly length: Length;
+export declare class Bytes {
+    protected readonly bytes: Uint8Array;
+    readonly length: number;
+    constructor(bytes: Uint8Array | ArrayBuffer | string | Bytes, byteLength?: number | number[]);
+    static keccak256(bytes: Uint8Array | ArrayBuffer | string | Bytes): Bytes;
+    static fromUtf8(utf8: string): Bytes;
+    static fromSlice(bytes: Uint8Array, start: number, length?: number): Bytes;
+    offset(index: number): Uint8Array;
+    toUint8Array(): Uint8Array;
+    toHex(): string;
+    toBase64(): string;
+    toBase32(): string;
+    toString(): string;
+    toUtf8(): string;
+    toJSON(): unknown;
+    equals(other: Bytes | Uint8Array | string): boolean;
 }
-/**
- * Helper type for dealing with flexible sized byte arrays.
- *
- * The actual min and and max values are not stored in runtime, they
- * are only there to differentiate the type from the Uint8Array at
- * compile time.
- * @see BrandedType
- */
-export interface FlexBytes<Min extends number, Max extends number> extends Uint8Array {
-    readonly __min__: Min;
-    readonly __max__: Max;
-}
-/**
- * Type guard for `Bytes<T>` type
- *
- * @param b       The byte array
- * @param length  The length of the byte array
- */
-export declare function isBytes<Length extends number>(b: unknown, length: Length): b is Bytes<Length>;
-/**
- * Function that verifies if passed data are Bytes and if the array has "length" number of bytes under given offset.
- * @param data
- * @param offset
- * @param length
- */
-export declare function hasBytesAtOffset(data: unknown, offset: number, length: number): boolean;
-/**
- * Verifies if a byte array has a certain length
- *
- * @param b       The byte array
- * @param length  The specified length
- */
-export declare function assertBytes<Length extends number>(b: unknown, length: Length): asserts b is Bytes<Length>;
-/**
- * Type guard for FlexBytes<Min,Max> type
- *
- * @param b       The byte array
- * @param min     Minimum size of the array
- * @param max     Maximum size of the array
- */
-export declare function isFlexBytes<Min extends number, Max extends number = Min>(b: unknown, min: Min, max: Max): b is FlexBytes<Min, Max>;
-/**
- * Verifies if a byte array has a certain length between min and max
- *
- * @param b       The byte array
- * @param min     Minimum size of the array
- * @param max     Maximum size of the array
- */
-export declare function assertFlexBytes<Min extends number, Max extends number = Min>(b: unknown, min: Min, max: Max): asserts b is FlexBytes<Min, Max>;
-/**
- * Return `length` bytes starting from `offset`
- *
- * @param data   The original data
- * @param offset The offset to start from
- * @param length The length of data to be returned
- */
-export declare function bytesAtOffset<Length extends number>(data: Uint8Array, offset: number, length: Length): Bytes<Length>;
-/**
- * Return flex bytes starting from `offset`
- *
- * @param data   The original data
- * @param offset The offset to start from
- * @param _min   The minimum size of the data
- * @param _max   The maximum size of the data
- */
-export declare function flexBytesAtOffset<Min extends number, Max extends number>(data: Uint8Array, offset: number, _min: Min, _max: Max): FlexBytes<Min, Max>;
-/**
- * Returns true if two byte arrays are equal
- *
- * @param a Byte array to compare
- * @param b Byte array to compare
- */
-export declare function bytesEqual(a: Uint8Array, b: Uint8Array): boolean;
-/**
- * Returns a new byte array filled with zeroes with the specified length
- *
- * @param length The length of data to be returned
- */
-export declare function makeBytes<Length extends number>(length: Length): Bytes<Length>;
-export declare function wrapBytesWithHelpers(data: Uint8Array): Data;

package/dist/types/utils/chunk-size.d.ts

@@ -0,0 +1 @@
+export declare function totalChunks(fileSize: number): number;

package/dist/types/utils/chunk-stream.browser.d.ts

@@ -0,0 +1,6 @@
+import { Bee, BeeRequestOptions, UploadOptions, UploadResult } from '..';
+import { BatchId, Reference } from './typed-bytes';
+import { UploadProgress } from './upload-progress';
+export declare function hashDirectory(_dir: string): Promise<void>;
+export declare function streamDirectory(_bee: Bee, _dir: string, _postageBatchId: BatchId | string | Uint8Array, _onUploadProgress?: (progress: UploadProgress) => void, _options?: UploadOptions, _requestOptions?: BeeRequestOptions): Promise<Reference>;
+export declare function streamFiles(bee: Bee, files: File[] | FileList, postageBatchId: BatchId, onUploadProgress?: (progress: UploadProgress) => void, options?: UploadOptions, requestOptions?: BeeRequestOptions): Promise<UploadResult>;

package/dist/types/utils/chunk-stream.d.ts

@@ -0,0 +1,6 @@
+import { Bee, BeeRequestOptions, UploadOptions, UploadResult } from '..';
+import { BatchId } from './typed-bytes';
+import { UploadProgress } from './upload-progress';
+export declare function hashDirectory(dir: string): Promise<import("./typed-bytes").Reference>;
+export declare function streamDirectory(bee: Bee, dir: string, postageBatchId: BatchId | string | Uint8Array, onUploadProgress?: (progress: UploadProgress) => void, options?: UploadOptions, requestOptions?: BeeRequestOptions): Promise<UploadResult>;
+export declare function streamFiles(_bee: Bee, _files: File[] | FileList, _postageBatchId: BatchId, _onUploadProgress?: (progress: UploadProgress) => void, _options?: UploadOptions, _requestOptions?: BeeRequestOptions): Promise<UploadResult>;

package/dist/types/utils/cid.d.ts

@@ -1,9 +1,10 @@
-import { Reference } from '..';
+import { Bytes } from './bytes';
+import { Reference } from './typed-bytes';
 export declare const SWARM_MANIFEST_CODEC = 250;
 export declare const SWARM_FEED_CODEC = 251;
 export type DecodedCID = {
     type: 'feed' | 'manifest';
     reference: Reference;
 };
-export declare function convertReferenceToCid(reference: Reference | string, type: 'feed' | 'manifest'): string;
+export declare function convertReferenceToCid(reference: string | Uint8Array | Bytes, type: 'feed' | 'manifest'): string;
 export declare function convertCidToReference(cid: string): DecodedCID;

package/dist/types/utils/collection.browser.d.ts

@@ -5,11 +5,11 @@ import { Collection } from '../types';
  *
  * @param dir path to the directory
  */
-export declare function makeCollectionFromFS(dir: string): Promise<Collection>;
+export declare function makeCollectionFromFS(_dir: string): Promise<Collection>;
 /**
  * Calculate folder size recursively
  *
  * @param dir the path to the folder to check
  * @returns size in bytes
  */
-export declare function getFolderSize(dir: string): Promise<number>;
+export declare function getFolderSize(_dir: string): Promise<number>;

package/dist/types/utils/collection.d.ts

@@ -1,7 +1,8 @@
 import { Collection } from '../types';
 export declare function isCollection(data: unknown): data is Collection;
 export declare function assertCollection(data: unknown): asserts data is Collection;
-export declare function makeCollectionFromFileList(fileList: FileList | File[]): Promise<Collection>;
+export declare function makeFilePath(file: File): string;
+export declare function makeCollectionFromFileList(fileList: FileList | File[]): Collection;
 /**
  * Calculate cumulative size of files
  *