@nemtus/symbol-rest-api-client-fetch 1.0.1 → 1.0.2

package/cjs/api/apis/AccountRoutesApi.d.ts

@@ -10,29 +10,110 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { AccountIds, AccountInfoDTO, AccountOrderByEnum, AccountPage, MerkleStateInfoDTO, Order } from '../models/index';
+import { type AccountIds } from '../models/AccountIds';
+import { type AccountInfoDTO } from '../models/AccountInfoDTO';
+import { type AccountOrderByEnum } from '../models/AccountOrderByEnum';
+import { type AccountPage } from '../models/AccountPage';
+import { type MerkleStateInfoDTO } from '../models/MerkleStateInfoDTO';
+import { type Order } from '../models/Order';
 export interface GetAccountInfoRequest {
+    /**
+     * Account public key as 64 hexadecimal characters, or account address as 39 Base32
+     * (network prefix `T` for testnet, `N` for mainnet).
+     *
+     */
     accountId: string;
 }
 export interface GetAccountInfoMerkleRequest {
+    /**
+     * Account public key as 64 hexadecimal characters, or account address as 39 Base32
+     * (network prefix `T` for testnet, `N` for mainnet).
+     *
+     */
     accountId: string;
 }
 export interface GetAccountsInfoRequest {
+    /**
+     *
+     */
     accountIds?: AccountIds;
 }
 export interface SearchAccountsRequest {
+    /**
+     * Filter by address (include), in Base32 format.
+     *
+     * The exact meaning depends on the endpoint:
+     * - transaction search: returns transactions where the address appears as the sender, recipient, or cosigner
+     * - account search: matches the account address
+     * - account restriction search: matches the restricted account address
+     * - hash lock and secret lock search: matches the lock owner address
+     *
+     * On transaction search endpoints, this filter cannot be combined with `recipientAddress` and
+     * `signerPublicKey`.
+     *
+     */
     address?: string;
+    /**
+     * Select the number of entries to return per page.
+     * Values outside the allowed range are clamped to the schema minimum or maximum.
+     *
+     */
     pageSize?: number;
+    /**
+     * Page number for numbered pagination (1-based).
+     *
+     * Numbered and cursor pagination can be combined, but this is not recommended because the semantics
+     * are harder to reason about. For cursor-style flows, keep `pageNumber=1` and advance pages by
+     * updating only `offset`. For numbered pagination flows, omit `offset` and advance pages by
+     * incrementing `pageNumber`.
+     *
+     */
     pageNumber?: number;
+    /**
+     * Cursor for pagination. Provide the value of the sort field (`orderBy`) from the
+     * last entry of the previous page. **The offset type must match `orderBy`:**
+     * - `orderBy=id`: use the entry's `id` (ObjectId, 24-char hex).
+     * - `orderBy=height`: use the block height (string, e.g. `"17592"`).
+     * - `orderBy=balance`: use the mosaic balance amount (string, e.g. `"1000000"`).
+     *
+     * Allowed `orderBy` values depend on the endpoint. If `orderBy` is omitted, `id` is used by default.
+     *
+     * Set `offset` to the sort-field value of the last entry from the previous page. Across pages,
+     * this value decreases with `order=desc` and increases with `order=asc`.
+     *
+     * Numbered and cursor pagination can be combined, but this is not recommended because the semantics
+     * are harder to reason about. For cursor-style flows, keep `pageNumber=1` and advance pages by
+     * updating only `offset`. For numbered pagination flows, omit `offset` and advance pages by
+     * incrementing `pageNumber`.
+     *
+     */
     offset?: string;
+    /**
+     * Sort responses in ascending or descending order based on the collection property set on the param `orderBy`.
+     * If the request does not specify `orderBy`, REST returns the collection ordered by id.
+     * The default sort direction depends on the endpoint implementation.
+     *
+     */
     order?: Order;
+    /**
+     * Sort responses by the property set.
+     * If `balance` option is selected, the request must define the `mosaicId` filter.
+     *
+     */
     orderBy?: AccountOrderByEnum;
+    /**
+     * Filter by mosaic identifier (include).
+     */
     mosaicId?: string;
 }
 /**
  *
  */
 export declare class AccountRoutesApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for getAccountInfo without sending the request
