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

package/esm/api/models/InflationReceiptDTO.d.ts

@@ -18,40 +18,25 @@ import type { ReceiptTypeEnum } from './ReceiptTypeEnum';
 export interface InflationReceiptDTO {
     /**
      * Version of the receipt format.
-     * @type {number}
-     * @memberof InflationReceiptDTO
      */
     version: number;
     /**
      *
-     * @type {ReceiptTypeEnum}
-     * @memberof InflationReceiptDTO
      */
     type: ReceiptTypeEnum;
     /**
-     * Unique [mosaic](https://docs.symbol.dev/concepts/mosaic.html) identifier.
-     * A 64-bit unsigned integer derived from the creator's address and a registration nonce,
-     * encoded as a 16-character hexadecimal string.
-     *
-     * @type {string}
-     * @memberof InflationReceiptDTO
+     * Identifier of the network currency mosaic created by inflation.
      */
     mosaicId: string;
     /**
-     * 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 InflationReceiptDTO
+     * Amount of mosaic units created by inflation, expressed in the mosaic's smallest (atomic) unit.
      */
     amount: string;
 }
 /**
  * Check if a given object implements the InflationReceiptDTO interface.
  */
-export declare function instanceOfInflationReceiptDTO(value: Record<string, any>): value is InflationReceiptDTO;
+export declare function instanceOfInflationReceiptDTO(value: object): value is InflationReceiptDTO;
 export declare function InflationReceiptDTOFromJSON(json: any): InflationReceiptDTO;
 export declare function InflationReceiptDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): InflationReceiptDTO;
 export declare function InflationReceiptDTOToJSON(json: any): InflationReceiptDTO;

package/esm/api/models/LinkActionEnum.js

