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

package/esm/api/apis/MetadataRoutesApi.js

@@ -12,29 +12,39 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import { CompositeHashesToJSON, MerkleStateInfoDTOFromJSON, MetadataInfoDTOFromJSON, MetadataPageFromJSON, } from '../models/index';
+import { CompositeHashesToJSON, } from '../models/CompositeHashes';
+import { MerkleStateInfoDTOFromJSON, } from '../models/MerkleStateInfoDTO';
+import { MetadataInfoDTOFromJSON, } from '../models/MetadataInfoDTO';
+import { MetadataPageFromJSON, } from '../models/MetadataPage';
 /**
  *
  */
 export class MetadataRoutesApi extends runtime.BaseAPI {
     /**
-     * Returns the metadata entry associated with the given composite hash.
-     * Get metadata information
+     * Creates request options for getMetadata without sending the request
      */
-    async getMetadataRaw(requestParameters, initOverrides) {
+    async getMetadataRequestOpts(requestParameters) {
         if (requestParameters['compositeHash'] == null) {
             throw new runtime.RequiredError('compositeHash', 'Required parameter "compositeHash" was null or undefined when calling getMetadata().');
         }
         const queryParameters = {};
         const headerParameters = {};
         let urlPath = `/metadata/{compositeHash}`;
-        urlPath = urlPath.replace(`{${"compositeHash"}}`, encodeURIComponent(String(requestParameters['compositeHash'])));
-        const response = await this.request({
+        urlPath = urlPath.replace('{compositeHash}', encodeURIComponent(String(requestParameters['compositeHash'])));
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns the metadata entry associated with the given composite hash.
+     * Get metadata information
+     */
+    async getMetadataRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getMetadataRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => MetadataInfoDTOFromJSON(jsonValue));
     }
     /**
@@ -46,10 +56,9 @@ export class MetadataRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Returns the metadata entries associated with the given composite hashes.
-     * Get metadata information for an array of composite hashes
+     * Creates request options for getMetadataEntries without sending the request
      */
-    async getMetadataEntriesRaw(requestParameters, initOverrides) {
+    async getMetadataEntriesRequestOpts(requestParameters) {
         if (requestParameters['compositeHashes'] == null) {
             throw new runtime.RequiredError('compositeHashes', 'Required parameter "compositeHashes" was null or undefined when calling getMetadataEntries().');
         }
@@ -57,13 +66,21 @@ export class MetadataRoutesApi extends runtime.BaseAPI {
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         let urlPath = `/metadata`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: CompositeHashesToJSON(requestParameters['compositeHashes']),
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns the metadata entries associated with the given composite hashes.
+     * Get metadata information for an array of composite hashes
+     */
+    async getMetadataEntriesRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getMetadataEntriesRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MetadataInfoDTOFromJSON));
     }
     /**
@@ -75,23 +92,30 @@ export class MetadataRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Returns the Merkle proof for the metadata state entry associated with the given composite hash.
-     * Get metadata Merkle information
+     * Creates request options for getMetadataMerkle without sending the request
      */
-    async getMetadataMerkleRaw(requestParameters, initOverrides) {
+    async getMetadataMerkleRequestOpts(requestParameters) {
         if (requestParameters['compositeHash'] == null) {
             throw new runtime.RequiredError('compositeHash', 'Required parameter "compositeHash" was null or undefined when calling getMetadataMerkle().');
         }
         const queryParameters = {};
         const headerParameters = {};
         let urlPath = `/metadata/{compositeHash}/merkle`;
-        urlPath = urlPath.replace(`{${"compositeHash"}}`, encodeURIComponent(String(requestParameters['compositeHash'])));
-        const response = await this.request({
+        urlPath = urlPath.replace('{compositeHash}', encodeURIComponent(String(requestParameters['compositeHash'])));
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns the Merkle proof for the metadata state entry associated with the given composite hash.
+     * Get metadata Merkle information
+     */
+    async getMetadataMerkleRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getMetadataMerkleRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => MerkleStateInfoDTOFromJSON(jsonValue));
     }
     /**
@@ -103,10 +127,9 @@ export class MetadataRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Returns the decoded binary payload stored in Metal metadata entries identified by the given metal id. Metal is a convention for storing chunked binary payloads in metadata entries. See the [metal-on-symbol repository](https://github.com/OPENSPHERE-Inc/metal-on-symbol). The response content type is derived from the stored Metal seal when available, or defaults to `application/octet-stream`. Optional query parameters can override the response headers for content type and filename.
-     * Get Metal metadata binary data
+     * Creates request options for getMetadataMetal without sending the request
      */
-    async getMetadataMetalRaw(requestParameters, initOverrides) {
+    async getMetadataMetalRequestOpts(requestParameters) {
         if (requestParameters['metalId'] == null) {
             throw new runtime.RequiredError('metalId', 'Required parameter "metalId" was null or undefined when calling getMetadataMetal().');
         }
@@ -122,13 +145,21 @@ export class MetadataRoutesApi extends runtime.BaseAPI {
         }
         const headerParameters = {};
         let urlPath = `/metadata/metal/{metalId}`;
-        urlPath = urlPath.replace(`{${"metalId"}}`, encodeURIComponent(String(requestParameters['metalId'])));
-        const response = await this.request({
+        urlPath = urlPath.replace('{metalId}', encodeURIComponent(String(requestParameters['metalId'])));
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns the decoded binary payload stored in Metal metadata entries identified by the given metal id. Metal is a convention for storing chunked binary payloads in metadata entries. See the [metal-on-symbol repository](https://github.com/OPENSPHERE-Inc/metal-on-symbol). The response content type is derived from the stored Metal seal when available, or defaults to `application/octet-stream`. Optional query parameters can override the response headers for content type and filename.
+     * Get Metal metadata binary data
+     */
+    async getMetadataMetalRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getMetadataMetalRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.BlobApiResponse(response);
     }
     /**
@@ -140,10 +171,9 @@ export class MetadataRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Returns a paginated list of metadata entries.  Results can be filtered by source address, target address, scoped metadata key, target ID, and metadata type.
-     * Search metadata entries
+     * Creates request options for searchMetadataEntries without sending the request
      */
-    async searchMetadataEntriesRaw(requestParameters, initOverrides) {
+    async searchMetadataEntriesRequestOpts(requestParameters) {
         const queryParameters = {};
         if (requestParameters['sourceAddress'] != null) {
             queryParameters['sourceAddress'] = requestParameters['sourceAddress'];
@@ -174,12 +204,20 @@ export class MetadataRoutesApi extends runtime.BaseAPI {
         }
         const headerParameters = {};
         let urlPath = `/metadata`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns a paginated list of metadata entries.  Results can be filtered by source address, target address, scoped metadata key, target ID, and metadata type.
+     * Search metadata entries
+     */
+    async searchMetadataEntriesRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.searchMetadataEntriesRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => MetadataPageFromJSON(jsonValue));
     }
     /**

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

@@ -10,27 +10,85 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { MerkleStateInfoDTO, MosaicIds, MosaicInfoDTO, MosaicPage, Order } from '../models/index';
+import { type MerkleStateInfoDTO } from '../models/MerkleStateInfoDTO';
+import { type MosaicIds } from '../models/MosaicIds';
+import { type MosaicInfoDTO } from '../models/MosaicInfoDTO';
+import { type MosaicPage } from '../models/MosaicPage';
+import { type Order } from '../models/Order';
 export interface GetMosaicRequest {
+    /**
+     * Mosaic identifier encoded as a 16-character hexadecimal string.
+     */
     mosaicId: string;
 }
 export interface GetMosaicMerkleRequest {
+    /**
+     * Mosaic identifier encoded as a 16-character hexadecimal string.
+     */
     mosaicId: string;
 }
 export interface GetMosaicsRequest {
+    /**
+     *
+     */
     mosaicIds: MosaicIds;
 }
 export interface SearchMosaicsRequest {
+    /**
+     * Filter by owner address in Base32 format (include).
+     */
     ownerAddress?: 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 MosaicRoutesApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for getMosaic without sending the request
+     */
+    getMosaicRequestOpts(requestParameters: GetMosaicRequest): Promise<runtime.RequestOpts>;
     /**
      * 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
@@ -41,6 +99,10 @@ export declare class MosaicRoutesApi extends runtime.BaseAPI {
      * Get mosaic information
      */
     getMosaic(requestParameters: GetMosaicRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MosaicInfoDTO>;
+    /**
+     * Creates request options for getMosaicMerkle without sending the request
+     */
+    getMosaicMerkleRequestOpts(requestParameters: GetMosaicMerkleRequest): Promise<runtime.RequestOpts>;
     /**
      * 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
@@ -51,6 +113,10 @@ export declare class MosaicRoutesApi extends runtime.BaseAPI {
      * Get mosaic Merkle information
      */
     getMosaicMerkle(requestParameters: GetMosaicMerkleRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MerkleStateInfoDTO>;
+    /**
+     * Creates request options for getMosaics without sending the request
+     */
+    getMosaicsRequestOpts(requestParameters: GetMosaicsRequest): Promise<runtime.RequestOpts>;
     /**
      * 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
@@ -61,6 +127,10 @@ export declare class MosaicRoutesApi extends runtime.BaseAPI {
      * Get mosaics information for an array of mosaics
      */
     getMosaics(requestParameters: GetMosaicsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<MosaicInfoDTO>>;
+    /**
+     * Creates request options for searchMosaics without sending the request
+     */
+    searchMosaicsRequestOpts(requestParameters: SearchMosaicsRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns a paginated list of mosaics matching the given criteria. Results can be filtered by mosaic owner address. Standard pagination parameters apply.
      * Search mosaics

package/esm/api/apis/MosaicRoutesApi.js

@@ -12,29 +12,39 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import { MerkleStateInfoDTOFromJSON, MosaicIdsToJSON, MosaicInfoDTOFromJSON, MosaicPageFromJSON, } from '../models/index';
+import { MerkleStateInfoDTOFromJSON, } from '../models/MerkleStateInfoDTO';
+import { MosaicIdsToJSON, } from '../models/MosaicIds';
+import { MosaicInfoDTOFromJSON, } from '../models/MosaicInfoDTO';
+import { MosaicPageFromJSON, } from '../models/MosaicPage';
 /**
  *
  */
 export 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
      */
-    async getMosaicRaw(requestParameters, initOverrides) {
+    async getMosaicRequestOpts(requestParameters) {
         if (requestParameters['mosaicId'] == null) {
             throw new runtime.RequiredError('mosaicId', 'Required parameter "mosaicId" was null or undefined when calling getMosaic().');
         }
         const queryParameters = {};
         const headerParameters = {};
         let urlPath = `/mosaics/{mosaicId}`;
-        urlPath = urlPath.replace(`{${"mosaicId"}}`, encodeURIComponent(String(requestParameters['mosaicId'])));
-        const response = await this.request({
+        urlPath = urlPath.replace('{mosaicId}', encodeURIComponent(String(requestParameters['mosaicId'])));
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * 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
+     */
+    async getMosaicRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getMosaicRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => MosaicInfoDTOFromJSON(jsonValue));
     }
     /**
@@ -46,23 +56,30 @@ export class MosaicRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * 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
      */
-    async getMosaicMerkleRaw(requestParameters, initOverrides) {
+    async getMosaicMerkleRequestOpts(requestParameters) {
         if (requestParameters['mosaicId'] == null) {
             throw new runtime.RequiredError('mosaicId', 'Required parameter "mosaicId" was null or undefined when calling getMosaicMerkle().');
         }
         const queryParameters = {};
         const headerParameters = {};
         let urlPath = `/mosaics/{mosaicId}/merkle`;
-        urlPath = urlPath.replace(`{${"mosaicId"}}`, encodeURIComponent(String(requestParameters['mosaicId'])));
-        const response = await this.request({
+        urlPath = urlPath.replace('{mosaicId}', encodeURIComponent(String(requestParameters['mosaicId'])));
+        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 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
+     */
+    async getMosaicMerkleRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getMosaicMerkleRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => MerkleStateInfoDTOFromJSON(jsonValue));
     }
     /**
@@ -74,10 +91,9 @@ export class MosaicRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * 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
      */
-    async getMosaicsRaw(requestParameters, initOverrides) {
+    async getMosaicsRequestOpts(requestParameters) {
         if (requestParameters['mosaicIds'] == null) {
             throw new runtime.RequiredError('mosaicIds', 'Required parameter "mosaicIds" was null or undefined when calling getMosaics().');
         }
@@ -85,13 +101,21 @@ export class MosaicRoutesApi extends runtime.BaseAPI {
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         let urlPath = `/mosaics`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: MosaicIdsToJSON(requestParameters['mosaicIds']),
-        }, initOverrides);
+        };
+    }
+    /**
+     * 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
+     */
+    async getMosaicsRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getMosaicsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MosaicInfoDTOFromJSON));
     }
     /**
@@ -103,10 +127,9 @@ export class MosaicRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * 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
      */
-    async searchMosaicsRaw(requestParameters, initOverrides) {
+    async searchMosaicsRequestOpts(requestParameters) {
         const queryParameters = {};
         if (requestParameters['ownerAddress'] != null) {
             queryParameters['ownerAddress'] = requestParameters['ownerAddress'];
@@ -125,12 +148,20 @@ export class MosaicRoutesApi extends runtime.BaseAPI {
         }
         const headerParameters = {};
         let urlPath = `/mosaics`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns a paginated list of mosaics matching the given criteria. Results can be filtered by mosaic owner address. Standard pagination parameters apply.
+     * Search mosaics
+     */
+    async searchMosaicsRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.searchMosaicsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => MosaicPageFromJSON(jsonValue));
     }
     /**

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