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

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

@@ -10,27 +10,95 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { AccountRestrictionsInfoDTO, AccountRestrictionsPage, Addresses, MerkleStateInfoDTO, Order } from '../models/index';
+import { type AccountRestrictionsInfoDTO } from '../models/AccountRestrictionsInfoDTO';
+import { type AccountRestrictionsPage } from '../models/AccountRestrictionsPage';
+import { type Addresses } from '../models/Addresses';
+import { type MerkleStateInfoDTO } from '../models/MerkleStateInfoDTO';
+import { type Order } from '../models/Order';
 export interface GetAccountRestrictionsRequest {
+    /**
+     * Account address in Base32-encoded format.
+     */
     address: string;
 }
 export interface GetAccountRestrictionsBatchRequest {
+    /**
+     *
+     */
     addresses: Addresses;
 }
 export interface GetAccountRestrictionsMerkleRequest {
+    /**
+     * Account address in Base32-encoded format.
+     */
     address: string;
 }
 export interface SearchAccountRestrictionsRequest {
+    /**
+     * Filter by address (include), in Base32 format.
+     *
+     * The exact meaning depends on the endpoint:
+     * - transaction search: returns transactions where the address appears as the sender, recipient, or cosigner
+     * - account search: matches the account address
+     * - account restriction search: matches the restricted account address
+     * - hash lock and secret lock search: matches the lock owner address
+     *
+     * On transaction search endpoints, this filter cannot be combined with `recipientAddress` and
+     * `signerPublicKey`.
+     *
+     */
     address?: string;
+    /**
+     * Select the number of entries to return per page.
+     * Values outside the allowed range are clamped to the schema minimum or maximum.
+     *
+     */
     pageSize?: number;
+    /**
+     * Page number for numbered pagination (1-based).
+     *
+     * Numbered and cursor pagination can be combined, but this is not recommended because the semantics
+     * are harder to reason about. For cursor-style flows, keep `pageNumber=1` and advance pages by
+     * updating only `offset`. For numbered pagination flows, omit `offset` and advance pages by
+     * incrementing `pageNumber`.
+     *
+     */
     pageNumber?: number;
+    /**
+     * Cursor for pagination. Provide the value of the sort field (`orderBy`) from the
+     * last entry of the previous page. **The offset type must match `orderBy`:**
+     * - `orderBy=id`: use the entry's `id` (ObjectId, 24-char hex).
+     * - `orderBy=height`: use the block height (string, e.g. `"17592"`).
+     * - `orderBy=balance`: use the mosaic balance amount (string, e.g. `"1000000"`).
+     *
+     * Allowed `orderBy` values depend on the endpoint. If `orderBy` is omitted, `id` is used by default.
+     *
+     * Set `offset` to the sort-field value of the last entry from the previous page. Across pages,
+     * this value decreases with `order=desc` and increases with `order=asc`.
+     *
+     * Numbered and cursor pagination can be combined, but this is not recommended because the semantics
+     * are harder to reason about. For cursor-style flows, keep `pageNumber=1` and advance pages by
+     * updating only `offset`. For numbered pagination flows, omit `offset` and advance pages by
+     * incrementing `pageNumber`.
+     *
+     */
     offset?: string;
+    /**
+     * Sort responses in ascending or descending order based on the collection property set on the param `orderBy`.
+     * If the request does not specify `orderBy`, REST returns the collection ordered by id.
+     * The default sort direction depends on the endpoint implementation.
+     *
+     */
     order?: Order;
 }
 /**
  *
  */
 export declare class RestrictionAccountRoutesApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for getAccountRestrictions without sending the request