+     */
+    getAccountInfoRequestOpts(requestParameters: GetAccountInfoRequest): Promise<runtime.RequestOpts>;
     /**
      * Retrieves account data for a given account identifier. The response contains the account state including balance, importance, public key, linked keys, and activity buckets.  The `accountId` path parameter accepts either a public key or a Base32-encoded address.
      * Get account information
@@ -43,6 +124,10 @@ export declare class AccountRoutesApi extends runtime.BaseAPI {
      * Get account information
      */
     getAccountInfo(requestParameters: GetAccountInfoRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AccountInfoDTO>;
+    /**
+     * Creates request options for getAccountInfoMerkle without sending the request
+     */
+    getAccountInfoMerkleRequestOpts(requestParameters: GetAccountInfoMerkleRequest): Promise<runtime.RequestOpts>;
     /**
      * Retrieves the Merkle proof data for a given account. The Merkle path can be used to independently verify that the account state is included in the block state hash.  If no account state entry exists for the supplied account ID, the endpoint still returns a Merkle proof response, but it is a negative proof showing that no account state entry exists for the requested account.  The `accountId` path parameter accepts either a public key or a Base32-encoded address.
      * Get account Merkle information
@@ -53,6 +138,10 @@ export declare class AccountRoutesApi extends runtime.BaseAPI {
      * Get account Merkle information
      */
     getAccountInfoMerkle(requestParameters: GetAccountInfoMerkleRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MerkleStateInfoDTO>;
+    /**
+     * Creates request options for getAccountsInfo without sending the request
+     */
+    getAccountsInfoRequestOpts(requestParameters: GetAccountsInfoRequest): Promise<runtime.RequestOpts>;
     /**
      * Retrieves account data for multiple accounts in a single request. This is the batch equivalent of the single-account endpoint.  The request body accepts either an array of public keys or an array of addresses (not both). If both `publicKeys` and `addresses` are provided, the request is invalid and the server returns `409` error.
      * Get accounts information
@@ -63,6 +152,10 @@ export declare class AccountRoutesApi extends runtime.BaseAPI {
      * Get accounts information
      */
     getAccountsInfo(requestParameters?: GetAccountsInfoRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<AccountInfoDTO>>;
+    /**
+     * Creates request options for searchAccounts without sending the request
+     */
+    searchAccountsRequestOpts(requestParameters: SearchAccountsRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns a paginated list of accounts matching the given criteria.  Results can be filtered by `address` and `mosaicId` (mosaic ownership), and ordered by `id` or `balance`. Standard pagination parameters (`pageSize`, `pageNumber`, `offset`, `order`) apply. The `orderBy` parameter supports `id` and `balance`; when using `orderBy=balance`, the `mosaicId` filter is required. The `offset` value must match the `orderBy` field.
      * Search accounts

package/cjs/api/apis/AccountRoutesApi.js

@@ -57,16 +57,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AccountRoutesApi = void 0;
 const runtime = __importStar(require("../runtime"));
-const index_1 = require("../models/index");
+const AccountIds_1 = require("../models/AccountIds");
+const AccountInfoDTO_1 = require("../models/AccountInfoDTO");
+const AccountPage_1 = require("../models/AccountPage");
+const MerkleStateInfoDTO_1 = require("../models/MerkleStateInfoDTO");
 /**
  *
  */
 class AccountRoutesApi extends runtime.BaseAPI {
     /**
-     * Retrieves account data for a given account identifier. The response contains the account state including balance, importance, public key, linked keys, and activity buckets.  The `accountId` path parameter accepts either a public key or a Base32-encoded address.
-     * Get account information
+     * Creates request options for getAccountInfo without sending the request
      */
-    getAccountInfoRaw(requestParameters, initOverrides) {
+    getAccountInfoRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['accountId'] == null) {
                 throw new runtime.RequiredError('accountId', 'Required parameter "accountId" was null or undefined when calling getAccountInfo().');
@@ -74,14 +76,24 @@ class AccountRoutesApi extends runtime.BaseAPI {
             const queryParameters = {};
             const headerParameters = {};
             let urlPath = `/accounts/{accountId}`;
-            urlPath = urlPath.replace(`{${"accountId"}}`, encodeURIComponent(String(requestParameters['accountId'])));
-            const response = yield this.request({
+            urlPath = urlPath.replace('{accountId}', encodeURIComponent(String(requestParameters['accountId'])));
+            return {
                 path: urlPath,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.AccountInfoDTOFromJSON)(jsonValue));
+            };
+        });
+    }
+    /**
+     * Retrieves account data for a given account identifier. The response contains the account state including balance, importance, public key, linked keys, and activity buckets.  The `accountId` path parameter accepts either a public key or a Base32-encoded address.
+     * Get account information
+     */
+    getAccountInfoRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getAccountInfoRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, AccountInfoDTO_1.AccountInfoDTOFromJSON)(jsonValue));
         });
     }
     /**
@@ -95,10 +107,9 @@ class AccountRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Retrieves the Merkle proof data for a given account. The Merkle path can be used to independently verify that the account state is included in the block state hash.  If no account state entry exists for the supplied account ID, the endpoint still returns a Merkle proof response, but it is a negative proof showing that no account state entry exists for the requested account.  The `accountId` path parameter accepts either a public key or a Base32-encoded address.
-     * Get account Merkle information
+     * Creates request options for getAccountInfoMerkle without sending the request
      */
