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

package/cjs/api/apis/MosaicRoutesApi.js

@@ -57,16 +57,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MosaicRoutesApi = void 0;
 const runtime = __importStar(require("../runtime"));
-const index_1 = require("../models/index");
+const MerkleStateInfoDTO_1 = require("../models/MerkleStateInfoDTO");
+const MosaicIds_1 = require("../models/MosaicIds");
+const MosaicInfoDTO_1 = require("../models/MosaicInfoDTO");
+const MosaicPage_1 = require("../models/MosaicPage");
 /**
  *
  */
 class MosaicRoutesApi extends runtime.BaseAPI {
     /**
-     * Retrieves the current on-chain state for a mosaic. The response includes the mosaic definition, such as supply, divisibility, owner address, duration, and behavior flags.
-     * Get mosaic information
+     * Creates request options for getMosaic without sending the request
      */
-    getMosaicRaw(requestParameters, initOverrides) {
+    getMosaicRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['mosaicId'] == null) {
                 throw new runtime.RequiredError('mosaicId', 'Required parameter "mosaicId" was null or undefined when calling getMosaic().');
@@ -74,14 +76,24 @@ class MosaicRoutesApi extends runtime.BaseAPI {
             const queryParameters = {};
             const headerParameters = {};
             let urlPath = `/mosaics/{mosaicId}`;
-            urlPath = urlPath.replace(`{${"mosaicId"}}`, encodeURIComponent(String(requestParameters['mosaicId'])));
-            const response = yield this.request({
+            urlPath = urlPath.replace('{mosaicId}', encodeURIComponent(String(requestParameters['mosaicId'])));
+            return {
                 path: urlPath,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.MosaicInfoDTOFromJSON)(jsonValue));
+            };
+        });
+    }
+    /**
+     * Retrieves the current on-chain state for a mosaic. The response includes the mosaic definition, such as supply, divisibility, owner address, duration, and behavior flags.
+     * Get mosaic information
+     */
+    getMosaicRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getMosaicRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, MosaicInfoDTO_1.MosaicInfoDTOFromJSON)(jsonValue));
         });
     }
     /**
@@ -95,10 +107,9 @@ class MosaicRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Returns the [Merkle proof](https://docs.symbol.dev/concepts/data-validation.html#merkle-proof) for a mosaic.  Clients can use this information to verify that the mosaic state is included in the node\'s state Merkle tree. If the supplied mosaic ID does not exist, the endpoint still returns a Merkle proof response, but it is a negative proof showing that no mosaic state entry exists for the requested mosaic ID. See [Data Validation](https://docs.symbol.dev/concepts/data-validation.html) for an overview of Patricia Merkle trees and state proofs on Symbol.
-     * Get mosaic Merkle information
+     * Creates request options for getMosaicMerkle without sending the request
      */
-    getMosaicMerkleRaw(requestParameters, initOverrides) {
+    getMosaicMerkleRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['mosaicId'] == null) {
                 throw new runtime.RequiredError('mosaicId', 'Required parameter "mosaicId" was null or undefined when calling getMosaicMerkle().');
@@ -106,14 +117,24 @@ class MosaicRoutesApi extends runtime.BaseAPI {
             const queryParameters = {};
             const headerParameters = {};
             let urlPath = `/mosaics/{mosaicId}/merkle`;
-            urlPath = urlPath.replace(`{${"mosaicId"}}`, encodeURIComponent(String(requestParameters['mosaicId'])));
-            const response = yield this.request({
+            urlPath = urlPath.replace('{mosaicId}', encodeURIComponent(String(requestParameters['mosaicId'])));
+            return {
                 path: urlPath,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.MerkleStateInfoDTOFromJSON)(jsonValue));
+            };
+        });
+    }
+    /**
+     * Returns the [Merkle proof](https://docs.symbol.dev/concepts/data-validation.html#merkle-proof) for a mosaic.  Clients can use this information to verify that the mosaic state is included in the node\'s state Merkle tree. If the supplied mosaic ID does not exist, the endpoint still returns a Merkle proof response, but it is a negative proof showing that no mosaic state entry exists for the requested mosaic ID. See [Data Validation](https://docs.symbol.dev/concepts/data-validation.html) for an overview of Patricia Merkle trees and state proofs on Symbol.
+     * Get mosaic Merkle information
+     */
+    getMosaicMerkleRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getMosaicMerkleRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, MerkleStateInfoDTO_1.MerkleStateInfoDTOFromJSON)(jsonValue));
         });
     }
     /**
@@ -127,10 +148,9 @@ class MosaicRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Retrieves the current on-chain state for multiple mosaics. The response includes only mosaics that were found, so its length can be smaller than the number of requested identifiers. Response entries are not guaranteed to preserve the order of the requested identifiers.
-     * Get mosaics information for an array of mosaics
+     * Creates request options for getMosaics without sending the request
      */
