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

package/esm/api/apis/TransactionRoutesApi.js

@@ -12,16 +12,20 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import { AnnounceTransactionInfoDTOFromJSON, CosignatureToJSON, TransactionIdsToJSON, TransactionInfoDTOFromJSON, TransactionPageFromJSON, TransactionPayloadToJSON, } from '../models/index';
+import { AnnounceTransactionInfoDTOFromJSON, } from '../models/AnnounceTransactionInfoDTO';
+import { CosignatureToJSON, } from '../models/Cosignature';
+import { TransactionIdsToJSON, } from '../models/TransactionIds';
+import { TransactionInfoDTOFromJSON, } from '../models/TransactionInfoDTO';
+import { TransactionPageFromJSON, } from '../models/TransactionPage';
+import { TransactionPayloadToJSON, } from '../models/TransactionPayload';
 /**
  *
  */
 export class TransactionRoutesApi extends runtime.BaseAPI {
     /**
-     * Broadcasts a detached cosignature for an aggregate bonded transaction to the network through this node.  The request must contain the detached cosignature fields: cosignature version, signer public key, cosignature signature, and the parent aggregate transaction hash. Detached cosignatures are normally created client-side with a [Symbol SDK](https://docs.symbol.dev/sdk.html) and then announced with this endpoint.  Acceptance by this node does not mean the parent aggregate bonded transaction is already confirmed on-chain. The cosignature still needs to be propagated and processed by the network.  To verify the effect of the cosignature, query the **parent aggregate bonded transaction**, for example with [`GET /transactionStatus/{hash}`](/transactionStatus/{hash}) using the parent aggregate transaction hash. Transaction status availability is not guaranteed indefinitely: failed statuses are stored in a capped collection and may be evicted as new entries arrive.
-     * Announce a cosignature transaction
+     * Creates request options for announceCosignatureTransaction without sending the request
      */
-    async announceCosignatureTransactionRaw(requestParameters, initOverrides) {
+    async announceCosignatureTransactionRequestOpts(requestParameters) {
         if (requestParameters['cosignature'] == null) {
             throw new runtime.RequiredError('cosignature', 'Required parameter "cosignature" was null or undefined when calling announceCosignatureTransaction().');
         }
@@ -29,13 +33,21 @@ export class TransactionRoutesApi extends runtime.BaseAPI {
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         let urlPath = `/transactions/cosignature`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
             body: CosignatureToJSON(requestParameters['cosignature']),
-        }, initOverrides);
+        };
+    }
+    /**
+     * Broadcasts a detached cosignature for an aggregate bonded transaction to the network through this node.  The request must contain the detached cosignature fields: cosignature version, signer public key, cosignature signature, and the parent aggregate transaction hash. Detached cosignatures are normally created client-side with a [Symbol SDK](https://docs.symbol.dev/sdk.html) and then announced with this endpoint.  Acceptance by this node does not mean the parent aggregate bonded transaction is already confirmed on-chain. The cosignature still needs to be propagated and processed by the network.  To verify the effect of the cosignature, query the **parent aggregate bonded transaction**, for example with [`GET /transactionStatus/{hash}`](/transactionStatus/{hash}) using the parent aggregate transaction hash. Transaction status availability is not guaranteed indefinitely: failed statuses are stored in a capped collection and may be evicted as new entries arrive.
+     * Announce a cosignature transaction
+     */
+    async announceCosignatureTransactionRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.announceCosignatureTransactionRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => AnnounceTransactionInfoDTOFromJSON(jsonValue));
     }
     /**
@@ -47,10 +59,9 @@ export class TransactionRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Broadcasts a signed aggregate bonded transaction to the network through this node.  The request must contain the serialized aggregate bonded transaction payload in hexadecimal form. Transactions are normally created and signed client-side with a [Symbol SDK](https://docs.symbol.dev/sdk.html) and then announced with this endpoint.  Acceptance by this node does not mean the transaction is already part of the blockchain. The transaction still needs to be validated and confirmed by the network.  To verify the final result, query `GET /transactionStatus/{hash}` on the same node that received the announce request. If that node drops the transaction before propagation, other nodes may not know the transaction at all and can return `404` for the same hash. Transaction status availability is not guaranteed indefinitely: failed statuses are stored in a capped collection and may be evicted as new entries arrive.
-     * Announce an aggregate bonded transaction
+     * Creates request options for announcePartialTransaction without sending the request
      */
