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

package/esm/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/esm/api/apis/BlockRoutesApi.js

@@ -12,29 +12,38 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import { BlockInfoDTOFromJSON, BlockPageFromJSON, MerkleProofInfoDTOFromJSON, } from '../models/index';
+import { BlockInfoDTOFromJSON, } from '../models/BlockInfoDTO';
+import { BlockPageFromJSON, } from '../models/BlockPage';
+import { MerkleProofInfoDTOFromJSON, } from '../models/MerkleProofInfoDTO';
 /**
  *
  */
 export 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
      */
-    async getBlockByHeightRaw(requestParameters, initOverrides) {
+    async getBlockByHeightRequestOpts(requestParameters) {
         if (requestParameters['height'] == null) {
             throw new runtime.RequiredError('height', 'Required parameter "height" was null or undefined when calling getBlockByHeight().');
         }
         const queryParameters = {};
         const headerParameters = {};
         let urlPath = `/blocks/{height}`;
-        urlPath = urlPath.replace(`{${"height"}}`, encodeURIComponent(String(requestParameters['height'])));
-        const response = await this.request({
+        urlPath = urlPath.replace('{height}', encodeURIComponent(String(requestParameters['height'])));
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * 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
+     */
+    async getBlockByHeightRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getBlockByHeightRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => BlockInfoDTOFromJSON(jsonValue));
     }
     /**
@@ -46,10 +55,9 @@ export class BlockRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * 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
      */
-    async getMerkleReceiptsRaw(requestParameters, initOverrides) {
+    async getMerkleReceiptsRequestOpts(requestParameters) {
         if (requestParameters['height'] == null) {
             throw new runtime.RequiredError('height', 'Required parameter "height" was null or undefined when calling getMerkleReceipts().');
         }
@@ -59,14 +67,22 @@ export 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 = await 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);
+        };
+    }
+    /**
+     * 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
+     */
+    async getMerkleReceiptsRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getMerkleReceiptsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => MerkleProofInfoDTOFromJSON(jsonValue));
     }
     /**
@@ -78,10 +94,9 @@ export class BlockRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * 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
      */
-    async getMerkleTransactionRaw(requestParameters, initOverrides) {
+    async getMerkleTransactionRequestOpts(requestParameters) {
         if (requestParameters['height'] == null) {
             throw new runtime.RequiredError('height', 'Required parameter "height" was null or undefined when calling getMerkleTransaction().');
         }
@@ -91,14 +106,22 @@ export 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 = await 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);
+        };
+    }
+    /**
+     * 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
+     */
+    async getMerkleTransactionRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getMerkleTransactionRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => MerkleProofInfoDTOFromJSON(jsonValue));
     }
     /**
@@ -110,10 +133,9 @@ export class BlockRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * 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
      */
