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

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

@@ -18,30 +18,21 @@ import type { ReceiptTypeEnum } from './ReceiptTypeEnum';
 export interface MosaicExpiryReceiptDTO {
     /**
      * Version of the receipt format.
-     * @type {number}
-     * @memberof MosaicExpiryReceiptDTO
      */
     version: number;
     /**
      *
-     * @type {ReceiptTypeEnum}
-     * @memberof MosaicExpiryReceiptDTO
      */
     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 MosaicExpiryReceiptDTO
+     * Identifier of the expired mosaic.
      */
     artifactId: string;
 }
 /**
  * Check if a given object implements the MosaicExpiryReceiptDTO interface.
  */
-export declare function instanceOfMosaicExpiryReceiptDTO(value: Record<string, any>): value is MosaicExpiryReceiptDTO;
+export declare function instanceOfMosaicExpiryReceiptDTO(value: object): value is MosaicExpiryReceiptDTO;
 export declare function MosaicExpiryReceiptDTOFromJSON(json: any): MosaicExpiryReceiptDTO;
 export declare function MosaicExpiryReceiptDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MosaicExpiryReceiptDTO;
 export declare function MosaicExpiryReceiptDTOToJSON(json: any): MosaicExpiryReceiptDTO;

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

@@ -20,21 +20,17 @@ export interface MosaicGlobalRestrictionDTO {
      * 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 MosaicGlobalRestrictionDTO
      */
     id: string;
     /**
      *
-     * @type {MosaicGlobalRestrictionEntryWrapperDTO}
-     * @memberof MosaicGlobalRestrictionDTO
      */
     mosaicRestrictionEntry: MosaicGlobalRestrictionEntryWrapperDTO;
 }
 /**
  * Check if a given object implements the MosaicGlobalRestrictionDTO interface.
  */
-export declare function instanceOfMosaicGlobalRestrictionDTO(value: Record<string, any>): value is MosaicGlobalRestrictionDTO;
+export declare function instanceOfMosaicGlobalRestrictionDTO(value: object): value is MosaicGlobalRestrictionDTO;
 export declare function MosaicGlobalRestrictionDTOFromJSON(json: any): MosaicGlobalRestrictionDTO;
 export declare function MosaicGlobalRestrictionDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MosaicGlobalRestrictionDTO;
 export declare function MosaicGlobalRestrictionDTOToJSON(json: any): MosaicGlobalRestrictionDTO;

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

@@ -20,21 +20,17 @@ export interface MosaicGlobalRestrictionEntryDTO {
      * 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 MosaicGlobalRestrictionEntryDTO
      */
     key: string;
     /**
      *
-     * @type {MosaicGlobalRestrictionEntryRestrictionDTO}
-     * @memberof MosaicGlobalRestrictionEntryDTO
      */
     restriction: MosaicGlobalRestrictionEntryRestrictionDTO;
 }
 /**
  * Check if a given object implements the MosaicGlobalRestrictionEntryDTO interface.
  */
-export declare function instanceOfMosaicGlobalRestrictionEntryDTO(value: Record<string, any>): value is MosaicGlobalRestrictionEntryDTO;
+export declare function instanceOfMosaicGlobalRestrictionEntryDTO(value: object): value is MosaicGlobalRestrictionEntryDTO;
 export declare function MosaicGlobalRestrictionEntryDTOFromJSON(json: any): MosaicGlobalRestrictionEntryDTO;
 export declare function MosaicGlobalRestrictionEntryDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MosaicGlobalRestrictionEntryDTO;
 export declare function MosaicGlobalRestrictionEntryDTOToJSON(json: any): MosaicGlobalRestrictionEntryDTO;

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

