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

package/esm/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/esm/api/apis/RestrictionMosaicRoutesApi.js

@@ -12,29 +12,39 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import { CompositeHashesToJSON, MerkleStateInfoDTOFromJSON, MosaicRestrictionDTOFromJSON, MosaicRestrictionsPageFromJSON, } from '../models/index';
+import { CompositeHashesToJSON, } from '../models/CompositeHashes';
+import { MerkleStateInfoDTOFromJSON, } from '../models/MerkleStateInfoDTO';
+import { MosaicRestrictionDTOFromJSON, } from '../models/MosaicRestrictionDTO';
+import { MosaicRestrictionsPageFromJSON, } from '../models/MosaicRestrictionsPage';
 /**
  *
  */
 export 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
      */
-    async getMosaicRestrictionsRaw(requestParameters, initOverrides) {
+    async getMosaicRestrictionsRequestOpts(requestParameters) {
         if (requestParameters['compositeHash'] == null) {
             throw new runtime.RequiredError('compositeHash', 'Required parameter "compositeHash" was null or undefined when calling getMosaicRestrictions().');
         }
         const queryParameters = {};
         const headerParameters = {};
         let urlPath = `/restrictions/mosaic/{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 mosaic restriction entry associated with the given composite hash.
+     * Get mosaic restrictions
+     */
+    async getMosaicRestrictionsRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getMosaicRestrictionsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => MosaicRestrictionDTOFromJSON(jsonValue));
     }
     /**
@@ -46,10 +56,9 @@ export class RestrictionMosaicRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * 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
      */
-    async getMosaicRestrictionsBatchRaw(requestParameters, initOverrides) {
+    async getMosaicRestrictionsBatchRequestOpts(requestParameters) {
         if (requestParameters['compositeHashes'] == null) {
             throw new runtime.RequiredError('compositeHashes', 'Required parameter "compositeHashes" was null or undefined when calling getMosaicRestrictionsBatch().');
         }
@@ -57,13 +66,21 @@ export class RestrictionMosaicRoutesApi extends runtime.BaseAPI {
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         let urlPath = `/restrictions/mosaic`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: CompositeHashesToJSON(requestParameters['compositeHashes']),
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns mosaic restriction entries for the given composite hashes.
+     * Get mosaic restrictions for an array of composite hashes
+     */
+    async getMosaicRestrictionsBatchRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getMosaicRestrictionsBatchRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MosaicRestrictionDTOFromJSON));
     }
     /**
@@ -75,23 +92,30 @@ export class RestrictionMosaicRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * 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
      */
-    async getMosaicRestrictionsMerkleRaw(requestParameters, initOverrides) {
+    async getMosaicRestrictionsMerkleRequestOpts(requestParameters) {
         if (requestParameters['compositeHash'] == null) {
             throw new runtime.RequiredError('compositeHash', 'Required parameter "compositeHash" was null or undefined when calling getMosaicRestrictionsMerkle().');
         }
         const queryParameters = {};
         const headerParameters = {};
         let urlPath = `/restrictions/mosaic/{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 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
+     */
+    async getMosaicRestrictionsMerkleRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getMosaicRestrictionsMerkleRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => MerkleStateInfoDTOFromJSON(jsonValue));
     }
     /**
@@ -103,10 +127,9 @@ export class RestrictionMosaicRoutesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * 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
      */
-    async searchMosaicRestrictionsRaw(requestParameters, initOverrides) {
+    async searchMosaicRestrictionsRequestOpts(requestParameters) {
         const queryParameters = {};
         if (requestParameters['mosaicId'] != null) {
             queryParameters['mosaicId'] = requestParameters['mosaicId'];
@@ -131,12 +154,20 @@ export class RestrictionMosaicRoutesApi extends runtime.BaseAPI {
         }
         const headerParameters = {};
         let urlPath = `/restrictions/mosaic`;
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+    /**
+     * Returns a paginated list of mosaic restriction entries, optionally filtered by mosaic ID, entry type, and target address.
+     * Search mosaic restrictions
+     */
+    async searchMosaicRestrictionsRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.searchMosaicRestrictionsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => MosaicRestrictionsPageFromJSON(jsonValue));
     }
     /**

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

@@ -10,36 +10,151 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { CompositeHashes, MerkleStateInfoDTO, Order, SecretLockInfoDTO, SecretLockPage } from '../models/index';
+import { type CompositeHashes } from '../models/CompositeHashes';
+import { type MerkleStateInfoDTO } from '../models/MerkleStateInfoDTO';
+import { type Order } from '../models/Order';
+import { type SecretLockInfoDTO } from '../models/SecretLockInfoDTO';
+import { type SecretLockPage } from '../models/SecretLockPage';
 export interface GetSecretLockRequest {
+    /**
+     * Composite hash encoded as a 64-character hexadecimal string.
+     */
     compositeHash: string;
 }
 export interface GetSecretLockMerkleRequest {
+    /**
+     * Composite hash encoded as a 64-character hexadecimal string.
+     */
     compositeHash: string;
 }
 export interface GetSecretLocksRequest {
+    /**
+     *
+     */
     compositeHashes: CompositeHashes;
 }
 export interface SearchAccountSecretLocksRequest {
+    /**
+     * Account address in Base32-encoded format.
+     */
     address: string;
+    /**
+     * Filter by the 256-bit hashed secret associated with the secret lock (include).
+     */
     secret?: 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 interface SearchSecretLockRequest {
+    /**
+     * 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;
+    /**
+     * Filter by the 256-bit hashed secret associated with the secret lock (include).
+     */
     secret?: 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 SecretLockRoutesApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for getSecretLock without sending the request
+     */
+    getSecretLockRequestOpts(requestParameters: GetSecretLockRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns the secret lock entry associated with the given composite hash.
      * Get secret lock information
@@ -50,6 +165,10 @@ export declare class SecretLockRoutesApi extends runtime.BaseAPI {
      * Get secret lock information
      */
     getSecretLock(requestParameters: GetSecretLockRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SecretLockInfoDTO>;
+    /**
+     * Creates request options for getSecretLockMerkle without sending the request
+     */
+    getSecretLockMerkleRequestOpts(requestParameters: GetSecretLockMerkleRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns the state Merkle proof for the secret lock entry associated with the given composite hash.
      * Get secret lock Merkle information
@@ -60,6 +179,10 @@ export declare class SecretLockRoutesApi extends runtime.BaseAPI {
      * Get secret lock Merkle information
      */
     getSecretLockMerkle(requestParameters: GetSecretLockMerkleRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MerkleStateInfoDTO>;
+    /**
+     * Creates request options for getSecretLocks without sending the request
+     */
+    getSecretLocksRequestOpts(requestParameters: GetSecretLocksRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns secret lock entries associated with the given composite hashes.
      * Get secret lock information for an array of composite hashes
@@ -70,6 +193,10 @@ export declare class SecretLockRoutesApi extends runtime.BaseAPI {
      * Get secret lock information for an array of composite hashes
      */
     getSecretLocks(requestParameters: GetSecretLocksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<SecretLockInfoDTO>>;
+    /**
+     * Creates request options for searchAccountSecretLocks without sending the request
+     */
+    searchAccountSecretLocksRequestOpts(requestParameters: SearchAccountSecretLocksRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns a paginated list of secret lock entries owned by the given account address, optionally filtered by secret.
      * Search secret lock entries by account
@@ -80,6 +207,10 @@ export declare class SecretLockRoutesApi extends runtime.BaseAPI {
      * Search secret lock entries by account
      */
     searchAccountSecretLocks(requestParameters: SearchAccountSecretLocksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SecretLockPage>;
+    /**
+     * Creates request options for searchSecretLock without sending the request
+     */
+    searchSecretLockRequestOpts(requestParameters: SearchSecretLockRequest): Promise<runtime.RequestOpts>;
     /**
      * Returns a paginated list of secret lock entries, optionally filtered by owner address and secret.
      * Search secret lock entries