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

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

@@ -19,57 +19,35 @@
 export interface MosaicNetworkPropertiesDTO {
     /**
      * Maximum number of mosaics that an account can own.
-     * @type {string}
-     * @memberof MosaicNetworkPropertiesDTO
      */
     maxMosaicsPerAccount?: string;
     /**
      * Maximum mosaic duration (BlockSpan format, e.g. `3650d` for 3650 days).
-     * @type {string}
-     * @memberof MosaicNetworkPropertiesDTO
      */
     maxMosaicDuration?: string;
     /**
      * Maximum mosaic divisibility.
-     * @type {string}
-     * @memberof MosaicNetworkPropertiesDTO
      */
     maxMosaicDivisibility?: string;
     /**
-     * Represents a unique account address in Base32 format. The first character indicates the network
-     * (`T` for testnet, `N` for mainnet). Addresses are 39 characters long, Base32-encoded,
-     * and include an embedded 3-byte checksum. The node validates this checksum, so an address
-     * with even a single altered character will be rejected.
+     * Legacy address (in Base32 format) of the mosaic rental fee sink.
+     * Used before treasury reissuance fork. May be absent on newer networks.
      *
-     * @type {string}
-     * @memberof MosaicNetworkPropertiesDTO
      */
     mosaicRentalFeeSinkAddressV1?: string;
     /**
-     * Represents a unique account address in Base32 format. The first character indicates the network
-     * (`T` for testnet, `N` for mainnet). Addresses are 39 characters long, Base32-encoded,
-     * and include an embedded 3-byte checksum. The node validates this checksum, so an address
-     * with even a single altered character will be rejected.
-     *
-     * @type {string}
-     * @memberof MosaicNetworkPropertiesDTO
+     * Address of the mosaic rental fee sink account (receives fees for mosaic creation).
      */
     mosaicRentalFeeSinkAddress?: 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 MosaicNetworkPropertiesDTO
+     * Mosaic rental fee in atomic units (paid to create a new mosaic).
      */
     mosaicRentalFee?: string;
 }
 /**
  * Check if a given object implements the MosaicNetworkPropertiesDTO interface.
  */
-export declare function instanceOfMosaicNetworkPropertiesDTO(value: Record<string, any>): value is MosaicNetworkPropertiesDTO;
+export declare function instanceOfMosaicNetworkPropertiesDTO(value: object): value is MosaicNetworkPropertiesDTO;
 export declare function MosaicNetworkPropertiesDTOFromJSON(json: any): MosaicNetworkPropertiesDTO;
 export declare function MosaicNetworkPropertiesDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MosaicNetworkPropertiesDTO;
 export declare function MosaicNetworkPropertiesDTOToJSON(json: any): MosaicNetworkPropertiesDTO;

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

@@ -19,21 +19,17 @@ import type { MosaicInfoDTO } from './MosaicInfoDTO';
 export interface MosaicPage {
     /**
      * Array of mosaic information objects.
-     * @type {Array<MosaicInfoDTO>}
-     * @memberof MosaicPage
      */
     data: Array<MosaicInfoDTO>;
     /**
      *
-     * @type {Pagination}
-     * @memberof MosaicPage
      */
     pagination: Pagination;
 }
 /**
  * Check if a given object implements the MosaicPage interface.
  */
-export declare function instanceOfMosaicPage(value: Record<string, any>): value is MosaicPage;
+export declare function instanceOfMosaicPage(value: object): value is MosaicPage;
 export declare function MosaicPageFromJSON(json: any): MosaicPage;
 export declare function MosaicPageFromJSONTyped(json: any, ignoreDiscriminator: boolean): MosaicPage;
 export declare function MosaicPageToJSON(json: any): MosaicPage;

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

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

package/esm/api/models/MosaicRestrictionEntryTypeEnum.js

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

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

@@ -17,15 +17,13 @@
 export interface MosaicRestrictionNetworkPropertiesDTO {
     /**
      * Maximum number of mosaic restriction values.
-     * @type {string}
-     * @memberof MosaicRestrictionNetworkPropertiesDTO
      */
     maxMosaicRestrictionValues?: string;
 }
 /**
  * Check if a given object implements the MosaicRestrictionNetworkPropertiesDTO interface.
  */