@@ -17,12 +17,10 @@ import type { MosaicRestrictionTypeEnum } from './MosaicRestrictionTypeEnum';
  */
 export interface MosaicGlobalRestrictionEntryRestrictionDTO {
     /**
-     * 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.
+     * Mosaic identifier providing the restriction key used by this global restriction rule.
+     * The global restriction for the requested mosaic depends on the rule defined on this reference mosaic.
+     * This value is `0` when the restriction key is defined on the same mosaic.
      *
-     * @type {string}
-     * @memberof MosaicGlobalRestrictionEntryRestrictionDTO
      */
     referenceMosaicId: string;
     /**
@@ -30,21 +28,17 @@ export interface MosaicGlobalRestrictionEntryRestrictionDTO {
      * 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 MosaicGlobalRestrictionEntryRestrictionDTO
      */
     restrictionValue: string;
     /**
      *
-     * @type {MosaicRestrictionTypeEnum}
-     * @memberof MosaicGlobalRestrictionEntryRestrictionDTO
      */
     restrictionType: MosaicRestrictionTypeEnum;
 }
 /**
  * Check if a given object implements the MosaicGlobalRestrictionEntryRestrictionDTO interface.
  */
-export declare function instanceOfMosaicGlobalRestrictionEntryRestrictionDTO(value: Record<string, any>): value is MosaicGlobalRestrictionEntryRestrictionDTO;
+export declare function instanceOfMosaicGlobalRestrictionEntryRestrictionDTO(value: object): value is MosaicGlobalRestrictionEntryRestrictionDTO;
 export declare function MosaicGlobalRestrictionEntryRestrictionDTOFromJSON(json: any): MosaicGlobalRestrictionEntryRestrictionDTO;
 export declare function MosaicGlobalRestrictionEntryRestrictionDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MosaicGlobalRestrictionEntryRestrictionDTO;
 export declare function MosaicGlobalRestrictionEntryRestrictionDTOToJSON(json: any): MosaicGlobalRestrictionEntryRestrictionDTO;

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

@@ -22,42 +22,29 @@ export interface MosaicGlobalRestrictionEntryWrapperDTO {
      * schema of the entity changes (e.g. new fields are added), allowing the node to
      * deserialize entries written under earlier formats.
      *
-     * @type {number}
-     * @memberof MosaicGlobalRestrictionEntryWrapperDTO
      */
     version: number;
     /**
-     * 256-bit hash encoded as a 64-character hexadecimal string.
-     * @type {string}
-     * @memberof MosaicGlobalRestrictionEntryWrapperDTO
+     * Composite hash uniquely identifying the mosaic restriction entry.
      */
     compositeHash: string;
     /**
      *
-     * @type {MosaicRestrictionEntryTypeEnum}
-     * @memberof MosaicGlobalRestrictionEntryWrapperDTO
      */
     entryType: MosaicRestrictionEntryTypeEnum;
     /**
-     * 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 MosaicGlobalRestrictionEntryWrapperDTO
+     * Mosaic identifier for which the restrictions are defined.
      */
     mosaicId: string;
     /**
      * Global restriction rules associated with the mosaic.
-     * @type {Array<MosaicGlobalRestrictionEntryDTO>}
-     * @memberof MosaicGlobalRestrictionEntryWrapperDTO
      */
     restrictions: Array<MosaicGlobalRestrictionEntryDTO>;
 }
 /**
  * Check if a given object implements the MosaicGlobalRestrictionEntryWrapperDTO interface.
  */
-export declare function instanceOfMosaicGlobalRestrictionEntryWrapperDTO(value: Record<string, any>): value is MosaicGlobalRestrictionEntryWrapperDTO;
+export declare function instanceOfMosaicGlobalRestrictionEntryWrapperDTO(value: object): value is MosaicGlobalRestrictionEntryWrapperDTO;
 export declare function MosaicGlobalRestrictionEntryWrapperDTOFromJSON(json: any): MosaicGlobalRestrictionEntryWrapperDTO;
 export declare function MosaicGlobalRestrictionEntryWrapperDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MosaicGlobalRestrictionEntryWrapperDTO;
 export declare function MosaicGlobalRestrictionEntryWrapperDTOToJSON(json: any): MosaicGlobalRestrictionEntryWrapperDTO;

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