-    getAccountInfoMerkleRaw(requestParameters, initOverrides) {
+    getAccountInfoMerkleRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['accountId'] == null) {
                 throw new runtime.RequiredError('accountId', 'Required parameter "accountId" was null or undefined when calling getAccountInfoMerkle().');
@@ -106,14 +117,24 @@ class AccountRoutesApi extends runtime.BaseAPI {
             const queryParameters = {};
             const headerParameters = {};
             let urlPath = `/accounts/{accountId}/merkle`;
-            urlPath = urlPath.replace(`{${"accountId"}}`, encodeURIComponent(String(requestParameters['accountId'])));
-            const response = yield this.request({
+            urlPath = urlPath.replace('{accountId}', encodeURIComponent(String(requestParameters['accountId'])));
+            return {
                 path: urlPath,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.MerkleStateInfoDTOFromJSON)(jsonValue));
+            };
+        });
+    }
+    /**
+     * Retrieves the Merkle proof data for a given account. The Merkle path can be used to independently verify that the account state is included in the block state hash.  If no account state entry exists for the supplied account ID, the endpoint still returns a Merkle proof response, but it is a negative proof showing that no account state entry exists for the requested account.  The `accountId` path parameter accepts either a public key or a Base32-encoded address.
+     * Get account Merkle information
+     */
+    getAccountInfoMerkleRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getAccountInfoMerkleRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, MerkleStateInfoDTO_1.MerkleStateInfoDTOFromJSON)(jsonValue));
         });
     }
     /**
@@ -127,23 +148,32 @@ class AccountRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Retrieves account data for multiple accounts in a single request. This is the batch equivalent of the single-account endpoint.  The request body accepts either an array of public keys or an array of addresses (not both). If both `publicKeys` and `addresses` are provided, the request is invalid and the server returns `409` error.
-     * Get accounts information
+     * Creates request options for getAccountsInfo without sending the request
      */
