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

package/cjs/api/apis/TransactionRoutesApi.js

@@ -57,16 +57,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionRoutesApi = void 0;
 const runtime = __importStar(require("../runtime"));
-const index_1 = require("../models/index");
+const AnnounceTransactionInfoDTO_1 = require("../models/AnnounceTransactionInfoDTO");
+const Cosignature_1 = require("../models/Cosignature");
+const TransactionIds_1 = require("../models/TransactionIds");
+const TransactionInfoDTO_1 = require("../models/TransactionInfoDTO");
+const TransactionPage_1 = require("../models/TransactionPage");
+const TransactionPayload_1 = require("../models/TransactionPayload");
 /**
  *
  */
 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
      */
-    announceCosignatureTransactionRaw(requestParameters, initOverrides) {
+    announceCosignatureTransactionRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['cosignature'] == null) {
                 throw new runtime.RequiredError('cosignature', 'Required parameter "cosignature" was null or undefined when calling announceCosignatureTransaction().');
@@ -75,14 +79,24 @@ class TransactionRoutesApi extends runtime.BaseAPI {
             const headerParameters = {};
             headerParameters['Content-Type'] = 'application/json';
             let urlPath = `/transactions/cosignature`;
-            const response = yield this.request({
+            return {
                 path: urlPath,
                 method: 'PUT',
                 headers: headerParameters,
                 query: queryParameters,
-                body: (0, index_1.CosignatureToJSON)(requestParameters['cosignature']),
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.AnnounceTransactionInfoDTOFromJSON)(jsonValue));
+                body: (0, Cosignature_1.CosignatureToJSON)(requestParameters['cosignature']),
+            };
+        });
+    }
+    /**
+     * 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
+     */
+    announceCosignatureTransactionRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.announceCosignatureTransactionRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, AnnounceTransactionInfoDTO_1.AnnounceTransactionInfoDTOFromJSON)(jsonValue));
         });
     }
     /**
@@ -96,10 +110,9 @@ class TransactionRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * 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
      */
-    announcePartialTransactionRaw(requestParameters, initOverrides) {
+    announcePartialTransactionRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['transactionPayload'] == null) {
                 throw new runtime.RequiredError('transactionPayload', 'Required parameter "transactionPayload" was null or undefined when calling announcePartialTransaction().');
@@ -108,14 +121,24 @@ class TransactionRoutesApi extends runtime.BaseAPI {
             const headerParameters = {};
             headerParameters['Content-Type'] = 'application/json';
             let urlPath = `/transactions/partial`;
-            const response = yield this.request({
+            return {
                 path: urlPath,
                 method: 'PUT',
                 headers: headerParameters,
                 query: queryParameters,
-                body: (0, index_1.TransactionPayloadToJSON)(requestParameters['transactionPayload']),
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.AnnounceTransactionInfoDTOFromJSON)(jsonValue));
+                body: (0, TransactionPayload_1.TransactionPayloadToJSON)(requestParameters['transactionPayload']),
+            };
+        });
+    }
+    /**
+     * 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
+     */
+    announcePartialTransactionRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.announcePartialTransactionRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, AnnounceTransactionInfoDTO_1.AnnounceTransactionInfoDTOFromJSON)(jsonValue));
         });
     }
     /**
@@ -129,10 +152,9 @@ class TransactionRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * 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
      */
-    announceTransactionRaw(requestParameters, initOverrides) {
+    announceTransactionRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['transactionPayload'] == null) {
                 throw new runtime.RequiredError('transactionPayload', 'Required parameter "transactionPayload" was null or undefined when calling announceTransaction().');
@@ -141,14 +163,24 @@ class TransactionRoutesApi extends runtime.BaseAPI {
             const headerParameters = {};
             headerParameters['Content-Type'] = 'application/json';
             let urlPath = `/transactions`;
-            const response = yield this.request({
+            return {
                 path: urlPath,
                 method: 'PUT',
                 headers: headerParameters,
                 query: queryParameters,
-                body: (0, index_1.TransactionPayloadToJSON)(requestParameters['transactionPayload']),
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.AnnounceTransactionInfoDTOFromJSON)(jsonValue));
+                body: (0, TransactionPayload_1.TransactionPayloadToJSON)(requestParameters['transactionPayload']),
+            };
+        });
+    }
+    /**
+     * 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
+     */
+    announceTransactionRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.announceTransactionRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, AnnounceTransactionInfoDTO_1.AnnounceTransactionInfoDTOFromJSON)(jsonValue));
         });
     }
     /**
@@ -162,10 +194,9 @@ class TransactionRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * 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
      */