@@ -21,8 +21,6 @@ export interface MosaicGlobalRestrictionTransactionBodyDTO {
      * If the most significant bit of byte 0 is set, the value contains a namespace ID alias
      * instead of a concrete mosaic ID.
      *
-     * @type {string}
-     * @memberof MosaicGlobalRestrictionTransactionBodyDTO
      */
     mosaicId: string;
     /**
@@ -30,14 +28,10 @@ export interface MosaicGlobalRestrictionTransactionBodyDTO {
      * If the most significant bit of byte 0 is set, the value contains a namespace ID alias
      * instead of a concrete mosaic ID.
      *
-     * @type {string}
-     * @memberof MosaicGlobalRestrictionTransactionBodyDTO
      */
     referenceMosaicId: string;
     /**
      * Restriction key represented as a 64-bit hexadecimal value.
-     * @type {string}
-     * @memberof MosaicGlobalRestrictionTransactionBodyDTO
      */
     restrictionKey: string;
     /**
@@ -45,8 +39,6 @@ export interface MosaicGlobalRestrictionTransactionBodyDTO {
      * 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 MosaicGlobalRestrictionTransactionBodyDTO
      */
     previousRestrictionValue: string;
     /**
@@ -54,27 +46,21 @@ export interface MosaicGlobalRestrictionTransactionBodyDTO {
      * 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 MosaicGlobalRestrictionTransactionBodyDTO
      */
     newRestrictionValue: string;
     /**
      *
-     * @type {MosaicRestrictionTypeEnum}
-     * @memberof MosaicGlobalRestrictionTransactionBodyDTO
      */
     previousRestrictionType: MosaicRestrictionTypeEnum;
     /**
      *
-     * @type {MosaicRestrictionTypeEnum}
-     * @memberof MosaicGlobalRestrictionTransactionBodyDTO
      */
     newRestrictionType: MosaicRestrictionTypeEnum;
 }
 /**
  * Check if a given object implements the MosaicGlobalRestrictionTransactionBodyDTO interface.
  */
-export declare function instanceOfMosaicGlobalRestrictionTransactionBodyDTO(value: Record<string, any>): value is MosaicGlobalRestrictionTransactionBodyDTO;
+export declare function instanceOfMosaicGlobalRestrictionTransactionBodyDTO(value: object): value is MosaicGlobalRestrictionTransactionBodyDTO;
 export declare function MosaicGlobalRestrictionTransactionBodyDTOFromJSON(json: any): MosaicGlobalRestrictionTransactionBodyDTO;
 export declare function MosaicGlobalRestrictionTransactionBodyDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MosaicGlobalRestrictionTransactionBodyDTO;
 export declare function MosaicGlobalRestrictionTransactionBodyDTOToJSON(json: any): MosaicGlobalRestrictionTransactionBodyDTO;

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