+     */
+    getAccountRestrictionsRequestOpts(requestParameters: GetAccountRestrictionsRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns the account restriction entry associated with the given account address.
      * Get account restrictions
@@ -41,6 +109,10 @@ export declare class RestrictionAccountRoutesApi extends runtime.BaseAPI {
      * Get account restrictions
      */
     getAccountRestrictions(requestParameters: GetAccountRestrictionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AccountRestrictionsInfoDTO>;
+    /**
+     * Creates request options for getAccountRestrictionsBatch without sending the request
+     */
+    getAccountRestrictionsBatchRequestOpts(requestParameters: GetAccountRestrictionsBatchRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns account restriction entries for the given account addresses.
      * Get account restrictions for an array of addresses
@@ -51,6 +123,10 @@ export declare class RestrictionAccountRoutesApi extends runtime.BaseAPI {
      * Get account restrictions for an array of addresses
      */
     getAccountRestrictionsBatch(requestParameters: GetAccountRestrictionsBatchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<AccountRestrictionsInfoDTO>>;
+    /**
+     * Creates request options for getAccountRestrictionsMerkle without sending the request
+     */
+    getAccountRestrictionsMerkleRequestOpts(requestParameters: GetAccountRestrictionsMerkleRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns the Merkle state proof for the account restriction entry associated with the given account address. If no account restriction entry exists for the supplied address, the endpoint still returns a Merkle proof response, but it is a negative proof showing that no account restriction state entry exists for the requested address.
      * Get account restrictions Merkle information
@@ -61,6 +137,10 @@ export declare class RestrictionAccountRoutesApi extends runtime.BaseAPI {
      * Get account restrictions Merkle information
      */
     getAccountRestrictionsMerkle(requestParameters: GetAccountRestrictionsMerkleRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MerkleStateInfoDTO>;
+    /**
+     * Creates request options for searchAccountRestrictions without sending the request
+     */
+    searchAccountRestrictionsRequestOpts(requestParameters: SearchAccountRestrictionsRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns a paginated list of account restriction entries, optionally filtered by account address.
      * Search account restrictions

package/cjs/api/apis/RestrictionAccountRoutesApi.js

@@ -57,16 +57,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RestrictionAccountRoutesApi = void 0;
 const runtime = __importStar(require("../runtime"));
-const index_1 = require("../models/index");
+const AccountRestrictionsInfoDTO_1 = require("../models/AccountRestrictionsInfoDTO");
+const AccountRestrictionsPage_1 = require("../models/AccountRestrictionsPage");
+const Addresses_1 = require("../models/Addresses");
+const MerkleStateInfoDTO_1 = require("../models/MerkleStateInfoDTO");
 /**
  *
  */
 class RestrictionAccountRoutesApi extends runtime.BaseAPI {
     /**
-     * Returns the account restriction entry associated with the given account address.
-     * Get account restrictions
+     * Creates request options for getAccountRestrictions without sending the request
      */
-    getAccountRestrictionsRaw(requestParameters, initOverrides) {
+    getAccountRestrictionsRequestOpts(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 getAccountRestrictions().');
@@ -74,14 +76,24 @@ class RestrictionAccountRoutesApi extends runtime.BaseAPI {
             const queryParameters = {};
             const headerParameters = {};
             let urlPath = `/restrictions/account/{address}`;
-            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.AccountRestrictionsInfoDTOFromJSON)(jsonValue));
+            };
+        });
+    }
+    /**
+     * Returns the account restriction entry associated with the given account address.
+     * Get account restrictions
+     */
+    getAccountRestrictionsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getAccountRestrictionsRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, AccountRestrictionsInfoDTO_1.AccountRestrictionsInfoDTOFromJSON)(jsonValue));
         });
     }
     /**
@@ -95,10 +107,9 @@ class RestrictionAccountRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Returns account restriction entries for the given account addresses.
-     * Get account restrictions for an array of addresses
+     * Creates request options for getAccountRestrictionsBatch without sending the request
      */
-    getAccountRestrictionsBatchRaw(requestParameters, initOverrides) {
+    getAccountRestrictionsBatchRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['addresses'] == null) {
                 throw new runtime.RequiredError('addresses', 'Required parameter "addresses" was null or undefined when calling getAccountRestrictionsBatch().');
@@ -107,14 +118,24 @@ class RestrictionAccountRoutesApi extends runtime.BaseAPI {
             const headerParameters = {};
             headerParameters['Content-Type'] = 'application/json';
             let urlPath = `/restrictions/account`;
-            const response = yield this.request({
+            return {
                 path: urlPath,
                 method: 'POST',
                 headers: headerParameters,
                 query: queryParameters,
-                body: (0, index_1.AddressesToJSON)(requestParameters['addresses']),
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.AccountRestrictionsInfoDTOFromJSON));
+                body: (0, Addresses_1.AddressesToJSON)(requestParameters['addresses']),
+            };
+        });
+    }
+    /**
+     * Returns account restriction entries for the given account addresses.
+     * Get account restrictions for an array of addresses
+     */
+    getAccountRestrictionsBatchRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getAccountRestrictionsBatchRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(AccountRestrictionsInfoDTO_1.AccountRestrictionsInfoDTOFromJSON));
         });
     }
     /**
@@ -128,10 +149,9 @@ class RestrictionAccountRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Returns the Merkle state proof for the account restriction entry associated with the given account address. If no account restriction entry exists for the supplied address, the endpoint still returns a Merkle proof response, but it is a negative proof showing that no account restriction state entry exists for the requested address.
-     * Get account restrictions Merkle information
+     * Creates request options for getAccountRestrictionsMerkle without sending the request
      */
