@ethersphere/bee-js 12.2.1 → 12.3.0

package/dist/mjs/utils/type.js

@@ -1,8 +1,6 @@
-import { Types } from 'cafe-utility';
 import * as stream from 'stream';
-import { TAGS_LIMIT_MAX, TAGS_LIMIT_MIN } from "../types/index.js";
 import { isFile } from "./file.js";
-import { PublicKey, Reference } from "./typed-bytes.js";
+import { TagInputSchema, TagUidSchema } from "./schema.js";
 export function isReadable(value) {
   return typeof stream.Readable !== 'undefined' && value instanceof stream.Readable;
 }
@@ -10,214 +8,19 @@ export function asNumberString(value, options) {
   if (typeof value === 'bigint') {
     value = value.toString();
   }
-  return Types.asIntegerString(value, options);
-}
-export function prepareBeeRequestOptions(value) {
-  const object = Types.asObject(value, {
-    name: 'BeeRequestOptions'
-  });
-  return {
-    baseURL: Types.asOptional(x => Types.asString(x, {
-      name: 'baseURL'
-    }), object.baseURL),
-    timeout: Types.asOptional(x => Types.asInteger(x, {
-      name: 'timeout',
-      min: 0
-    }), object.timeout),
-    headers: Types.asOptional(x => Types.asStringMap(x, {
-      name: 'headers'
-    }), object.headers),
-    onRequest: Types.asOptional(x => Types.asFunction(x, {
-      name: 'onRequest'
-    }), object.onRequest),
-    httpAgent: object.httpAgent,
-    httpsAgent: object.httpsAgent,
-    endlesslyRetry: Types.asOptional(x => Types.asBoolean(x, {
-      name: 'endlesslyRetry'
-    }), object.endlesslyRetry),
-    signal: object.signal
-  };
-}
-export function prepareDownloadOptions(value) {
-  const object = Types.asObject(value, {
-    name: 'DownloadOptions'
-  });
-  return {
-    redundancyStrategy: Types.asOptional(x => Types.asInteger(x, {
-      name: 'redundancyStrategy'
-    }), object.redundancyStrategy),
-    fallback: Types.asOptional(x => Types.asBoolean(x, {
-      name: 'fallback'
-    }), object.fallback),
-    timeoutMs: Types.asOptional(x => Types.asInteger(x, {
-      name: 'timeoutMs',
-      min: 0
-    }), object.timeoutMs),
-    actPublisher: Types.asOptional(x => new PublicKey(x), object.actPublisher),
-    actHistoryAddress: Types.asOptional(x => new Reference(x), object.actHistoryAddress),
-    actTimestamp: Types.asOptional(x => Types.asNumber(x, {
-      name: 'actTimestamp'
-    }), object.actTimestamp)
-  };
-}
-export function prepareUploadOptions(value, name = 'UploadOptions') {
-  const object = Types.asObject(value, {
-    name
-  });
-  return {
-    act: Types.asOptional(x => Types.asBoolean(x, {
-      name: 'act'
-    }), object.act),
-    actHistoryAddress: Types.asOptional(x => new Reference(x), object.actHistoryAddress),
-    deferred: Types.asOptional(x => Types.asBoolean(x, {
-      name: 'deferred'
-    }), object.deferred),
-    encrypt: Types.asOptional(x => Types.asBoolean(x, {
-      name: 'encrypt'
-    }), object.encrypt),
-    pin: Types.asOptional(x => Types.asBoolean(x, {
-      name: 'pin'
-    }), object.pin),
-    tag: Types.asOptional(x => Types.asInteger(x, {
-      name: 'tag',
-      min: 0
-    }), object.tag)
-  };
-}
-export function prepareRedundantUploadOptions(value, name = 'UploadOptions') {
-  const uploadOptions = prepareUploadOptions(value, name);
-  const object = Types.asObject(value, {
-    name
-  });
-  return {
-    ...uploadOptions,
-    redundancyLevel: Types.asOptional(x => Types.asInteger(x, {
-      name: 'redundancyLevel',
-      min: 0
-    }), object.redundancyLevel)
-  };
-}
-export function prepareFileUploadOptions(value) {
-  const uploadOptions = prepareUploadOptions(value, 'FileUploadOptions');
-  const object = Types.asObject(value, {
-    name: 'FileUploadOptions'
-  });
-  return {
-    ...uploadOptions,
-    size: Types.asOptional(x => Types.asInteger(x, {
-      name: 'size',
-      min: 0
-    }), object.size),
-    contentType: Types.asOptional(x => Types.asString(x, {
-      name: 'contentType'
-    }), object.contentType),
-    redundancyLevel: Types.asOptional(x => Types.asInteger(x, {
-      name: 'redundancyLevel',
-      min: 0
-    }), object.redundancyLevel)
-  };
-}
-export function prepareCollectionUploadOptions(value) {
-  const uploadOptions = prepareUploadOptions(value, 'CollectionUploadOptions');
-  const object = Types.asObject(value, {
-    name: 'CollectionUploadOptions'
-  });
-  return {
-    ...uploadOptions,
-    errorDocument: Types.asOptional(x => Types.asString(x, {
-      name: 'errorDocument'
-    }), object.errorDocument),
-    indexDocument: Types.asOptional(x => Types.asString(x, {
-      name: 'indexDocument'
-    }), object.indexDocument),
-    redundancyLevel: Types.asOptional(x => Types.asInteger(x, {
-      name: 'redundancyLevel',
-      min: 0
-    }), object.redundancyLevel)
-  };
-}
-export function isTag(value) {
-  try {
-    const object = Types.asObject(value, {
-      name: 'Tag'
-    });
-    Types.asInteger(object.uid, {
-      name: 'Tag.uid'
-    });
-    return true;
-  } catch {
-    return false;
+  if (typeof value !== 'string' || !/^-?\d+$/.test(value)) {
+    throw new TypeError(`${options?.name ?? 'value'} is not a valid integer string, got: ${value}`);
   }
+  if (options?.min !== undefined && BigInt(value) < options.min) {
+    throw new RangeError(`${options?.name ?? 'value'} must be >= ${options.min}, got: ${value}`);
+  }
+  if (options?.max !== undefined && BigInt(value) > options.max) {
+    throw new RangeError(`${options?.name ?? 'value'} must be <= ${options.max}, got: ${value}`);
+  }
+  return value;
 }
-export function preparePssMessageHandler(value) {
-  const object = Types.asObject(value, {
-    name: 'PssMessageHandler'
-  });
-  return {
-    onMessage: Types.asFunction(object.onMessage, {
-      name: 'onMessage'
-    }),
-    onError: Types.asFunction(object.onError, {
-      name: 'onError'
-    }),
-    onClose: Types.asFunction(object.onClose, {
-      name: 'onClose'
-    })
-  };
-}
-export function prepareGsocMessageHandler(value) {
-  const object = Types.asObject(value, {
-    name: 'GsocMessageHandler'
-  });
-  return {
-    onMessage: Types.asFunction(object.onMessage, {
-      name: 'onMessage'
-    }),
-    onError: Types.asFunction(object.onError, {
-      name: 'onError'
-    }),
-    onClose: Types.asFunction(object.onClose, {
-      name: 'onClose'
-    })
-  };
-}
-export function preparePostageBatchOptions(value) {
-  const object = Types.asObject(value, {
-    name: 'PostageBatchOptions'
-  });
-  return {
-    gasPrice: Types.asOptional(x => asNumberString(x, {
-      name: 'gasPrice'
-    }), object.gasPrice),
-    immutableFlag: Types.asOptional(x => Types.asBoolean(x, {
-      name: 'immutableFlag'
-    }), object.immutableFlag),
-    label: Types.asOptional(x => Types.asString(x, {
-      name: 'label'
-    }), object.label),
-    waitForUsable: Types.asOptional(x => Types.asBoolean(x, {
-      name: 'waitForUsable'
-    }), object.waitForUsable),
-    waitForUsableTimeout: Types.asOptional(x => Types.asInteger(x, {
-      name: 'waitForUsableTimeout',
-      min: 0
-    }), object.waitForUsableTimeout)
-  };
-}
-export function prepareTransactionOptions(value, name = 'TransactionOptions') {
-  const object = Types.asObject(value, {
-    name
-  });
-  return {
-    gasLimit: Types.asOptional(x => asNumberString(x, {
-      name: 'gasLimit',
-      min: 0n
-    }), object.gasLimit),
-    gasPrice: Types.asOptional(x => asNumberString(x, {
-      name: 'gasPrice',
-      min: 0n
-    }), object.gasPrice)
-  };
+export function isTag(value) {
+  return TagInputSchema.safeParse(value).success;
 }
 /**
  * Check whether the given parameter is valid data to upload
@@ -239,26 +42,6 @@ export function assertFileData(value) {
     throw new TypeError('Data must be either string, Readable, Uint8Array or File!');
   }
 }
-/**
- * Checks whether optional options for AllTags query are valid
- * @param options
- */
-export function prepareAllTagsOptions(value) {
-  const object = Types.asObject(value, {
-    name: 'AllTagsOptions'
-  });
-  return {
-    limit: Types.asOptional(x => Types.asInteger(x, {
-      name: 'limit',
-      min: TAGS_LIMIT_MIN,
-      max: TAGS_LIMIT_MAX
-    }), object.limit),
-    offset: Types.asOptional(x => Types.asInteger(x, {
-      name: 'offset',
-      min: 0
-    }), object.offset)
-  };
-}
 /**
  * Utility functions that return Tag UID
  * @param tagUid
@@ -270,10 +53,7 @@ export function makeTagUid(tagUid) {
   if (isTag(tagUid)) {
     return tagUid.uid;
   } else if (typeof tagUid === 'number' || typeof tagUid === 'string') {
-    return Types.asNumber(tagUid, {
-      name: 'tagUid',
-      min: 0
-    });
+    return TagUidSchema.parse(tagUid);
   }
   throw new TypeError(`Expected number | Tag | string from tagUid, got: ${tagUid}`);
 }

package/dist/mjs/utils/url.js

@@ -1,3 +1,4 @@
+import { BAD_PORTS } from "./bad-ports.js";
 import { BeeArgumentError } from "./error.js";
 /**
  * Validates that passed string is valid URL of Bee.
@@ -17,6 +18,24 @@ export function isValidBeeUrl(url) {
     return false;
   }
 }
+/**
+ * Validates that passed string is valid port to use Bee and is not a bad port.
+ * We support only HTTP and HTTPS protocols. Bad ports are defined in
+ * the WHATWG Fetch spec (https://fetch.spec.whatwg.org/#port-blocking)
+ * and are blocked for HTTP/HTTPS requests.
+ *
+ * @param port
+ */
+export function isValidBeePort(port) {
+  if (typeof port !== 'string') {
+    return false;
+  }
+  if (BAD_PORTS.includes(port)) {
+    return false;
+  }
+  const portNumber = parseInt(port, 10);
+  return portNumber > 0 && portNumber < 65536 && !isNaN(portNumber);
+}
 /**
  * Validates that passed string is valid URL of Bee, if not it throws BeeArgumentError.
  * We support only HTTP and HTTPS protocols.
@@ -27,6 +46,10 @@ export function assertBeeUrl(url) {
   if (!isValidBeeUrl(url)) {
     throw new BeeArgumentError('URL is not valid!', url);
   }
+  const port = new URL(url).port;
+  if (port && !isValidBeePort(port)) {
+    throw new BeeArgumentError('Port in URL is considered bad port and cannot be used!', port);
+  }
 }
 /**
  * Removes trailing slash out of the given string.

package/dist/types/bee.d.ts

@@ -1154,6 +1154,22 @@ export declare class Bee {
      * @returns
      */
     getDurationExtensionCost(postageBatchId: BatchId | Uint8Array | string, duration: Duration, requestOptions?: BeeRequestOptions): Promise<BZZ>;
+    /**
+     * Updates the label of a certain postage batch.
+     *
+     * @param postageBatchId Batch ID of the postage batch to update.
+     * @param label New label for the postage batch.
+     * @param requestOptions Options for making requests, such as timeouts, custom HTTP agents, headers, etc.
+     */
+    updatePostageBatchLabel(postageBatchId: BatchId | Uint8Array | string, label: string, requestOptions?: BeeRequestOptions): Promise<void>;
+    /**
+     * Renames a storage. This is a convenience method that calls {@link updatePostageBatchLabel}.
+     *
+     * @param postageBatchId Batch ID of the postage batch to update.
+     * @param newName New name for the storage.
+     * @param requestOptions Options for making requests, such as timeouts, custom HTTP agents, headers, etc.
+     */
+    renameStorage(postageBatchId: BatchId | Uint8Array | string, newLabel: string, requestOptions?: BeeRequestOptions): Promise<void>;
     /**
      * Calculates the `amount` and expected duration extension for topping up a postage batch with a given BZZ value.
      *
@@ -1228,6 +1244,13 @@ export declare class Bee {
      * @see [Bee Debug API reference - `GET /stamps/${id}`](https://docs.ethswarm.org/api/#tag/Postage-Stamps/paths/~1stamps~1%7Bbatch_id%7D/get)
      */
     getPostageBatch(postageBatchId: BatchId | Uint8Array | string, requestOptions?: BeeRequestOptions, encryption?: boolean, erasureCodeLevel?: RedundancyLevel): Promise<PostageBatch>;
+    /**
+     * Returns details for specific globally available postage batch.
+     *
+     * @param postageBatchId Batch ID
+     * @param requestOptions Options for making requests, such as timeouts, custom HTTP agents, headers, etc.
+     */
+    getGlobalPostageBatch(postageBatchId: BatchId | Uint8Array | string, requestOptions?: BeeRequestOptions): Promise<GlobalPostageBatch>;
     /**
      * Return detailed information related to buckets for specific postage batch.
      *

package/dist/types/index.d.ts

@@ -1,5 +1,4 @@
 import { Bee } from './bee';
-import { BeeDev } from './bee-dev';
 import { Stamper } from './stamper/stamper';
 export { MerkleTree } from 'cafe-utility';
 export type { Chunk } from './chunk/cac';
@@ -16,12 +15,11 @@ export { Size } from './utils/size';
 export * from './utils/tokens';
 export * from './utils/typed-bytes';
 export type { UploadProgress } from './utils/upload-progress';
-export { Bee, BeeDev, Stamper };
+export { Bee, 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;

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

@@ -1,4 +1,5 @@
-import type { BeeRequestOptions, Bin, NodeAddresses, Peer, PingResponse, RemovePeerResponse, Topology } from '../../types';
+import type { BeeRequestOptions, Peer, PingResponse, RemovePeerResponse, Topology } from '../../types';
+import { NodeAddresses } from '../../types/debug';
 import { PeerAddress } from '../../utils/typed-bytes';
 export declare function getNodeAddresses(requestOptions: BeeRequestOptions): Promise<NodeAddresses>;
 export declare function getPeers(requestOptions: BeeRequestOptions): Promise<Peer[]>;
@@ -6,4 +7,3 @@ export declare function getBlocklist(requestOptions: BeeRequestOptions): Promise
 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: PeerAddress): Promise<PingResponse>;
-export declare function asBin(value: unknown, name: string): Bin;

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

@@ -1,9 +1,11 @@
 import type { BeeRequestOptions, GlobalPostageBatch, NumberString, PostageBatch, PostageBatchBuckets, PostageBatchOptions, RedundancyLevel } from '../../types';
 import { BatchId } from '../../utils/typed-bytes';
 export declare function getGlobalPostageBatches(requestOptions: BeeRequestOptions): Promise<GlobalPostageBatch[]>;
+export declare function getGlobalPostageBatch(requestOptions: BeeRequestOptions, postageBatchId: BatchId): Promise<GlobalPostageBatch>;
 export declare function getAllPostageBatches(requestOptions: BeeRequestOptions): Promise<PostageBatch[]>;
 export declare function getPostageBatch(requestOptions: BeeRequestOptions, postageBatchId: BatchId, encryption?: boolean, erasureCodeLevel?: RedundancyLevel): 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 updatePostageBatchLabel(requestOptions: BeeRequestOptions, id: BatchId, label: string): Promise<void>;
 export declare function topUpBatch(requestOptions: BeeRequestOptions, id: BatchId, amount: NumberString): Promise<BatchId>;
 export declare function diluteBatch(requestOptions: BeeRequestOptions, id: BatchId, depth: number): Promise<BatchId>;

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

@@ -219,6 +219,7 @@ export interface ChainState {
     block: number;
     totalAmount: NumberString;
     currentPrice: number;
+    minimumValidityBlocks?: number;
 }
 export interface WalletBalance {
     bzzBalance: BZZ;

package/dist/types/types/schema/balance.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { BZZ } from '../../utils/tokens';
+export declare const GetAllBalancesResponse: z.ZodObject<{
+    balances: z.ZodArray<z.ZodObject<{
+        peer: z.ZodString;
+        balance: z.ZodPipe<z.ZodString, z.ZodTransform<BZZ, string>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const GetPeerBalanceResponse: z.ZodObject<{
+    peer: z.ZodString;
+    balance: z.ZodPipe<z.ZodString, z.ZodTransform<BZZ, string>>;
+}, z.core.$strip>;

package/dist/types/types/schema/chequebook.d.ts

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+import { BZZ } from '../../utils/tokens';
+import { EthAddress, TransactionId } from '../../utils/typed-bytes';
+export declare const GetChequebookAddressResponse: z.ZodObject<{
+    chequebookAddress: z.ZodPipe<z.ZodString, z.ZodTransform<EthAddress, string>>;
+}, z.core.$strip>;
+export declare const GetChequebookBalanceResponse: z.ZodObject<{
+    availableBalance: z.ZodPipe<z.ZodString, z.ZodTransform<BZZ, string>>;
+    totalBalance: z.ZodPipe<z.ZodString, z.ZodTransform<BZZ, string>>;
+}, z.core.$strip>;
+export declare const GetLastCashoutActionResponse: z.ZodObject<{
+    peer: z.ZodString;
+    uncashedAmount: z.ZodPipe<z.ZodString, z.ZodTransform<BZZ, string>>;
+    transactionHash: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+    lastCashedCheque: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        beneficiary: z.ZodPipe<z.ZodString, z.ZodTransform<EthAddress, string>>;
+        chequebook: z.ZodPipe<z.ZodString, z.ZodTransform<EthAddress, string>>;
+        payout: z.ZodPipe<z.ZodString, z.ZodTransform<BZZ, string>>;
+    }, z.core.$strip>>>, z.ZodTransform<{
+        beneficiary: EthAddress;
+        chequebook: EthAddress;
+        payout: BZZ;
+    } | null, {
+        beneficiary: EthAddress;
+        chequebook: EthAddress;
+        payout: BZZ;
+    } | null | undefined>>;
+    result: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        recipient: z.ZodString;
+        lastPayout: z.ZodPipe<z.ZodString, z.ZodTransform<BZZ, string>>;
+        bounced: z.ZodBoolean;
+    }, z.core.$strip>>>, z.ZodTransform<{
+        recipient: string;
+        lastPayout: BZZ;
+        bounced: boolean;
+    } | null, {
+        recipient: string;
+        lastPayout: BZZ;
+        bounced: boolean;
+    } | null | undefined>>;
+}, z.core.$strip>;
+export declare const GetLastChequesForPeerResponse: z.ZodObject<{
+    peer: z.ZodString;
+    lastreceived: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        beneficiary: z.ZodPipe<z.ZodString, z.ZodTransform<EthAddress, string>>;
+        chequebook: z.ZodPipe<z.ZodString, z.ZodTransform<EthAddress, string>>;
+        payout: z.ZodPipe<z.ZodString, z.ZodTransform<BZZ, string>>;
+    }, z.core.$strip>>>, z.ZodTransform<{
+        beneficiary: EthAddress;
+        chequebook: EthAddress;
+        payout: BZZ;
+    } | null, {
+        beneficiary: EthAddress;
+        chequebook: EthAddress;
+        payout: BZZ;
+    } | null | undefined>>;
+    lastsent: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        beneficiary: z.ZodPipe<z.ZodString, z.ZodTransform<EthAddress, string>>;
+        chequebook: z.ZodPipe<z.ZodString, z.ZodTransform<EthAddress, string>>;
+        payout: z.ZodPipe<z.ZodString, z.ZodTransform<BZZ, string>>;
+    }, z.core.$strip>>>, z.ZodTransform<{
+        beneficiary: EthAddress;
+        chequebook: EthAddress;
+        payout: BZZ;
+    } | null, {
+        beneficiary: EthAddress;
+        chequebook: EthAddress;
+        payout: BZZ;
+    } | null | undefined>>;
+}, z.core.$strip>;
+export declare const GetLastChequesResponse: z.ZodObject<{
+    lastcheques: z.ZodArray<z.ZodObject<{
+        peer: z.ZodString;
+        lastreceived: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            beneficiary: z.ZodPipe<z.ZodString, z.ZodTransform<EthAddress, string>>;
+            chequebook: z.ZodPipe<z.ZodString, z.ZodTransform<EthAddress, string>>;
+            payout: z.ZodPipe<z.ZodString, z.ZodTransform<BZZ, string>>;
+        }, z.core.$strip>>>, z.ZodTransform<{
+            beneficiary: EthAddress;
+            chequebook: EthAddress;
+            payout: BZZ;
+        } | null, {
+            beneficiary: EthAddress;
+            chequebook: EthAddress;
+            payout: BZZ;
+        } | null | undefined>>;
+        lastsent: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            beneficiary: z.ZodPipe<z.ZodString, z.ZodTransform<EthAddress, string>>;
+            chequebook: z.ZodPipe<z.ZodString, z.ZodTransform<EthAddress, string>>;
+            payout: z.ZodPipe<z.ZodString, z.ZodTransform<BZZ, string>>;
+        }, z.core.$strip>>>, z.ZodTransform<{
+            beneficiary: EthAddress;
+            chequebook: EthAddress;
+            payout: BZZ;
+        } | null, {
+            beneficiary: EthAddress;
+            chequebook: EthAddress;
+            payout: BZZ;
+        } | null | undefined>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const TransactionHashResponse: z.ZodObject<{
+    transactionHash: z.ZodPipe<z.ZodString, z.ZodTransform<TransactionId, string>>;
+}, z.core.$strip>;

package/dist/types/types/schema/connectivity.d.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { EthAddress, PeerAddress, PublicKey } from '../../utils/typed-bytes';
+export declare const GetNodeAddressesResponse: z.ZodObject<{
+    overlay: z.ZodPipe<z.ZodString, z.ZodTransform<PeerAddress, string>>;
+    underlay: z.ZodArray<z.ZodString>;
+    ethereum: z.ZodPipe<z.ZodString, z.ZodTransform<EthAddress, string>>;
+    publicKey: z.ZodPipe<z.ZodString, z.ZodTransform<PublicKey, string>>;
+    pssPublicKey: z.ZodPipe<z.ZodString, z.ZodTransform<PublicKey, string>>;
+}, z.core.$strip>;
+export declare const GetPeersResponse: z.ZodObject<{
+    peers: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        fullNode: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const GetBlocklistResponse: z.ZodObject<{
+    peers: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        fullNode: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const GetTopologyResponse: z.ZodObject<{
+    baseAddr: z.ZodString;
+    population: z.ZodNumber;
+    connected: z.ZodNumber;
+    timestamp: z.ZodString;
+    nnLowWatermark: z.ZodNumber;
+    depth: z.ZodNumber;
+    reachability: z.ZodString;
+    networkAvailability: z.ZodString;
+    bins: z.ZodRecord<z.ZodString, z.ZodObject<{
+        population: z.ZodNumber;
+        connected: z.ZodNumber;
+        connectedPeers: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            address: z.ZodString;
+        }, z.core.$strip>>>>, z.ZodTransform<{
+            address: string;
+        }[], {
+            address: string;
+        }[] | null | undefined>>;
+        disconnectedPeers: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            address: z.ZodString;
+        }, z.core.$strip>>>>, z.ZodTransform<{
+            address: string;
+        }[], {
+            address: string;
+        }[] | null | undefined>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/dist/types/types/schema/envelope.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export declare const PostEnvelopeBodyResponse: z.ZodObject<{
+    issuer: z.ZodPipe<z.ZodString, z.ZodTransform<Uint8Array<ArrayBufferLike>, string>>;
+    index: z.ZodPipe<z.ZodString, z.ZodTransform<Uint8Array<ArrayBufferLike>, string>>;
+    timestamp: z.ZodPipe<z.ZodString, z.ZodTransform<Uint8Array<ArrayBufferLike>, string>>;
+    signature: z.ZodPipe<z.ZodString, z.ZodTransform<Uint8Array<ArrayBufferLike>, string>>;
+}, z.core.$strip>;

package/dist/types/types/schema/grantee.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { PublicKey, Reference } from '../../utils/typed-bytes';
+export declare const GetGranteesBodyResponse: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<PublicKey, string>>>;
+export declare const GranteesResultBodyResponse: z.ZodObject<{
+    ref: z.ZodPipe<z.ZodString, z.ZodTransform<Reference, string>>;
+    historyref: z.ZodPipe<z.ZodString, z.ZodTransform<Reference, string>>;
+}, z.core.$strip>;

package/dist/types/types/schema/pinning.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+export declare const GetAllPinsResponse: z.ZodObject<{
+    references: z.ZodNullable<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;

package/dist/types/types/schema/rchash.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+export declare const RchashResponse: z.ZodObject<{
+    durationSeconds: z.ZodNumber;
+}, z.core.$strip>;

package/dist/types/types/schema/settlements.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { BZZ } from '../../utils/tokens';
+export declare const GetSettlementsResponse: z.ZodObject<{
+    peer: z.ZodString;
+    sent: z.ZodPipe<z.ZodString, z.ZodTransform<BZZ, string>>;
+    received: z.ZodPipe<z.ZodString, z.ZodTransform<BZZ, string>>;
+}, z.core.$strip>;
+export declare const GetAllSettlementsResponse: z.ZodObject<{
+    totalSent: z.ZodPipe<z.ZodString, z.ZodTransform<BZZ, string>>;
+    totalReceived: z.ZodPipe<z.ZodString, z.ZodTransform<BZZ, string>>;
+    settlements: z.ZodArray<z.ZodObject<{
+        peer: z.ZodString;
+        sent: z.ZodPipe<z.ZodString, z.ZodTransform<BZZ, string>>;
+        received: z.ZodPipe<z.ZodString, z.ZodTransform<BZZ, string>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/dist/types/types/schema/stake.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { BZZ, DAI } from '../../utils/tokens';
+import { TransactionId } from '../../utils/typed-bytes';
+export declare const GetStakeResponse: z.ZodObject<{
+    stakedAmount: z.ZodPipe<z.ZodString, z.ZodTransform<BZZ, string>>;
+}, z.core.$strip>;
+export declare const GetWithdrawableStakeResponse: z.ZodObject<{
+    withdrawableAmount: z.ZodPipe<z.ZodString, z.ZodTransform<BZZ, string>>;
+}, z.core.$strip>;
+export declare const TxHashResponse: z.ZodObject<{
+    txHash: z.ZodPipe<z.ZodString, z.ZodTransform<TransactionId, string>>;
+}, z.core.$strip>;
+export declare const GetRedistributionStateResponse: z.ZodObject<{
+    minimumGasFunds: z.ZodPipe<z.ZodString, z.ZodTransform<DAI, string>>;
+    hasSufficientFunds: z.ZodBoolean;
+    isFrozen: z.ZodBoolean;
+    isFullySynced: z.ZodBoolean;
+    phase: z.ZodString;
+    round: z.ZodNumber;
+    lastWonRound: z.ZodNumber;
+    lastPlayedRound: z.ZodNumber;
+    lastFrozenRound: z.ZodNumber;
+    lastSelectedRound: z.ZodNumber;
+    lastSampleDurationSeconds: z.ZodNumber;
+    block: z.ZodNumber;
+    reward: z.ZodPipe<z.ZodString, z.ZodTransform<BZZ, string>>;
+    fees: z.ZodPipe<z.ZodString, z.ZodTransform<DAI, string>>;
+    isHealthy: z.ZodBoolean;
+}, z.core.$strip>;