@@ -18,11 +18,9 @@ import type { MosaicRestrictionTypeEnum } from './MosaicRestrictionTypeEnum';
  */
 export interface MosaicGlobalRestrictionTransactionDTO {
     /**
-     * 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 MosaicGlobalRestrictionTransactionDTO
      */
     size: number;
     /**
@@ -30,58 +28,32 @@ export interface MosaicGlobalRestrictionTransactionDTO {
      * over the serialized entity payload. Can be verified with the signer's public key (`signerPublicKey`).
      * Used for blocks, transactions, and cosignatures.
      *
-     * @type {string}
-     * @memberof MosaicGlobalRestrictionTransactionDTO
      */
     signature: string;
     /**
-     * 256-bit public key encoded as a hexadecimal string (64 hex characters).
-     * @type {string}
-     * @memberof MosaicGlobalRestrictionTransactionDTO
+     * 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 MosaicGlobalRestrictionTransactionDTO
      */
     version: number;
     /**
      * Network type (mainnet or testnet). Ensures the entity targets the correct network.
-     * @type {NetworkTypeEnum}
-     * @memberof MosaicGlobalRestrictionTransactionDTO
      */
     network: NetworkTypeEnum;
     /**
      * Entity type identifier (e.g. transaction type code, block type). Determines the entity schema.
-     * @type {number}
-     * @memberof MosaicGlobalRestrictionTransactionDTO
      */
     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 MosaicGlobalRestrictionTransactionDTO
+     * 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 MosaicGlobalRestrictionTransactionDTO
      */
     deadline: string;
     /**
@@ -89,8 +61,6 @@ export interface MosaicGlobalRestrictionTransactionDTO {
      * If the most significant bit of byte 0 is set, the value contains a namespace ID alias
      * instead of a concrete mosaic ID.
      *
-     * @type {string}
-     * @memberof MosaicGlobalRestrictionTransactionDTO
      */
     mosaicId: string;
     /**
@@ -98,14 +68,10 @@ export interface MosaicGlobalRestrictionTransactionDTO {
      * If the most significant bit of byte 0 is set, the value contains a namespace ID alias
      * instead of a concrete mosaic ID.
      *
-     * @type {string}
-     * @memberof MosaicGlobalRestrictionTransactionDTO
      */
     referenceMosaicId: string;
     /**
      * Restriction key represented as a 64-bit hexadecimal value.
-     * @type {string}
-     * @memberof MosaicGlobalRestrictionTransactionDTO
      */
     restrictionKey: string;
     /**
@@ -113,8 +79,6 @@ export interface MosaicGlobalRestrictionTransactionDTO {
      * 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 MosaicGlobalRestrictionTransactionDTO
      */
     previousRestrictionValue: string;
     /**
@@ -122,27 +86,21 @@ export interface MosaicGlobalRestrictionTransactionDTO {
      * 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 MosaicGlobalRestrictionTransactionDTO
      */
     newRestrictionValue: string;
     /**
      *
-     * @type {MosaicRestrictionTypeEnum}
-     * @memberof MosaicGlobalRestrictionTransactionDTO
      */
     previousRestrictionType: MosaicRestrictionTypeEnum;
     /**
      *
-     * @type {MosaicRestrictionTypeEnum}
-     * @memberof MosaicGlobalRestrictionTransactionDTO
      */
     newRestrictionType: MosaicRestrictionTypeEnum;
 }
 /**
  * Check if a given object implements the MosaicGlobalRestrictionTransactionDTO interface.
  */
-export declare function instanceOfMosaicGlobalRestrictionTransactionDTO(value: Record<string, any>): value is MosaicGlobalRestrictionTransactionDTO;
+export declare function instanceOfMosaicGlobalRestrictionTransactionDTO(value: object): value is MosaicGlobalRestrictionTransactionDTO;
 export declare function MosaicGlobalRestrictionTransactionDTOFromJSON(json: any): MosaicGlobalRestrictionTransactionDTO;
 export declare function MosaicGlobalRestrictionTransactionDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MosaicGlobalRestrictionTransactionDTO;
 export declare function MosaicGlobalRestrictionTransactionDTOToJSON(json: any): MosaicGlobalRestrictionTransactionDTO;

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

@@ -17,15 +17,13 @@
 export interface MosaicIds {
     /**
      * Array of mosaic identifiers.
-     * @type {Array<string>}
-     * @memberof MosaicIds
      */
     mosaicIds?: Array<string>;
 }
 /**
  * Check if a given object implements the MosaicIds interface.
  */
-export declare function instanceOfMosaicIds(value: Record<string, any>): value is MosaicIds;
+export declare function instanceOfMosaicIds(value: object): value is MosaicIds;
 export declare function MosaicIdsFromJSON(json: any): MosaicIds;
 export declare function MosaicIdsFromJSONTyped(json: any, ignoreDiscriminator: boolean): MosaicIds;
 export declare function MosaicIdsToJSON(json: any): MosaicIds;

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

