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

package/esm/api/apis/MultisigRoutesApi.js

@@ -12,29 +12,38 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import { MerkleStateInfoDTOFromJSON, MultisigAccountGraphInfoDTOFromJSON, MultisigAccountInfoDTOFromJSON, } from '../models/index';
+import { MerkleStateInfoDTOFromJSON, } from '../models/MerkleStateInfoDTO';
+import { MultisigAccountGraphInfoDTOFromJSON, } from '../models/MultisigAccountGraphInfoDTO';
+import { MultisigAccountInfoDTOFromJSON, } from '../models/MultisigAccountInfoDTO';
 /**
  *
  */
 export 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
      */
-    async getAccountMultisigRaw(requestParameters, initOverrides) {
+    async getAccountMultisigRequestOpts(requestParameters) {
         if (requestParameters['address'] == null) {
             throw new runtime.RequiredError('address', 'Required parameter "address" was null or undefined when calling getAccountMultisig().');
         }
         const queryParameters = {};
         const headerParameters = {};
         let urlPath = `/account/{address}/multisig`;
-        urlPath = urlPath.replace(`{${"address"}}`, encodeURIComponent(String(requestParameters['address'])));
-        const response = await this.request({
+        urlPath = urlPath.replace('{address}', encodeURIComponent(String(requestParameters['address'])));
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * 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
+     */
+    async getAccountMultisigRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getAccountMultisigRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => MultisigAccountInfoDTOFromJSON(jsonValue));
     }
     /**
@@ -46,23 +55,30 @@ export class MultisigRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * 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
      */
-    async getAccountMultisigGraphRaw(requestParameters, initOverrides) {
+    async getAccountMultisigGraphRequestOpts(requestParameters) {
         if (requestParameters['address'] == null) {
             throw new runtime.RequiredError('address', 'Required parameter "address" was null or undefined when calling getAccountMultisigGraph().');
         }
         const queryParameters = {};
         const headerParameters = {};
         let urlPath = `/account/{address}/multisig/graph`;
-        urlPath = urlPath.replace(`{${"address"}}`, encodeURIComponent(String(requestParameters['address'])));
-        const response = await this.request({
+        urlPath = urlPath.replace('{address}', encodeURIComponent(String(requestParameters['address'])));
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * 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
+     */
+    async getAccountMultisigGraphRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getAccountMultisigGraphRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MultisigAccountGraphInfoDTOFromJSON));
     }
     /**
@@ -74,23 +90,30 @@ export class MultisigRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * 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
      */
-    async getAccountMultisigMerkleRaw(requestParameters, initOverrides) {
+    async getAccountMultisigMerkleRequestOpts(requestParameters) {
         if (requestParameters['address'] == null) {
             throw new runtime.RequiredError('address', 'Required parameter "address" was null or undefined when calling getAccountMultisigMerkle().');
         }
         const queryParameters = {};
         const headerParameters = {};
         let urlPath = `/account/{address}/multisig/merkle`;
-        urlPath = urlPath.replace(`{${"address"}}`, encodeURIComponent(String(requestParameters['address'])));
-        const response = await this.request({
+        urlPath = urlPath.replace('{address}', encodeURIComponent(String(requestParameters['address'])));
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * 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
+     */
+    async getAccountMultisigMerkleRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getAccountMultisigMerkleRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => MerkleStateInfoDTOFromJSON(jsonValue));
     }
     /**

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

package/esm/api/apis/NamespaceRoutesApi.js

@@ -12,16 +12,23 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import { AccountsNamesDTOFromJSON, AddressesToJSON, MerkleStateInfoDTOFromJSON, MosaicIdsToJSON, MosaicsNamesDTOFromJSON, NamespaceIdsToJSON, NamespaceInfoDTOFromJSON, NamespaceNameDTOFromJSON, NamespacePageFromJSON, } from '../models/index';
+import { AccountsNamesDTOFromJSON, } from '../models/AccountsNamesDTO';
+import { AddressesToJSON, } from '../models/Addresses';
+import { MerkleStateInfoDTOFromJSON, } from '../models/MerkleStateInfoDTO';
+import { MosaicIdsToJSON, } from '../models/MosaicIds';
+import { MosaicsNamesDTOFromJSON, } from '../models/MosaicsNamesDTO';
+import { NamespaceIdsToJSON, } from '../models/NamespaceIds';
+import { NamespaceInfoDTOFromJSON, } from '../models/NamespaceInfoDTO';
+import { NamespaceNameDTOFromJSON, } from '../models/NamespaceNameDTO';
+import { NamespacePageFromJSON, } from '../models/NamespacePage';
 /**
  *
  */
 export class NamespaceRoutesApi extends runtime.BaseAPI {
     /**
-     * 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
+     * Creates request options for getAccountsNames without sending the request
      */
-    async getAccountsNamesRaw(requestParameters, initOverrides) {
+    async getAccountsNamesRequestOpts(requestParameters) {
         if (requestParameters['addresses'] == null) {
             throw new runtime.RequiredError('addresses', 'Required parameter "addresses" was null or undefined when calling getAccountsNames().');
         }
@@ -29,13 +36,21 @@ export class NamespaceRoutesApi extends runtime.BaseAPI {
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         let urlPath = `/namespaces/account/names`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: AddressesToJSON(requestParameters['addresses']),
-        }, initOverrides);
+        };
+    }
+    /**
+     * 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
+     */
+    async getAccountsNamesRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getAccountsNamesRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => AccountsNamesDTOFromJSON(jsonValue));
     }
     /**
@@ -47,10 +62,9 @@ export class NamespaceRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * 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
+     * Creates request options for getMosaicsNames without sending the request
      */
-    async getMosaicsNamesRaw(requestParameters, initOverrides) {
+    async getMosaicsNamesRequestOpts(requestParameters) {
         if (requestParameters['mosaicIds'] == null) {
             throw new runtime.RequiredError('mosaicIds', 'Required parameter "mosaicIds" was null or undefined when calling getMosaicsNames().');
         }
@@ -58,13 +72,21 @@ export class NamespaceRoutesApi extends runtime.BaseAPI {
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         let urlPath = `/namespaces/mosaic/names`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: MosaicIdsToJSON(requestParameters['mosaicIds']),
-        }, initOverrides);
+        };
+    }
+    /**
+     * 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
+     */
+    async getMosaicsNamesRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getMosaicsNamesRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => MosaicsNamesDTOFromJSON(jsonValue));
     }
     /**
@@ -76,23 +98,30 @@ export class NamespaceRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Retrieves the current on-chain state for a namespace.
-     * Get namespace information
+     * Creates request options for getNamespace without sending the request
      */