@@ -20,7 +20,7 @@
  */
 export const LinkActionEnum = {
     NUMBER_0: 0,
-    NUMBER_1: 1
+    NUMBER_1: 1,
 };
 export function instanceOfLinkActionEnum(value) {
     for (const key in LinkActionEnum) {

package/esm/api/models/LockHashAlgorithmEnum.js

@@ -22,7 +22,7 @@
 export const LockHashAlgorithmEnum = {
     NUMBER_0: 0,
     NUMBER_1: 1,
-    NUMBER_2: 2
+    NUMBER_2: 2,
 };
 export function instanceOfLockHashAlgorithmEnum(value) {
     for (const key in LockHashAlgorithmEnum) {

package/esm/api/models/LockStatus.js

@@ -20,7 +20,7 @@
  */
 export const LockStatus = {
     NUMBER_0: 0,
-    NUMBER_1: 1
+    NUMBER_1: 1,
 };
 export function instanceOfLockStatus(value) {
     for (const key in LockStatus) {

package/esm/api/models/MerklePathItemDTO.d.ts

@@ -20,21 +20,17 @@ import type { PositionEnum } from './PositionEnum';
 export interface MerklePathItemDTO {
     /**
      *
-     * @type {PositionEnum}
-     * @memberof MerklePathItemDTO
      */
     position?: PositionEnum;
     /**
-     * 256-bit hash encoded as a 64-character hexadecimal string.
-     * @type {string}
-     * @memberof MerklePathItemDTO
+     * Sibling node hash used when recalculating the Merkle root.
      */
     hash?: string;
 }
 /**
  * Check if a given object implements the MerklePathItemDTO interface.
  */
-export declare function instanceOfMerklePathItemDTO(value: Record<string, any>): value is MerklePathItemDTO;
+export declare function instanceOfMerklePathItemDTO(value: object): value is MerklePathItemDTO;
 export declare function MerklePathItemDTOFromJSON(json: any): MerklePathItemDTO;
 export declare function MerklePathItemDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MerklePathItemDTO;
 export declare function MerklePathItemDTOToJSON(json: any): MerklePathItemDTO;

package/esm/api/models/MerkleProofInfoDTO.d.ts

@@ -18,15 +18,13 @@ import type { MerklePathItemDTO } from './MerklePathItemDTO';
 export interface MerkleProofInfoDTO {
     /**
      * List of complementary Merkle path items needed to recalculate the Merkle root.
-     * @type {Array<MerklePathItemDTO>}
-     * @memberof MerkleProofInfoDTO
      */
     merklePath?: Array<MerklePathItemDTO>;
 }
 /**
  * Check if a given object implements the MerkleProofInfoDTO interface.
  */
-export declare function instanceOfMerkleProofInfoDTO(value: Record<string, any>): value is MerkleProofInfoDTO;
+export declare function instanceOfMerkleProofInfoDTO(value: object): value is MerkleProofInfoDTO;
 export declare function MerkleProofInfoDTOFromJSON(json: any): MerkleProofInfoDTO;
 export declare function MerkleProofInfoDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MerkleProofInfoDTO;
 export declare function MerkleProofInfoDTOToJSON(json: any): MerkleProofInfoDTO;

package/esm/api/models/MerkleStateInfoDTO.d.ts

@@ -24,21 +24,17 @@ export interface MerkleStateInfoDTO {
      * See [Symbol Technical Reference](https://symbol.github.io/symbol-technicalref/main.pdf)
      * chapter 4.3 for the tree structure specification.
      *
-     * @type {string}
-     * @memberof MerkleStateInfoDTO
      */
     raw: string;
     /**
      * Merkle tree parsed from Merkle tree raw.
-     * @type {Array<MerkleStateInfoDTOTreeInner>}
-     * @memberof MerkleStateInfoDTO
      */
     tree: Array<MerkleStateInfoDTOTreeInner>;
 }
 /**
  * Check if a given object implements the MerkleStateInfoDTO interface.
  */
-export declare function instanceOfMerkleStateInfoDTO(value: Record<string, any>): value is MerkleStateInfoDTO;
+export declare function instanceOfMerkleStateInfoDTO(value: object): value is MerkleStateInfoDTO;
 export declare function MerkleStateInfoDTOFromJSON(json: any): MerkleStateInfoDTO;
 export declare function MerkleStateInfoDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MerkleStateInfoDTO;
 export declare function MerkleStateInfoDTOToJSON(json: any): MerkleStateInfoDTO;

package/esm/api/models/MerkleStateInfoDTOTreeInner.d.ts

@@ -19,63 +19,45 @@ import type { MerkleTreeNodeTypeEnum } from './MerkleTreeNodeTypeEnum';
 export interface MerkleStateInfoDTOTreeInner {
     /**
      * Node type (always leaf).
-     * @type {MerkleTreeNodeTypeEnum}
-     * @memberof MerkleStateInfoDTOTreeInner
      */
     type: MerkleTreeNodeTypeEnum;
     /**
      * Full path (hex) from root to this leaf.
-     * @type {string}
-     * @memberof MerkleStateInfoDTOTreeInner
      */
     path: string;
     /**
      * Compact-encoded path.
-     * @type {string}
-     * @memberof MerkleStateInfoDTOTreeInner
      */
     encodedPath: string;
     /**
      * Number of nibbles in the path.
-     * @type {number}
-     * @memberof MerkleStateInfoDTOTreeInner
      */
     nibbleCount: number;
     /**
      * Bitmask indicating which nibble slots (0 to 15) have child links.
-     * @type {string}
-     * @memberof MerkleStateInfoDTOTreeInner
      */
     linkMask: string;
     /**
      * Child links (max 16, one per nibble).
-     * @type {Array<MerkleTreeBranchLinkDTO>}
-     * @memberof MerkleStateInfoDTOTreeInner
      */
     links: Array<MerkleTreeBranchLinkDTO>;
     /**
-     * 256-bit hash encoded as a 64-character hexadecimal string.
-     * @type {string}
-     * @memberof MerkleStateInfoDTOTreeInner
+     * Hash of the branch node.
      */
     branchHash: string;
     /**
      * Leaf value (SHA3-256 hash of the entity state).
-     * @type {string}
-     * @memberof MerkleStateInfoDTOTreeInner
      */
     value: string;
     /**
-     * 256-bit hash encoded as a 64-character hexadecimal string.
-     * @type {string}
-     * @memberof MerkleStateInfoDTOTreeInner
+     * Hash of the leaf node.
      */
     leafHash: string;
 }
 /**
  * Check if a given object implements the MerkleStateInfoDTOTreeInner interface.
  */
-export declare function instanceOfMerkleStateInfoDTOTreeInner(value: Record<string, any>): value is MerkleStateInfoDTOTreeInner;
+export declare function instanceOfMerkleStateInfoDTOTreeInner(value: object): value is MerkleStateInfoDTOTreeInner;
 export declare function MerkleStateInfoDTOTreeInnerFromJSON(json: any): MerkleStateInfoDTOTreeInner;
 export declare function MerkleStateInfoDTOTreeInnerFromJSONTyped(json: any, ignoreDiscriminator: boolean): MerkleStateInfoDTOTreeInner;
 export declare function MerkleStateInfoDTOTreeInnerToJSON(json: any): MerkleStateInfoDTOTreeInner;

package/esm/api/models/MerkleTreeBranchDTO.d.ts

@@ -21,51 +21,37 @@ import type { MerkleTreeNodeTypeEnum } from './MerkleTreeNodeTypeEnum';
 export interface MerkleTreeBranchDTO {
     /**
      * Node type (always branch).
-     * @type {MerkleTreeNodeTypeEnum}
-     * @memberof MerkleTreeBranchDTO
      */
     type: MerkleTreeNodeTypeEnum;
     /**
      * Path prefix (hex) from root to this branch.
-     * @type {string}
-     * @memberof MerkleTreeBranchDTO
      */
     path: string;
     /**
      * Compact-encoded path.
-     * @type {string}
-     * @memberof MerkleTreeBranchDTO
      */
     encodedPath: string;
     /**
      * Number of nibbles in the path.
-     * @type {number}
-     * @memberof MerkleTreeBranchDTO
      */
     nibbleCount: number;
     /**
      * Bitmask indicating which nibble slots (0 to 15) have child links.
-     * @type {string}
-     * @memberof MerkleTreeBranchDTO
      */
     linkMask: string;
     /**
      * Child links (max 16, one per nibble).
-     * @type {Array<MerkleTreeBranchLinkDTO>}
-     * @memberof MerkleTreeBranchDTO
      */
     links: Array<MerkleTreeBranchLinkDTO>;
     /**
-     * 256-bit hash encoded as a 64-character hexadecimal string.
-     * @type {string}
-     * @memberof MerkleTreeBranchDTO
+     * Hash of the branch node.
      */
     branchHash: string;
 }
 /**
  * Check if a given object implements the MerkleTreeBranchDTO interface.
  */
-export declare function instanceOfMerkleTreeBranchDTO(value: Record<string, any>): value is MerkleTreeBranchDTO;
+export declare function instanceOfMerkleTreeBranchDTO(value: object): value is MerkleTreeBranchDTO;
 export declare function MerkleTreeBranchDTOFromJSON(json: any): MerkleTreeBranchDTO;
 export declare function MerkleTreeBranchDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MerkleTreeBranchDTO;
 export declare function MerkleTreeBranchDTOToJSON(json: any): MerkleTreeBranchDTO;

package/esm/api/models/MerkleTreeBranchLinkDTO.d.ts

@@ -19,21 +19,17 @@
 export interface MerkleTreeBranchLinkDTO {
     /**
      * Nibble index (0 to 15) identifying this child slot (hex).
-     * @type {string}
-     * @memberof MerkleTreeBranchLinkDTO
      */
     bit: string;
     /**
-     * 256-bit hash encoded as a 64-character hexadecimal string.
-     * @type {string}
-     * @memberof MerkleTreeBranchLinkDTO
+     * Hash of the child node.
      */
     link: string;
 }
 /**
  * Check if a given object implements the MerkleTreeBranchLinkDTO interface.
  */
-export declare function instanceOfMerkleTreeBranchLinkDTO(value: Record<string, any>): value is MerkleTreeBranchLinkDTO;
+export declare function instanceOfMerkleTreeBranchLinkDTO(value: object): value is MerkleTreeBranchLinkDTO;
 export declare function MerkleTreeBranchLinkDTOFromJSON(json: any): MerkleTreeBranchLinkDTO;
 export declare function MerkleTreeBranchLinkDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MerkleTreeBranchLinkDTO;
 export declare function MerkleTreeBranchLinkDTOToJSON(json: any): MerkleTreeBranchLinkDTO;

package/esm/api/models/MerkleTreeLeafDTO.d.ts

@@ -20,45 +20,33 @@ import type { MerkleTreeNodeTypeEnum } from './MerkleTreeNodeTypeEnum';
 export interface MerkleTreeLeafDTO {
     /**
      * Node type (always leaf).
-     * @type {MerkleTreeNodeTypeEnum}
-     * @memberof MerkleTreeLeafDTO
      */
     type: MerkleTreeNodeTypeEnum;
     /**
      * Full path (hex) from root to this leaf.
-     * @type {string}
-     * @memberof MerkleTreeLeafDTO
      */
     path: string;
     /**
      * Compact-encoded path.
-     * @type {string}
-     * @memberof MerkleTreeLeafDTO
      */
     encodedPath: string;
     /**
      * Number of nibbles in the path.
-     * @type {number}
-     * @memberof MerkleTreeLeafDTO
      */
     nibbleCount: number;
     /**
      * Leaf value (SHA3-256 hash of the entity state).
-     * @type {string}
-     * @memberof MerkleTreeLeafDTO
      */
     value: string;
     /**
-     * 256-bit hash encoded as a 64-character hexadecimal string.
-     * @type {string}
-     * @memberof MerkleTreeLeafDTO
+     * Hash of the leaf node.
      */
     leafHash: string;
 }
 /**
  * Check if a given object implements the MerkleTreeLeafDTO interface.
  */
-export declare function instanceOfMerkleTreeLeafDTO(value: Record<string, any>): value is MerkleTreeLeafDTO;
+export declare function instanceOfMerkleTreeLeafDTO(value: object): value is MerkleTreeLeafDTO;
 export declare function MerkleTreeLeafDTOFromJSON(json: any): MerkleTreeLeafDTO;
 export declare function MerkleTreeLeafDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MerkleTreeLeafDTO;
 export declare function MerkleTreeLeafDTOToJSON(json: any): MerkleTreeLeafDTO;

package/esm/api/models/MerkleTreeNodeTypeEnum.js

@@ -21,7 +21,7 @@
  */
 export const MerkleTreeNodeTypeEnum = {
     NUMBER_0: 0,
-    NUMBER_255: 255
+    NUMBER_255: 255,
 };
 export function instanceOfMerkleTreeNodeTypeEnum(value) {
     for (const key in MerkleTreeNodeTypeEnum) {

package/esm/api/models/MessageGroup.d.ts

@@ -19,39 +19,29 @@ import type { StageEnum } from './StageEnum';
 export interface MessageGroup {
     /**
      * Finalization stage (prevote, precommit, or count).
-     * @type {StageEnum}
-     * @memberof MessageGroup
      */
     stage: StageEnum;
     /**
-     * Height of a block in the blockchain. Starts at 1 and increments by one per block.
-     * Represented as a string to preserve precision, since the value is an unsigned 64-bit integer.
-     *
-     * @type {string}
-     * @memberof MessageGroup
+     * Block height corresponding to the first hash.
      */
     height: string;
     /**
      * Block hashes voted for at this stage. Ordered by height; the first hash corresponds to `height`,
      * subsequent hashes to consecutive block heights.
      *
-     * @type {Array<string>}
-     * @memberof MessageGroup
      */
     hashes: Array<string>;
     /**
      * BLS aggregate signatures from the finalizer set attesting to the votes.
      * Each entry contains `root` and `bottom` of the Bm tree.
      *
-     * @type {Array<BmTreeSignature>}
-     * @memberof MessageGroup
      */
     signatures: Array<BmTreeSignature>;
 }
 /**
  * Check if a given object implements the MessageGroup interface.
  */
-export declare function instanceOfMessageGroup(value: Record<string, any>): value is MessageGroup;
+export declare function instanceOfMessageGroup(value: object): value is MessageGroup;
 export declare function MessageGroupFromJSON(json: any): MessageGroup;
 export declare function MessageGroupFromJSONTyped(json: any, ignoreDiscriminator: boolean): MessageGroup;
 export declare function MessageGroupToJSON(json: any): MessageGroup;

package/esm/api/models/MetadataEntryDTO.d.ts

@@ -22,48 +22,34 @@ export interface MetadataEntryDTO {
      * schema of the entity changes (e.g. new fields are added), allowing the node to
      * deserialize entries written under earlier formats.
      *
-     * @type {number}
-     * @memberof MetadataEntryDTO
      */
     version: number;
     /**
-     * 256-bit hash encoded as a 64-character hexadecimal string.
-     * @type {string}
-     * @memberof MetadataEntryDTO
+     * Composite hash derived from sourceAddress, targetAddress, scopedMetadataKey, targetId, and metadataType.
+     * It uniquely identifies the metadata entry.
+     *
      */
     compositeHash: string;
     /**
-     * Address encoded as a 48-character hexadecimal string (24 bytes).
-     * The REST API returns addresses in this format. For Base32-encoded addresses (39 chars) see `Address`.
-     *
-     * @type {string}
-     * @memberof MetadataEntryDTO
+     * Hex-encoded address of the account that created the metadata entry.
      */
     sourceAddress: string;
     /**
-     * Address encoded as a 48-character hexadecimal string (24 bytes).
-     * The REST API returns addresses in this format. For Base32-encoded addresses (39 chars) see `Address`.
+     * Hex-encoded address of the target account.
+     * For mosaic metadata and namespace metadata, this is the address of the resource owner.
      *
-     * @type {string}
-     * @memberof MetadataEntryDTO
      */
     targetAddress: string;
     /**
      * 64-bit key assigned by the metadata creator to identify the metadata entry within the source and target context.
-     * @type {string}
-     * @memberof MetadataEntryDTO
      */
     scopedMetadataKey: string;
     /**
      *
-     * @type {MetadataEntryDTOTargetId}
-     * @memberof MetadataEntryDTO
      */
     targetId?: MetadataEntryDTOTargetId;
     /**
      *
-     * @type {MetadataTypeEnum}
-     * @memberof MetadataEntryDTO
      */
     metadataType: MetadataTypeEnum;
     /**
@@ -72,8 +58,6 @@ export interface MetadataEntryDTO {
      * value size after applying the update. When the value shrinks, this is the previous stored value size
      * before truncation.
      *
-     * @type {number}
-     * @memberof MetadataEntryDTO
      */
     valueSize: number;
     /**
@@ -82,15 +66,13 @@ export interface MetadataEntryDTO {
      * When no previous value exists, it contains the new value.
      * When updating existing metadata, it contains the byte-wise XOR of the previous value and the new value.
      *
-     * @type {string}
-     * @memberof MetadataEntryDTO
      */
     value: string;
 }
 /**
  * Check if a given object implements the MetadataEntryDTO interface.
  */
-export declare function instanceOfMetadataEntryDTO(value: Record<string, any>): value is MetadataEntryDTO;
+export declare function instanceOfMetadataEntryDTO(value: object): value is MetadataEntryDTO;
 export declare function MetadataEntryDTOFromJSON(json: any): MetadataEntryDTO;
 export declare function MetadataEntryDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MetadataEntryDTO;
 export declare function MetadataEntryDTOToJSON(json: any): MetadataEntryDTO;

package/esm/api/models/MetadataEntryDTOTargetId.d.ts

@@ -19,7 +19,7 @@ export interface MetadataEntryDTOTargetId {
 /**
  * Check if a given object implements the MetadataEntryDTOTargetId interface.
  */
-export declare function instanceOfMetadataEntryDTOTargetId(value: Record<string, any>): value is MetadataEntryDTOTargetId;
+export declare function instanceOfMetadataEntryDTOTargetId(value: object): value is MetadataEntryDTOTargetId;
 export declare function MetadataEntryDTOTargetIdFromJSON(json: any): MetadataEntryDTOTargetId;
 export declare function MetadataEntryDTOTargetIdFromJSONTyped(json: any, ignoreDiscriminator: boolean): MetadataEntryDTOTargetId;
 export declare function MetadataEntryDTOTargetIdToJSON(json: any): MetadataEntryDTOTargetId;

package/esm/api/models/MetadataInfoDTO.d.ts

@@ -20,21 +20,17 @@ export interface MetadataInfoDTO {
      * Unique identifier of the object in the node's database (MongoDB ObjectId).
      * Used as the `offset` parameter value for cursor-based pagination.
      *
-     * @type {string}
-     * @memberof MetadataInfoDTO
      */
     id: string;
     /**
      *
-     * @type {MetadataEntryDTO}
-     * @memberof MetadataInfoDTO
      */
     metadataEntry: MetadataEntryDTO;
 }
 /**
  * Check if a given object implements the MetadataInfoDTO interface.
  */
-export declare function instanceOfMetadataInfoDTO(value: Record<string, any>): value is MetadataInfoDTO;
+export declare function instanceOfMetadataInfoDTO(value: object): value is MetadataInfoDTO;
 export declare function MetadataInfoDTOFromJSON(json: any): MetadataInfoDTO;
 export declare function MetadataInfoDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MetadataInfoDTO;
 export declare function MetadataInfoDTOToJSON(json: any): MetadataInfoDTO;

package/esm/api/models/MetadataNetworkPropertiesDTO.d.ts

@@ -17,15 +17,13 @@
 export interface MetadataNetworkPropertiesDTO {
     /**
      * Maximum metadata value size.
-     * @type {string}
-     * @memberof MetadataNetworkPropertiesDTO
      */
     maxValueSize?: string;
 }
 /**
  * Check if a given object implements the MetadataNetworkPropertiesDTO interface.
  */
-export declare function instanceOfMetadataNetworkPropertiesDTO(value: Record<string, any>): value is MetadataNetworkPropertiesDTO;
+export declare function instanceOfMetadataNetworkPropertiesDTO(value: object): value is MetadataNetworkPropertiesDTO;
 export declare function MetadataNetworkPropertiesDTOFromJSON(json: any): MetadataNetworkPropertiesDTO;
 export declare function MetadataNetworkPropertiesDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MetadataNetworkPropertiesDTO;
 export declare function MetadataNetworkPropertiesDTOToJSON(json: any): MetadataNetworkPropertiesDTO;

package/esm/api/models/MetadataPage.d.ts

@@ -19,21 +19,17 @@ import type { MetadataInfoDTO } from './MetadataInfoDTO';
 export interface MetadataPage {
     /**
      * Array of metadata entries.
-     * @type {Array<MetadataInfoDTO>}
-     * @memberof MetadataPage
      */
     data: Array<MetadataInfoDTO>;
     /**
      *
-     * @type {Pagination}
-     * @memberof MetadataPage
      */
     pagination: Pagination;
 }
 /**
  * Check if a given object implements the MetadataPage interface.
  */
-export declare function instanceOfMetadataPage(value: Record<string, any>): value is MetadataPage;
+export declare function instanceOfMetadataPage(value: object): value is MetadataPage;
 export declare function MetadataPageFromJSON(json: any): MetadataPage;
 export declare function MetadataPageFromJSONTyped(json: any, ignoreDiscriminator: boolean): MetadataPage;
 export declare function MetadataPageToJSON(json: any): MetadataPage;

package/esm/api/models/MetadataTypeEnum.js

@@ -22,7 +22,7 @@
 export const MetadataTypeEnum = {
     NUMBER_0: 0,
     NUMBER_1: 1,
-    NUMBER_2: 2
+    NUMBER_2: 2,
 };
 export function instanceOfMetadataTypeEnum(value) {
     for (const key in MetadataTypeEnum) {

package/esm/api/models/ModelError.d.ts

@@ -23,21 +23,17 @@ export interface ModelError {
      * - `ResourceNotFound`: requested resource does not exist (HTTP 404).
      * - `InvalidArgument`: required arguments missing or unacceptable (HTTP 409).
      *
-     * @type {string}
-     * @memberof ModelError
      */
     code: string;
     /**
      * Human-readable error description. May include the invalid value or resource identifier.
-     * @type {string}
-     * @memberof ModelError
      */
     message: string;
 }
 /**
  * Check if a given object implements the ModelError interface.
  */
-export declare function instanceOfModelError(value: Record<string, any>): value is ModelError;
+export declare function instanceOfModelError(value: object): value is ModelError;
 export declare function ModelErrorFromJSON(json: any): ModelError;
 export declare function ModelErrorFromJSONTyped(json: any, ignoreDiscriminator: boolean): ModelError;
 export declare function ModelErrorToJSON(json: any): ModelError;

package/esm/api/models/Mosaic.d.ts

@@ -24,8 +24,6 @@ export interface Mosaic {
      * A 64-bit unsigned integer derived from the creator's address and a registration nonce,
      * encoded as a 16-character hexadecimal string.
      *
-     * @type {string}
-     * @memberof Mosaic
      */
     id: string;
     /**
@@ -34,15 +32,13 @@ export interface Mosaic {
      * `123.456789` whole units. Encoded as a string to preserve precision, since the value
      * is an unsigned 64-bit integer.
      *
-     * @type {string}
-     * @memberof Mosaic
      */
     amount: string;
 }
 /**
  * Check if a given object implements the Mosaic interface.
  */
-export declare function instanceOfMosaic(value: Record<string, any>): value is Mosaic;
+export declare function instanceOfMosaic(value: object): value is Mosaic;
 export declare function MosaicFromJSON(json: any): Mosaic;
 export declare function MosaicFromJSONTyped(json: any, ignoreDiscriminator: boolean): Mosaic;
 export declare function MosaicToJSON(json: any): Mosaic;

package/esm/api/models/MosaicAddressRestrictionDTO.d.ts

@@ -20,21 +20,17 @@ export interface MosaicAddressRestrictionDTO {
      * Unique identifier of the object in the node's database (MongoDB ObjectId).
      * Used as the `offset` parameter value for cursor-based pagination.
      *
-     * @type {string}
-     * @memberof MosaicAddressRestrictionDTO
      */
     id: string;
     /**
      *
-     * @type {MosaicAddressRestrictionEntryWrapperDTO}
-     * @memberof MosaicAddressRestrictionDTO
      */
     mosaicRestrictionEntry: MosaicAddressRestrictionEntryWrapperDTO;
 }
 /**
  * Check if a given object implements the MosaicAddressRestrictionDTO interface.
  */
-export declare function instanceOfMosaicAddressRestrictionDTO(value: Record<string, any>): value is MosaicAddressRestrictionDTO;
+export declare function instanceOfMosaicAddressRestrictionDTO(value: object): value is MosaicAddressRestrictionDTO;
 export declare function MosaicAddressRestrictionDTOFromJSON(json: any): MosaicAddressRestrictionDTO;
 export declare function MosaicAddressRestrictionDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MosaicAddressRestrictionDTO;
 export declare function MosaicAddressRestrictionDTOToJSON(json: any): MosaicAddressRestrictionDTO;

package/esm/api/models/MosaicAddressRestrictionEntryDTO.d.ts

@@ -19,8 +19,6 @@ export interface MosaicAddressRestrictionEntryDTO {
      * Creator-defined 64-bit numeric identifier of a mosaic restriction, scoped to a mosaic.
      * It can be derived from a human-readable name by hashing it, and is represented as a decimal string in stored restriction entries.
      *
-     * @type {string}
-     * @memberof MosaicAddressRestrictionEntryDTO
      */
     key: string;
     /**
@@ -28,15 +26,13 @@ export interface MosaicAddressRestrictionEntryDTO {
      * For address restrictions, it is the value assigned to the target address;
      * for global restrictions, it is the threshold evaluated with the restriction type.
      *
-     * @type {string}
-     * @memberof MosaicAddressRestrictionEntryDTO
      */
     value: string;
 }
 /**
  * Check if a given object implements the MosaicAddressRestrictionEntryDTO interface.
  */
-export declare function instanceOfMosaicAddressRestrictionEntryDTO(value: Record<string, any>): value is MosaicAddressRestrictionEntryDTO;
+export declare function instanceOfMosaicAddressRestrictionEntryDTO(value: object): value is MosaicAddressRestrictionEntryDTO;
 export declare function MosaicAddressRestrictionEntryDTOFromJSON(json: any): MosaicAddressRestrictionEntryDTO;
 export declare function MosaicAddressRestrictionEntryDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MosaicAddressRestrictionEntryDTO;
 export declare function MosaicAddressRestrictionEntryDTOToJSON(json: any): MosaicAddressRestrictionEntryDTO;