-    async announcePartialTransactionRaw(requestParameters, initOverrides) {
+    async announcePartialTransactionRequestOpts(requestParameters) {
         if (requestParameters['transactionPayload'] == null) {
             throw new runtime.RequiredError('transactionPayload', 'Required parameter "transactionPayload" was null or undefined when calling announcePartialTransaction().');
         }
@@ -58,13 +69,21 @@ export class TransactionRoutesApi extends runtime.BaseAPI {
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         let urlPath = `/transactions/partial`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
             body: TransactionPayloadToJSON(requestParameters['transactionPayload']),
-        }, initOverrides);
+        };
+    }
+    /**
+     * Broadcasts a signed aggregate bonded transaction to the network through this node.  The request must contain the serialized aggregate bonded transaction payload in hexadecimal form. Transactions are normally created and signed client-side with a [Symbol SDK](https://docs.symbol.dev/sdk.html) and then announced with this endpoint.  Acceptance by this node does not mean the transaction is already part of the blockchain. The transaction still needs to be validated and confirmed by the network.  To verify the final result, query `GET /transactionStatus/{hash}` on the same node that received the announce request. If that node drops the transaction before propagation, other nodes may not know the transaction at all and can return `404` for the same hash. Transaction status availability is not guaranteed indefinitely: failed statuses are stored in a capped collection and may be evicted as new entries arrive.
+     * Announce an aggregate bonded transaction
+     */
+    async announcePartialTransactionRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.announcePartialTransactionRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => AnnounceTransactionInfoDTOFromJSON(jsonValue));
     }
     /**
@@ -76,10 +95,9 @@ export class TransactionRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Broadcasts a signed transaction to the network through this node.  The request must contain the serialized transaction payload in hexadecimal form. Transactions are normally created and signed client-side with a [Symbol SDK](https://docs.symbol.dev/sdk.html) and then announced with this endpoint.  The [catbuffer library](https://github.com/symbol/symbol/tree/main/catbuffer) defines the binary serialization format used by Symbol entities.  Acceptance by this node does not mean the transaction is already part of the blockchain. The transaction still needs to be validated and confirmed by the network.  To verify the final result, query `GET /transactionStatus/{hash}` on the same node that received the announce request. If that node drops the transaction before propagation, other nodes may not know the transaction at all and can return `404` for the same hash. Transaction status availability is not guaranteed indefinitely: failed statuses are stored in a capped collection and may be evicted as new entries arrive.
-     * Announce a new transaction
+     * Creates request options for announceTransaction without sending the request
      */
-    async announceTransactionRaw(requestParameters, initOverrides) {
+    async announceTransactionRequestOpts(requestParameters) {
         if (requestParameters['transactionPayload'] == null) {
             throw new runtime.RequiredError('transactionPayload', 'Required parameter "transactionPayload" was null or undefined when calling announceTransaction().');
         }
@@ -87,13 +105,21 @@ export class TransactionRoutesApi extends runtime.BaseAPI {
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         let urlPath = `/transactions`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
             body: TransactionPayloadToJSON(requestParameters['transactionPayload']),
-        }, initOverrides);
+        };
+    }
+    /**
+     * Broadcasts a signed transaction to the network through this node.  The request must contain the serialized transaction payload in hexadecimal form. Transactions are normally created and signed client-side with a [Symbol SDK](https://docs.symbol.dev/sdk.html) and then announced with this endpoint.  The [catbuffer library](https://github.com/symbol/symbol/tree/main/catbuffer) defines the binary serialization format used by Symbol entities.  Acceptance by this node does not mean the transaction is already part of the blockchain. The transaction still needs to be validated and confirmed by the network.  To verify the final result, query `GET /transactionStatus/{hash}` on the same node that received the announce request. If that node drops the transaction before propagation, other nodes may not know the transaction at all and can return `404` for the same hash. Transaction status availability is not guaranteed indefinitely: failed statuses are stored in a capped collection and may be evicted as new entries arrive.
+     * Announce a new transaction
+     */
+    async announceTransactionRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.announceTransactionRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => AnnounceTransactionInfoDTOFromJSON(jsonValue));
     }
     /**
@@ -105,23 +131,30 @@ export class TransactionRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Returns confirmed transaction information given a transaction ID assigned by the node or transaction hash.  Use this endpoint when you need on-chain transaction data (the transaction is already included in a block). Use `getUnconfirmedTransaction` while the transaction is still in a node\'s unconfirmed pool, and use `getPartialTransaction` for aggregate bonded transactions waiting for cosignatures.
-     * Get confirmed transaction information
+     * Creates request options for getConfirmedTransaction without sending the request
      */
