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

package/cjs/api/models/VrfKeyLinkTransactionDTO.d.ts

@@ -21,11 +21,9 @@ import type { LinkActionEnum } from './LinkActionEnum';
  */
 export interface VrfKeyLinkTransactionDTO {
     /**
-     * Unsigned 32-bit integer.
-     * Represented as integer since it fits in JSON number precision.
+     * Total size of the serialized entity in bytes. Includes the full binary payload,
+     * including the 4-byte size field itself.
      *
-     * @type {number}
-     * @memberof VrfKeyLinkTransactionDTO
      */
     size: number;
     /**
@@ -33,77 +31,47 @@ export interface VrfKeyLinkTransactionDTO {
      * over the serialized entity payload. Can be verified with the signer's public key (`signerPublicKey`).
      * Used for blocks, transactions, and cosignatures.
      *
-     * @type {string}
-     * @memberof VrfKeyLinkTransactionDTO
      */
     signature: string;
     /**
-     * 256-bit public key encoded as a hexadecimal string (64 hex characters).
-     * @type {string}
-     * @memberof VrfKeyLinkTransactionDTO
+     * Public key of the account that signed the entity (e.g. block harvester, transaction signer).
      */
     signerPublicKey: string;
     /**
      * Entity version. Indicates the schema variant for serialization and validation.
-     * @type {number}
-     * @memberof VrfKeyLinkTransactionDTO
      */
     version: number;
     /**
      * Network type (mainnet or testnet). Ensures the entity targets the correct network.
-     * @type {NetworkTypeEnum}
-     * @memberof VrfKeyLinkTransactionDTO
      */
     network: NetworkTypeEnum;
     /**
      * Entity type identifier (e.g. transaction type code, block type). Determines the entity schema.
-     * @type {number}
-     * @memberof VrfKeyLinkTransactionDTO
      */
     type: number;
     /**
-     * Absolute amount expressed in the mosaic's smallest (atomic) unit, with no decimal point.
-     * For example, an amount of `123456789` for a mosaic with divisibility 6 represents
-     * `123.456789` whole units. Encoded as a string to preserve precision, since the value
-     * is an unsigned 64-bit integer.
-     *
-     * @type {string}
-     * @memberof VrfKeyLinkTransactionDTO
+     * Maximum fee the signer is willing to pay for this transaction, in smallest (atomic) units.
      */
     maxFee: string;
     /**
-     * Network timestamp in **milliseconds** since the creation of the nemesis (first) block.
-     * Used for block timestamps, transaction deadlines, and time synchronization.
-     *
-     * **Finding the nemesis block time:** The `epochAdjustment` field returned by the
-     * [`/network/properties`] endpoint gives the nemesis block creation time in seconds since the
-     * [UNIX epoch](https://en.wikipedia.org/wiki/Unix_time). For Symbol MAINNET this is
-     * always `1615853185` (15 March 2021, 00:06:25 UTC).
-     *
-     * **Converting to real time:** Add this timestamp (ms) to `epochAdjustment × 1000` (ms), then use standard date functions.
-     * Note: `epochAdjustment` may be returned as a string like `"1615853185s"`; use the numeric part.
+     * Latest network time at which the transaction can still be included in a block, expressed in milliseconds
+     * since the creation of the nemesis (first) block.
      *
-     * @type {string}
-     * @memberof VrfKeyLinkTransactionDTO
      */
     deadline: string;
     /**
      * 256-bit public key encoded as a hexadecimal string (64 hex characters).
-     * @type {string}
-     * @memberof VrfKeyLinkTransactionDTO
      */
     linkedPublicKey: string;
     /**
      *
-     * @type {LinkActionEnum}
-     * @memberof VrfKeyLinkTransactionDTO
      */
     linkAction: LinkActionEnum;
 }
 /**
  * Check if a given object implements the VrfKeyLinkTransactionDTO interface.
  */
-export declare function instanceOfVrfKeyLinkTransactionDTO(value: Record<string, any>): value is VrfKeyLinkTransactionDTO;
+export declare function instanceOfVrfKeyLinkTransactionDTO(value: object): value is VrfKeyLinkTransactionDTO;
 export declare function VrfKeyLinkTransactionDTOFromJSON(json: any): VrfKeyLinkTransactionDTO;
 export declare function VrfKeyLinkTransactionDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): VrfKeyLinkTransactionDTO;
 export declare function VrfKeyLinkTransactionDTOToJSON(json: any): VrfKeyLinkTransactionDTO;