-    getMosaicsRaw(requestParameters, initOverrides) {
+    getMosaicsRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['mosaicIds'] == null) {
                 throw new runtime.RequiredError('mosaicIds', 'Required parameter "mosaicIds" was null or undefined when calling getMosaics().');
@@ -139,14 +159,24 @@ class MosaicRoutesApi extends runtime.BaseAPI {
             const headerParameters = {};
             headerParameters['Content-Type'] = 'application/json';
             let urlPath = `/mosaics`;
-            const response = yield this.request({
+            return {
                 path: urlPath,
                 method: 'POST',
                 headers: headerParameters,
                 query: queryParameters,
-                body: (0, index_1.MosaicIdsToJSON)(requestParameters['mosaicIds']),
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.MosaicInfoDTOFromJSON));
+                body: (0, MosaicIds_1.MosaicIdsToJSON)(requestParameters['mosaicIds']),
+            };
+        });
+    }
+    /**
+     * Retrieves the current on-chain state for multiple mosaics. The response includes only mosaics that were found, so its length can be smaller than the number of requested identifiers. Response entries are not guaranteed to preserve the order of the requested identifiers.
+     * Get mosaics information for an array of mosaics
+     */
+    getMosaicsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getMosaicsRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MosaicInfoDTO_1.MosaicInfoDTOFromJSON));
         });
     }
     /**
@@ -160,10 +190,9 @@ class MosaicRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Returns a paginated list of mosaics matching the given criteria. Results can be filtered by mosaic owner address. Standard pagination parameters apply.
-     * Search mosaics
+     * Creates request options for searchMosaics without sending the request
      */
-    searchMosaicsRaw(requestParameters, initOverrides) {
+    searchMosaicsRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             const queryParameters = {};
             if (requestParameters['ownerAddress'] != null) {
@@ -183,13 +212,23 @@ class MosaicRoutesApi extends runtime.BaseAPI {
             }
             const headerParameters = {};
             let urlPath = `/mosaics`;
-            const response = yield this.request({
+            return {
                 path: urlPath,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.MosaicPageFromJSON)(jsonValue));
+            };
+        });
+    }
+    /**
+     * Returns a paginated list of mosaics matching the given criteria. Results can be filtered by mosaic owner address. Standard pagination parameters apply.
+     * Search mosaics
+     */
+    searchMosaicsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.searchMosaicsRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, MosaicPage_1.MosaicPageFromJSON)(jsonValue));
         });
     }
     /**

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

@@ -10,20 +10,35 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { MerkleStateInfoDTO, MultisigAccountGraphInfoDTO, MultisigAccountInfoDTO } from '../models/index';
+import { type MerkleStateInfoDTO } from '../models/MerkleStateInfoDTO';
+import { type MultisigAccountGraphInfoDTO } from '../models/MultisigAccountGraphInfoDTO';
+import { type MultisigAccountInfoDTO } from '../models/MultisigAccountInfoDTO';
 export interface GetAccountMultisigRequest {
+    /**
+     * Account address in Base32-encoded format.
+     */
     address: string;
 }
 export interface GetAccountMultisigGraphRequest {
+    /**
+     * Account address in Base32-encoded format.
+     */
     address: string;
 }
 export interface GetAccountMultisigMerkleRequest {
+    /**
+     * Account address in Base32-encoded format.
+     */
     address: string;
 }
 /**
  *
  */
 export declare class MultisigRoutesApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for getAccountMultisig without sending the request