-    getAccountRestrictionsMerkleRaw(requestParameters, initOverrides) {
+    getAccountRestrictionsMerkleRequestOpts(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 getAccountRestrictionsMerkle().');
@@ -139,14 +159,24 @@ class RestrictionAccountRoutesApi extends runtime.BaseAPI {
             const queryParameters = {};
             const headerParameters = {};
             let urlPath = `/restrictions/account/{address}/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 state proof for the account restriction entry associated with the given account address. If no account restriction entry exists for the supplied address, the endpoint still returns a Merkle proof response, but it is a negative proof showing that no account restriction state entry exists for the requested address.
+     * Get account restrictions Merkle information
+     */
+    getAccountRestrictionsMerkleRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getAccountRestrictionsMerkleRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, MerkleStateInfoDTO_1.MerkleStateInfoDTOFromJSON)(jsonValue));
         });
     }
     /**
@@ -160,10 +190,9 @@ class RestrictionAccountRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Returns a paginated list of account restriction entries, optionally filtered by account address.
-     * Search account restrictions
+     * Creates request options for searchAccountRestrictions without sending the request
      */
-    searchAccountRestrictionsRaw(requestParameters, initOverrides) {
+    searchAccountRestrictionsRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             const queryParameters = {};
             if (requestParameters['address'] != null) {
@@ -183,13 +212,23 @@ class RestrictionAccountRoutesApi extends runtime.BaseAPI {
             }
             const headerParameters = {};
             let urlPath = `/restrictions/account`;
-            const response = yield this.request({
+            return {
                 path: urlPath,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.AccountRestrictionsPageFromJSON)(jsonValue));
+            };
+        });
+    }
+    /**
+     * Returns a paginated list of account restriction entries, optionally filtered by account address.
+     * Search account restrictions
+     */
+    searchAccountRestrictionsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.searchAccountRestrictionsRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, AccountRestrictionsPage_1.AccountRestrictionsPageFromJSON)(jsonValue));
         });
     }
     /**

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

@@ -10,29 +10,94 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { CompositeHashes, MerkleStateInfoDTO, MosaicRestrictionDTO, MosaicRestrictionEntryTypeEnum, MosaicRestrictionsPage, Order } from '../models/index';
+import { type CompositeHashes } from '../models/CompositeHashes';
+import { type MerkleStateInfoDTO } from '../models/MerkleStateInfoDTO';
+import { type MosaicRestrictionDTO } from '../models/MosaicRestrictionDTO';
+import { type MosaicRestrictionEntryTypeEnum } from '../models/MosaicRestrictionEntryTypeEnum';
+import { type MosaicRestrictionsPage } from '../models/MosaicRestrictionsPage';
+import { type Order } from '../models/Order';
 export interface GetMosaicRestrictionsRequest {
+    /**
+     * Composite hash encoded as a 64-character hexadecimal string.
+     */
     compositeHash: string;
 }
 export interface GetMosaicRestrictionsBatchRequest {
+    /**
+     *
+     */
     compositeHashes: CompositeHashes;
 }
 export interface GetMosaicRestrictionsMerkleRequest {
+    /**
+     * Composite hash encoded as a 64-character hexadecimal string.
+     */
     compositeHash: string;
 }
 export interface SearchMosaicRestrictionsRequest {
+    /**
+     * Filter by mosaic identifier (include).
+     */
     mosaicId?: string;
+    /**
+     * Filter by entry type (include).
+     */
     entryType?: MosaicRestrictionEntryTypeEnum;
+    /**
+     * Filter by target address in Base32 (include).
+     */
     targetAddress?: string;
+    /**
+     * Select the number of entries to return per page.
+     * Values outside the allowed range are clamped to the schema minimum or maximum.
+     *
+     */
     pageSize?: number;
+    /**
+     * Page number for numbered pagination (1-based).
+     *
+     * Numbered and cursor pagination can be combined, but this is not recommended because the semantics
+     * are harder to reason about. For cursor-style flows, keep `pageNumber=1` and advance pages by
+     * updating only `offset`. For numbered pagination flows, omit `offset` and advance pages by
+     * incrementing `pageNumber`.
+     *
+     */
     pageNumber?: number;
+    /**
+     * Cursor for pagination. Provide the value of the sort field (`orderBy`) from the
+     * last entry of the previous page. **The offset type must match `orderBy`:**
+     * - `orderBy=id`: use the entry's `id` (ObjectId, 24-char hex).
+     * - `orderBy=height`: use the block height (string, e.g. `"17592"`).
+     * - `orderBy=balance`: use the mosaic balance amount (string, e.g. `"1000000"`).
+     *
+     * Allowed `orderBy` values depend on the endpoint. If `orderBy` is omitted, `id` is used by default.
+     *
+     * Set `offset` to the sort-field value of the last entry from the previous page. Across pages,
+     * this value decreases with `order=desc` and increases with `order=asc`.
+     *
+     * Numbered and cursor pagination can be combined, but this is not recommended because the semantics
+     * are harder to reason about. For cursor-style flows, keep `pageNumber=1` and advance pages by
+     * updating only `offset`. For numbered pagination flows, omit `offset` and advance pages by
+     * incrementing `pageNumber`.
+     *
+     */
     offset?: string;
+    /**
+     * Sort responses in ascending or descending order based on the collection property set on the param `orderBy`.
+     * If the request does not specify `orderBy`, REST returns the collection ordered by id.
+     * The default sort direction depends on the endpoint implementation.
+     *
+     */
     order?: Order;
 }
 /**
  *
  */
 export declare class RestrictionMosaicRoutesApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for getMosaicRestrictions without sending the request
+     */
+    getMosaicRestrictionsRequestOpts(requestParameters: GetMosaicRestrictionsRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns the mosaic restriction entry associated with the given composite hash.
      * Get mosaic restrictions
@@ -43,6 +108,10 @@ export declare class RestrictionMosaicRoutesApi extends runtime.BaseAPI {
      * Get mosaic restrictions
      */
     getMosaicRestrictions(requestParameters: GetMosaicRestrictionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MosaicRestrictionDTO>;
+    /**
+     * Creates request options for getMosaicRestrictionsBatch without sending the request
+     */
+    getMosaicRestrictionsBatchRequestOpts(requestParameters: GetMosaicRestrictionsBatchRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns mosaic restriction entries for the given composite hashes.
      * Get mosaic restrictions for an array of composite hashes
@@ -53,6 +122,10 @@ export declare class RestrictionMosaicRoutesApi extends runtime.BaseAPI {
      * Get mosaic restrictions for an array of composite hashes
      */
     getMosaicRestrictionsBatch(requestParameters: GetMosaicRestrictionsBatchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<MosaicRestrictionDTO>>;
+    /**
+     * Creates request options for getMosaicRestrictionsMerkle without sending the request
+     */
+    getMosaicRestrictionsMerkleRequestOpts(requestParameters: GetMosaicRestrictionsMerkleRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns the Merkle state proof for the mosaic restriction entry associated with the given composite hash. If no mosaic restriction entry exists for the supplied composite hash, the endpoint still returns a Merkle proof response, but it is a negative proof showing that no mosaic restriction state entry exists for the requested composite hash.
      * Get mosaic restrictions Merkle information
@@ -63,6 +136,10 @@ export declare class RestrictionMosaicRoutesApi extends runtime.BaseAPI {
      * Get mosaic restrictions Merkle information
      */
     getMosaicRestrictionsMerkle(requestParameters: GetMosaicRestrictionsMerkleRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MerkleStateInfoDTO>;
+    /**
+     * Creates request options for searchMosaicRestrictions without sending the request
+     */
+    searchMosaicRestrictionsRequestOpts(requestParameters: SearchMosaicRestrictionsRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns a paginated list of mosaic restriction entries, optionally filtered by mosaic ID, entry type, and target address.
      * Search mosaic restrictions

package/cjs/api/apis/RestrictionMosaicRoutesApi.js

@@ -57,16 +57,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RestrictionMosaicRoutesApi = void 0;
 const runtime = __importStar(require("../runtime"));
-const index_1 = require("../models/index");
+const CompositeHashes_1 = require("../models/CompositeHashes");
+const MerkleStateInfoDTO_1 = require("../models/MerkleStateInfoDTO");
+const MosaicRestrictionDTO_1 = require("../models/MosaicRestrictionDTO");
+const MosaicRestrictionsPage_1 = require("../models/MosaicRestrictionsPage");
 /**
  *
  */
 class RestrictionMosaicRoutesApi extends runtime.BaseAPI {
     /**
-     * Returns the mosaic restriction entry associated with the given composite hash.
-     * Get mosaic restrictions
+     * Creates request options for getMosaicRestrictions without sending the request
      */
-    getMosaicRestrictionsRaw(requestParameters, initOverrides) {
+    getMosaicRestrictionsRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['compositeHash'] == null) {
                 throw new runtime.RequiredError('compositeHash', 'Required parameter "compositeHash" was null or undefined when calling getMosaicRestrictions().');
@@ -74,14 +76,24 @@ class RestrictionMosaicRoutesApi extends runtime.BaseAPI {
             const queryParameters = {};
             const headerParameters = {};
             let urlPath = `/restrictions/mosaic/{compositeHash}`;
-            urlPath = urlPath.replace(`{${"compositeHash"}}`, encodeURIComponent(String(requestParameters['compositeHash'])));
-            const response = yield this.request({
+            urlPath = urlPath.replace('{compositeHash}', encodeURIComponent(String(requestParameters['compositeHash'])));
+            return {
                 path: urlPath,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.MosaicRestrictionDTOFromJSON)(jsonValue));
+            };
+        });
+    }
+    /**
+     * Returns the mosaic restriction entry associated with the given composite hash.
+     * Get mosaic restrictions
+     */
+    getMosaicRestrictionsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getMosaicRestrictionsRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, MosaicRestrictionDTO_1.MosaicRestrictionDTOFromJSON)(jsonValue));
         });
     }
     /**
@@ -95,10 +107,9 @@ class RestrictionMosaicRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Returns mosaic restriction entries for the given composite hashes.
-     * Get mosaic restrictions for an array of composite hashes
+     * Creates request options for getMosaicRestrictionsBatch without sending the request
      */
-    getMosaicRestrictionsBatchRaw(requestParameters, initOverrides) {
+    getMosaicRestrictionsBatchRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['compositeHashes'] == null) {
                 throw new runtime.RequiredError('compositeHashes', 'Required parameter "compositeHashes" was null or undefined when calling getMosaicRestrictionsBatch().');
@@ -107,14 +118,24 @@ class RestrictionMosaicRoutesApi extends runtime.BaseAPI {
             const headerParameters = {};
             headerParameters['Content-Type'] = 'application/json';
             let urlPath = `/restrictions/mosaic`;
-            const response = yield this.request({
+            return {
                 path: urlPath,
                 method: 'POST',
                 headers: headerParameters,
                 query: queryParameters,
-                body: (0, index_1.CompositeHashesToJSON)(requestParameters['compositeHashes']),
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.MosaicRestrictionDTOFromJSON));
+                body: (0, CompositeHashes_1.CompositeHashesToJSON)(requestParameters['compositeHashes']),
+            };
+        });
+    }
+    /**
+     * Returns mosaic restriction entries for the given composite hashes.
+     * Get mosaic restrictions for an array of composite hashes
+     */
+    getMosaicRestrictionsBatchRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getMosaicRestrictionsBatchRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MosaicRestrictionDTO_1.MosaicRestrictionDTOFromJSON));
         });
     }
     /**
@@ -128,10 +149,9 @@ class RestrictionMosaicRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Returns the Merkle state proof for the mosaic restriction entry associated with the given composite hash. If no mosaic restriction entry exists for the supplied composite hash, the endpoint still returns a Merkle proof response, but it is a negative proof showing that no mosaic restriction state entry exists for the requested composite hash.
-     * Get mosaic restrictions Merkle information
+     * Creates request options for getMosaicRestrictionsMerkle without sending the request
      */
-    getMosaicRestrictionsMerkleRaw(requestParameters, initOverrides) {
+    getMosaicRestrictionsMerkleRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['compositeHash'] == null) {
                 throw new runtime.RequiredError('compositeHash', 'Required parameter "compositeHash" was null or undefined when calling getMosaicRestrictionsMerkle().');
@@ -139,14 +159,24 @@ class RestrictionMosaicRoutesApi extends runtime.BaseAPI {
             const queryParameters = {};
             const headerParameters = {};
             let urlPath = `/restrictions/mosaic/{compositeHash}/merkle`;
-            urlPath = urlPath.replace(`{${"compositeHash"}}`, encodeURIComponent(String(requestParameters['compositeHash'])));
-            const response = yield this.request({
+            urlPath = urlPath.replace('{compositeHash}', encodeURIComponent(String(requestParameters['compositeHash'])));
+            return {
                 path: urlPath,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.MerkleStateInfoDTOFromJSON)(jsonValue));
+            };
+        });
+    }
+    /**
+     * Returns the Merkle state proof for the mosaic restriction entry associated with the given composite hash. If no mosaic restriction entry exists for the supplied composite hash, the endpoint still returns a Merkle proof response, but it is a negative proof showing that no mosaic restriction state entry exists for the requested composite hash.
+     * Get mosaic restrictions Merkle information
+     */
+    getMosaicRestrictionsMerkleRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getMosaicRestrictionsMerkleRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, MerkleStateInfoDTO_1.MerkleStateInfoDTOFromJSON)(jsonValue));
         });
     }
     /**
@@ -160,10 +190,9 @@ class RestrictionMosaicRoutesApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Returns a paginated list of mosaic restriction entries, optionally filtered by mosaic ID, entry type, and target address.
-     * Search mosaic restrictions
+     * Creates request options for searchMosaicRestrictions without sending the request
      */
-    searchMosaicRestrictionsRaw(requestParameters, initOverrides) {
+    searchMosaicRestrictionsRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             const queryParameters = {};
             if (requestParameters['mosaicId'] != null) {
@@ -189,13 +218,23 @@ class RestrictionMosaicRoutesApi extends runtime.BaseAPI {
             }
             const headerParameters = {};
             let urlPath = `/restrictions/mosaic`;
-            const response = yield this.request({
+            return {
                 path: urlPath,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.MosaicRestrictionsPageFromJSON)(jsonValue));
+            };
+        });
+    }
+    /**
+     * Returns a paginated list of mosaic restriction entries, optionally filtered by mosaic ID, entry type, and target address.
+     * Search mosaic restrictions
+     */
+    searchMosaicRestrictionsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.searchMosaicRestrictionsRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, MosaicRestrictionsPage_1.MosaicRestrictionsPageFromJSON)(jsonValue));
         });
     }
     /**