@@ -20,21 +20,17 @@ export interface MosaicInfoDTO {
      * 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 MosaicInfoDTO
      */
     id: string;
     /**
      *
-     * @type {MosaicDTO}
-     * @memberof MosaicInfoDTO
      */
     mosaic: MosaicDTO;
 }
 /**
  * Check if a given object implements the MosaicInfoDTO interface.
  */
-export declare function instanceOfMosaicInfoDTO(value: Record<string, any>): value is MosaicInfoDTO;
+export declare function instanceOfMosaicInfoDTO(value: object): value is MosaicInfoDTO;
 export declare function MosaicInfoDTOFromJSON(json: any): MosaicInfoDTO;
 export declare function MosaicInfoDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MosaicInfoDTO;
 export declare function MosaicInfoDTOToJSON(json: any): MosaicInfoDTO;

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

@@ -22,14 +22,10 @@ export interface MosaicMetadataTransactionBodyDTO {
      * If bit 0 of byte 0 is not set, the value represents a regular address.
      * Otherwise, it represents a namespace ID alias encoded as an unresolved address.
      *
-     * @type {string}
-     * @memberof MosaicMetadataTransactionBodyDTO
      */
     targetAddress: string;
     /**
      * 64-bit key assigned by the metadata creator to identify the metadata entry within the source and target context.
-     * @type {string}
-     * @memberof MosaicMetadataTransactionBodyDTO
      */
     scopedMetadataKey: string;
     /**
@@ -37,16 +33,12 @@ export interface MosaicMetadataTransactionBodyDTO {
      * If the most significant bit of byte 0 is set, the value contains a namespace ID alias
      * instead of a concrete mosaic ID.
      *
-     * @type {string}
-     * @memberof MosaicMetadataTransactionBodyDTO
      */
     targetMosaicId: string;
     /**
      * Change in metadata value size, in bytes.
      * Positive values increase the stored value size, negative values decrease it.
      *
-     * @type {number}
-     * @memberof MosaicMetadataTransactionBodyDTO
      */
     valueSizeDelta: number;
     /**
@@ -55,8 +47,6 @@ export interface MosaicMetadataTransactionBodyDTO {
      * value size after applying the update. When the value shrinks, this is the previous stored value size
      * before truncation.
      *
-     * @type {number}
-     * @memberof MosaicMetadataTransactionBodyDTO
      */
     valueSize: number;
     /**
@@ -65,15 +55,13 @@ export interface MosaicMetadataTransactionBodyDTO {
      * 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 MosaicMetadataTransactionBodyDTO
      */
     value: string;
 }
 /**
  * Check if a given object implements the MosaicMetadataTransactionBodyDTO interface.
  */
-export declare function instanceOfMosaicMetadataTransactionBodyDTO(value: Record<string, any>): value is MosaicMetadataTransactionBodyDTO;
+export declare function instanceOfMosaicMetadataTransactionBodyDTO(value: object): value is MosaicMetadataTransactionBodyDTO;
 export declare function MosaicMetadataTransactionBodyDTOFromJSON(json: any): MosaicMetadataTransactionBodyDTO;
 export declare function MosaicMetadataTransactionBodyDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MosaicMetadataTransactionBodyDTO;
 export declare function MosaicMetadataTransactionBodyDTOToJSON(json: any): MosaicMetadataTransactionBodyDTO;

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

