@ethersphere/bee-js 8.3.1 → 9.0.2

package/dist/types/chunk/bmt.d.ts

@@ -1,4 +1,4 @@
-import { Bytes } from '../utils/bytes';
+import { Reference } from '../utils/typed-bytes';
 /**
  * Calculate a Binary Merkle Tree hash for a chunk
  *
@@ -13,4 +13,4 @@ import { Bytes } from '../utils/bytes';
  *
  * @returns the keccak256 hash in a byte array
  */
-export declare function bmtHash(chunkContent: Uint8Array): Bytes<32>;
+export declare function calculateChunkAddress(chunkContent: Uint8Array): Reference;

package/dist/types/chunk/cac.d.ts

@@ -1,5 +1,5 @@
-import { BrandedType, PlainBytesReference } from '../types';
-import { Bytes, FlexBytes } from '../utils/bytes';
+import { Bytes } from '../utils/bytes';
+import { Reference, Span } from '../utils/typed-bytes';
 export declare const MIN_PAYLOAD_SIZE = 1;
 export declare const MAX_PAYLOAD_SIZE = 4096;
 /**
@@ -13,31 +13,14 @@ export declare const MAX_PAYLOAD_SIZE = 4096;
  */
 export interface Chunk {
     readonly data: Uint8Array;
-    span(): Bytes<8>;
-    payload(): FlexBytes<1, 4096>;
-    address(): PlainBytesReference;
+    span: Span;
+    payload: Bytes;
+    address: Reference;
 }
-type ValidChunkData = BrandedType<Uint8Array, 'ValidChunkData'>;
 /**
  * Creates a content addressed chunk and verifies the payload size.
  *
  * @param payloadBytes the data to be stored in the chunk
  */
-export declare function makeContentAddressedChunk(payloadBytes: Uint8Array): Chunk;
-/**
- * Type guard for valid content addressed chunk data
- *
- * @param data          The chunk data
- * @param chunkAddress  The address of the chunk
- */
-export declare function isValidChunkData(data: unknown, chunkAddress: PlainBytesReference): data is ValidChunkData;
-/**
- * Asserts if data are representing given address of its chunk.
- *
- * @param data          The chunk data
- * @param chunkAddress  The address of the chunk
- *
- * @returns a valid content addressed chunk or throws error
- */
-export declare function assertValidChunkData(data: unknown, chunkAddress: PlainBytesReference): asserts data is ValidChunkData;
-export {};
+export declare function makeContentAddressedChunk(payloadBytes: Uint8Array | string): Chunk;
+export declare function asContentAddressedChunk(chunkBytes: Uint8Array): Chunk;

package/dist/types/chunk/soc.d.ts

@@ -1,8 +1,7 @@
-import { BatchId, BeeRequestOptions, PlainBytesReference, Signature, Signer, UploadOptions, UploadResult } from '../types';
+import { BeeRequestOptions, UploadOptions, UploadResult } from '../types';
 import { Bytes } from '../utils/bytes';
-import { EthAddress } from '../utils/eth';
+import { BatchId, EthAddress, Identifier, PrivateKey, Reference, Signature } from '../utils/typed-bytes';
 import { Chunk } from './cac';
-export type Identifier = Bytes<32>;
 /**
  * With single owner chunks, a user can assign arbitrary data to an
  * address and attest chunk integrity with their digital signature.
@@ -12,9 +11,9 @@ export type Identifier = Bytes<32>;
  * and the owner of the chunk.
  */
 export interface SingleOwnerChunk extends Chunk {
-    identifier: () => Identifier;
-    signature: () => Signature;
-    owner: () => EthAddress;
+    identifier: Identifier;
+    signature: Signature;
+    owner: EthAddress;
 }
 /**
  * Verifies if the data is a valid single owner chunk
@@ -24,16 +23,16 @@ export interface SingleOwnerChunk extends Chunk {
  *
  * @returns a single owner chunk or throws error
  */
-export declare function makeSingleOwnerChunkFromData(data: Uint8Array, address: PlainBytesReference): SingleOwnerChunk;
-export declare function makeSOCAddress(identifier: Identifier, address: EthAddress): PlainBytesReference;
+export declare function makeSingleOwnerChunkFromData(data: Bytes | Uint8Array, address: Reference | Uint8Array | string): SingleOwnerChunk;
+export declare function makeSOCAddress(identifier: Identifier, address: EthAddress): Reference;
 /**
  * Creates a single owner chunk object
  *
  * @param chunk       A chunk object used for the span and payload
  * @param identifier  The identifier of the chunk
- * @param signer      The singer interface for signing the chunk
+ * @param signer      The signer interface for signing the chunk
  */