-    async searchBlocksRaw(requestParameters, initOverrides) {
+    async searchBlocksRequestOpts(requestParameters) {
         const queryParameters = {};
         if (requestParameters['signerPublicKey'] != null) {
             queryParameters['signerPublicKey'] = requestParameters['signerPublicKey'];
@@ -144,12 +166,20 @@ export class BlockRoutesApi extends runtime.BaseAPI {
         }
         const headerParameters = {};
         let urlPath = `/blocks`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * 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
+     */
+    async searchBlocksRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.searchBlocksRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => BlockPageFromJSON(jsonValue));
     }
     /**

package/esm/api/apis/ChainRoutesApi.d.ts

@@ -10,11 +10,15 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { ChainInfoDTO } from '../models/index';
+import { type ChainInfoDTO } from '../models/ChainInfoDTO';
 /**
  *
  */
 export declare class ChainRoutesApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for getChainInfo without sending the request
+     */
+    getChainInfoRequestOpts(): Promise<runtime.RequestOpts>;
     /**
      * Returns the current state of the blockchain: chain height, chain score, and the latest finalized block.
      * Get chain information

package/esm/api/apis/ChainRoutesApi.js

@@ -12,25 +12,32 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import { ChainInfoDTOFromJSON, } from '../models/index';
+import { ChainInfoDTOFromJSON, } from '../models/ChainInfoDTO';
 /**
  *
  */
 export class ChainRoutesApi extends runtime.BaseAPI {
     /**
-     * Returns the current state of the blockchain: chain height, chain score, and the latest finalized block.
-     * Get chain information
+     * Creates request options for getChainInfo without sending the request
      */
-    async getChainInfoRaw(initOverrides) {
+    async getChainInfoRequestOpts() {
         const queryParameters = {};
         const headerParameters = {};
         let urlPath = `/chain/info`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns the current state of the blockchain: chain height, chain score, and the latest finalized block.
+     * Get chain information
+     */
+    async getChainInfoRaw(initOverrides) {
+        const requestOptions = await this.getChainInfoRequestOpts();
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => ChainInfoDTOFromJSON(jsonValue));
     }
     /**

package/esm/api/apis/FinalizationRoutesApi.d.ts

@@ -10,17 +10,29 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { FinalizationProofDTO } from '../models/index';
+import { type FinalizationProofDTO } from '../models/FinalizationProofDTO';
 export interface GetFinalizationProofAtEpochRequest {
+    /**
+     * The finalization epoch is a sequential integer. Each epoch groups a set of blocks
+     * for finalization voting (interval defined by network config, e.g. 1440 blocks for mainnet).
+     *
+     */
     epoch: number;
 }
 export interface GetFinalizationProofAtHeightRequest {
+    /**
+     * Filter by block height (include). Sequential block position in the chain; starts at 1 and increments by one.
+     */
     height: string;
 }
 /**
  *
  */
 export declare class FinalizationRoutesApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for getFinalizationProofAtEpoch without sending the request
+     */
+    getFinalizationProofAtEpochRequestOpts(requestParameters: GetFinalizationProofAtEpochRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns the finalization proof for the greatest block height associated with the given finalization epoch.
      * Get finalization proof at epoch
@@ -31,6 +43,10 @@ export declare class FinalizationRoutesApi extends runtime.BaseAPI {
      * Get finalization proof at epoch
      */
     getFinalizationProofAtEpoch(requestParameters: GetFinalizationProofAtEpochRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FinalizationProofDTO>;
+    /**
+     * Creates request options for getFinalizationProofAtHeight without sending the request
+     */
+    getFinalizationProofAtHeightRequestOpts(requestParameters: GetFinalizationProofAtHeightRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns the finalization proof for the block at the given height.
      * Get finalization proof at height

package/esm/api/apis/FinalizationRoutesApi.js

@@ -12,29 +12,36 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import { FinalizationProofDTOFromJSON, } from '../models/index';
+import { FinalizationProofDTOFromJSON, } from '../models/FinalizationProofDTO';
 /**
  *
  */
 export class FinalizationRoutesApi extends runtime.BaseAPI {
     /**
-     * Returns the finalization proof for the greatest block height associated with the given finalization epoch.
-     * Get finalization proof at epoch
+     * Creates request options for getFinalizationProofAtEpoch without sending the request
      */
-    async getFinalizationProofAtEpochRaw(requestParameters, initOverrides) {
+    async getFinalizationProofAtEpochRequestOpts(requestParameters) {
         if (requestParameters['epoch'] == null) {
             throw new runtime.RequiredError('epoch', 'Required parameter "epoch" was null or undefined when calling getFinalizationProofAtEpoch().');
         }
         const queryParameters = {};
         const headerParameters = {};
         let urlPath = `/finalization/proof/epoch/{epoch}`;
-        urlPath = urlPath.replace(`{${"epoch"}}`, encodeURIComponent(String(requestParameters['epoch'])));
-        const response = await this.request({
+        urlPath = urlPath.replace('{epoch}', encodeURIComponent(String(requestParameters['epoch'])));
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns the finalization proof for the greatest block height associated with the given finalization epoch.
+     * Get finalization proof at epoch
+     */
+    async getFinalizationProofAtEpochRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getFinalizationProofAtEpochRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => FinalizationProofDTOFromJSON(jsonValue));
     }
     /**
@@ -46,23 +53,30 @@ export class FinalizationRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Returns the finalization proof for the block at the given height.
-     * Get finalization proof at height
+     * Creates request options for getFinalizationProofAtHeight without sending the request
      */
-    async getFinalizationProofAtHeightRaw(requestParameters, initOverrides) {
+    async getFinalizationProofAtHeightRequestOpts(requestParameters) {
         if (requestParameters['height'] == null) {
             throw new runtime.RequiredError('height', 'Required parameter "height" was null or undefined when calling getFinalizationProofAtHeight().');
         }
         const queryParameters = {};
         const headerParameters = {};
         let urlPath = `/finalization/proof/height/{height}`;
-        urlPath = urlPath.replace(`{${"height"}}`, encodeURIComponent(String(requestParameters['height'])));
-        const response = await this.request({
+        urlPath = urlPath.replace('{height}', encodeURIComponent(String(requestParameters['height'])));
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns the finalization proof for the block at the given height.
+     * Get finalization proof at height
+     */
+    async getFinalizationProofAtHeightRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getFinalizationProofAtHeightRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => FinalizationProofDTOFromJSON(jsonValue));
     }
     /**