@@ -17,11 +17,9 @@ import type { NetworkTypeEnum } from './NetworkTypeEnum';
  */
 export interface MosaicMetadataTransactionDTO {
     /**
-     * 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 MosaicMetadataTransactionDTO
      */
     size: number;
     /**
@@ -29,58 +27,32 @@ export interface MosaicMetadataTransactionDTO {
      * over the serialized entity payload. Can be verified with the signer's public key (`signerPublicKey`).
      * Used for blocks, transactions, and cosignatures.
      *
-     * @type {string}
-     * @memberof MosaicMetadataTransactionDTO
      */
     signature: string;
     /**
-     * 256-bit public key encoded as a hexadecimal string (64 hex characters).
-     * @type {string}
-     * @memberof MosaicMetadataTransactionDTO
+     * 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 MosaicMetadataTransactionDTO
      */
     version: number;
     /**
      * Network type (mainnet or testnet). Ensures the entity targets the correct network.
-     * @type {NetworkTypeEnum}
-     * @memberof MosaicMetadataTransactionDTO
      */
     network: NetworkTypeEnum;
     /**
      * Entity type identifier (e.g. transaction type code, block type). Determines the entity schema.
-     * @type {number}
-     * @memberof MosaicMetadataTransactionDTO
      */
     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 MosaicMetadataTransactionDTO
+     * 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 MosaicMetadataTransactionDTO
      */
     deadline: string;
     /**
@@ -88,14 +60,10 @@ export interface MosaicMetadataTransactionDTO {
      * If bit 0 of byte 0 is not set, the value represents a regular address.
      * Otherwise, it represents a namespace ID alias encoded as an unresolved address.
      *
-     * @type {string}
-     * @memberof MosaicMetadataTransactionDTO
      */
     targetAddress: string;
     /**
      * 64-bit key assigned by the metadata creator to identify the metadata entry within the source and target context.
-     * @type {string}
-     * @memberof MosaicMetadataTransactionDTO
      */
     scopedMetadataKey: string;
     /**
@@ -103,16 +71,12 @@ export interface MosaicMetadataTransactionDTO {
      * If the most significant bit of byte 0 is set, the value contains a namespace ID alias
      * instead of a concrete mosaic ID.
      *
-     * @type {string}
-     * @memberof MosaicMetadataTransactionDTO
      */
     targetMosaicId: string;
     /**
      * Change in metadata value size, in bytes.
      * Positive values increase the stored value size, negative values decrease it.
      *
-     * @type {number}
-     * @memberof MosaicMetadataTransactionDTO
      */
     valueSizeDelta: number;
     /**
@@ -121,8 +85,6 @@ export interface MosaicMetadataTransactionDTO {
      * value size after applying the update. When the value shrinks, this is the previous stored value size
      * before truncation.
      *
-     * @type {number}
-     * @memberof MosaicMetadataTransactionDTO
      */
     valueSize: number;
     /**
@@ -131,15 +93,13 @@ export interface MosaicMetadataTransactionDTO {
      * 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 MosaicMetadataTransactionDTO
      */
     value: string;
 }
 /**
  * Check if a given object implements the MosaicMetadataTransactionDTO interface.
  */
-export declare function instanceOfMosaicMetadataTransactionDTO(value: Record<string, any>): value is MosaicMetadataTransactionDTO;
+export declare function instanceOfMosaicMetadataTransactionDTO(value: object): value is MosaicMetadataTransactionDTO;
 export declare function MosaicMetadataTransactionDTOFromJSON(json: any): MosaicMetadataTransactionDTO;
 export declare function MosaicMetadataTransactionDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MosaicMetadataTransactionDTO;
 export declare function MosaicMetadataTransactionDTOToJSON(json: any): MosaicMetadataTransactionDTO;

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

@@ -19,25 +19,18 @@
  */
 export interface MosaicNamesDTO {
     /**
-     * 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 MosaicNamesDTO
+     * Mosaic identifier for which namespace names were resolved.
      */
     mosaicId: string;
     /**
      * Namespace names currently linked to the mosaic identifier.
-     * @type {Array<string>}
-     * @memberof MosaicNamesDTO
      */
     names: Array<string>;
 }
 /**
  * Check if a given object implements the MosaicNamesDTO interface.
  */
-export declare function instanceOfMosaicNamesDTO(value: Record<string, any>): value is MosaicNamesDTO;
+export declare function instanceOfMosaicNamesDTO(value: object): value is MosaicNamesDTO;
 export declare function MosaicNamesDTOFromJSON(json: any): MosaicNamesDTO;
 export declare function MosaicNamesDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MosaicNamesDTO;
 export declare function MosaicNamesDTOToJSON(json: any): MosaicNamesDTO;