+     */
+    getAccountMultisigRequestOpts(requestParameters: GetAccountMultisigRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns the current multisig state for an account.  The response includes the approval thresholds for the multisig account, its direct cosignatories, and the multisig accounts where the queried account is itself acting as a cosignatory.  If the queried account is only a cosignatory, the endpoint still returns `200`, with `minApproval = 0`, `minRemoval = 0`, an empty `cosignatoryAddresses` array, and the related multisig accounts listed in `multisigAddresses`.  If the account is neither a multisig account nor a cosignatory of any multisig account, the endpoint returns `404`.
      * Get multisig account information
@@ -34,6 +49,10 @@ export declare class MultisigRoutesApi extends runtime.BaseAPI {
      * Get multisig account information
      */
     getAccountMultisig(requestParameters: GetAccountMultisigRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MultisigAccountInfoDTO>;
+    /**
+     * Creates request options for getAccountMultisigGraph without sending the request
+     */
+    getAccountMultisigGraphRequestOpts(requestParameters: GetAccountMultisigGraphRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns the multisig graph centered on the requested account.  Level `0` contains the requested account. Negative levels contain multisig accounts for which the queried account acts as a cosignatory. Positive levels contain multisig relationships discovered through the queried account\'s cosignatories.  If the requested account is a cosignatory but is not itself managed as a multisig account, the response still includes level `0` for that account. In this case, the level `0` entry has `minApproval = 0`, `minRemoval = 0`, an empty `cosignatoryAddresses` array, and `multisigAddresses` listing the multisig accounts it can cosign.  If the requested account is neither a multisig account nor a cosignatory of any multisig account, no multisig state entry exists for it and the endpoint returns `404`.  If the requested account is itself a multisig account, the response includes its multisig state at level `0` together with any reachable negative and positive graph levels.
      * Get multisig account graph information
@@ -44,6 +63,10 @@ export declare class MultisigRoutesApi extends runtime.BaseAPI {
      * Get multisig account graph information
      */
     getAccountMultisigGraph(requestParameters: GetAccountMultisigGraphRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<MultisigAccountGraphInfoDTO>>;
+    /**
+     * Creates request options for getAccountMultisigMerkle without sending the request
+     */
+    getAccountMultisigMerkleRequestOpts(requestParameters: GetAccountMultisigMerkleRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns the [Merkle proof](https://docs.symbol.dev/concepts/data-validation.html#merkle-proof) for the multisig state entry associated with the requested account.  If the requested account is a cosignatory, the endpoint returns the Merkle proof for that account\'s multisig state entry. Cosignatory-only accounts still have a multisig state entry with `minApproval = 0`, `minRemoval = 0`, an empty `cosignatoryAddresses` array, and `multisigAddresses` listing the multisig accounts they can cosign.  If the requested account is itself a multisig account, the endpoint returns the Merkle proof for that multisig account state entry.  If the requested account is neither a multisig account nor a cosignatory, the endpoint still returns a Merkle proof response, but it is a negative proof showing that no multisig state entry exists for the supplied address.
      * Get multisig account Merkle information

package/cjs/api/apis/MultisigRoutesApi.js

@@ -57,16 +57,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MultisigRoutesApi = void 0;
 const runtime = __importStar(require("../runtime"));
-const index_1 = require("../models/index");
+const MerkleStateInfoDTO_1 = require("../models/MerkleStateInfoDTO");
+const MultisigAccountGraphInfoDTO_1 = require("../models/MultisigAccountGraphInfoDTO");
+const MultisigAccountInfoDTO_1 = require("../models/MultisigAccountInfoDTO");
 /**
  *
  */
 class MultisigRoutesApi extends runtime.BaseAPI {
     /**
-     * Returns the current multisig state for an account.  The response includes the approval thresholds for the multisig account, its direct cosignatories, and the multisig accounts where the queried account is itself acting as a cosignatory.  If the queried account is only a cosignatory, the endpoint still returns `200`, with `minApproval = 0`, `minRemoval = 0`, an empty `cosignatoryAddresses` array, and the related multisig accounts listed in `multisigAddresses`.  If the account is neither a multisig account nor a cosignatory of any multisig account, the endpoint returns `404`.
-     * Get multisig account information
+     * Creates request options for getAccountMultisig without sending the request
      */
-    getAccountMultisigRaw(requestParameters, initOverrides) {
+    getAccountMultisigRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['address'] == null) {
                 throw new runtime.RequiredError('address', 'Required parameter "address" was null or undefined when calling getAccountMultisig().');
@@ -74,14 +75,24 @@ class MultisigRoutesApi extends runtime.BaseAPI {
             const queryParameters = {};
             const headerParameters = {};
             let urlPath = `/account/{address}/multisig`;
-            urlPath = urlPath.replace(`{${"address"}}`, encodeURIComponent(String(requestParameters['address'])));
-            const response = yield this.request({
+            urlPath = urlPath.replace('{address}', encodeURIComponent(String(requestParameters['address'])));
+            return {
                 path: urlPath,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.MultisigAccountInfoDTOFromJSON)(jsonValue));
+            };
+        });
+    }
+    /**
+     * Returns the current multisig state for an account.  The response includes the approval thresholds for the multisig account, its direct cosignatories, and the multisig accounts where the queried account is itself acting as a cosignatory.  If the queried account is only a cosignatory, the endpoint still returns `200`, with `minApproval = 0`, `minRemoval = 0`, an empty `cosignatoryAddresses` array, and the related multisig accounts listed in `multisigAddresses`.  If the account is neither a multisig account nor a cosignatory of any multisig account, the endpoint returns `404`.
+     * Get multisig account information
+     */
+    getAccountMultisigRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getAccountMultisigRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, MultisigAccountInfoDTO_1.MultisigAccountInfoDTOFromJSON)(jsonValue));
         });
     }
     /**
@@ -95,10 +106,9 @@ class MultisigRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Returns the multisig graph centered on the requested account.  Level `0` contains the requested account. Negative levels contain multisig accounts for which the queried account acts as a cosignatory. Positive levels contain multisig relationships discovered through the queried account\'s cosignatories.  If the requested account is a cosignatory but is not itself managed as a multisig account, the response still includes level `0` for that account. In this case, the level `0` entry has `minApproval = 0`, `minRemoval = 0`, an empty `cosignatoryAddresses` array, and `multisigAddresses` listing the multisig accounts it can cosign.  If the requested account is neither a multisig account nor a cosignatory of any multisig account, no multisig state entry exists for it and the endpoint returns `404`.  If the requested account is itself a multisig account, the response includes its multisig state at level `0` together with any reachable negative and positive graph levels.
-     * Get multisig account graph information
+     * Creates request options for getAccountMultisigGraph without sending the request
      */
-    getAccountMultisigGraphRaw(requestParameters, initOverrides) {
+    getAccountMultisigGraphRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['address'] == null) {
                 throw new runtime.RequiredError('address', 'Required parameter "address" was null or undefined when calling getAccountMultisigGraph().');
@@ -106,14 +116,24 @@ class MultisigRoutesApi extends runtime.BaseAPI {
             const queryParameters = {};
             const headerParameters = {};
             let urlPath = `/account/{address}/multisig/graph`;
-            urlPath = urlPath.replace(`{${"address"}}`, encodeURIComponent(String(requestParameters['address'])));
-            const response = yield this.request({
+            urlPath = urlPath.replace('{address}', encodeURIComponent(String(requestParameters['address'])));
+            return {
                 path: urlPath,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.MultisigAccountGraphInfoDTOFromJSON));
+            };
+        });
+    }
+    /**
+     * Returns the multisig graph centered on the requested account.  Level `0` contains the requested account. Negative levels contain multisig accounts for which the queried account acts as a cosignatory. Positive levels contain multisig relationships discovered through the queried account\'s cosignatories.  If the requested account is a cosignatory but is not itself managed as a multisig account, the response still includes level `0` for that account. In this case, the level `0` entry has `minApproval = 0`, `minRemoval = 0`, an empty `cosignatoryAddresses` array, and `multisigAddresses` listing the multisig accounts it can cosign.  If the requested account is neither a multisig account nor a cosignatory of any multisig account, no multisig state entry exists for it and the endpoint returns `404`.  If the requested account is itself a multisig account, the response includes its multisig state at level `0` together with any reachable negative and positive graph levels.
+     * Get multisig account graph information
+     */
+    getAccountMultisigGraphRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getAccountMultisigGraphRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MultisigAccountGraphInfoDTO_1.MultisigAccountGraphInfoDTOFromJSON));
         });
     }
     /**
@@ -127,10 +147,9 @@ class MultisigRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Returns the [Merkle proof](https://docs.symbol.dev/concepts/data-validation.html#merkle-proof) for the multisig state entry associated with the requested account.  If the requested account is a cosignatory, the endpoint returns the Merkle proof for that account\'s multisig state entry. Cosignatory-only accounts still have a multisig state entry with `minApproval = 0`, `minRemoval = 0`, an empty `cosignatoryAddresses` array, and `multisigAddresses` listing the multisig accounts they can cosign.  If the requested account is itself a multisig account, the endpoint returns the Merkle proof for that multisig account state entry.  If the requested account is neither a multisig account nor a cosignatory, the endpoint still returns a Merkle proof response, but it is a negative proof showing that no multisig state entry exists for the supplied address.
-     * Get multisig account Merkle information
+     * Creates request options for getAccountMultisigMerkle without sending the request
      */