-    async getConfirmedTransactionRaw(requestParameters, initOverrides) {
+    async getConfirmedTransactionRequestOpts(requestParameters) {
         if (requestParameters['transactionId'] == null) {
             throw new runtime.RequiredError('transactionId', 'Required parameter "transactionId" was null or undefined when calling getConfirmedTransaction().');
         }
         const queryParameters = {};
         const headerParameters = {};
         let urlPath = `/transactions/confirmed/{transactionId}`;
-        urlPath = urlPath.replace(`{${"transactionId"}}`, encodeURIComponent(String(requestParameters['transactionId'])));
-        const response = await this.request({
+        urlPath = urlPath.replace('{transactionId}', encodeURIComponent(String(requestParameters['transactionId'])));
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns confirmed transaction information given a transaction ID assigned by the node or transaction hash.  Use this endpoint when you need on-chain transaction data (the transaction is already included in a block). Use `getUnconfirmedTransaction` while the transaction is still in a node\'s unconfirmed pool, and use `getPartialTransaction` for aggregate bonded transactions waiting for cosignatures.
+     * Get confirmed transaction information
+     */
+    async getConfirmedTransactionRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getConfirmedTransactionRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => TransactionInfoDTOFromJSON(jsonValue));
     }
     /**
@@ -133,10 +166,9 @@ export class TransactionRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Returns confirmed transactions for the list of identifiers in the request body. Each request item can be either a transaction ID assigned by the node or a transaction hash. Both values are returned by transaction retrieval and search endpoints, for example `GET /transactions/confirmed` and `GET /transactions/confirmed/{transactionId}`.  Use this endpoint when you need on-chain data for multiple transactions in one call. Use `getUnconfirmedTransactions` for transactions still pending in a node pool, and use `getPartialTransactions` for aggregate bonded transactions waiting for cosignatures.
-     * Get confirmed transactions information
+     * Creates request options for getConfirmedTransactions without sending the request
      */
-    async getConfirmedTransactionsRaw(requestParameters, initOverrides) {
+    async getConfirmedTransactionsRequestOpts(requestParameters) {
         if (requestParameters['transactionIds'] == null) {
             throw new runtime.RequiredError('transactionIds', 'Required parameter "transactionIds" was null or undefined when calling getConfirmedTransactions().');
         }
@@ -144,13 +176,21 @@ export class TransactionRoutesApi extends runtime.BaseAPI {
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         let urlPath = `/transactions/confirmed`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: TransactionIdsToJSON(requestParameters['transactionIds']),
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns confirmed transactions for the list of identifiers in the request body. Each request item can be either a transaction ID assigned by the node or a transaction hash. Both values are returned by transaction retrieval and search endpoints, for example `GET /transactions/confirmed` and `GET /transactions/confirmed/{transactionId}`.  Use this endpoint when you need on-chain data for multiple transactions in one call. Use `getUnconfirmedTransactions` for transactions still pending in a node pool, and use `getPartialTransactions` for aggregate bonded transactions waiting for cosignatures.
+     * Get confirmed transactions information
+     */
+    async getConfirmedTransactionsRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getConfirmedTransactionsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(TransactionInfoDTOFromJSON));
     }
     /**
@@ -162,23 +202,30 @@ export class TransactionRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Returns one partial transaction identified by the path value. Partial transactions are aggregate bonded transactions waiting for the remaining cosignatures.  The path accepts either the transaction ID assigned by the node or the transaction hash. Both values are returned by transaction retrieval and search endpoints, for example `GET /transactions/partial` and `GET /transactions/partial/{transactionId}`.  Use this endpoint for aggregate bonded transactions before they are fully cosigned. Use `getUnconfirmedTransaction` for non-partial transactions that are in a node\'s unconfirmed pool, and use `getConfirmedTransaction` once the transaction is confirmed on-chain.
-     * Get partial transaction information
+     * Creates request options for getPartialTransaction without sending the request
      */
-    async getPartialTransactionRaw(requestParameters, initOverrides) {
+    async getPartialTransactionRequestOpts(requestParameters) {
         if (requestParameters['transactionId'] == null) {
             throw new runtime.RequiredError('transactionId', 'Required parameter "transactionId" was null or undefined when calling getPartialTransaction().');
         }
         const queryParameters = {};
         const headerParameters = {};
         let urlPath = `/transactions/partial/{transactionId}`;
-        urlPath = urlPath.replace(`{${"transactionId"}}`, encodeURIComponent(String(requestParameters['transactionId'])));
-        const response = await this.request({
+        urlPath = urlPath.replace('{transactionId}', encodeURIComponent(String(requestParameters['transactionId'])));
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns one partial transaction identified by the path value. Partial transactions are aggregate bonded transactions waiting for the remaining cosignatures.  The path accepts either the transaction ID assigned by the node or the transaction hash. Both values are returned by transaction retrieval and search endpoints, for example `GET /transactions/partial` and `GET /transactions/partial/{transactionId}`.  Use this endpoint for aggregate bonded transactions before they are fully cosigned. Use `getUnconfirmedTransaction` for non-partial transactions that are in a node\'s unconfirmed pool, and use `getConfirmedTransaction` once the transaction is confirmed on-chain.
+     * Get partial transaction information
+     */
+    async getPartialTransactionRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getPartialTransactionRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => TransactionInfoDTOFromJSON(jsonValue));
     }
     /**
@@ -190,10 +237,9 @@ export class TransactionRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Returns partial transactions for the list of identifiers in the request body. Partial transactions are aggregate bonded transactions waiting for the remaining cosignatures.  Each request item can be either a transaction ID assigned by the node or a transaction hash. Both values are returned by transaction retrieval and search endpoints, for example `GET /transactions/partial` and `GET /transactions/partial/{transactionId}`.  Use this endpoint for aggregate bonded transactions that still wait for required cosignatures. Use `getUnconfirmedTransactions` for non-partial pending transactions accepted by a node but not yet included in a block, and use `getConfirmedTransactions` once transactions are confirmed on-chain.
-     * Get information about partial transactions
+     * Creates request options for getPartialTransactions without sending the request
      */
-    async getPartialTransactionsRaw(requestParameters, initOverrides) {
+    async getPartialTransactionsRequestOpts(requestParameters) {
         if (requestParameters['transactionIds'] == null) {
             throw new runtime.RequiredError('transactionIds', 'Required parameter "transactionIds" was null or undefined when calling getPartialTransactions().');
         }
@@ -201,13 +247,21 @@ export class TransactionRoutesApi extends runtime.BaseAPI {
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         let urlPath = `/transactions/partial`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: TransactionIdsToJSON(requestParameters['transactionIds']),
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns partial transactions for the list of identifiers in the request body. Partial transactions are aggregate bonded transactions waiting for the remaining cosignatures.  Each request item can be either a transaction ID assigned by the node or a transaction hash. Both values are returned by transaction retrieval and search endpoints, for example `GET /transactions/partial` and `GET /transactions/partial/{transactionId}`.  Use this endpoint for aggregate bonded transactions that still wait for required cosignatures. Use `getUnconfirmedTransactions` for non-partial pending transactions accepted by a node but not yet included in a block, and use `getConfirmedTransactions` once transactions are confirmed on-chain.
+     * Get information about partial transactions
+     */
+    async getPartialTransactionsRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getPartialTransactionsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(TransactionInfoDTOFromJSON));
     }
     /**
@@ -219,23 +273,30 @@ export class TransactionRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Returns one unconfirmed transaction identified by the path value. An unconfirmed transaction is accepted by a node and pending inclusion in a block.  The path accepts either the transaction ID assigned by the node or the transaction hash. Both values are returned by transaction retrieval and search endpoints, for example `GET /transactions/unconfirmed` and `GET /transactions/unconfirmed/{transactionId}`.  Use this endpoint while a transaction is accepted by a node but not yet included in a block. Use `getConfirmedTransaction` once it is confirmed on-chain, and use `getPartialTransaction` for aggregate bonded transactions waiting for cosignatures.
-     * Get unconfirmed transaction information
+     * Creates request options for getUnconfirmedTransaction without sending the request
      */
-    async getUnconfirmedTransactionRaw(requestParameters, initOverrides) {
+    async getUnconfirmedTransactionRequestOpts(requestParameters) {
         if (requestParameters['transactionId'] == null) {
             throw new runtime.RequiredError('transactionId', 'Required parameter "transactionId" was null or undefined when calling getUnconfirmedTransaction().');
         }
         const queryParameters = {};
         const headerParameters = {};
         let urlPath = `/transactions/unconfirmed/{transactionId}`;
-        urlPath = urlPath.replace(`{${"transactionId"}}`, encodeURIComponent(String(requestParameters['transactionId'])));
-        const response = await this.request({
+        urlPath = urlPath.replace('{transactionId}', encodeURIComponent(String(requestParameters['transactionId'])));
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns one unconfirmed transaction identified by the path value. An unconfirmed transaction is accepted by a node and pending inclusion in a block.  The path accepts either the transaction ID assigned by the node or the transaction hash. Both values are returned by transaction retrieval and search endpoints, for example `GET /transactions/unconfirmed` and `GET /transactions/unconfirmed/{transactionId}`.  Use this endpoint while a transaction is accepted by a node but not yet included in a block. Use `getConfirmedTransaction` once it is confirmed on-chain, and use `getPartialTransaction` for aggregate bonded transactions waiting for cosignatures.
+     * Get unconfirmed transaction information
+     */
+    async getUnconfirmedTransactionRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getUnconfirmedTransactionRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => TransactionInfoDTOFromJSON(jsonValue));
     }
     /**
@@ -247,10 +308,9 @@ export class TransactionRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Returns unconfirmed transactions for the list of identifiers in the request body. Unconfirmed transactions are accepted by a node and pending inclusion in a block.  Each request item can be either a transaction ID assigned by the node or a transaction hash. Both values are returned by transaction retrieval and search endpoints, for example `GET /transactions/unconfirmed` and `GET /transactions/unconfirmed/{transactionId}`.  Use this endpoint when checking multiple transactions that are accepted by a node but not yet included in a block. Use `getConfirmedTransactions` for on-chain transactions, and use `getPartialTransactions` for aggregate bonded transactions waiting for cosignatures.
-     * Get information about unconfirmed transactions
+     * Creates request options for getUnconfirmedTransactions without sending the request
      */
-    async getUnconfirmedTransactionsRaw(requestParameters, initOverrides) {
+    async getUnconfirmedTransactionsRequestOpts(requestParameters) {
         if (requestParameters['transactionIds'] == null) {
             throw new runtime.RequiredError('transactionIds', 'Required parameter "transactionIds" was null or undefined when calling getUnconfirmedTransactions().');
         }
@@ -258,13 +318,21 @@ export class TransactionRoutesApi extends runtime.BaseAPI {
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         let urlPath = `/transactions/unconfirmed`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: TransactionIdsToJSON(requestParameters['transactionIds']),
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns unconfirmed transactions for the list of identifiers in the request body. Unconfirmed transactions are accepted by a node and pending inclusion in a block.  Each request item can be either a transaction ID assigned by the node or a transaction hash. Both values are returned by transaction retrieval and search endpoints, for example `GET /transactions/unconfirmed` and `GET /transactions/unconfirmed/{transactionId}`.  Use this endpoint when checking multiple transactions that are accepted by a node but not yet included in a block. Use `getConfirmedTransactions` for on-chain transactions, and use `getPartialTransactions` for aggregate bonded transactions waiting for cosignatures.
+     * Get information about unconfirmed transactions
+     */
+    async getUnconfirmedTransactionsRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getUnconfirmedTransactionsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(TransactionInfoDTOFromJSON));
     }
     /**
@@ -276,10 +344,9 @@ export class TransactionRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Returns a paginated list of confirmed transactions matching the supplied filters.  Use this endpoint when you need on-chain transactions only (already included in blocks). Use `searchUnconfirmedTransactions` for transactions that are still pending in a node pool, and use `searchPartialTransactions` for aggregate bonded transactions waiting for cosignatures.  If a transaction was announced with an alias rather than an address, the address considered during filtering is the one resolved from that alias at confirmation time.  For cursor-style pagination on this endpoint, set `offset` to the `id` of the last transaction from the previous page. For general pagination strategy guidance, see the `offset` and `pageNumber` query parameter descriptions.
-     * Search confirmed transactions
+     * Creates request options for searchConfirmedTransactions without sending the request
      */
-    async searchConfirmedTransactionsRaw(requestParameters, initOverrides) {
+    async searchConfirmedTransactionsRequestOpts(requestParameters) {
         const queryParameters = {};
         if (requestParameters['address'] != null) {
             queryParameters['address'] = requestParameters['address'];
@@ -328,12 +395,20 @@ export class TransactionRoutesApi extends runtime.BaseAPI {
         }
         const headerParameters = {};
         let urlPath = `/transactions/confirmed`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns a paginated list of confirmed transactions matching the supplied filters.  Use this endpoint when you need on-chain transactions only (already included in blocks). Use `searchUnconfirmedTransactions` for transactions that are still pending in a node pool, and use `searchPartialTransactions` for aggregate bonded transactions waiting for cosignatures.  If a transaction was announced with an alias rather than an address, the address considered during filtering is the one resolved from that alias at confirmation time.  For cursor-style pagination on this endpoint, set `offset` to the `id` of the last transaction from the previous page. For general pagination strategy guidance, see the `offset` and `pageNumber` query parameter descriptions.
+     * Search confirmed transactions
+     */
+    async searchConfirmedTransactionsRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.searchConfirmedTransactionsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => TransactionPageFromJSON(jsonValue));
     }
     /**
@@ -345,10 +420,9 @@ export class TransactionRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Returns a paginated list of partial transactions matching the supplied filters.  Use this endpoint for aggregate bonded transactions that still wait for required cosignatures. Use `searchUnconfirmedTransactions` for non-partial pending transactions, and use `searchConfirmedTransactions` once transactions are confirmed on-chain.  For cursor-style pagination on this endpoint, set `offset` to the `id` of the last transaction from the previous page. For general pagination strategy guidance, see the `offset` and `pageNumber` query parameter descriptions.
-     * Search partial transactions
+     * Creates request options for searchPartialTransactions without sending the request
      */
-    async searchPartialTransactionsRaw(requestParameters, initOverrides) {
+    async searchPartialTransactionsRequestOpts(requestParameters) {
         const queryParameters = {};
         if (requestParameters['address'] != null) {
             queryParameters['address'] = requestParameters['address'];
@@ -397,12 +471,20 @@ export class TransactionRoutesApi extends runtime.BaseAPI {
         }
         const headerParameters = {};
         let urlPath = `/transactions/partial`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns a paginated list of partial transactions matching the supplied filters.  Use this endpoint for aggregate bonded transactions that still wait for required cosignatures. Use `searchUnconfirmedTransactions` for non-partial pending transactions, and use `searchConfirmedTransactions` once transactions are confirmed on-chain.  For cursor-style pagination on this endpoint, set `offset` to the `id` of the last transaction from the previous page. For general pagination strategy guidance, see the `offset` and `pageNumber` query parameter descriptions.
+     * Search partial transactions
+     */
+    async searchPartialTransactionsRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.searchPartialTransactionsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => TransactionPageFromJSON(jsonValue));
     }
     /**
@@ -414,10 +496,9 @@ export class TransactionRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Returns a paginated list of unconfirmed transactions matching the supplied filters.  Use this endpoint for transactions accepted by a node but not yet included in a block. Use `searchConfirmedTransactions` for on-chain transactions, and use `searchPartialTransactions` for aggregate bonded transactions waiting for cosignatures.  For cursor-style pagination on this endpoint, set `offset` to the `id` of the last transaction from the previous page. For general pagination strategy guidance, see the `offset` and `pageNumber` query parameter descriptions.
-     * Search unconfirmed transactions
+     * Creates request options for searchUnconfirmedTransactions without sending the request
      */
-    async searchUnconfirmedTransactionsRaw(requestParameters, initOverrides) {
+    async searchUnconfirmedTransactionsRequestOpts(requestParameters) {
         const queryParameters = {};
         if (requestParameters['address'] != null) {
             queryParameters['address'] = requestParameters['address'];
@@ -466,12 +547,20 @@ export class TransactionRoutesApi extends runtime.BaseAPI {
         }
         const headerParameters = {};
         let urlPath = `/transactions/unconfirmed`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns a paginated list of unconfirmed transactions matching the supplied filters.  Use this endpoint for transactions accepted by a node but not yet included in a block. Use `searchConfirmedTransactions` for on-chain transactions, and use `searchPartialTransactions` for aggregate bonded transactions waiting for cosignatures.  For cursor-style pagination on this endpoint, set `offset` to the `id` of the last transaction from the previous page. For general pagination strategy guidance, see the `offset` and `pageNumber` query parameter descriptions.
+     * Search unconfirmed transactions
+     */
+    async searchUnconfirmedTransactionsRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.searchUnconfirmedTransactionsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => TransactionPageFromJSON(jsonValue));
     }
     /**

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

@@ -10,17 +10,28 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { TransactionHashes, TransactionStatusDTO } from '../models/index';
+import { type TransactionHashes } from '../models/TransactionHashes';
+import { type TransactionStatusDTO } from '../models/TransactionStatusDTO';
 export interface GetTransactionStatusRequest {
+    /**
+     * Transaction hash encoded as a 64-character hexadecimal string.
+     */
     hash: string;
 }
 export interface GetTransactionStatusesRequest {
+    /**
+     *
+     */
     transactionHashes: TransactionHashes;
 }
 /**
  *
  */
 export declare class TransactionStatusRoutesApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for getTransactionStatus without sending the request
+     */
+    getTransactionStatusRequestOpts(requestParameters: GetTransactionStatusRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns the current status of the transaction identified by the given transaction hash.  When checking status after announcing a transaction, it is best to query the same node that received the announce request. If that node rejects the transaction before propagation, only that node may know the detailed rejection reason. Other nodes may not know the transaction at all because it was never propagated.
      * Get transaction status
@@ -31,6 +42,10 @@ export declare class TransactionStatusRoutesApi extends runtime.BaseAPI {
      * Get transaction status
      */
     getTransactionStatus(requestParameters: GetTransactionStatusRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TransactionStatusDTO>;
+    /**
+     * Creates request options for getTransactionStatuses without sending the request
+     */
+    getTransactionStatusesRequestOpts(requestParameters: GetTransactionStatusesRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns the current statuses of the transactions identified by the given array of transaction hashes.  When checking status after announcing transactions, it is best to query the same node that received the announce request. If that node rejects a transaction before propagation, only that node may know the detailed rejection reason. Other nodes may not know the transaction at all because it was never propagated.
      * Get transaction statuses

package/esm/api/apis/TransactionStatusRoutesApi.js

@@ -12,29 +12,37 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import { TransactionHashesToJSON, TransactionStatusDTOFromJSON, } from '../models/index';
+import { TransactionHashesToJSON, } from '../models/TransactionHashes';
+import { TransactionStatusDTOFromJSON, } from '../models/TransactionStatusDTO';
 /**
  *
  */
 export class TransactionStatusRoutesApi extends runtime.BaseAPI {
     /**
-     * Returns the current status of the transaction identified by the given transaction hash.  When checking status after announcing a transaction, it is best to query the same node that received the announce request. If that node rejects the transaction before propagation, only that node may know the detailed rejection reason. Other nodes may not know the transaction at all because it was never propagated.
-     * Get transaction status
+     * Creates request options for getTransactionStatus without sending the request
      */
-    async getTransactionStatusRaw(requestParameters, initOverrides) {
+    async getTransactionStatusRequestOpts(requestParameters) {
         if (requestParameters['hash'] == null) {
             throw new runtime.RequiredError('hash', 'Required parameter "hash" was null or undefined when calling getTransactionStatus().');
         }
         const queryParameters = {};
         const headerParameters = {};
         let urlPath = `/transactionStatus/{hash}`;
-        urlPath = urlPath.replace(`{${"hash"}}`, encodeURIComponent(String(requestParameters['hash'])));
-        const response = await this.request({
+        urlPath = urlPath.replace('{hash}', encodeURIComponent(String(requestParameters['hash'])));
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns the current status of the transaction identified by the given transaction hash.  When checking status after announcing a transaction, it is best to query the same node that received the announce request. If that node rejects the transaction before propagation, only that node may know the detailed rejection reason. Other nodes may not know the transaction at all because it was never propagated.
+     * Get transaction status
+     */
+    async getTransactionStatusRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getTransactionStatusRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => TransactionStatusDTOFromJSON(jsonValue));
     }
     /**
@@ -46,10 +54,9 @@ export class TransactionStatusRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Returns the current statuses of the transactions identified by the given array of transaction hashes.  When checking status after announcing transactions, it is best to query the same node that received the announce request. If that node rejects a transaction before propagation, only that node may know the detailed rejection reason. Other nodes may not know the transaction at all because it was never propagated.
-     * Get transaction statuses
+     * Creates request options for getTransactionStatuses without sending the request
      */
-    async getTransactionStatusesRaw(requestParameters, initOverrides) {
+    async getTransactionStatusesRequestOpts(requestParameters) {
         if (requestParameters['transactionHashes'] == null) {
             throw new runtime.RequiredError('transactionHashes', 'Required parameter "transactionHashes" was null or undefined when calling getTransactionStatuses().');
         }
@@ -57,13 +64,21 @@ export class TransactionStatusRoutesApi extends runtime.BaseAPI {
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         let urlPath = `/transactionStatus`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: TransactionHashesToJSON(requestParameters['transactionHashes']),
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns the current statuses of the transactions identified by the given array of transaction hashes.  When checking status after announcing transactions, it is best to query the same node that received the announce request. If that node rejects a transaction before propagation, only that node may know the detailed rejection reason. Other nodes may not know the transaction at all because it was never propagated.
+     * Get transaction statuses
+     */
+    async getTransactionStatusesRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getTransactionStatusesRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(TransactionStatusDTOFromJSON));
     }
     /**

package/esm/api/models/AccountAddressRestrictionTransactionBodyDTO.d.ts

@@ -18,27 +18,21 @@ import type { AccountRestrictionFlagsEnum } from './AccountRestrictionFlagsEnum'
 export interface AccountAddressRestrictionTransactionBodyDTO {
     /**
      *
-     * @type {AccountRestrictionFlagsEnum}
-     * @memberof AccountAddressRestrictionTransactionBodyDTO
      */
     restrictionFlags: AccountRestrictionFlagsEnum;
     /**
      * Account restriction additions.
-     * @type {Array<string>}
-     * @memberof AccountAddressRestrictionTransactionBodyDTO
      */
     restrictionAdditions: Array<string>;
     /**
      * Account restriction deletions.
-     * @type {Array<string>}
-     * @memberof AccountAddressRestrictionTransactionBodyDTO
      */
     restrictionDeletions: Array<string>;
 }
 /**
  * Check if a given object implements the AccountAddressRestrictionTransactionBodyDTO interface.
  */
-export declare function instanceOfAccountAddressRestrictionTransactionBodyDTO(value: Record<string, any>): value is AccountAddressRestrictionTransactionBodyDTO;
+export declare function instanceOfAccountAddressRestrictionTransactionBodyDTO(value: object): value is AccountAddressRestrictionTransactionBodyDTO;
 export declare function AccountAddressRestrictionTransactionBodyDTOFromJSON(json: any): AccountAddressRestrictionTransactionBodyDTO;
 export declare function AccountAddressRestrictionTransactionBodyDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): AccountAddressRestrictionTransactionBodyDTO;
 export declare function AccountAddressRestrictionTransactionBodyDTOToJSON(json: any): AccountAddressRestrictionTransactionBodyDTO;