package/cjs/api/runtime.d.ts

@@ -124,9 +124,21 @@ export interface RequestOpts {
 }
 export declare function querystring(params: HTTPQuery, prefix?: string): string;
 export declare function exists(json: any, key: string): boolean;
+/**
+ * Every generated date call site routes through these.
+ *
+ * `format: date` is a calendar date, with no time and no offset, so it is converted
+ * against the local calendar on both ends: they have to agree or the date shifts by
+ * a day. `format: date-time` is an instant and uses UTC.
+ */
+export declare function serializeDateTime(value: Date): string;
+export declare function serializeDate(value: Date): string;
+export declare function parseDate(value: Date | string): Date;
+export declare function parseDateTime(value: any): Date;
 export declare function mapValues(data: any, fn: (item: any) => any): {
     [key: string]: any;
 };
+export declare function anyToJSON(value: any): any;
 export declare function canConsumeForm(consumes: Consume[]): boolean;
 export interface Consume {
     contentType: string;
@@ -172,11 +184,32 @@ export declare class VoidApiResponse {
     constructor(raw: Response);
     value(): Promise<void>;
 }
+/**
+ * A Blob carrying the file name the server advertised, empty when it did not send one. It is a File
+ * wherever one can be built, and the bare Blob given a name otherwise. Same name and shape as the
+ * `typescript` generator's browser HttpFile.
+ */
+export type HttpFile = Blob & {
+    readonly name: string;
+};
 export declare class BlobApiResponse {
     raw: Response;
     constructor(raw: Response);
-    value(): Promise<Blob>;
+    /**
+     * The body named after the Content-Disposition header, so that a download keeps the name the
+     * server gave it. A File is built from a native Blob; the Blob itself is named where there is no
+     * global File (Node.js before 20), where File cannot be constructed, or where the Blob is not the
+     * native one, as returned by an injected fetch implementation such as node-fetch, which a File
+     * would stringify instead of wrapping.
+     */
+    value(): Promise<HttpFile>;
 }
+/**
+ * The file name advertised by a Content-Disposition header (RFC 6266): the RFC 5987 encoded
+ * `filename*` parameter first, falling back to the plain `filename` when it is malformed, not UTF-8
+ * or has no usable name. Any directory part is dropped; undefined when no usable name is advertised.
+ */
+export declare function parseContentDispositionFilename(headers: Headers): string | undefined;
 export declare class TextApiResponse {
     raw: Response;
     constructor(raw: Response);

package/cjs/api/runtime.js

@@ -25,8 +25,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TextApiResponse = exports.BlobApiResponse = exports.VoidApiResponse = exports.JSONApiResponse = exports.COLLECTION_FORMATS = exports.RequiredError = exports.FetchError = exports.ResponseError = exports.BaseAPI = exports.DefaultConfig = exports.Configuration = exports.BASE_PATH = void 0;
 exports.querystring = querystring;
 exports.exists = exists;
+exports.serializeDateTime = serializeDateTime;
+exports.serializeDate = serializeDate;
+exports.parseDate = parseDate;
+exports.parseDateTime = parseDateTime;
 exports.mapValues = mapValues;
+exports.anyToJSON = anyToJSON;
 exports.canConsumeForm = canConsumeForm;
+exports.parseContentDispositionFilename = parseContentDispositionFilename;
 exports.BASE_PATH = "https://reference.symboltest.net:3001".replace(/\/+$/, "");
 class Configuration {
     constructor(configuration = {}) {
@@ -219,7 +225,7 @@ class BaseAPI {
     }
 }
 exports.BaseAPI = BaseAPI;
-BaseAPI.jsonRegex = new RegExp('^(:?application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(:?;.*)?$', 'i');
+BaseAPI.jsonRegex = /^(:?application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(:?;.*)?$/i;
 ;
 function isBlob(value) {
     return typeof Blob !== 'undefined' && value instanceof Blob;
@@ -232,6 +238,11 @@ class ResponseError extends Error {
         super(msg);
         this.response = response;
         this.name = "ResponseError";
+        // restore prototype chain
+        const actualProto = new.target.prototype;
+        if (Object.setPrototypeOf) {
+            Object.setPrototypeOf(this, actualProto);
+        }
     }
 }
 exports.ResponseError = ResponseError;
@@ -240,6 +251,11 @@ class FetchError extends Error {
         super(msg);
         this.cause = cause;
         this.name = "FetchError";
+        // restore prototype chain
+        const actualProto = new.target.prototype;
+        if (Object.setPrototypeOf) {
+            Object.setPrototypeOf(this, actualProto);
+        }
     }
 }
 exports.FetchError = FetchError;
@@ -248,6 +264,11 @@ class RequiredError extends Error {
         super(msg);
         this.field = field;
         this.name = "RequiredError";
+        // restore prototype chain
+        const actualProto = new.target.prototype;
+        if (Object.setPrototypeOf) {
+            Object.setPrototypeOf(this, actualProto);
+        }
     }
 }
 exports.RequiredError = RequiredError;
@@ -275,7 +296,7 @@ function querystringSingleKey(key, value, keyPrefix = '') {
         return querystringSingleKey(key, valueAsArray, keyPrefix);
     }
     if (value instanceof Date) {
-        return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
+        return `${encodeURIComponent(fullKey)}=${encodeURIComponent(serializeDateTime(value))}`;
     }
     if (value instanceof Object) {
         return querystring(value, fullKey);
@@ -286,6 +307,52 @@ function exists(json, key) {
     const value = json[key];
     return value !== null && value !== undefined;
 }
+/**
+ * Every generated date call site routes through these.
+ *
+ * `format: date` is a calendar date, with no time and no offset, so it is converted
+ * against the local calendar on both ends: they have to agree or the date shifts by
+ * a day. `format: date-time` is an instant and uses UTC.
+ */
+function serializeDateTime(value) {
+    return value.toISOString();
+}
+function serializeDate(value) {
+    if (isNaN(value.getTime())) {
+        throw new RangeError('Invalid time value');
+    }
+    const year = ('000' + value.getFullYear()).slice(-4);
+    const month = ('0' + (value.getMonth() + 1)).slice(-2);
+    const day = ('0' + value.getDate()).slice(-2);
+    return `${year}-${month}-${day}`;
+}
+function parseDate(value) {
+    if (value instanceof Date) {
+        return value;
+    }
+    // `new Date("2026-08-05")` would parse as UTC midnight: a different day west of UTC.
+    // Local midnight is the stated day everywhere. setFullYear avoids the 1900 offset the
+    // multi-argument constructor applies to years 0-99.
+    const fullDate = /^(\d{4})-(\d{2})-(\d{2})$/.exec(String(value));
+    if (fullDate) {
+        const year = Number(fullDate[1]);
+        const month = Number(fullDate[2]) - 1;
+        const day = Number(fullDate[3]);
+        const date = new Date(0);
+        date.setFullYear(year, month, day);
+        date.setHours(0, 0, 0, 0);
+        // Out-of-range components (or a day the local zone skipped) silently roll over,
+        // which would hand back a date the server never sent.
+        if (date.getFullYear() !== year || date.getMonth() !== month || date.getDate() !== day) {
+            return new Date(NaN);
+        }
+        return date;
+    }
+    return new Date(value);
+}
+function parseDateTime(value) {
+    return new Date(value);
+}
 function mapValues(data, fn) {
     const result = {};
     for (const key of Object.keys(data)) {
@@ -293,9 +360,14 @@ function mapValues(data, fn) {
     }
     return result;
 }
+// Pass-through serializer for `any`-typed properties in form data. See #1877.
+function anyToJSON(value) {
+    return value;
+}
 function canConsumeForm(consumes) {
+    var _a;
     for (const consume of consumes) {
-        if ('multipart/form-data' === consume.contentType) {
+        if (((_a = consume.contentType) === null || _a === void 0 ? void 0 : _a.startsWith('multipart/form-data')) == true) {
             return true;
         }
     }
@@ -328,14 +400,74 @@ class BlobApiResponse {
     constructor(raw) {
         this.raw = raw;
     }
+    /**
+     * The body named after the Content-Disposition header, so that a download keeps the name the
+     * server gave it. A File is built from a native Blob; the Blob itself is named where there is no
+     * global File (Node.js before 20), where File cannot be constructed, or where the Blob is not the
+     * native one, as returned by an injected fetch implementation such as node-fetch, which a File
+     * would stringify instead of wrapping.
+     */
     value() {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.raw.blob();
+            var _a;
+            const blob = yield this.raw.blob();
+            const name = (_a = parseContentDispositionFilename(this.raw.headers)) !== null && _a !== void 0 ? _a : '';
+            if (typeof File !== 'undefined' && blob instanceof Blob) {
+                try {
+                    return new File([blob], name, { type: blob.type });
+                }
+                catch (_b) {
+                    // File cannot be constructed: name the Blob itself
+                }
+            }
+            return Object.assign(blob, { name });
         });
     }
     ;
 }
 exports.BlobApiResponse = BlobApiResponse;
+/**
+ * The file name advertised by a Content-Disposition header (RFC 6266): the RFC 5987 encoded
+ * `filename*` parameter first, falling back to the plain `filename` when it is malformed, not UTF-8
+ * or has no usable name. Any directory part is dropped; undefined when no usable name is advertised.
+ */
+function parseContentDispositionFilename(headers) {
+    var _a, _b;
+    const params = parseHeaderParameters((_a = headers.get('Content-Disposition')) !== null && _a !== void 0 ? _a : '');
+    return (_b = basename(decodeExtValue(params.get('filename*')))) !== null && _b !== void 0 ? _b : basename(params.get('filename'));
+}
+/** The decoded RFC 5987 ext-value, or undefined when it is not UTF-8 or its percent-encoding is malformed. */
+function decodeExtValue(value) {
+    const match = value === undefined ? null : /^utf-8'[^']*'(.*)$/i.exec(value);
+    try {
+        return match ? decodeURIComponent(match[1]) : undefined;
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+/**
+ * The `name=value` parameters of a header value, consumed one at a time so that a quoted-string is
+ * taken whole, `;` included. Names are lower-cased, quoted-string values are unquoted with their
+ * backslash escapes resolved, and the first occurrence of a name wins.
+ */
+function parseHeaderParameters(value) {
+    const params = new Map();
+    const parameter = /(?:^|;)\s*([^=;]+?)\s*=\s*(?:"((?:[^"\\]|\\.)*)"?|([^;]*))/g;
+    let match;
+    while ((match = parameter.exec(value)) !== null) {
+        const name = match[1].toLowerCase();
+        if (!params.has(name)) {
+            params.set(name, match[2] !== undefined ? match[2].replace(/\\(.)/g, '$1') : match[3].trim());
+        }
+    }
+    return params;
+}
+/** The last `/` or `\` separated segment of a file name, or undefined when it is not a file name. */
+function basename(name) {
+    const base = name === null || name === void 0 ? void 0 : name.split(/[\\/]/).pop();
+    return !base || base === '.' || base === '..' ? undefined : base;
+}
 class TextApiResponse {
     constructor(raw) {
         this.raw = raw;

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

@@ -10,29 +10,110 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { AccountIds, AccountInfoDTO, AccountOrderByEnum, AccountPage, MerkleStateInfoDTO, Order } from '../models/index';
+import { type AccountIds } from '../models/AccountIds';
+import { type AccountInfoDTO } from '../models/AccountInfoDTO';
+import { type AccountOrderByEnum } from '../models/AccountOrderByEnum';
+import { type AccountPage } from '../models/AccountPage';
+import { type MerkleStateInfoDTO } from '../models/MerkleStateInfoDTO';
+import { type Order } from '../models/Order';
 export interface GetAccountInfoRequest {
+    /**
+     * Account public key as 64 hexadecimal characters, or account address as 39 Base32
+     * (network prefix `T` for testnet, `N` for mainnet).
+     *
+     */
     accountId: string;
 }
 export interface GetAccountInfoMerkleRequest {
+    /**
+     * Account public key as 64 hexadecimal characters, or account address as 39 Base32
+     * (network prefix `T` for testnet, `N` for mainnet).
+     *
+     */
     accountId: string;
 }
 export interface GetAccountsInfoRequest {
+    /**
+     *
+     */
     accountIds?: AccountIds;
 }
 export interface SearchAccountsRequest {
+    /**
+     * 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;
+    /**
+     * Sort responses by the property set.
+     * If `balance` option is selected, the request must define the `mosaicId` filter.
+     *
+     */
     orderBy?: AccountOrderByEnum;
+    /**
+     * Filter by mosaic identifier (include).
+     */
     mosaicId?: string;
 }
 /**
  *
  */
 export declare class AccountRoutesApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for getAccountInfo without sending the request
+     */
+    getAccountInfoRequestOpts(requestParameters: GetAccountInfoRequest): Promise<runtime.RequestOpts>;
     /**
      * Retrieves account data for a given account identifier. The response contains the account state including balance, importance, public key, linked keys, and activity buckets.  The `accountId` path parameter accepts either a public key or a Base32-encoded address.
      * Get account information
@@ -43,6 +124,10 @@ export declare class AccountRoutesApi extends runtime.BaseAPI {
      * Get account information
      */
     getAccountInfo(requestParameters: GetAccountInfoRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AccountInfoDTO>;
+    /**
+     * Creates request options for getAccountInfoMerkle without sending the request
+     */
+    getAccountInfoMerkleRequestOpts(requestParameters: GetAccountInfoMerkleRequest): Promise<runtime.RequestOpts>;
     /**
      * Retrieves the Merkle proof data for a given account. The Merkle path can be used to independently verify that the account state is included in the block state hash.  If no account state entry exists for the supplied account ID, the endpoint still returns a Merkle proof response, but it is a negative proof showing that no account state entry exists for the requested account.  The `accountId` path parameter accepts either a public key or a Base32-encoded address.
      * Get account Merkle information
@@ -53,6 +138,10 @@ export declare class AccountRoutesApi extends runtime.BaseAPI {
      * Get account Merkle information
      */
     getAccountInfoMerkle(requestParameters: GetAccountInfoMerkleRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MerkleStateInfoDTO>;
+    /**
+     * Creates request options for getAccountsInfo without sending the request
+     */
+    getAccountsInfoRequestOpts(requestParameters: GetAccountsInfoRequest): Promise<runtime.RequestOpts>;
     /**
      * Retrieves account data for multiple accounts in a single request. This is the batch equivalent of the single-account endpoint.  The request body accepts either an array of public keys or an array of addresses (not both). If both `publicKeys` and `addresses` are provided, the request is invalid and the server returns `409` error.
      * Get accounts information
@@ -63,6 +152,10 @@ export declare class AccountRoutesApi extends runtime.BaseAPI {
      * Get accounts information
      */
     getAccountsInfo(requestParameters?: GetAccountsInfoRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<AccountInfoDTO>>;
+    /**
+     * Creates request options for searchAccounts without sending the request
+     */
+    searchAccountsRequestOpts(requestParameters: SearchAccountsRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns a paginated list of accounts matching the given criteria.  Results can be filtered by `address` and `mosaicId` (mosaic ownership), and ordered by `id` or `balance`. Standard pagination parameters (`pageSize`, `pageNumber`, `offset`, `order`) apply. The `orderBy` parameter supports `id` and `balance`; when using `orderBy=balance`, the `mosaicId` filter is required. The `offset` value must match the `orderBy` field.
      * Search accounts

package/esm/api/apis/AccountRoutesApi.js

@@ -12,29 +12,39 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import { AccountIdsToJSON, AccountInfoDTOFromJSON, AccountPageFromJSON, MerkleStateInfoDTOFromJSON, } from '../models/index';
+import { AccountIdsToJSON, } from '../models/AccountIds';
+import { AccountInfoDTOFromJSON, } from '../models/AccountInfoDTO';
+import { AccountPageFromJSON, } from '../models/AccountPage';
+import { MerkleStateInfoDTOFromJSON, } from '../models/MerkleStateInfoDTO';
 /**
  *
  */
 export class AccountRoutesApi extends runtime.BaseAPI {
     /**
-     * Retrieves account data for a given account identifier. The response contains the account state including balance, importance, public key, linked keys, and activity buckets.  The `accountId` path parameter accepts either a public key or a Base32-encoded address.
-     * Get account information
+     * Creates request options for getAccountInfo without sending the request
      */
-    async getAccountInfoRaw(requestParameters, initOverrides) {
+    async getAccountInfoRequestOpts(requestParameters) {
         if (requestParameters['accountId'] == null) {
             throw new runtime.RequiredError('accountId', 'Required parameter "accountId" was null or undefined when calling getAccountInfo().');
         }
         const queryParameters = {};
         const headerParameters = {};
         let urlPath = `/accounts/{accountId}`;
-        urlPath = urlPath.replace(`{${"accountId"}}`, encodeURIComponent(String(requestParameters['accountId'])));
-        const response = await this.request({
+        urlPath = urlPath.replace('{accountId}', encodeURIComponent(String(requestParameters['accountId'])));
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * Retrieves account data for a given account identifier. The response contains the account state including balance, importance, public key, linked keys, and activity buckets.  The `accountId` path parameter accepts either a public key or a Base32-encoded address.
+     * Get account information
+     */
+    async getAccountInfoRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getAccountInfoRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => AccountInfoDTOFromJSON(jsonValue));
     }
     /**
@@ -46,23 +56,30 @@ export class AccountRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Retrieves the Merkle proof data for a given account. The Merkle path can be used to independently verify that the account state is included in the block state hash.  If no account state entry exists for the supplied account ID, the endpoint still returns a Merkle proof response, but it is a negative proof showing that no account state entry exists for the requested account.  The `accountId` path parameter accepts either a public key or a Base32-encoded address.
-     * Get account Merkle information
+     * Creates request options for getAccountInfoMerkle without sending the request
      */
-    async getAccountInfoMerkleRaw(requestParameters, initOverrides) {
+    async getAccountInfoMerkleRequestOpts(requestParameters) {
         if (requestParameters['accountId'] == null) {
             throw new runtime.RequiredError('accountId', 'Required parameter "accountId" was null or undefined when calling getAccountInfoMerkle().');
         }
         const queryParameters = {};
         const headerParameters = {};
         let urlPath = `/accounts/{accountId}/merkle`;
-        urlPath = urlPath.replace(`{${"accountId"}}`, encodeURIComponent(String(requestParameters['accountId'])));
-        const response = await this.request({
+        urlPath = urlPath.replace('{accountId}', encodeURIComponent(String(requestParameters['accountId'])));
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * Retrieves the Merkle proof data for a given account. The Merkle path can be used to independently verify that the account state is included in the block state hash.  If no account state entry exists for the supplied account ID, the endpoint still returns a Merkle proof response, but it is a negative proof showing that no account state entry exists for the requested account.  The `accountId` path parameter accepts either a public key or a Base32-encoded address.
+     * Get account Merkle information
+     */
+    async getAccountInfoMerkleRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getAccountInfoMerkleRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => MerkleStateInfoDTOFromJSON(jsonValue));
     }
     /**
@@ -74,21 +91,28 @@ export class AccountRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Retrieves account data for multiple accounts in a single request. This is the batch equivalent of the single-account endpoint.  The request body accepts either an array of public keys or an array of addresses (not both). If both `publicKeys` and `addresses` are provided, the request is invalid and the server returns `409` error.
-     * Get accounts information
+     * Creates request options for getAccountsInfo without sending the request
      */
-    async getAccountsInfoRaw(requestParameters, initOverrides) {
+    async getAccountsInfoRequestOpts(requestParameters) {
         const queryParameters = {};
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         let urlPath = `/accounts`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: AccountIdsToJSON(requestParameters['accountIds']),
-        }, initOverrides);
+        };
+    }
+    /**
+     * Retrieves account data for multiple accounts in a single request. This is the batch equivalent of the single-account endpoint.  The request body accepts either an array of public keys or an array of addresses (not both). If both `publicKeys` and `addresses` are provided, the request is invalid and the server returns `409` error.
+     * Get accounts information
+     */
+    async getAccountsInfoRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getAccountsInfoRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(AccountInfoDTOFromJSON));
     }
     /**
@@ -100,10 +124,9 @@ export class AccountRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Returns a paginated list of accounts matching the given criteria.  Results can be filtered by `address` and `mosaicId` (mosaic ownership), and ordered by `id` or `balance`. Standard pagination parameters (`pageSize`, `pageNumber`, `offset`, `order`) apply. The `orderBy` parameter supports `id` and `balance`; when using `orderBy=balance`, the `mosaicId` filter is required. The `offset` value must match the `orderBy` field.
-     * Search accounts
+     * Creates request options for searchAccounts without sending the request
      */
-    async searchAccountsRaw(requestParameters, initOverrides) {
+    async searchAccountsRequestOpts(requestParameters) {
         const queryParameters = {};
         if (requestParameters['address'] != null) {
             queryParameters['address'] = requestParameters['address'];
@@ -128,12 +151,20 @@ export class AccountRoutesApi extends runtime.BaseAPI {
         }
         const headerParameters = {};
         let urlPath = `/accounts`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns a paginated list of accounts matching the given criteria.  Results can be filtered by `address` and `mosaicId` (mosaic ownership), and ordered by `id` or `balance`. Standard pagination parameters (`pageSize`, `pageNumber`, `offset`, `order`) apply. The `orderBy` parameter supports `id` and `balance`; when using `orderBy=balance`, the `mosaicId` filter is required. The `offset` value must match the `orderBy` field.
+     * Search accounts
+     */
+    async searchAccountsRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.searchAccountsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => AccountPageFromJSON(jsonValue));
     }
     /**