-    getConfirmedTransactionRaw(requestParameters, initOverrides) {
+    getConfirmedTransactionRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['transactionId'] == null) {
                 throw new runtime.RequiredError('transactionId', 'Required parameter "transactionId" was null or undefined when calling getConfirmedTransaction().');
@@ -173,14 +204,24 @@ class TransactionRoutesApi extends runtime.BaseAPI {
             const queryParameters = {};
             const headerParameters = {};
             let urlPath = `/transactions/confirmed/{transactionId}`;
-            urlPath = urlPath.replace(`{${"transactionId"}}`, encodeURIComponent(String(requestParameters['transactionId'])));
-            const response = yield this.request({
+            urlPath = urlPath.replace('{transactionId}', encodeURIComponent(String(requestParameters['transactionId'])));
+            return {
                 path: urlPath,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.TransactionInfoDTOFromJSON)(jsonValue));
+            };
+        });
+    }
+    /**
+     * 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
+     */
+    getConfirmedTransactionRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getConfirmedTransactionRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, TransactionInfoDTO_1.TransactionInfoDTOFromJSON)(jsonValue));
         });
     }
     /**
@@ -194,10 +235,9 @@ class TransactionRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * 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
      */
-    getConfirmedTransactionsRaw(requestParameters, initOverrides) {
+    getConfirmedTransactionsRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['transactionIds'] == null) {
                 throw new runtime.RequiredError('transactionIds', 'Required parameter "transactionIds" was null or undefined when calling getConfirmedTransactions().');
@@ -206,14 +246,24 @@ class TransactionRoutesApi extends runtime.BaseAPI {
             const headerParameters = {};
             headerParameters['Content-Type'] = 'application/json';
             let urlPath = `/transactions/confirmed`;
-            const response = yield this.request({
+            return {
                 path: urlPath,
                 method: 'POST',
                 headers: headerParameters,
                 query: queryParameters,
-                body: (0, index_1.TransactionIdsToJSON)(requestParameters['transactionIds']),
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.TransactionInfoDTOFromJSON));
+                body: (0, TransactionIds_1.TransactionIdsToJSON)(requestParameters['transactionIds']),
+            };
+        });
+    }
+    /**
+     * 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
+     */
+    getConfirmedTransactionsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getConfirmedTransactionsRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(TransactionInfoDTO_1.TransactionInfoDTOFromJSON));
         });
     }
     /**
@@ -227,10 +277,9 @@ class TransactionRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * 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
      */
-    getPartialTransactionRaw(requestParameters, initOverrides) {
+    getPartialTransactionRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['transactionId'] == null) {
                 throw new runtime.RequiredError('transactionId', 'Required parameter "transactionId" was null or undefined when calling getPartialTransaction().');
@@ -238,14 +287,24 @@ class TransactionRoutesApi extends runtime.BaseAPI {
             const queryParameters = {};
             const headerParameters = {};
             let urlPath = `/transactions/partial/{transactionId}`;
-            urlPath = urlPath.replace(`{${"transactionId"}}`, encodeURIComponent(String(requestParameters['transactionId'])));
-            const response = yield this.request({
+            urlPath = urlPath.replace('{transactionId}', encodeURIComponent(String(requestParameters['transactionId'])));
+            return {
                 path: urlPath,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.TransactionInfoDTOFromJSON)(jsonValue));
+            };
+        });
+    }
+    /**
+     * 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
+     */
+    getPartialTransactionRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getPartialTransactionRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, TransactionInfoDTO_1.TransactionInfoDTOFromJSON)(jsonValue));
         });
     }
     /**
@@ -259,10 +318,9 @@ class TransactionRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * 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
      */
-    getPartialTransactionsRaw(requestParameters, initOverrides) {
+    getPartialTransactionsRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['transactionIds'] == null) {
                 throw new runtime.RequiredError('transactionIds', 'Required parameter "transactionIds" was null or undefined when calling getPartialTransactions().');
@@ -271,14 +329,24 @@ class TransactionRoutesApi extends runtime.BaseAPI {
             const headerParameters = {};
             headerParameters['Content-Type'] = 'application/json';
             let urlPath = `/transactions/partial`;
-            const response = yield this.request({
+            return {
                 path: urlPath,
                 method: 'POST',
                 headers: headerParameters,
                 query: queryParameters,
-                body: (0, index_1.TransactionIdsToJSON)(requestParameters['transactionIds']),
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.TransactionInfoDTOFromJSON));
+                body: (0, TransactionIds_1.TransactionIdsToJSON)(requestParameters['transactionIds']),
+            };
+        });
+    }
+    /**
+     * 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
+     */
+    getPartialTransactionsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getPartialTransactionsRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(TransactionInfoDTO_1.TransactionInfoDTOFromJSON));
         });
     }
     /**
@@ -292,10 +360,9 @@ class TransactionRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * 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
      */