-    getAccountsInfoRaw(requestParameters, initOverrides) {
+    getAccountsInfoRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             const queryParameters = {};
             const headerParameters = {};
             headerParameters['Content-Type'] = 'application/json';
             let urlPath = `/accounts`;
-            const response = yield this.request({
+            return {
                 path: urlPath,
                 method: 'POST',
                 headers: headerParameters,
                 query: queryParameters,
-                body: (0, index_1.AccountIdsToJSON)(requestParameters['accountIds']),
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.AccountInfoDTOFromJSON));
+                body: (0, AccountIds_1.AccountIdsToJSON)(requestParameters['accountIds']),
+            };
+        });
+    }
+    /**
+     * Retrieves account data for multiple accounts in a single request. This is the batch equivalent of the single-account endpoint.  The request body accepts either an array of public keys or an array of addresses (not both). If both `publicKeys` and `addresses` are provided, the request is invalid and the server returns `409` error.
+     * Get accounts information
+     */
+    getAccountsInfoRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getAccountsInfoRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(AccountInfoDTO_1.AccountInfoDTOFromJSON));
         });
     }
     /**
@@ -157,10 +187,9 @@ class AccountRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Returns a paginated list of accounts matching the given criteria.  Results can be filtered by `address` and `mosaicId` (mosaic ownership), and ordered by `id` or `balance`. Standard pagination parameters (`pageSize`, `pageNumber`, `offset`, `order`) apply. The `orderBy` parameter supports `id` and `balance`; when using `orderBy=balance`, the `mosaicId` filter is required. The `offset` value must match the `orderBy` field.
-     * Search accounts
+     * Creates request options for searchAccounts without sending the request
      */
-    searchAccountsRaw(requestParameters, initOverrides) {
+    searchAccountsRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             const queryParameters = {};
             if (requestParameters['address'] != null) {
@@ -186,13 +215,23 @@ class AccountRoutesApi extends runtime.BaseAPI {
             }
             const headerParameters = {};
             let urlPath = `/accounts`;
-            const response = yield this.request({
+            return {
                 path: urlPath,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.AccountPageFromJSON)(jsonValue));
+            };
+        });
+    }
+    /**
+     * Returns a paginated list of accounts matching the given criteria.  Results can be filtered by `address` and `mosaicId` (mosaic ownership), and ordered by `id` or `balance`. Standard pagination parameters (`pageSize`, `pageNumber`, `offset`, `order`) apply. The `orderBy` parameter supports `id` and `balance`; when using `orderBy=balance`, the `mosaicId` filter is required. The `offset` value must match the `orderBy` field.
+     * Search accounts
+     */
+    searchAccountsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.searchAccountsRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, AccountPage_1.AccountPageFromJSON)(jsonValue));
         });
     }
     /**

package/cjs/api/apis/BlockRoutesApi.d.ts

@@ -10,33 +10,114 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { BlockInfoDTO, BlockOrderByEnum, BlockPage, MerkleProofInfoDTO, Order } from '../models/index';
+import { type BlockInfoDTO } from '../models/BlockInfoDTO';
+import { type BlockOrderByEnum } from '../models/BlockOrderByEnum';
+import { type BlockPage } from '../models/BlockPage';
+import { type MerkleProofInfoDTO } from '../models/MerkleProofInfoDTO';
+import { type Order } from '../models/Order';
 export interface GetBlockByHeightRequest {
+    /**
+     * Filter by block height (include). Sequential block position in the chain; starts at 1 and increments by one.
+     */
     height: string;
 }
 export interface GetMerkleReceiptsRequest {
+    /**
+     * Filter by block height (include). Sequential block position in the chain; starts at 1 and increments by one.
+     */
     height: string;
+    /**
+     * Receipt statement hash.
+     */
     hash: string;
 }
 export interface GetMerkleTransactionRequest {
+    /**
+     * Filter by block height (include). Sequential block position in the chain; starts at 1 and increments by one.
+     */
     height: string;
+    /**
+     * Transaction hash encoded as a 64-character hexadecimal string.
+     */
     hash: string;
 }
 export interface SearchBlocksRequest {
+    /**
+     * Filter transactions by the public key of the signing account (include).
+     */
     signerPublicKey?: string;
+    /**
+     * Filter by beneficiary address (include).
+     */
     beneficiaryAddress?: string;
+    /**
+     * Select the number of entries to return per page.
+     * Values outside the allowed range are clamped to the schema minimum or maximum.
+     *
+     */
     pageSize?: number;
+    /**
+     * Page number for numbered pagination (1-based).
+     *
+     * Numbered and cursor pagination can be combined, but this is not recommended because the semantics
+     * are harder to reason about. For cursor-style flows, keep `pageNumber=1` and advance pages by
+     * updating only `offset`. For numbered pagination flows, omit `offset` and advance pages by
+     * incrementing `pageNumber`.
+     *
+     */
     pageNumber?: number;
+    /**
+     * Cursor for pagination. Provide the value of the sort field (`orderBy`) from the
+     * last entry of the previous page. **The offset type must match `orderBy`:**
+     * - `orderBy=id`: use the entry's `id` (ObjectId, 24-char hex).
+     * - `orderBy=height`: use the block height (string, e.g. `"17592"`).
+     * - `orderBy=balance`: use the mosaic balance amount (string, e.g. `"1000000"`).
+     *
+     * Allowed `orderBy` values depend on the endpoint. If `orderBy` is omitted, `id` is used by default.
+     *
+     * Set `offset` to the sort-field value of the last entry from the previous page. Across pages,
+     * this value decreases with `order=desc` and increases with `order=asc`.
+     *
+     * Numbered and cursor pagination can be combined, but this is not recommended because the semantics
+     * are harder to reason about. For cursor-style flows, keep `pageNumber=1` and advance pages by
+     * updating only `offset`. For numbered pagination flows, omit `offset` and advance pages by
+     * incrementing `pageNumber`.
+     *
+     */
     offset?: string;
+    /**
+     * Sort responses in ascending or descending order based on the collection property set on the param `orderBy`.
+     * If the request does not specify `orderBy`, REST returns the collection ordered by id.
+     * The default sort direction depends on the endpoint implementation.
+     *
+     */
     order?: Order;
+    /**
+     * Sort responses by the property set. Defaults to `id` when not specified.
+     *
+     */
     orderBy?: BlockOrderByEnum;
+    /**
+     * Only blocks with timestamp greater or equal than this one are returned. The timestamp is
+     * expressed in milliseconds since the nemesis block.
+     *
+     */
     fromTimestamp?: string;
+    /**
+     * Only blocks with timestamp smaller or equal than this one are returned. The timestamp is
+     * expressed in milliseconds since the nemesis block.
+     *
+     */
     toTimestamp?: string;
 }
 /**
  *
  */
 export declare class BlockRoutesApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for getBlockByHeight without sending the request