-    getAccountMultisigMerkleRaw(requestParameters, initOverrides) {
+    getAccountMultisigMerkleRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['address'] == null) {
                 throw new runtime.RequiredError('address', 'Required parameter "address" was null or undefined when calling getAccountMultisigMerkle().');
@@ -138,14 +157,24 @@ class MultisigRoutesApi extends runtime.BaseAPI {
             const queryParameters = {};
             const headerParameters = {};
             let urlPath = `/account/{address}/multisig/merkle`;
-            urlPath = urlPath.replace(`{${"address"}}`, encodeURIComponent(String(requestParameters['address'])));
-            const response = yield this.request({
+            urlPath = urlPath.replace('{address}', encodeURIComponent(String(requestParameters['address'])));
+            return {
                 path: urlPath,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.MerkleStateInfoDTOFromJSON)(jsonValue));
+            };
+        });
+    }
+    /**
+     * Returns the [Merkle proof](https://docs.symbol.dev/concepts/data-validation.html#merkle-proof) for the multisig state entry associated with the requested account.  If the requested account is a cosignatory, the endpoint returns the Merkle proof for that account\'s multisig state entry. Cosignatory-only accounts still have a multisig state entry with `minApproval = 0`, `minRemoval = 0`, an empty `cosignatoryAddresses` array, and `multisigAddresses` listing the multisig accounts they can cosign.  If the requested account is itself a multisig account, the endpoint returns the Merkle proof for that multisig account state entry.  If the requested account is neither a multisig account nor a cosignatory, the endpoint still returns a Merkle proof response, but it is a negative proof showing that no multisig state entry exists for the supplied address.
+     * Get multisig account Merkle information
+     */
+    getAccountMultisigMerkleRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getAccountMultisigMerkleRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, MerkleStateInfoDTO_1.MerkleStateInfoDTOFromJSON)(jsonValue));
         });
     }
     /**

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

@@ -10,36 +10,123 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { AccountsNamesDTO, Addresses, AliasTypeEnum, MerkleStateInfoDTO, MosaicIds, MosaicsNamesDTO, NamespaceIds, NamespaceInfoDTO, NamespaceNameDTO, NamespacePage, NamespaceRegistrationTypeEnum, Order } from '../models/index';
+import { type AccountsNamesDTO } from '../models/AccountsNamesDTO';
+import { type Addresses } from '../models/Addresses';
+import { type AliasTypeEnum } from '../models/AliasTypeEnum';
+import { type MerkleStateInfoDTO } from '../models/MerkleStateInfoDTO';
+import { type MosaicIds } from '../models/MosaicIds';
+import { type MosaicsNamesDTO } from '../models/MosaicsNamesDTO';
+import { type NamespaceIds } from '../models/NamespaceIds';
+import { type NamespaceInfoDTO } from '../models/NamespaceInfoDTO';
+import { type NamespaceNameDTO } from '../models/NamespaceNameDTO';
+import { type NamespacePage } from '../models/NamespacePage';
+import { type NamespaceRegistrationTypeEnum } from '../models/NamespaceRegistrationTypeEnum';
+import { type Order } from '../models/Order';
 export interface GetAccountsNamesRequest {
+    /**
+     *
+     */
     addresses: Addresses;
 }
 export interface GetMosaicsNamesRequest {
+    /**
+     *
+     */
     mosaicIds: MosaicIds;
 }
 export interface GetNamespaceRequest {
+    /**
+     * Namespace identifier encoded as a 16-character hexadecimal string.
+     */
     namespaceId: string;
 }
 export interface GetNamespaceMerkleRequest {
+    /**
+     * Namespace identifier encoded as a 16-character hexadecimal string.
+     */
     namespaceId: string;
 }
 export interface GetNamespacesNamesRequest {
+    /**
+     *
+     */
     namespaceIds: NamespaceIds;
 }
 export interface SearchNamespacesRequest {
+    /**
+     * Filter by owner address in Base32 format (include).
+     */
     ownerAddress?: string;
+    /**
+     * Filter by namespace registration type (include).
+     * - 0: Root namespace.
+     * - 1: Subnamespace.
+     *
+     */
     registrationType?: NamespaceRegistrationTypeEnum;
+    /**
+     * Filter by the root namespace identifier (include).
+     */
     level0?: string;
+    /**
+     * Filter by alias type (include).
+     * - 0: Namespace has no alias.
+     * - 1: Namespace is linked to a mosaic ID.
+     * - 2: Namespace is linked to an address.
+     *
+     */
     aliasType?: AliasTypeEnum;
+    /**
+     * 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;
 }
 /**
  *
  */
 export declare class NamespaceRoutesApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for getAccountsNames without sending the request
+     */
+    getAccountsNamesRequestOpts(requestParameters: GetAccountsNamesRequest): Promise<runtime.RequestOpts>;
     /**
      * Resolves namespace names linked to account addresses.  Submit an array of addresses in the request body. For each address, the response returns the namespace names currently linked to that account.
      * Get readable names for a set of accounts
@@ -50,6 +137,10 @@ export declare class NamespaceRoutesApi extends runtime.BaseAPI {
      * Get readable names for a set of accounts
      */
     getAccountsNames(requestParameters: GetAccountsNamesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AccountsNamesDTO>;
+    /**
+     * Creates request options for getMosaicsNames without sending the request
+     */
+    getMosaicsNamesRequestOpts(requestParameters: GetMosaicsNamesRequest): Promise<runtime.RequestOpts>;
     /**
      * Resolves namespace names linked to mosaic identifiers.  Submit an array of mosaic identifiers in the request body. For each requested mosaic identifier, the response returns one entry in the same order as the request. Each entry contains the namespace names currently linked to that identifier. An empty `names` array means no namespace aliases were resolved for that identifier.
      * Get readable names for a set of mosaics
@@ -60,6 +151,10 @@ export declare class NamespaceRoutesApi extends runtime.BaseAPI {
      * Get readable names for a set of mosaics
      */
     getMosaicsNames(requestParameters: GetMosaicsNamesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MosaicsNamesDTO>;
+    /**
+     * Creates request options for getNamespace without sending the request
+     */
+    getNamespaceRequestOpts(requestParameters: GetNamespaceRequest): Promise<runtime.RequestOpts>;
     /**
      * Retrieves the current on-chain state for a namespace.
      * Get namespace information
@@ -70,6 +165,10 @@ export declare class NamespaceRoutesApi extends runtime.BaseAPI {
      * Get namespace information
      */
     getNamespace(requestParameters: GetNamespaceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<NamespaceInfoDTO>;
+    /**
+     * Creates request options for getNamespaceMerkle without sending the request
+     */
+    getNamespaceMerkleRequestOpts(requestParameters: GetNamespaceMerkleRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns the [Merkle proof](https://docs.symbol.dev/concepts/data-validation.html#merkle-proof) for a namespace.  Clients can use this information to verify that the namespace state is included in the node\'s state Merkle tree. If the supplied namespace ID does not exist, the endpoint still returns a Merkle proof response, but it is a negative proof showing that no namespace state entry exists for the requested namespace ID. See [Data Validation](https://docs.symbol.dev/concepts/data-validation.html) for an overview of Patricia Merkle trees and state proofs on Symbol.
      * Get namespace Merkle information
@@ -80,6 +179,10 @@ export declare class NamespaceRoutesApi extends runtime.BaseAPI {
      * Get namespace Merkle information
      */
     getNamespaceMerkle(requestParameters: GetNamespaceMerkleRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MerkleStateInfoDTO>;
+    /**
+     * Creates request options for getNamespacesNames without sending the request
+     */
+    getNamespacesNamesRequestOpts(requestParameters: GetNamespacesNamesRequest): Promise<runtime.RequestOpts>;
     /**
      * Resolves human-readable namespace names for namespace identifiers.  Submit an array of namespace identifiers in the request body. For each matching identifier, the response returns the namespace name. When a matching identifier is a subnamespace, the response will also include its parent namespace entry and parent namespace identifier. Identifiers that cannot be resolved are omitted from the response.
      * Get readable names for a set of namespaces
@@ -90,6 +193,10 @@ export declare class NamespaceRoutesApi extends runtime.BaseAPI {
      * Get readable names for a set of namespaces
      */
     getNamespacesNames(requestParameters: GetNamespacesNamesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<NamespaceNameDTO>>;
+    /**
+     * Creates request options for searchNamespaces without sending the request
+     */
+    searchNamespacesRequestOpts(requestParameters: SearchNamespacesRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns a paginated list of namespaces matching the given criteria.
      * Search namespaces