-    getUnconfirmedTransactionRaw(requestParameters, initOverrides) {
+    getUnconfirmedTransactionRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['transactionId'] == null) {
                 throw new runtime.RequiredError('transactionId', 'Required parameter "transactionId" was null or undefined when calling getUnconfirmedTransaction().');
@@ -303,14 +370,24 @@ class TransactionRoutesApi extends runtime.BaseAPI {
             const queryParameters = {};
             const headerParameters = {};
             let urlPath = `/transactions/unconfirmed/{transactionId}`;
-            urlPath = urlPath.replace(`{${"transactionId"}}`, encodeURIComponent(String(requestParameters['transactionId'])));
-            const response = yield this.request({
+            urlPath = urlPath.replace('{transactionId}', encodeURIComponent(String(requestParameters['transactionId'])));
+            return {
                 path: urlPath,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.TransactionInfoDTOFromJSON)(jsonValue));
+            };
+        });
+    }
+    /**
+     * 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
+     */
+    getUnconfirmedTransactionRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getUnconfirmedTransactionRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, TransactionInfoDTO_1.TransactionInfoDTOFromJSON)(jsonValue));
         });
     }
     /**
@@ -324,10 +401,9 @@ class TransactionRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * 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
      */
-    getUnconfirmedTransactionsRaw(requestParameters, initOverrides) {
+    getUnconfirmedTransactionsRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['transactionIds'] == null) {
                 throw new runtime.RequiredError('transactionIds', 'Required parameter "transactionIds" was null or undefined when calling getUnconfirmedTransactions().');
@@ -336,14 +412,24 @@ class TransactionRoutesApi extends runtime.BaseAPI {
             const headerParameters = {};
             headerParameters['Content-Type'] = 'application/json';
             let urlPath = `/transactions/unconfirmed`;
-            const response = yield this.request({
+            return {
                 path: urlPath,
                 method: 'POST',
                 headers: headerParameters,
                 query: queryParameters,
-                body: (0, index_1.TransactionIdsToJSON)(requestParameters['transactionIds']),
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.TransactionInfoDTOFromJSON));
+                body: (0, TransactionIds_1.TransactionIdsToJSON)(requestParameters['transactionIds']),
+            };
+        });
+    }
+    /**
+     * 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
+     */
+    getUnconfirmedTransactionsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getUnconfirmedTransactionsRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(TransactionInfoDTO_1.TransactionInfoDTOFromJSON));
         });
     }
     /**
@@ -357,10 +443,9 @@ class TransactionRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * 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
      */
-    searchConfirmedTransactionsRaw(requestParameters, initOverrides) {
+    searchConfirmedTransactionsRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             const queryParameters = {};
             if (requestParameters['address'] != null) {
@@ -410,13 +495,23 @@ class TransactionRoutesApi extends runtime.BaseAPI {
             }
             const headerParameters = {};
             let urlPath = `/transactions/confirmed`;
-            const response = yield this.request({
+            return {
                 path: urlPath,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.TransactionPageFromJSON)(jsonValue));
+            };
+        });
+    }
+    /**
+     * 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
+     */
+    searchConfirmedTransactionsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.searchConfirmedTransactionsRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, TransactionPage_1.TransactionPageFromJSON)(jsonValue));
         });
     }
     /**
@@ -430,10 +525,9 @@ class TransactionRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * 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
      */
-    searchPartialTransactionsRaw(requestParameters, initOverrides) {
+    searchPartialTransactionsRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             const queryParameters = {};
             if (requestParameters['address'] != null) {
@@ -483,13 +577,23 @@ class TransactionRoutesApi extends runtime.BaseAPI {
             }
             const headerParameters = {};
             let urlPath = `/transactions/partial`;
-            const response = yield this.request({
+            return {
                 path: urlPath,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.TransactionPageFromJSON)(jsonValue));
+            };
+        });
+    }
+    /**
+     * 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
+     */
+    searchPartialTransactionsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.searchPartialTransactionsRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, TransactionPage_1.TransactionPageFromJSON)(jsonValue));
         });
     }
     /**
@@ -503,10 +607,9 @@ class TransactionRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * 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
      */
-    searchUnconfirmedTransactionsRaw(requestParameters, initOverrides) {
+    searchUnconfirmedTransactionsRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             const queryParameters = {};
             if (requestParameters['address'] != null) {
@@ -556,13 +659,23 @@ class TransactionRoutesApi extends runtime.BaseAPI {
             }
             const headerParameters = {};
             let urlPath = `/transactions/unconfirmed`;
-            const response = yield this.request({
+            return {
                 path: urlPath,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.TransactionPageFromJSON)(jsonValue));
+            };
+        });
+    }
+    /**
+     * 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
+     */
+    searchUnconfirmedTransactionsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.searchUnconfirmedTransactionsRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, TransactionPage_1.TransactionPageFromJSON)(jsonValue));
         });
     }
     /**

package/cjs/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