+     */
+    getBlockByHeightRequestOpts(requestParameters: GetBlockByHeightRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns the block at the given height. The response includes the block header, harvester signature, and block metadata (hash, total fee, generation hash, transaction and statement counts).  If the block is an importance block, the response additionally contains voting-eligible and harvesting-eligible account counts, total voting balance, and the previous importance block hash.
      * Get block information
@@ -47,6 +128,10 @@ export declare class BlockRoutesApi extends runtime.BaseAPI {
      * Get block information
      */
     getBlockByHeight(requestParameters: GetBlockByHeightRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BlockInfoDTO>;
+    /**
+     * Creates request options for getMerkleReceipts without sending the request
+     */
+    getMerkleReceiptsRequestOpts(requestParameters: GetMerkleReceiptsRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns the [Merkle path](https://docs.symbol.dev/concepts/data-validation.html#merkle-proof) for a [receipt statement or resolution](https://docs.symbol.dev/concepts/receipt.html) linked to a block. The `hash` parameter is the receipt statement hash, not the transaction hash. The Merkle path is the minimum number of nodes needed to calculate the Merkle root.  Steps to calculate the Merkle root: 1. proofHash = hash (leaf). 2. Concatenate proofHash with the first unprocessed item from the merklePath list as follows: - `left`: the item hash is concatenated before the proofHash (proofHash = sha_256(item.hash + proofHash)). - `right`: the item hash is concatenated after the proofHash (proofHash = sha_256(proofHash + item.hash)). 3. Repeat 2. for every item in the merklePath list. 4. Compare if the calculated proofHash equals the one recorded in the [block header](https://docs.symbol.dev/concepts/block.html) (`block.receiptsHash`) to verify if the statement was linked with the block.
      * Get the Merkle path for a given receipt statement hash and block
@@ -57,6 +142,10 @@ export declare class BlockRoutesApi extends runtime.BaseAPI {
      * Get the Merkle path for a given receipt statement hash and block
      */
     getMerkleReceipts(requestParameters: GetMerkleReceiptsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MerkleProofInfoDTO>;
+    /**
+     * Creates request options for getMerkleTransaction without sending the request
+     */
+    getMerkleTransactionRequestOpts(requestParameters: GetMerkleTransactionRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns the [Merkle path](https://docs.symbol.dev/concepts/data-validation.html#merkle-proof) for a [transaction](https://docs.symbol.dev/concepts/transaction.html) included in a block. The Merkle path is the minimum number of nodes needed to calculate the Merkle root.  Steps to calculate the Merkle root: 1. proofHash = hash (leaf). 2. Concatenate proofHash with the first unprocessed item from the merklePath list as follows: - `left`: the item hash is concatenated before the proofHash (proofHash = sha_256(item.hash + proofHash)). - `right`: the item hash is concatenated after the proofHash (proofHash = sha_256(proofHash + item.hash)). 3. Repeat 2. for every item in the merklePath list. 4. Compare if the calculated proofHash equals the one recorded in the [block header](https://docs.symbol.dev/concepts/block.html) (`block.transactionsHash`) to verify if the transaction was included in the block.
      * Get the Merkle path for a given transaction and block
@@ -67,6 +156,10 @@ export declare class BlockRoutesApi extends runtime.BaseAPI {
      * Get the Merkle path for a given transaction and block
      */
     getMerkleTransaction(requestParameters: GetMerkleTransactionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MerkleProofInfoDTO>;
+    /**
+     * Creates request options for searchBlocks without sending the request
+     */
+    searchBlocksRequestOpts(requestParameters: SearchBlocksRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns a paginated list of blocks matching the given criteria.  Results can be filtered by harvester (`signerPublicKey`), `beneficiaryAddress`, and timestamp range. Standard pagination parameters (`pageSize`, `pageNumber`, `offset`, `order`) apply. The `orderBy` parameter supports `id` and `height`. The `offset` value must match the `orderBy` field.
      * Search blocks

package/cjs/api/apis/BlockRoutesApi.js

@@ -57,16 +57,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlockRoutesApi = void 0;
 const runtime = __importStar(require("../runtime"));
-const index_1 = require("../models/index");
+const BlockInfoDTO_1 = require("../models/BlockInfoDTO");
+const BlockPage_1 = require("../models/BlockPage");
+const MerkleProofInfoDTO_1 = require("../models/MerkleProofInfoDTO");
 /**
  *
  */
 class BlockRoutesApi extends runtime.BaseAPI {
     /**
-     * Returns the block at the given height. The response includes the block header, harvester signature, and block metadata (hash, total fee, generation hash, transaction and statement counts).  If the block is an importance block, the response additionally contains voting-eligible and harvesting-eligible account counts, total voting balance, and the previous importance block hash.
-     * Get block information
+     * Creates request options for getBlockByHeight without sending the request
      */
-    getBlockByHeightRaw(requestParameters, initOverrides) {
+    getBlockByHeightRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['height'] == null) {
                 throw new runtime.RequiredError('height', 'Required parameter "height" was null or undefined when calling getBlockByHeight().');
@@ -74,14 +75,24 @@ class BlockRoutesApi extends runtime.BaseAPI {
             const queryParameters = {};
             const headerParameters = {};
             let urlPath = `/blocks/{height}`;
-            urlPath = urlPath.replace(`{${"height"}}`, encodeURIComponent(String(requestParameters['height'])));
-            const response = yield this.request({
+            urlPath = urlPath.replace('{height}', encodeURIComponent(String(requestParameters['height'])));
+            return {
                 path: urlPath,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.BlockInfoDTOFromJSON)(jsonValue));
+            };
+        });
+    }
+    /**
+     * Returns the block at the given height. The response includes the block header, harvester signature, and block metadata (hash, total fee, generation hash, transaction and statement counts).  If the block is an importance block, the response additionally contains voting-eligible and harvesting-eligible account counts, total voting balance, and the previous importance block hash.
+     * Get block information
+     */
+    getBlockByHeightRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getBlockByHeightRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, BlockInfoDTO_1.BlockInfoDTOFromJSON)(jsonValue));
         });
     }
     /**
@@ -95,10 +106,9 @@ class BlockRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Returns the [Merkle path](https://docs.symbol.dev/concepts/data-validation.html#merkle-proof) for a [receipt statement or resolution](https://docs.symbol.dev/concepts/receipt.html) linked to a block. The `hash` parameter is the receipt statement hash, not the transaction hash. The Merkle path is the minimum number of nodes needed to calculate the Merkle root.  Steps to calculate the Merkle root: 1. proofHash = hash (leaf). 2. Concatenate proofHash with the first unprocessed item from the merklePath list as follows: - `left`: the item hash is concatenated before the proofHash (proofHash = sha_256(item.hash + proofHash)). - `right`: the item hash is concatenated after the proofHash (proofHash = sha_256(proofHash + item.hash)). 3. Repeat 2. for every item in the merklePath list. 4. Compare if the calculated proofHash equals the one recorded in the [block header](https://docs.symbol.dev/concepts/block.html) (`block.receiptsHash`) to verify if the statement was linked with the block.
-     * Get the Merkle path for a given receipt statement hash and block
+     * Creates request options for getMerkleReceipts without sending the request
      */
-    getMerkleReceiptsRaw(requestParameters, initOverrides) {
+    getMerkleReceiptsRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['height'] == null) {
                 throw new runtime.RequiredError('height', 'Required parameter "height" was null or undefined when calling getMerkleReceipts().');
@@ -109,15 +119,25 @@ class BlockRoutesApi extends runtime.BaseAPI {
             const queryParameters = {};
             const headerParameters = {};
             let urlPath = `/blocks/{height}/statements/{hash}/merkle`;
-            urlPath = urlPath.replace(`{${"height"}}`, encodeURIComponent(String(requestParameters['height'])));
-            urlPath = urlPath.replace(`{${"hash"}}`, encodeURIComponent(String(requestParameters['hash'])));
-            const response = yield this.request({
+            urlPath = urlPath.replace('{height}', encodeURIComponent(String(requestParameters['height'])));
+            urlPath = urlPath.replace('{hash}', encodeURIComponent(String(requestParameters['hash'])));
+            return {
                 path: urlPath,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.MerkleProofInfoDTOFromJSON)(jsonValue));
+            };
+        });
+    }
+    /**
+     * Returns the [Merkle path](https://docs.symbol.dev/concepts/data-validation.html#merkle-proof) for a [receipt statement or resolution](https://docs.symbol.dev/concepts/receipt.html) linked to a block. The `hash` parameter is the receipt statement hash, not the transaction hash. The Merkle path is the minimum number of nodes needed to calculate the Merkle root.  Steps to calculate the Merkle root: 1. proofHash = hash (leaf). 2. Concatenate proofHash with the first unprocessed item from the merklePath list as follows: - `left`: the item hash is concatenated before the proofHash (proofHash = sha_256(item.hash + proofHash)). - `right`: the item hash is concatenated after the proofHash (proofHash = sha_256(proofHash + item.hash)). 3. Repeat 2. for every item in the merklePath list. 4. Compare if the calculated proofHash equals the one recorded in the [block header](https://docs.symbol.dev/concepts/block.html) (`block.receiptsHash`) to verify if the statement was linked with the block.
+     * Get the Merkle path for a given receipt statement hash and block
+     */
+    getMerkleReceiptsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getMerkleReceiptsRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, MerkleProofInfoDTO_1.MerkleProofInfoDTOFromJSON)(jsonValue));
         });
     }
     /**
@@ -131,10 +151,9 @@ class BlockRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Returns the [Merkle path](https://docs.symbol.dev/concepts/data-validation.html#merkle-proof) for a [transaction](https://docs.symbol.dev/concepts/transaction.html) included in a block. The Merkle path is the minimum number of nodes needed to calculate the Merkle root.  Steps to calculate the Merkle root: 1. proofHash = hash (leaf). 2. Concatenate proofHash with the first unprocessed item from the merklePath list as follows: - `left`: the item hash is concatenated before the proofHash (proofHash = sha_256(item.hash + proofHash)). - `right`: the item hash is concatenated after the proofHash (proofHash = sha_256(proofHash + item.hash)). 3. Repeat 2. for every item in the merklePath list. 4. Compare if the calculated proofHash equals the one recorded in the [block header](https://docs.symbol.dev/concepts/block.html) (`block.transactionsHash`) to verify if the transaction was included in the block.
-     * Get the Merkle path for a given transaction and block
+     * Creates request options for getMerkleTransaction without sending the request
      */
-    getMerkleTransactionRaw(requestParameters, initOverrides) {
+    getMerkleTransactionRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['height'] == null) {
                 throw new runtime.RequiredError('height', 'Required parameter "height" was null or undefined when calling getMerkleTransaction().');
@@ -145,15 +164,25 @@ class BlockRoutesApi extends runtime.BaseAPI {
             const queryParameters = {};
             const headerParameters = {};
             let urlPath = `/blocks/{height}/transactions/{hash}/merkle`;
-            urlPath = urlPath.replace(`{${"height"}}`, encodeURIComponent(String(requestParameters['height'])));
-            urlPath = urlPath.replace(`{${"hash"}}`, encodeURIComponent(String(requestParameters['hash'])));
-            const response = yield this.request({
+            urlPath = urlPath.replace('{height}', encodeURIComponent(String(requestParameters['height'])));
+            urlPath = urlPath.replace('{hash}', encodeURIComponent(String(requestParameters['hash'])));
+            return {
                 path: urlPath,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.MerkleProofInfoDTOFromJSON)(jsonValue));
+            };
+        });
+    }
+    /**
+     * Returns the [Merkle path](https://docs.symbol.dev/concepts/data-validation.html#merkle-proof) for a [transaction](https://docs.symbol.dev/concepts/transaction.html) included in a block. The Merkle path is the minimum number of nodes needed to calculate the Merkle root.  Steps to calculate the Merkle root: 1. proofHash = hash (leaf). 2. Concatenate proofHash with the first unprocessed item from the merklePath list as follows: - `left`: the item hash is concatenated before the proofHash (proofHash = sha_256(item.hash + proofHash)). - `right`: the item hash is concatenated after the proofHash (proofHash = sha_256(proofHash + item.hash)). 3. Repeat 2. for every item in the merklePath list. 4. Compare if the calculated proofHash equals the one recorded in the [block header](https://docs.symbol.dev/concepts/block.html) (`block.transactionsHash`) to verify if the transaction was included in the block.
+     * Get the Merkle path for a given transaction and block
+     */
+    getMerkleTransactionRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getMerkleTransactionRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, MerkleProofInfoDTO_1.MerkleProofInfoDTOFromJSON)(jsonValue));
         });
     }
     /**
@@ -167,10 +196,9 @@ class BlockRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Returns a paginated list of blocks matching the given criteria.  Results can be filtered by harvester (`signerPublicKey`), `beneficiaryAddress`, and timestamp range. Standard pagination parameters (`pageSize`, `pageNumber`, `offset`, `order`) apply. The `orderBy` parameter supports `id` and `height`. The `offset` value must match the `orderBy` field.
-     * Search blocks
+     * Creates request options for searchBlocks without sending the request
      */
-    searchBlocksRaw(requestParameters, initOverrides) {
+    searchBlocksRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             const queryParameters = {};
             if (requestParameters['signerPublicKey'] != null) {
@@ -202,13 +230,23 @@ class BlockRoutesApi extends runtime.BaseAPI {
             }
             const headerParameters = {};
             let urlPath = `/blocks`;
-            const response = yield this.request({
+            return {
                 path: urlPath,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.BlockPageFromJSON)(jsonValue));
+            };
+        });
+    }
+    /**
+     * Returns a paginated list of blocks matching the given criteria.  Results can be filtered by harvester (`signerPublicKey`), `beneficiaryAddress`, and timestamp range. Standard pagination parameters (`pageSize`, `pageNumber`, `offset`, `order`) apply. The `orderBy` parameter supports `id` and `height`. The `offset` value must match the `orderBy` field.
+     * Search blocks
+     */
+    searchBlocksRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.searchBlocksRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, BlockPage_1.BlockPageFromJSON)(jsonValue));
         });
     }
     /**