-export declare function makeSingleOwnerChunk(chunk: Chunk, identifier: Identifier, signer: Signer): Promise<SingleOwnerChunk>;
+export declare function makeSingleOwnerChunk(chunk: Chunk, identifier: Identifier | Uint8Array | string, signer: PrivateKey | Uint8Array | string): SingleOwnerChunk;
 /**
  * Helper function to upload a chunk.
  *
@@ -41,7 +40,7 @@ export declare function makeSingleOwnerChunk(chunk: Chunk, identifier: Identifie
  *
  * @param requestOptions  Options for making requests
  * @param chunk           A chunk object
- * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
+ * @param stamp  Postage BatchId that will be assigned to uploaded data
  * @param options         Upload options
  */
 export declare function uploadSingleOwnerChunk(requestOptions: BeeRequestOptions, chunk: SingleOwnerChunk, stamp: BatchId | Uint8Array | string, options?: UploadOptions): Promise<UploadResult>;
@@ -49,18 +48,19 @@ export declare function uploadSingleOwnerChunk(requestOptions: BeeRequestOptions
  * Helper function to create and upload SOC.
  *
  * @param requestOptions  Options for making requests
- * @param signer          The singer interface for signing the chunk
+ * @param signer          The signer interface for signing the chunk
  * @param postageBatchId
  * @param identifier      The identifier of the chunk
  * @param data            The chunk data
  * @param options
  */
-export declare function uploadSingleOwnerChunkData(requestOptions: BeeRequestOptions, signer: Signer, stamp: BatchId | Uint8Array | string, identifier: Identifier, data: Uint8Array, options?: UploadOptions): Promise<UploadResult>;
+export declare function uploadSingleOwnerChunkData(requestOptions: BeeRequestOptions, signer: PrivateKey | Uint8Array | string, stamp: BatchId | Uint8Array | string, identifier: Identifier | Uint8Array | string, data: Uint8Array, options?: UploadOptions): Promise<UploadResult>;
+export declare function uploadSingleOwnerChunkWithWrappedChunk(requestOptions: BeeRequestOptions, signer: PrivateKey | Uint8Array | string, stamp: BatchId | Uint8Array | string, identifier: Identifier | Uint8Array | string, rootChunk: Uint8Array, options?: UploadOptions): Promise<UploadResult>;
 /**
  * Helper function to download SOC.
  *
  * @param url           The url of the Bee service
- * @param ownerAddress  The singer interface for signing the chunk
+ * @param ownerAddress  The signer interface for signing the chunk
  * @param identifier    The identifier of the chunk
  */
-export declare function downloadSingleOwnerChunk(requestOptions: BeeRequestOptions, ownerAddress: EthAddress, identifier: Identifier): Promise<SingleOwnerChunk>;
+export declare function downloadSingleOwnerChunk(requestOptions: BeeRequestOptions, ownerAddress: EthAddress | Uint8Array | string, identifier: Identifier | Uint8Array | string): Promise<SingleOwnerChunk>;

package/dist/types/feed/identifier.d.ts

@@ -1,4 +1,2 @@
-import { Identifier } from '../chunk/soc';
-import { Topic } from '../types';
-import { Index } from './index';
-export declare function makeFeedIdentifier(topic: Topic, index: Index): Identifier;
+import { FeedIndex, Identifier, Topic } from '../utils/typed-bytes';
+export declare function makeFeedIdentifier(topic: Topic, index: FeedIndex | number): Identifier;

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

@@ -1,28 +1,24 @@
+import { Optional } from 'cafe-utility';
+import { Chunk } from '../chunk/cac';
 import { FeedUpdateOptions } from '../modules/feed';
-import { BatchId, BeeRequestOptions, BytesReference, FEED_INDEX_HEX_LENGTH, FeedReader, FeedWriter, PlainBytesReference, Signer, Topic, UploadOptions, UploadResult } from '../types';
+import { BeeRequestOptions, FeedReader, FeedWriter, UploadOptions, UploadResult } from '../types';
 import { Bytes } from '../utils/bytes';
-import { EthAddress, HexEthAddress } from '../utils/eth';
-import { HexString } from '../utils/hex';
-import type { FeedType } from './type';
+import { BatchId, EthAddress, FeedIndex, PrivateKey, Reference, Topic } from '../utils/typed-bytes';
 export interface Epoch {
     time: number;
     level: number;
 }
-/**
- * Bytes of Feed's Index.
- * For Sequential Feeds this is numeric value in big-endian.
- */
-export type IndexBytes = Bytes<8>;
-export type Index = number | Epoch | IndexBytes | string;
 export interface FeedUploadOptions extends UploadOptions, FeedUpdateOptions {
 }
 export interface FeedUpdate {
-    timestamp: number;
-    reference: BytesReference;
+    timestamp: Optional<number>;
+    payload: Bytes;
 }
-export declare function findNextIndex(requestOptions: BeeRequestOptions, owner: HexEthAddress, topic: Topic, options?: FeedUpdateOptions): Promise<HexString<typeof FEED_INDEX_HEX_LENGTH>>;
-export declare function updateFeed(requestOptions: BeeRequestOptions, signer: Signer, topic: Topic, reference: BytesReference, postageBatchId: BatchId, options?: FeedUploadOptions): Promise<UploadResult>;
-export declare function getFeedUpdateChunkReference(owner: EthAddress, topic: Topic, index: Index): PlainBytesReference;
-export declare function downloadFeedUpdate(requestOptions: BeeRequestOptions, owner: EthAddress, topic: Topic, index: Index): Promise<FeedUpdate>;
-export declare function makeFeedReader(requestOptions: BeeRequestOptions, type: FeedType, topic: Topic, owner: HexEthAddress): FeedReader;
-export declare function makeFeedWriter(requestOptions: BeeRequestOptions, type: FeedType, topic: Topic, signer: Signer): FeedWriter;
+export declare function findNextIndex(requestOptions: BeeRequestOptions, owner: EthAddress, topic: Topic): Promise<FeedIndex>;
+export declare function updateFeedWithReference(requestOptions: BeeRequestOptions, signer: PrivateKey, topic: Topic, reference: Reference | string | Uint8Array, postageBatchId: BatchId, options?: FeedUploadOptions): Promise<UploadResult>;
+export declare function updateFeedWithPayload(requestOptions: BeeRequestOptions, signer: PrivateKey, topic: Topic, data: Uint8Array | string, postageBatchId: BatchId, options?: FeedUploadOptions): Promise<UploadResult>;
+export declare function getFeedUpdateChunkReference(owner: EthAddress, topic: Topic, index: FeedIndex): Reference;
+export declare function downloadFeedUpdate(requestOptions: BeeRequestOptions, owner: EthAddress, topic: Topic, index: FeedIndex | number, hasTimestamp?: boolean): Promise<FeedUpdate>;
+export declare function downloadFeedUpdateAsCAC(requestOptions: BeeRequestOptions, owner: EthAddress, topic: Topic, index: FeedIndex | number): Promise<Chunk>;
+export declare function makeFeedReader(requestOptions: BeeRequestOptions, topic: Topic, owner: EthAddress): FeedReader;
+export declare function makeFeedWriter(requestOptions: BeeRequestOptions, topic: Topic, signer: PrivateKey): FeedWriter;

package/dist/types/feed/retrievable.d.ts

@@ -1,5 +1,4 @@
 import { Bee } from '../bee';
-import { BeeRequestOptions, Topic } from '../types';
-import { EthAddress } from '../utils/eth';
-import { Index } from './index';
-export declare function areAllSequentialFeedsUpdateRetrievable(bee: Bee, owner: EthAddress, topic: Topic, index: Index, requestOptions: BeeRequestOptions): Promise<boolean>;
+import { BeeRequestOptions, DownloadOptions } from '../types';
+import { EthAddress, FeedIndex, Topic } from '../utils/typed-bytes';
+export declare function areAllSequentialFeedsUpdateRetrievable(bee: Bee, owner: EthAddress, topic: Topic, index: FeedIndex, options: DownloadOptions | undefined, requestOptions: BeeRequestOptions): Promise<boolean>;

package/dist/types/index.d.ts

@@ -1,18 +1,45 @@
 import { Bee } from './bee';
+import { BeeDev } from './bee-dev';
+import { Stamper } from './stamper/stamper';
+export { MerkleTree } from 'cafe-utility';
+export { MantarayNode } from './manifest/manifest';
 export { SUPPORTED_BEE_VERSION, SUPPORTED_BEE_VERSION_EXACT } from './modules/debug/status';
 export * from './types';
+export { Bytes } from './utils/bytes';
 export * from './utils/constants';
+export { Duration } from './utils/duration';
 export * from './utils/error';
 export * as Utils from './utils/expose';
-export { Bee };
+export { Size } from './utils/size';
+export * from './utils/tokens';
+export * from './utils/typed-bytes';
+export { Bee, BeeDev, Stamper };
 declare global {
     interface Window {
         BeeJs: {
             Bee: typeof import('./bee').Bee;
+            BeeDev: typeof import('./bee-dev').BeeDev;
+            Stamper: typeof import('./stamper/stamper').Stamper;
             Utils: typeof import('./utils/expose');
+            Duration: typeof import('./utils/duration').Duration;
+            Size: typeof import('./utils/size').Size;
             BeeError: typeof import('./utils/error').BeeError;
             BeeArgumentError: typeof import('./utils/error').BeeArgumentError;
             BeeResponseError: typeof import('./utils/error').BeeResponseError;
+            MantarayNode: typeof import('./manifest/manifest').MantarayNode;
+            MerkleTree: typeof import('cafe-utility').MerkleTree;
+            PrivateKey: typeof import('./utils/typed-bytes').PrivateKey;
+            PublicKey: typeof import('./utils/typed-bytes').PublicKey;
+            EthAddress: typeof import('./utils/typed-bytes').EthAddress;
+            Identifier: typeof import('./utils/typed-bytes').Identifier;
+            Reference: typeof import('./utils/typed-bytes').Reference;
+            TransactionId: typeof import('./utils/typed-bytes').TransactionId;
+            Span: typeof import('./utils/typed-bytes').Span;
+            PeerAddress: typeof import('./utils/typed-bytes').PeerAddress;
+            BatchId: typeof import('./utils/typed-bytes').BatchId;
+            Signature: typeof import('./utils/typed-bytes').Signature;
+            Topic: typeof import('./utils/typed-bytes').Topic;
+            FeedIndex: typeof import('./utils/typed-bytes').FeedIndex;
         };
     }
 }

package/dist/types/manifest/manifest.d.ts

@@ -0,0 +1,106 @@
+import { Optional, Uint8ArrayReader } from 'cafe-utility';
+import { Bee, BeeRequestOptions, DownloadOptions, UploadOptions, UploadResult } from '..';
+import { FeedPayloadResult } from '../modules/feed';
+import { Bytes } from '../utils/bytes';
+import { BatchId, Reference } from '../utils/typed-bytes';
+export declare class Fork {
+    prefix: Uint8Array;
+    node: MantarayNode;
+    constructor(prefix: Uint8Array, node: MantarayNode);
+    static split(a: Fork, b: Fork): Fork;
+    marshal(): Uint8Array;
+    static unmarshal(reader: Uint8ArrayReader): Fork;
+}
+interface MantarayNodeOptions {
+    selfAddress?: Uint8Array;
+    targetAddress?: Uint8Array;
+    obfuscationKey?: Uint8Array;
+    metadata?: Record<string, string> | null;
+    path?: Uint8Array | null;
+    parent?: MantarayNode | null;
+}
+export declare class MantarayNode {
+    obfuscationKey: Uint8Array;
+    selfAddress: Uint8Array | null;
+    targetAddress: Uint8Array;
+    metadata: Record<string, string> | undefined | null;
+    path: Uint8Array;
+    forks: Map<number, Fork>;
+    parent: MantarayNode | null;
+    constructor(options?: MantarayNodeOptions);
+    get fullPath(): Uint8Array;
+    get fullPathString(): string;
+    /**
+     * Returns the metadata at the `/` path to access idiomatic properties.
+     */
+    getRootMetadata(): Optional<Record<string, string>>;
+    /**
+     * Returns the `swarm-index-document` and `swarm-error-document` metadata values.
+     */
+    getDocsMetadata(): {
+        indexDocument: string | null;
+        errorDocument: string | null;
+    };
+    /**
+     * Attempts to resolve the manifest as a feed, returning the latest update.
+     */
+    resolveFeed(bee: Bee, requestOptions?: BeeRequestOptions): Promise<Optional<FeedPayloadResult>>;
+    /**
+     * Gets the binary representation of the node.
+     */
+    marshal(): Promise<Uint8Array>;
+    /**
+     * Downloads and unmarshals a MantarayNode from the given reference.
+     *
+     * Do not forget calling `loadRecursively` on the returned node to load the entire tree.
+     */
+    static unmarshal(bee: Bee, reference: Reference | Uint8Array | string, options?: DownloadOptions, requestOptions?: BeeRequestOptions): Promise<MantarayNode>;
+    /**
+     * Unmarshals a MantarayNode from the given data.
+     *
+     * Do not forget calling `loadRecursively` on the returned node to load the entire tree.
+     */
+    static unmarshalFromData(data: Uint8Array): MantarayNode;
+    /**
+     * Adds a fork to the node.
+     */
+    addFork(path: string | Uint8Array, reference: string | Uint8Array | Bytes | Reference, metadata?: Record<string, string> | null): void;
+    /**
+     * Removes a fork from the node.
+     */
+    removeFork(path: string | Uint8Array): void;
+    /**
+     * Calculates the self address of the node.
+     */
+    calculateSelfAddress(): Promise<Reference>;
+    /**
+     * Saves the node and its children recursively.
+     */
+    saveRecursively(bee: Bee, postageBatchId: string | BatchId, options?: UploadOptions, requestOptions?: BeeRequestOptions): Promise<UploadResult>;
+    /**
+     * Loads the node and its children recursively.
+     */
+    loadRecursively(bee: Bee, options?: DownloadOptions, requestOptions?: BeeRequestOptions): Promise<void>;
+    /**
+     * Finds a node in the tree by its path.
+     */
+    find(path: string | Uint8Array): MantarayNode | null;
+    /**
+     * Finds the closest node in the tree to the given path.
+     */
+    findClosest(path: string | Uint8Array, current?: Uint8Array): [MantarayNode, Uint8Array];
+    /**
+     * Returns an array of all nodes in the tree which have a target address set.
+     *
+     * Must be called after `loadRecursively`.
+     */
+    collect(nodes?: MantarayNode[]): MantarayNode[];
+    /**
+     * Returns a path:reference map of all nodes in the tree which have a target address set.
+     *
+     * Must be called after `loadRecursively`.
+     */
+    collectAndMap(): Record<string, string>;
+    determineType(): number;
+}
+export {};

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

@@ -1,5 +1,8 @@
-import type { BatchId, BeeRequestOptions, Data, DownloadRedundancyOptions, ReferenceInformation, ReferenceOrEns, UploadOptions, UploadRedundancyOptions } from '../types';
+import type { BeeRequestOptions, DownloadOptions, RedundantUploadOptions, ReferenceInformation } from '../types';
 import { UploadResult } from '../types';
+import { Bytes } from '../utils/bytes';
+import { ResourceLocator } from '../utils/resource-locator';
+import { BatchId, Reference } from '../utils/typed-bytes';
 /**
  * Upload data to a Bee node
  *
@@ -8,25 +11,25 @@ import { UploadResult } from '../types';
  * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
  * @param options         Additional options like tag, encryption, pinning
  */
-export declare function upload(requestOptions: BeeRequestOptions, data: string | Uint8Array, postageBatchId: BatchId, options?: UploadOptions & UploadRedundancyOptions): Promise<UploadResult>;
+export declare function upload(requestOptions: BeeRequestOptions, data: string | Uint8Array, postageBatchId: BatchId, options?: RedundantUploadOptions): Promise<UploadResult>;
 /**
  * Requests content length for a reference
  *
  * @param requestOptions Options for making requests
  * @param hash Bee content reference
  */
-export declare function head(requestOptions: BeeRequestOptions, hash: ReferenceOrEns): Promise<ReferenceInformation>;
+export declare function head(requestOptions: BeeRequestOptions, reference: Reference | Uint8Array | string): Promise<ReferenceInformation>;
 /**
  * Download data as a byte array
  *
  * @param requestOptions Options for making requests
  * @param hash Bee content reference
  */
-export declare function download(requestOptions: BeeRequestOptions, hash: ReferenceOrEns, options?: DownloadRedundancyOptions): Promise<Data>;
+export declare function download(requestOptions: BeeRequestOptions, resource: ResourceLocator, options?: DownloadOptions): Promise<Bytes>;
 /**
  * Download data as a readable stream
  *
  * @param requestOptions Options for making requests
  * @param hash Bee content reference
  */
-export declare function downloadReadable(requestOptions: BeeRequestOptions, hash: ReferenceOrEns, options?: DownloadRedundancyOptions): Promise<ReadableStream<Uint8Array>>;
+export declare function downloadReadable(requestOptions: BeeRequestOptions, resource: ResourceLocator, options?: DownloadOptions): Promise<ReadableStream<Uint8Array>>;

package/dist/types/modules/bzz.d.ts

@@ -1,6 +1,9 @@
 /// <reference types="node" />
 import { Readable } from 'stream';
-import { BatchId, BeeRequestOptions, Collection, CollectionUploadOptions, Data, DownloadRedundancyOptions, FileData, FileUploadOptions, ReferenceOrEns, UploadHeaders, UploadRedundancyOptions, UploadResult } from '../types';
+import { BeeRequestOptions, Collection, CollectionUploadOptions, DownloadOptions, FileData, FileUploadOptions, UploadResult } from '../types';
+import { Bytes } from '../utils/bytes';
+import { ResourceLocator } from '../utils/resource-locator';
+import { BatchId, Reference } from '../utils/typed-bytes';
 /**
  * Upload single file
  *
@@ -10,7 +13,7 @@ import { BatchId, BeeRequestOptions, Collection, CollectionUploadOptions, Data,
  * @param name Name that will be attached to the uploaded file. Wraps the data into manifest with set index document.
  * @param options
  */
-export declare function uploadFile(requestOptions: BeeRequestOptions, data: string | Uint8Array | Readable | ArrayBuffer, postageBatchId: BatchId, name?: string, options?: FileUploadOptions & UploadRedundancyOptions): Promise<UploadResult>;
+export declare function uploadFile(requestOptions: BeeRequestOptions, data: string | Uint8Array | Readable | ArrayBuffer, postageBatchId: BatchId, name?: string, options?: FileUploadOptions): Promise<UploadResult>;
 /**
  * Download single file as a buffer
  *
@@ -18,7 +21,7 @@ export declare function uploadFile(requestOptions: BeeRequestOptions, data: stri
  * @param hash Bee file or collection hash
  * @param path If hash is collection then this defines path to a single file in the collection
  */
-export declare function downloadFile(requestOptions: BeeRequestOptions, hash: ReferenceOrEns, path?: string, options?: DownloadRedundancyOptions): Promise<FileData<Data>>;
+export declare function downloadFile(requestOptions: BeeRequestOptions, resource: ResourceLocator, path?: string, options?: DownloadOptions): Promise<FileData<Bytes>>;
 /**
  * Download single file as a readable stream
  *
@@ -26,13 +29,8 @@ export declare function downloadFile(requestOptions: BeeRequestOptions, hash: Re
  * @param hash Bee file or collection hash
  * @param path If hash is collection then this defines path to a single file in the collection
  */
-export declare function downloadFileReadable(requestOptions: BeeRequestOptions, hash: ReferenceOrEns, path?: string, options?: DownloadRedundancyOptions): Promise<FileData<ReadableStream<Uint8Array>>>;
+export declare function downloadFileReadable(requestOptions: BeeRequestOptions, reference: Reference, path?: string, options?: DownloadOptions): Promise<FileData<ReadableStream<Uint8Array>>>;
 /*******************************************************************************************************************/
-export interface CollectionUploadHeaders extends UploadHeaders {
-    'swarm-index-document'?: string;
-    'swarm-error-document'?: string;
-}
-export declare function extractCollectionUploadHeaders(postageBatchId: BatchId, options?: CollectionUploadOptions & UploadRedundancyOptions): CollectionUploadHeaders & UploadRedundancyOptions;
 /**
  * Upload collection
  * @param requestOptions Options for making requests
@@ -40,4 +38,4 @@ export declare function extractCollectionUploadHeaders(postageBatchId: BatchId,
  * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
  * @param options
  */
-export declare function uploadCollection(requestOptions: BeeRequestOptions, collection: Collection, postageBatchId: BatchId, options?: CollectionUploadOptions & UploadRedundancyOptions): Promise<UploadResult>;
+export declare function uploadCollection(requestOptions: BeeRequestOptions, collection: Collection, postageBatchId: BatchId, options?: CollectionUploadOptions): Promise<UploadResult>;

package/dist/types/modules/chunk.d.ts

@@ -1,4 +1,5 @@
-import type { BatchId, BeeRequestOptions, Data, ReferenceOrEns, UploadOptions, UploadResult } from '../types';
+import type { BeeRequestOptions, DownloadOptions, EnvelopeWithBatchId, UploadOptions, UploadResult } from '../types';
+import { BatchId, Reference } from '../utils/typed-bytes';
 /**
  * Upload chunk to a Bee node
  *
@@ -11,7 +12,7 @@ import type { BatchId, BeeRequestOptions, Data, ReferenceOrEns, UploadOptions, U
  * @param stamp BatchId or marshaled stamp to be used for the upload
  * @param options Additional options like tag, encryption, pinning
  */
-export declare function upload(requestOptions: BeeRequestOptions, data: Uint8Array, stamp: BatchId | Uint8Array | string, options?: UploadOptions): Promise<UploadResult>;
+export declare function upload(requestOptions: BeeRequestOptions, data: Uint8Array, stamp: EnvelopeWithBatchId | BatchId | Uint8Array | string, options?: UploadOptions): Promise<UploadResult>;
 /**
  * Download chunk data as a byte array
  *
@@ -19,4 +20,4 @@ export declare function upload(requestOptions: BeeRequestOptions, data: Uint8Arr
  * @param hash Bee content reference
  *
  */
-export declare function download(requestOptions: BeeRequestOptions, hash: ReferenceOrEns): Promise<Data>;
+export declare function download(requestOptions: BeeRequestOptions, reference: Reference | string | Uint8Array, options?: DownloadOptions): Promise<Uint8Array>;

package/dist/types/modules/debug/balance.d.ts

@@ -1,4 +1,5 @@
 import type { BalanceResponse, BeeRequestOptions, PeerBalance } from '../../types';
+import { PeerAddress } from '../../utils/typed-bytes';
 /**
  * Get the balances with all known peers including prepaid services
  *
@@ -11,7 +12,7 @@ export declare function getAllBalances(requestOptions: BeeRequestOptions): Promi
  * @param requestOptions Options for making requests
  * @param address Swarm address of peer
  */
-export declare function getPeerBalance(requestOptions: BeeRequestOptions, address: string): Promise<PeerBalance>;
+export declare function getPeerBalance(requestOptions: BeeRequestOptions, address: PeerAddress): Promise<PeerBalance>;
 /**
  * Get the past due consumption balances with all known peers
  *
@@ -24,4 +25,4 @@ export declare function getPastDueConsumptionBalances(requestOptions: BeeRequest
  * @param requestOptions Options for making requests
  * @param address Swarm address of peer
  */
-export declare function getPastDueConsumptionPeerBalance(requestOptions: BeeRequestOptions, address: string): Promise<PeerBalance>;
+export declare function getPastDueConsumptionPeerBalance(requestOptions: BeeRequestOptions, address: PeerAddress): Promise<PeerBalance>;

package/dist/types/modules/debug/chequebook.d.ts

@@ -1,4 +1,5 @@
-import type { BeeRequestOptions, CashoutOptions, ChequebookAddressResponse, ChequebookBalanceResponse, LastCashoutActionResponse, LastChequesForPeerResponse, LastChequesResponse, NumberString, TransactionHash } from '../../types';
+import type { BeeRequestOptions, ChequebookAddressResponse, ChequebookBalanceResponse, LastCashoutActionResponse, LastChequesForPeerResponse, LastChequesResponse, NumberString, TransactionOptions } from '../../types';
+import { PeerAddress, TransactionId } from '../../utils/typed-bytes';
 /**
  * Get the address of the chequebook contract used
  *
@@ -17,7 +18,7 @@ export declare function getChequebookBalance(requestOptions: BeeRequestOptions):
  * @param requestOptions Options for making requests
  * @param peer  Swarm address of peer
  */
-export declare function getLastCashoutAction(requestOptions: BeeRequestOptions, peer: string): Promise<LastCashoutActionResponse>;
+export declare function getLastCashoutAction(requestOptions: BeeRequestOptions, peer: PeerAddress): Promise<LastCashoutActionResponse>;
 /**
  * Cashout the last cheque for the peer
  *
@@ -25,14 +26,14 @@ export declare function getLastCashoutAction(requestOptions: BeeRequestOptions,
  * @param peer  Swarm address of peer
  * @param options
  */
-export declare function cashoutLastCheque(requestOptions: BeeRequestOptions, peer: string, options?: CashoutOptions): Promise<TransactionHash>;
+export declare function cashoutLastCheque(requestOptions: BeeRequestOptions, peer: PeerAddress, options?: TransactionOptions): Promise<TransactionId>;
 /**
  * Get last cheques for the peer
  *
  * @param requestOptions Options for making requests
  * @param peer  Swarm address of peer
  */
-export declare function getLastChequesForPeer(requestOptions: BeeRequestOptions, peer: string): Promise<LastChequesForPeerResponse>;
+export declare function getLastChequesForPeer(requestOptions: BeeRequestOptions, peer: PeerAddress): Promise<LastChequesForPeerResponse>;
 /**
  * Get last cheques for all peers
  *
@@ -47,7 +48,7 @@ export declare function getLastCheques(requestOptions: BeeRequestOptions): Promi
  * @param gasPrice Gas Price in WEI for the transaction call
  * @return string  Hash of the transaction
  */
-export declare function depositTokens(requestOptions: BeeRequestOptions, amount: number | NumberString, gasPrice?: NumberString): Promise<TransactionHash>;
+export declare function depositTokens(requestOptions: BeeRequestOptions, amount: NumberString | string | bigint, gasPrice?: NumberString | string | bigint): Promise<TransactionId>;
 /**
  * Withdraw tokens from the chequebook to the overlay address
  *
@@ -56,4 +57,4 @@ export declare function depositTokens(requestOptions: BeeRequestOptions, amount:
  * @param gasPrice Gas Price in WEI for the transaction call
  * @return string  Hash of the transaction
  */
-export declare function withdrawTokens(requestOptions: BeeRequestOptions, amount: number | NumberString, gasPrice?: NumberString): Promise<TransactionHash>;
+export declare function withdrawTokens(requestOptions: BeeRequestOptions, amount: NumberString | string | bigint, gasPrice?: NumberString | string | bigint): Promise<TransactionId>;

package/dist/types/modules/debug/connectivity.d.ts

@@ -1,7 +1,9 @@
-import type { BeeRequestOptions, NodeAddresses, Peer, PingResponse, RemovePeerResponse, Topology } from '../../types';
+import type { BeeRequestOptions, Bin, NodeAddresses, Peer, PingResponse, RemovePeerResponse, Topology } from '../../types';
+import { PeerAddress } from '../../utils/typed-bytes';
 export declare function getNodeAddresses(requestOptions: BeeRequestOptions): Promise<NodeAddresses>;
 export declare function getPeers(requestOptions: BeeRequestOptions): Promise<Peer[]>;
 export declare function getBlocklist(requestOptions: BeeRequestOptions): Promise<Peer[]>;
-export declare function removePeer(requestOptions: BeeRequestOptions, peer: string): Promise<RemovePeerResponse>;
+export declare function removePeer(requestOptions: BeeRequestOptions, peer: PeerAddress): Promise<RemovePeerResponse>;
 export declare function getTopology(requestOptions: BeeRequestOptions): Promise<Topology>;
-export declare function pingPeer(requestOptions: BeeRequestOptions, peer: string): Promise<PingResponse>;
+export declare function pingPeer(requestOptions: BeeRequestOptions, peer: PeerAddress): Promise<PingResponse>;
+export declare function asBin(value: unknown, name: string): Bin;

package/dist/types/modules/debug/settlements.d.ts

@@ -1,11 +1,12 @@
 import type { AllSettlements, BeeRequestOptions, Settlements } from '../../types';
+import { PeerAddress } from '../../utils/typed-bytes';
 /**
  * Get amount of sent and received from settlements with a peer
  *
  * @param requestOptions Options for making requests
  * @param peer  Swarm address of peer
  */
-export declare function getSettlements(requestOptions: BeeRequestOptions, peer: string): Promise<Settlements>;
+export declare function getSettlements(requestOptions: BeeRequestOptions, peer: PeerAddress): Promise<Settlements>;
 /**
  * Get settlements with all known peers and total amount sent or received
  *

package/dist/types/modules/debug/stake.d.ts

@@ -1,10 +1,12 @@
 import { BeeRequestOptions, NumberString, RedistributionState, TransactionOptions } from '../../types';
+import { BZZ } from '../../utils/tokens';
+import { TransactionId } from '../../utils/typed-bytes';
 /**
  * Gets the staked amount
  *
  * @param requestOptions Options for making requests
  */
-export declare function getStake(requestOptions: BeeRequestOptions): Promise<NumberString>;
+export declare function getStake(requestOptions: BeeRequestOptions): Promise<BZZ>;
 /**
  * Stake given amount of tokens.
  *
@@ -12,7 +14,7 @@ export declare function getStake(requestOptions: BeeRequestOptions): Promise<Num
  * @param amount
  * @param options
  */
-export declare function stake(requestOptions: BeeRequestOptions, amount: NumberString, options?: TransactionOptions): Promise<void>;
+export declare function stake(requestOptions: BeeRequestOptions, amount: NumberString | string | bigint, options?: TransactionOptions): Promise<TransactionId>;
 /**
  * Get current status of node in redistribution game
  *

package/dist/types/modules/debug/stamps.d.ts

@@ -1,8 +1,9 @@
-import type { BatchId, BeeRequestOptions, NumberString, PostageBatch, PostageBatchBuckets, PostageBatchOptions } from '../../types';
-export declare function getGlobalPostageBatches(requestOptions: BeeRequestOptions): Promise<PostageBatch[]>;
+import type { BeeRequestOptions, GlobalPostageBatch, NumberString, PostageBatch, PostageBatchBuckets, PostageBatchOptions } from '../../types';
+import { BatchId } from '../../utils/typed-bytes';
+export declare function getGlobalPostageBatches(requestOptions: BeeRequestOptions): Promise<GlobalPostageBatch[]>;
 export declare function getAllPostageBatches(requestOptions: BeeRequestOptions): Promise<PostageBatch[]>;
 export declare function getPostageBatch(requestOptions: BeeRequestOptions, postageBatchId: BatchId): Promise<PostageBatch>;
 export declare function getPostageBatchBuckets(requestOptions: BeeRequestOptions, postageBatchId: BatchId): Promise<PostageBatchBuckets>;
 export declare function createPostageBatch(requestOptions: BeeRequestOptions, amount: NumberString, depth: number, options?: PostageBatchOptions): Promise<BatchId>;
-export declare function topUpBatch(requestOptions: BeeRequestOptions, id: string, amount: NumberString): Promise<BatchId>;
-export declare function diluteBatch(requestOptions: BeeRequestOptions, id: string, depth: number): Promise<BatchId>;
+export declare function topUpBatch(requestOptions: BeeRequestOptions, id: BatchId, amount: NumberString): Promise<BatchId>;
+export declare function diluteBatch(requestOptions: BeeRequestOptions, id: BatchId, depth: number): Promise<BatchId>;