-export declare function instanceOfMosaicRestrictionNetworkPropertiesDTO(value: Record<string, any>): value is MosaicRestrictionNetworkPropertiesDTO;
+export declare function instanceOfMosaicRestrictionNetworkPropertiesDTO(value: object): value is MosaicRestrictionNetworkPropertiesDTO;
 export declare function MosaicRestrictionNetworkPropertiesDTOFromJSON(json: any): MosaicRestrictionNetworkPropertiesDTO;
 export declare function MosaicRestrictionNetworkPropertiesDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MosaicRestrictionNetworkPropertiesDTO;
 export declare function MosaicRestrictionNetworkPropertiesDTOToJSON(json: any): MosaicRestrictionNetworkPropertiesDTO;

package/esm/api/models/MosaicRestrictionTypeEnum.js

@@ -30,7 +30,7 @@ export const MosaicRestrictionTypeEnum = {
     NUMBER_3: 3,
     NUMBER_4: 4,
     NUMBER_5: 5,
-    NUMBER_6: 6
+    NUMBER_6: 6,
 };
 export function instanceOfMosaicRestrictionTypeEnum(value) {
     for (const key in MosaicRestrictionTypeEnum) {

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

@@ -19,21 +19,17 @@ import type { Pagination } from './Pagination';
 export interface MosaicRestrictionsPage {
     /**
      * Array of mosaic restrictions.
-     * @type {Array<MosaicRestrictionsPageDataInner>}
-     * @memberof MosaicRestrictionsPage
      */
     data: Array<MosaicRestrictionsPageDataInner>;
     /**
      *
-     * @type {Pagination}
-     * @memberof MosaicRestrictionsPage
      */
     pagination: Pagination;
 }
 /**
  * Check if a given object implements the MosaicRestrictionsPage interface.
  */
-export declare function instanceOfMosaicRestrictionsPage(value: Record<string, any>): value is MosaicRestrictionsPage;
+export declare function instanceOfMosaicRestrictionsPage(value: object): value is MosaicRestrictionsPage;
 export declare function MosaicRestrictionsPageFromJSON(json: any): MosaicRestrictionsPage;
 export declare function MosaicRestrictionsPageFromJSONTyped(json: any, ignoreDiscriminator: boolean): MosaicRestrictionsPage;
 export declare function MosaicRestrictionsPageToJSON(json: any): MosaicRestrictionsPage;

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

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

package/esm/api/models/MosaicSupplyChangeActionEnum.js

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

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

@@ -21,8 +21,6 @@ export interface MosaicSupplyChangeTransactionBodyDTO {
      * 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 MosaicSupplyChangeTransactionBodyDTO
      */
     mosaicId: string;
     /**
@@ -31,21 +29,17 @@ export interface MosaicSupplyChangeTransactionBodyDTO {
      * `123.456789` whole units. Encoded as a string to preserve precision, since the value
      * is an unsigned 64-bit integer.
      *
-     * @type {string}
-     * @memberof MosaicSupplyChangeTransactionBodyDTO
      */
     delta: string;
     /**
      *
-     * @type {MosaicSupplyChangeActionEnum}
-     * @memberof MosaicSupplyChangeTransactionBodyDTO
      */
     action: MosaicSupplyChangeActionEnum;
 }
 /**
  * Check if a given object implements the MosaicSupplyChangeTransactionBodyDTO interface.
  */
-export declare function instanceOfMosaicSupplyChangeTransactionBodyDTO(value: Record<string, any>): value is MosaicSupplyChangeTransactionBodyDTO;
+export declare function instanceOfMosaicSupplyChangeTransactionBodyDTO(value: object): value is MosaicSupplyChangeTransactionBodyDTO;
 export declare function MosaicSupplyChangeTransactionBodyDTOFromJSON(json: any): MosaicSupplyChangeTransactionBodyDTO;
 export declare function MosaicSupplyChangeTransactionBodyDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MosaicSupplyChangeTransactionBodyDTO;
 export declare function MosaicSupplyChangeTransactionBodyDTOToJSON(json: any): MosaicSupplyChangeTransactionBodyDTO;

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

@@ -18,11 +18,9 @@ import type { MosaicSupplyChangeActionEnum } from './MosaicSupplyChangeActionEnu
  */
 export interface MosaicSupplyChangeTransactionDTO {
     /**
-     * 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 MosaicSupplyChangeTransactionDTO
      */
     size: number;
     /**
@@ -30,58 +28,32 @@ export interface MosaicSupplyChangeTransactionDTO {
      * over the serialized entity payload. Can be verified with the signer's public key (`signerPublicKey`).
      * Used for blocks, transactions, and cosignatures.
      *
-     * @type {string}
-     * @memberof MosaicSupplyChangeTransactionDTO
      */
     signature: string;
     /**
-     * 256-bit public key encoded as a hexadecimal string (64 hex characters).
-     * @type {string}
-     * @memberof MosaicSupplyChangeTransactionDTO
+     * 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 MosaicSupplyChangeTransactionDTO
      */
     version: number;
     /**
      * Network type (mainnet or testnet). Ensures the entity targets the correct network.
-     * @type {NetworkTypeEnum}
-     * @memberof MosaicSupplyChangeTransactionDTO
      */
     network: NetworkTypeEnum;
     /**
      * Entity type identifier (e.g. transaction type code, block type). Determines the entity schema.
-     * @type {number}
-     * @memberof MosaicSupplyChangeTransactionDTO
      */
     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 MosaicSupplyChangeTransactionDTO
+     * 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 MosaicSupplyChangeTransactionDTO
      */
     deadline: string;
     /**
@@ -89,8 +61,6 @@ export interface MosaicSupplyChangeTransactionDTO {
      * 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 MosaicSupplyChangeTransactionDTO
      */
     mosaicId: string;
     /**
@@ -99,21 +69,17 @@ export interface MosaicSupplyChangeTransactionDTO {
      * `123.456789` whole units. Encoded as a string to preserve precision, since the value
      * is an unsigned 64-bit integer.
      *
-     * @type {string}
-     * @memberof MosaicSupplyChangeTransactionDTO
      */
     delta: string;
     /**
      *
-     * @type {MosaicSupplyChangeActionEnum}
-     * @memberof MosaicSupplyChangeTransactionDTO
      */
     action: MosaicSupplyChangeActionEnum;
 }
 /**
  * Check if a given object implements the MosaicSupplyChangeTransactionDTO interface.
  */
-export declare function instanceOfMosaicSupplyChangeTransactionDTO(value: Record<string, any>): value is MosaicSupplyChangeTransactionDTO;
+export declare function instanceOfMosaicSupplyChangeTransactionDTO(value: object): value is MosaicSupplyChangeTransactionDTO;
 export declare function MosaicSupplyChangeTransactionDTOFromJSON(json: any): MosaicSupplyChangeTransactionDTO;
 export declare function MosaicSupplyChangeTransactionDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MosaicSupplyChangeTransactionDTO;
 export declare function MosaicSupplyChangeTransactionDTOToJSON(json: any): MosaicSupplyChangeTransactionDTO;

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

@@ -20,8 +20,6 @@ export interface MosaicSupplyRevocationTransactionBodyDTO {
      * 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 MosaicSupplyRevocationTransactionBodyDTO
      */
     sourceAddress: string;
     /**
@@ -29,8 +27,6 @@ export interface MosaicSupplyRevocationTransactionBodyDTO {
      * 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 MosaicSupplyRevocationTransactionBodyDTO
      */
     mosaicId: string;
     /**
@@ -39,15 +35,13 @@ export interface MosaicSupplyRevocationTransactionBodyDTO {
      * `123.456789` whole units. Encoded as a string to preserve precision, since the value
      * is an unsigned 64-bit integer.
      *
-     * @type {string}
-     * @memberof MosaicSupplyRevocationTransactionBodyDTO
      */
     amount: string;
 }
 /**
  * Check if a given object implements the MosaicSupplyRevocationTransactionBodyDTO interface.
  */
-export declare function instanceOfMosaicSupplyRevocationTransactionBodyDTO(value: Record<string, any>): value is MosaicSupplyRevocationTransactionBodyDTO;
+export declare function instanceOfMosaicSupplyRevocationTransactionBodyDTO(value: object): value is MosaicSupplyRevocationTransactionBodyDTO;
 export declare function MosaicSupplyRevocationTransactionBodyDTOFromJSON(json: any): MosaicSupplyRevocationTransactionBodyDTO;
 export declare function MosaicSupplyRevocationTransactionBodyDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MosaicSupplyRevocationTransactionBodyDTO;
 export declare function MosaicSupplyRevocationTransactionBodyDTOToJSON(json: any): MosaicSupplyRevocationTransactionBodyDTO;

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

@@ -17,11 +17,9 @@ import type { NetworkTypeEnum } from './NetworkTypeEnum';
  */
 export interface MosaicSupplyRevocationTransactionDTO {
     /**
-     * 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 MosaicSupplyRevocationTransactionDTO
      */
     size: number;
     /**
@@ -29,58 +27,32 @@ export interface MosaicSupplyRevocationTransactionDTO {
      * over the serialized entity payload. Can be verified with the signer's public key (`signerPublicKey`).
      * Used for blocks, transactions, and cosignatures.
      *
-     * @type {string}
-     * @memberof MosaicSupplyRevocationTransactionDTO
      */
     signature: string;
     /**
-     * 256-bit public key encoded as a hexadecimal string (64 hex characters).
-     * @type {string}
-     * @memberof MosaicSupplyRevocationTransactionDTO
+     * 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 MosaicSupplyRevocationTransactionDTO
      */
     version: number;
     /**
      * Network type (mainnet or testnet). Ensures the entity targets the correct network.
-     * @type {NetworkTypeEnum}
-     * @memberof MosaicSupplyRevocationTransactionDTO
      */
     network: NetworkTypeEnum;
     /**
      * Entity type identifier (e.g. transaction type code, block type). Determines the entity schema.
-     * @type {number}
-     * @memberof MosaicSupplyRevocationTransactionDTO
      */
     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 MosaicSupplyRevocationTransactionDTO
+     * 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 MosaicSupplyRevocationTransactionDTO
      */
     deadline: string;
     /**
@@ -88,8 +60,6 @@ export interface MosaicSupplyRevocationTransactionDTO {
      * 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 MosaicSupplyRevocationTransactionDTO
      */
     sourceAddress: string;
     /**
@@ -97,8 +67,6 @@ export interface MosaicSupplyRevocationTransactionDTO {
      * 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 MosaicSupplyRevocationTransactionDTO
      */
     mosaicId: string;
     /**
@@ -107,15 +75,13 @@ export interface MosaicSupplyRevocationTransactionDTO {
      * `123.456789` whole units. Encoded as a string to preserve precision, since the value
      * is an unsigned 64-bit integer.
      *
-     * @type {string}
-     * @memberof MosaicSupplyRevocationTransactionDTO
      */
     amount: string;
 }
 /**
  * Check if a given object implements the MosaicSupplyRevocationTransactionDTO interface.
  */
-export declare function instanceOfMosaicSupplyRevocationTransactionDTO(value: Record<string, any>): value is MosaicSupplyRevocationTransactionDTO;
+export declare function instanceOfMosaicSupplyRevocationTransactionDTO(value: object): value is MosaicSupplyRevocationTransactionDTO;
 export declare function MosaicSupplyRevocationTransactionDTOFromJSON(json: any): MosaicSupplyRevocationTransactionDTO;
 export declare function MosaicSupplyRevocationTransactionDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MosaicSupplyRevocationTransactionDTO;
 export declare function MosaicSupplyRevocationTransactionDTOToJSON(json: any): MosaicSupplyRevocationTransactionDTO;

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

@@ -21,15 +21,13 @@ import type { MosaicNamesDTO } from './MosaicNamesDTO';
 export interface MosaicsNamesDTO {
     /**
      * Array of namespace name entries resolved for the requested mosaic identifiers in request order.
-     * @type {Array<MosaicNamesDTO>}
-     * @memberof MosaicsNamesDTO
      */
     mosaicNames: Array<MosaicNamesDTO>;
 }
 /**
  * Check if a given object implements the MosaicsNamesDTO interface.
  */
-export declare function instanceOfMosaicsNamesDTO(value: Record<string, any>): value is MosaicsNamesDTO;
+export declare function instanceOfMosaicsNamesDTO(value: object): value is MosaicsNamesDTO;
 export declare function MosaicsNamesDTOFromJSON(json: any): MosaicsNamesDTO;
 export declare function MosaicsNamesDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MosaicsNamesDTO;
 export declare function MosaicsNamesDTOToJSON(json: any): MosaicsNamesDTO;

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

@@ -22,21 +22,17 @@ export interface MultisigAccountGraphInfoDTO {
      * account acts as a cosignatory, and positive levels are multisig relationships reached through
      * cosignatories.
      *
-     * @type {number}
-     * @memberof MultisigAccountGraphInfoDTO
      */
     level: number;
     /**
      * Multisig state entries discovered at this graph level.
-     * @type {Array<MultisigAccountInfoDTO>}
-     * @memberof MultisigAccountGraphInfoDTO
      */
     multisigEntries: Array<MultisigAccountInfoDTO>;
 }
 /**
  * Check if a given object implements the MultisigAccountGraphInfoDTO interface.
  */
-export declare function instanceOfMultisigAccountGraphInfoDTO(value: Record<string, any>): value is MultisigAccountGraphInfoDTO;
+export declare function instanceOfMultisigAccountGraphInfoDTO(value: object): value is MultisigAccountGraphInfoDTO;
 export declare function MultisigAccountGraphInfoDTOFromJSON(json: any): MultisigAccountGraphInfoDTO;
 export declare function MultisigAccountGraphInfoDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MultisigAccountGraphInfoDTO;
 export declare function MultisigAccountGraphInfoDTOToJSON(json: any): MultisigAccountGraphInfoDTO;

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

@@ -18,15 +18,13 @@ import type { MultisigDTO } from './MultisigDTO';
 export interface MultisigAccountInfoDTO {
     /**
      * Full multisig state for the requested account.
-     * @type {MultisigDTO}
-     * @memberof MultisigAccountInfoDTO
      */
     multisig: MultisigDTO;
 }
 /**
  * Check if a given object implements the MultisigAccountInfoDTO interface.
  */
-export declare function instanceOfMultisigAccountInfoDTO(value: Record<string, any>): value is MultisigAccountInfoDTO;
+export declare function instanceOfMultisigAccountInfoDTO(value: object): value is MultisigAccountInfoDTO;
 export declare function MultisigAccountInfoDTOFromJSON(json: any): MultisigAccountInfoDTO;
 export declare function MultisigAccountInfoDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MultisigAccountInfoDTO;
 export declare function MultisigAccountInfoDTOToJSON(json: any): MultisigAccountInfoDTO;

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

@@ -20,8 +20,6 @@ export interface MultisigAccountModificationTransactionBodyDTO {
      * cosignatory. When converting a regular account into a multisig account, the initial value is
      * derived from this delta because the previous threshold is zero.
      *
-     * @type {number}
-     * @memberof MultisigAccountModificationTransactionBodyDTO
      */
     minRemovalDelta: number;
     /**
@@ -29,29 +27,23 @@ export interface MultisigAccountModificationTransactionBodyDTO {
      * transaction. When converting a regular account into a multisig account, the initial value is
      * derived from this delta because the previous threshold is zero.
      *
-     * @type {number}
-     * @memberof MultisigAccountModificationTransactionBodyDTO
      */
     minApprovalDelta: number;
     /**
      * Cosignatory addresses to add to the multisig account.
      * Newly added cosignatories must opt in by cosigning the aggregate transaction.
      *
-     * @type {Array<string>}
-     * @memberof MultisigAccountModificationTransactionBodyDTO
      */
     addressAdditions: Array<string>;
     /**
      * Cosignatory addresses to remove from the multisig account.
-     * @type {Array<string>}
-     * @memberof MultisigAccountModificationTransactionBodyDTO
      */
     addressDeletions: Array<string>;
 }
 /**
  * Check if a given object implements the MultisigAccountModificationTransactionBodyDTO interface.
  */
-export declare function instanceOfMultisigAccountModificationTransactionBodyDTO(value: Record<string, any>): value is MultisigAccountModificationTransactionBodyDTO;
+export declare function instanceOfMultisigAccountModificationTransactionBodyDTO(value: object): value is MultisigAccountModificationTransactionBodyDTO;
 export declare function MultisigAccountModificationTransactionBodyDTOFromJSON(json: any): MultisigAccountModificationTransactionBodyDTO;
 export declare function MultisigAccountModificationTransactionBodyDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): MultisigAccountModificationTransactionBodyDTO;
 export declare function MultisigAccountModificationTransactionBodyDTOToJSON(json: any): MultisigAccountModificationTransactionBodyDTO;