-    async getNamespaceRaw(requestParameters, initOverrides) {
+    async getNamespaceRequestOpts(requestParameters) {
         if (requestParameters['namespaceId'] == null) {
             throw new runtime.RequiredError('namespaceId', 'Required parameter "namespaceId" was null or undefined when calling getNamespace().');
         }
         const queryParameters = {};
         const headerParameters = {};
         let urlPath = `/namespaces/{namespaceId}`;
-        urlPath = urlPath.replace(`{${"namespaceId"}}`, encodeURIComponent(String(requestParameters['namespaceId'])));
-        const response = await this.request({
+        urlPath = urlPath.replace('{namespaceId}', encodeURIComponent(String(requestParameters['namespaceId'])));
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * Retrieves the current on-chain state for a namespace.
+     * Get namespace information
+     */
+    async getNamespaceRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getNamespaceRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => NamespaceInfoDTOFromJSON(jsonValue));
     }
     /**
@@ -104,23 +133,30 @@ export class NamespaceRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * 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
+     * Creates request options for getNamespaceMerkle without sending the request
      */
-    async getNamespaceMerkleRaw(requestParameters, initOverrides) {
+    async getNamespaceMerkleRequestOpts(requestParameters) {
         if (requestParameters['namespaceId'] == null) {
             throw new runtime.RequiredError('namespaceId', 'Required parameter "namespaceId" was null or undefined when calling getNamespaceMerkle().');
         }
         const queryParameters = {};
         const headerParameters = {};
         let urlPath = `/namespaces/{namespaceId}/merkle`;
-        urlPath = urlPath.replace(`{${"namespaceId"}}`, encodeURIComponent(String(requestParameters['namespaceId'])));
-        const response = await this.request({
+        urlPath = urlPath.replace('{namespaceId}', encodeURIComponent(String(requestParameters['namespaceId'])));
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * 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
+     */
+    async getNamespaceMerkleRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getNamespaceMerkleRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => MerkleStateInfoDTOFromJSON(jsonValue));
     }
     /**
@@ -132,10 +168,9 @@ export class NamespaceRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * 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
+     * Creates request options for getNamespacesNames without sending the request
      */
-    async getNamespacesNamesRaw(requestParameters, initOverrides) {
+    async getNamespacesNamesRequestOpts(requestParameters) {
         if (requestParameters['namespaceIds'] == null) {
             throw new runtime.RequiredError('namespaceIds', 'Required parameter "namespaceIds" was null or undefined when calling getNamespacesNames().');
         }
@@ -143,13 +178,21 @@ export class NamespaceRoutesApi extends runtime.BaseAPI {
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         let urlPath = `/namespaces/names`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: NamespaceIdsToJSON(requestParameters['namespaceIds']),
-        }, initOverrides);
+        };
+    }
+    /**
+     * 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
+     */
+    async getNamespacesNamesRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getNamespacesNamesRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(NamespaceNameDTOFromJSON));
     }
     /**
@@ -161,10 +204,9 @@ export class NamespaceRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Returns a paginated list of namespaces matching the given criteria.
-     * Search namespaces
+     * Creates request options for searchNamespaces without sending the request
      */
-    async searchNamespacesRaw(requestParameters, initOverrides) {
+    async searchNamespacesRequestOpts(requestParameters) {
         const queryParameters = {};
         if (requestParameters['ownerAddress'] != null) {
             queryParameters['ownerAddress'] = requestParameters['ownerAddress'];
@@ -192,12 +234,20 @@ export class NamespaceRoutesApi extends runtime.BaseAPI {
         }
         const headerParameters = {};
         let urlPath = `/namespaces`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns a paginated list of namespaces matching the given criteria.
+     * Search namespaces
+     */
+    async searchNamespacesRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.searchNamespacesRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => NamespacePageFromJSON(jsonValue));
     }
     /**

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

@@ -10,14 +10,25 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { NetworkConfigurationDTO, NetworkInflationDTO, NetworkTypeDTO, RentalFeesDTO, TransactionFeesDTO } from '../models/index';
+import { type NetworkConfigurationDTO } from '../models/NetworkConfigurationDTO';
+import { type NetworkInflationDTO } from '../models/NetworkInflationDTO';
+import { type NetworkTypeDTO } from '../models/NetworkTypeDTO';
+import { type RentalFeesDTO } from '../models/RentalFeesDTO';
+import { type TransactionFeesDTO } from '../models/TransactionFeesDTO';
 export interface GetNetworkInflationAtHeightRequest {
+    /**
+     * Filter by block height (include). Sequential block position in the chain; starts at 1 and increments by one.
+     */
     height: string;
 }
 /**
  *
  */
 export declare class NetworkRoutesApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for getCirculatingCurrencySupply without sending the request
+     */
+    getCirculatingCurrencySupplyRequestOpts(): Promise<runtime.RequestOpts>;
     /**
      * Returns the current circulating supply of the network currency mosaic.  Circulating supply represents the portion of total on-chain supply that is not held in designated uncirculating or reserved accounts (e.g. nemesis or treasury accounts).  Data sources:   - Mosaic supply and divisibility from blockchain state   - Nemesis signer public key from network properties file   - Uncirculating account public keys defined in rest.json (`uncirculatingAccountPublicKeys`)
      * Returns circulating currency supply
@@ -28,6 +39,10 @@ export declare class NetworkRoutesApi extends runtime.BaseAPI {
      * Returns circulating currency supply
      */
     getCirculatingCurrencySupply(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string>;
+    /**
+     * Creates request options for getMaxCurrencySupply without sending the request
+     */
+    getMaxCurrencySupplyRequestOpts(): Promise<runtime.RequestOpts>;
     /**
      * Returns the maximum possible supply of the network currency mosaic.  Data sources:   - Maximum supply (`chain.maxMosaicAtomicUnits`) defined in the network properties file   - Network currency divisibility from blockchain state  This represents the protocol-level supply cap configured for the network currency.
      * Returns max currency supply
@@ -38,6 +53,10 @@ export declare class NetworkRoutesApi extends runtime.BaseAPI {
      * Returns max currency supply
      */
     getMaxCurrencySupply(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string>;
+    /**
+     * Creates request options for getNetworkInflation without sending the request
+     */
+    getNetworkInflationRequestOpts(): Promise<runtime.RequestOpts>;
     /**
      * Retrieves the network inflation table, where each entry specifies a starting block height and the reward amount applied from that height onward.
      * Returns the inflation distribution schedule
@@ -48,6 +67,10 @@ export declare class NetworkRoutesApi extends runtime.BaseAPI {
      * Returns the inflation distribution schedule
      */
     getNetworkInflation(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<NetworkInflationDTO>>;
+    /**
+     * Creates request options for getNetworkInflationAtHeight without sending the request
+     */
+    getNetworkInflationAtHeightRequestOpts(requestParameters: GetNetworkInflationAtHeightRequest): Promise<runtime.RequestOpts>;
     /**
      * Retrieves network inflation parameters at a given block height.
      * Returns the inflation distribution data at a specific height
@@ -58,6 +81,10 @@ export declare class NetworkRoutesApi extends runtime.BaseAPI {
      * Returns the inflation distribution data at a specific height
      */
     getNetworkInflationAtHeight(requestParameters: GetNetworkInflationAtHeightRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<NetworkInflationDTO>;
+    /**
+     * Creates request options for getNetworkProperties without sending the request
+     */
+    getNetworkPropertiesRequestOpts(): Promise<runtime.RequestOpts>;
     /**
      * Returns the content from a catapult-server network configuration file (e.g. `config-network.properties`). To enable this feature, the REST setting `apiNode.networkPropertyFilePath` in the config file (e.g. `rest.json`) must define where the file is located.
      * Get the network properties
@@ -68,6 +95,10 @@ export declare class NetworkRoutesApi extends runtime.BaseAPI {
      * Get the network properties
      */
     getNetworkProperties(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<NetworkConfigurationDTO>;
+    /**
+     * Creates request options for getNetworkType without sending the request
+     */
+    getNetworkTypeRequestOpts(): Promise<runtime.RequestOpts>;
     /**
      * Returns the current network type.
      * Get the current network type of the chain
@@ -78,6 +109,10 @@ export declare class NetworkRoutesApi extends runtime.BaseAPI {
      * Get the current network type of the chain
      */
     getNetworkType(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<NetworkTypeDTO>;
+    /**
+     * Creates request options for getRentalFees without sending the request
+     */
+    getRentalFeesRequestOpts(): Promise<runtime.RequestOpts>;
     /**
      * Returns the estimated effective rental fees for namespaces and mosaics. This endpoint is only available if the REST instance has access to catapult-server `resources/config-network.properties` file. To activate this feature, add the setting `network.propertiesFilePath` in the configuration file (`rest/resources/rest.json`).
      * Get rental fees information
@@ -88,6 +123,10 @@ export declare class NetworkRoutesApi extends runtime.BaseAPI {
      * Get rental fees information
      */
     getRentalFees(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RentalFeesDTO>;
+    /**
+     * Creates request options for getTotalCurrencySupply without sending the request
+     */
+    getTotalCurrencySupplyRequestOpts(): Promise<runtime.RequestOpts>;
     /**
      * Returns the total current on-chain supply of the network currency mosaic.  Data sources:   - Mosaic supply and divisibility from blockchain state  This value includes both circulating and uncirculating balances and represents the full issued supply currently recorded on-chain.
      * Returns total currency supply
@@ -98,6 +137,10 @@ export declare class NetworkRoutesApi extends runtime.BaseAPI {
      * Returns total currency supply
      */
     getTotalCurrencySupply(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string>;
+    /**
+     * Creates request options for getTransactionFees without sending the request
+     */
+    getTransactionFeesRequestOpts(): Promise<runtime.RequestOpts>;
     /**
      * Returns the average, median, highest, and lowest fee multiplier over the last `numBlocksTransactionFeeStats` blocks. The setting `numBlocksTransactionFeeStats` is adjustable in the REST configuration file (`rest.json`) per REST instance.
      * Get transaction fees information