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

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

@@ -17,91 +17,53 @@
 export interface NamespaceNetworkPropertiesDTO {
     /**
      * Maximum namespace name size.
-     * @type {string}
-     * @memberof NamespaceNetworkPropertiesDTO
      */
     maxNameSize?: string;
     /**
      * Maximum number of children for a root namespace.
-     * @type {string}
-     * @memberof NamespaceNetworkPropertiesDTO
      */
     maxChildNamespaces?: string;
     /**
      * Maximum namespace depth.
-     * @type {string}
-     * @memberof NamespaceNetworkPropertiesDTO
      */
     maxNamespaceDepth?: string;
     /**
      * Minimum namespace duration.
-     * @type {string}
-     * @memberof NamespaceNetworkPropertiesDTO
      */
     minNamespaceDuration?: string;
     /**
      * Maximum namespace duration.
-     * @type {string}
-     * @memberof NamespaceNetworkPropertiesDTO
      */
     maxNamespaceDuration?: string;
     /**
      * Grace period during which time only the previous owner can renew an expired namespace.
-     * @type {string}
-     * @memberof NamespaceNetworkPropertiesDTO
      */
     namespaceGracePeriodDuration?: string;
     /**
      * Comma-separated list of reserved root namespace names that cannot be claimed.
-     * @type {string}
-     * @memberof NamespaceNetworkPropertiesDTO
      */
     reservedRootNamespaceNames?: 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 NamespaceNetworkPropertiesDTO
+     * Legacy (V1) address (in Base32 format) of the namespace rental fee sink. May be absent on newer networks.
      */
     namespaceRentalFeeSinkAddressV1?: 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 NamespaceNetworkPropertiesDTO
+     * Address of the namespace rental fee sink account.
      */
     namespaceRentalFeeSinkAddress?: 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 NamespaceNetworkPropertiesDTO
+     * Root namespace rental fee per block in atomic units.
      */
     rootNamespaceRentalFeePerBlock?: 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 NamespaceNetworkPropertiesDTO
+     * Child namespace rental fee in atomic units.
      */
     childNamespaceRentalFee?: string;
 }
 /**
  * Check if a given object implements the NamespaceNetworkPropertiesDTO interface.
  */
-export declare function instanceOfNamespaceNetworkPropertiesDTO(value: Record<string, any>): value is NamespaceNetworkPropertiesDTO;
+export declare function instanceOfNamespaceNetworkPropertiesDTO(value: object): value is NamespaceNetworkPropertiesDTO;
 export declare function NamespaceNetworkPropertiesDTOFromJSON(json: any): NamespaceNetworkPropertiesDTO;
 export declare function NamespaceNetworkPropertiesDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): NamespaceNetworkPropertiesDTO;
 export declare function NamespaceNetworkPropertiesDTOToJSON(json: any): NamespaceNetworkPropertiesDTO;

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

@@ -19,21 +19,17 @@ import type { NamespaceInfoDTO } from './NamespaceInfoDTO';
 export interface NamespacePage {
     /**
      * Array of namespace information entries.
-     * @type {Array<NamespaceInfoDTO>}
-     * @memberof NamespacePage
      */
     data: Array<NamespaceInfoDTO>;
     /**
      *
-     * @type {Pagination}
-     * @memberof NamespacePage
      */
     pagination: Pagination;
 }
 /**
  * Check if a given object implements the NamespacePage interface.
  */
-export declare function instanceOfNamespacePage(value: Record<string, any>): value is NamespacePage;
+export declare function instanceOfNamespacePage(value: object): value is NamespacePage;
 export declare function NamespacePageFromJSON(json: any): NamespacePage;
 export declare function NamespacePageFromJSONTyped(json: any, ignoreDiscriminator: boolean): NamespacePage;
 export declare function NamespacePageToJSON(json: any): NamespacePage;

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

@@ -18,8 +18,6 @@ import type { NamespaceRegistrationTypeEnum } from './NamespaceRegistrationTypeE
 export interface NamespaceRegistrationTransactionBodyDTO {
     /**
      * Duration expressed in number of blocks.
-     * @type {string}
-     * @memberof NamespaceRegistrationTransactionBodyDTO
      */
     duration?: string;
     /**
@@ -27,8 +25,6 @@ export interface NamespaceRegistrationTransactionBodyDTO {
      * A 64-bit unsigned integer derived from the namespace name and its parent namespace ID,
      * encoded as a 16-character hexadecimal string.
      *
-     * @type {string}
-     * @memberof NamespaceRegistrationTransactionBodyDTO
      */
     parentId?: string;
     /**
@@ -36,27 +32,21 @@ export interface NamespaceRegistrationTransactionBodyDTO {
      * A 64-bit unsigned integer derived from the namespace name and its parent namespace ID,
      * encoded as a 16-character hexadecimal string.
      *
-     * @type {string}
-     * @memberof NamespaceRegistrationTransactionBodyDTO
      */
     id: string;
     /**
      *
-     * @type {NamespaceRegistrationTypeEnum}
-     * @memberof NamespaceRegistrationTransactionBodyDTO
      */
     registrationType: NamespaceRegistrationTypeEnum;
     /**
      * Namespace name.
-     * @type {string}
-     * @memberof NamespaceRegistrationTransactionBodyDTO
      */
     name: string;
 }
 /**
  * Check if a given object implements the NamespaceRegistrationTransactionBodyDTO interface.
  */
-export declare function instanceOfNamespaceRegistrationTransactionBodyDTO(value: Record<string, any>): value is NamespaceRegistrationTransactionBodyDTO;
+export declare function instanceOfNamespaceRegistrationTransactionBodyDTO(value: object): value is NamespaceRegistrationTransactionBodyDTO;
 export declare function NamespaceRegistrationTransactionBodyDTOFromJSON(json: any): NamespaceRegistrationTransactionBodyDTO;
 export declare function NamespaceRegistrationTransactionBodyDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): NamespaceRegistrationTransactionBodyDTO;
 export declare function NamespaceRegistrationTransactionBodyDTOToJSON(json: any): NamespaceRegistrationTransactionBodyDTO;

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

@@ -18,11 +18,9 @@ import type { NamespaceRegistrationTypeEnum } from './NamespaceRegistrationTypeE
  */
 export interface NamespaceRegistrationTransactionDTO {
     /**
-     * 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 NamespaceRegistrationTransactionDTO
      */
     size: number;
     /**
@@ -30,64 +28,36 @@ export interface NamespaceRegistrationTransactionDTO {
      * over the serialized entity payload. Can be verified with the signer's public key (`signerPublicKey`).
      * Used for blocks, transactions, and cosignatures.
      *
-     * @type {string}
-     * @memberof NamespaceRegistrationTransactionDTO
      */
     signature: string;
     /**
-     * 256-bit public key encoded as a hexadecimal string (64 hex characters).
-     * @type {string}
-     * @memberof NamespaceRegistrationTransactionDTO
+     * 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 NamespaceRegistrationTransactionDTO
      */
     version: number;
     /**
      * Network type (mainnet or testnet). Ensures the entity targets the correct network.
-     * @type {NetworkTypeEnum}
-     * @memberof NamespaceRegistrationTransactionDTO
      */
     network: NetworkTypeEnum;
     /**
      * Entity type identifier (e.g. transaction type code, block type). Determines the entity schema.
-     * @type {number}
-     * @memberof NamespaceRegistrationTransactionDTO
      */
     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 NamespaceRegistrationTransactionDTO
+     * 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 NamespaceRegistrationTransactionDTO
      */
     deadline: string;
     /**
      * Duration expressed in number of blocks.
-     * @type {string}
-     * @memberof NamespaceRegistrationTransactionDTO
      */
     duration?: string;
     /**
@@ -95,8 +65,6 @@ export interface NamespaceRegistrationTransactionDTO {
      * A 64-bit unsigned integer derived from the namespace name and its parent namespace ID,
      * encoded as a 16-character hexadecimal string.
      *
-     * @type {string}
-     * @memberof NamespaceRegistrationTransactionDTO
      */
     parentId?: string;
     /**
@@ -104,27 +72,21 @@ export interface NamespaceRegistrationTransactionDTO {
      * A 64-bit unsigned integer derived from the namespace name and its parent namespace ID,
      * encoded as a 16-character hexadecimal string.
      *
-     * @type {string}
-     * @memberof NamespaceRegistrationTransactionDTO
      */
     id: string;
     /**
      *
-     * @type {NamespaceRegistrationTypeEnum}
-     * @memberof NamespaceRegistrationTransactionDTO
      */
     registrationType: NamespaceRegistrationTypeEnum;
     /**
      * Namespace name.
-     * @type {string}
-     * @memberof NamespaceRegistrationTransactionDTO
      */
     name: string;
 }
 /**
  * Check if a given object implements the NamespaceRegistrationTransactionDTO interface.
  */
-export declare function instanceOfNamespaceRegistrationTransactionDTO(value: Record<string, any>): value is NamespaceRegistrationTransactionDTO;
+export declare function instanceOfNamespaceRegistrationTransactionDTO(value: object): value is NamespaceRegistrationTransactionDTO;
 export declare function NamespaceRegistrationTransactionDTOFromJSON(json: any): NamespaceRegistrationTransactionDTO;
 export declare function NamespaceRegistrationTransactionDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): NamespaceRegistrationTransactionDTO;
 export declare function NamespaceRegistrationTransactionDTOToJSON(json: any): NamespaceRegistrationTransactionDTO;

package/esm/api/models/NamespaceRegistrationTypeEnum.js

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

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

@@ -23,49 +23,37 @@ import type { NetworkPropertiesDTO } from './NetworkPropertiesDTO';
 export interface NetworkConfigurationDTO {
     /**
      *
-     * @type {NetworkPropertiesDTO}
-     * @memberof NetworkConfigurationDTO
      */
     network: NetworkPropertiesDTO;
     /**
      *
-     * @type {ChainPropertiesDTO}
-     * @memberof NetworkConfigurationDTO
      */
     chain: ChainPropertiesDTO;
     /**
      *
-     * @type {PluginsPropertiesDTO}
-     * @memberof NetworkConfigurationDTO
      */
     plugins: PluginsPropertiesDTO;
     /**
      *
-     * @type {ForkHeightsDTO}
-     * @memberof NetworkConfigurationDTO
      */
     forkHeights: ForkHeightsDTO;
     /**
      * Multisignature approvals authorizing the network treasury reissuance event for the specified fork height.
      * More: https://hackmd.io/@syndicate/governance.
      *
-     * @type {Array<string>}
-     * @memberof NetworkConfigurationDTO
      */
     treasuryReissuanceTransactionSignatures?: Array<string>;
     /**
      * List of aggregate transaction hashes that were known to be invalid due to a bug and must be remapped to corrected hashes.
      * More: https://hackmd.io/@syndicate/postmortem-251022.
      *
-     * @type {Array<string>}
-     * @memberof NetworkConfigurationDTO
      */
     corruptAggregateTransactionHashes?: Array<string>;
 }
 /**
  * Check if a given object implements the NetworkConfigurationDTO interface.
  */
-export declare function instanceOfNetworkConfigurationDTO(value: Record<string, any>): value is NetworkConfigurationDTO;
+export declare function instanceOfNetworkConfigurationDTO(value: object): value is NetworkConfigurationDTO;
 export declare function NetworkConfigurationDTOFromJSON(json: any): NetworkConfigurationDTO;
 export declare function NetworkConfigurationDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): NetworkConfigurationDTO;
 export declare function NetworkConfigurationDTOToJSON(json: any): NetworkConfigurationDTO;

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

@@ -17,28 +17,18 @@
  */
 export interface NetworkInflationDTO {
     /**
-     * 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 NetworkInflationDTO
+     * Block height at which this reward amount becomes active.
      */
     startHeight: 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 NetworkInflationDTO
+     * Inflation reward per block in smallest (atomic) units of the network currency.
      */
     rewardAmount: string;
 }
 /**
  * Check if a given object implements the NetworkInflationDTO interface.
  */
-export declare function instanceOfNetworkInflationDTO(value: Record<string, any>): value is NetworkInflationDTO;
+export declare function instanceOfNetworkInflationDTO(value: object): value is NetworkInflationDTO;
 export declare function NetworkInflationDTOFromJSON(json: any): NetworkInflationDTO;
 export declare function NetworkInflationDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): NetworkInflationDTO;
 export declare function NetworkInflationDTOToJSON(json: any): NetworkInflationDTO;

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

@@ -18,39 +18,29 @@ import type { NodeIdentityEqualityStrategy } from './NodeIdentityEqualityStrateg
 export interface NetworkPropertiesDTO {
     /**
      * Network identifier.
-     * @type {string}
-     * @memberof NetworkPropertiesDTO
      */
     identifier?: string;
     /**
      *
-     * @type {NodeIdentityEqualityStrategy}
-     * @memberof NetworkPropertiesDTO
      */
     nodeEqualityStrategy?: NodeIdentityEqualityStrategy;
     /**
      * 256-bit public key encoded as a hexadecimal string (64 hex characters).
-     * @type {string}
-     * @memberof NetworkPropertiesDTO
      */
     nemesisSignerPublicKey?: string;
     /**
      * 256-bit hash encoded as a 64-character hexadecimal string.
-     * @type {string}
-     * @memberof NetworkPropertiesDTO
      */
     generationHashSeed?: string;
     /**
      * Nemesis epoch time adjustment.
-     * @type {string}
-     * @memberof NetworkPropertiesDTO
      */
     epochAdjustment?: string;
 }
 /**
  * Check if a given object implements the NetworkPropertiesDTO interface.
  */
-export declare function instanceOfNetworkPropertiesDTO(value: Record<string, any>): value is NetworkPropertiesDTO;
+export declare function instanceOfNetworkPropertiesDTO(value: object): value is NetworkPropertiesDTO;
 export declare function NetworkPropertiesDTOFromJSON(json: any): NetworkPropertiesDTO;
 export declare function NetworkPropertiesDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): NetworkPropertiesDTO;
 export declare function NetworkPropertiesDTOToJSON(json: any): NetworkPropertiesDTO;

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

@@ -17,14 +17,10 @@
 export interface NetworkTypeDTO {
     /**
      * Network name (mainnet or testnet).
-     * @type {string}
-     * @memberof NetworkTypeDTO
      */
     name: NetworkTypeDTONameEnum;
     /**
      * A short text describing the network.
-     * @type {string}
-     * @memberof NetworkTypeDTO
      */
     description: string;
 }
@@ -39,7 +35,7 @@ export type NetworkTypeDTONameEnum = typeof NetworkTypeDTONameEnum[keyof typeof
 /**
  * Check if a given object implements the NetworkTypeDTO interface.
  */
-export declare function instanceOfNetworkTypeDTO(value: Record<string, any>): value is NetworkTypeDTO;
+export declare function instanceOfNetworkTypeDTO(value: object): value is NetworkTypeDTO;
 export declare function NetworkTypeDTOFromJSON(json: any): NetworkTypeDTO;
 export declare function NetworkTypeDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): NetworkTypeDTO;
 export declare function NetworkTypeDTOToJSON(json: any): NetworkTypeDTO;

package/esm/api/models/NetworkTypeDTO.js

@@ -16,7 +16,7 @@
  */
 export const NetworkTypeDTONameEnum = {
     Mainnet: 'mainnet',
-    Testnet: 'testnet'
+    Testnet: 'testnet',
 };
 /**
  * Check if a given object implements the NetworkTypeDTO interface.

package/esm/api/models/NetworkTypeEnum.js

@@ -20,7 +20,7 @@
  */
 export const NetworkTypeEnum = {
     NUMBER_104: 104,
-    NUMBER_152: 152
+    NUMBER_152: 152,
 };
 export function instanceOfNetworkTypeEnum(value) {
     for (const key in NetworkTypeEnum) {

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

@@ -18,21 +18,17 @@ import type { NodeStatusEnum } from './NodeStatusEnum';
 export interface NodeHealthDTO {
     /**
      * API node service status.
-     * @type {NodeStatusEnum}
-     * @memberof NodeHealthDTO
      */
     apiNode: NodeStatusEnum;
     /**
      * MongoDB service status.
-     * @type {NodeStatusEnum}
-     * @memberof NodeHealthDTO
      */
     db: NodeStatusEnum;
 }
 /**
  * Check if a given object implements the NodeHealthDTO interface.
  */
-export declare function instanceOfNodeHealthDTO(value: Record<string, any>): value is NodeHealthDTO;
+export declare function instanceOfNodeHealthDTO(value: object): value is NodeHealthDTO;
 export declare function NodeHealthDTOFromJSON(json: any): NodeHealthDTO;
 export declare function NodeHealthDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): NodeHealthDTO;
 export declare function NodeHealthDTOToJSON(json: any): NodeHealthDTO;

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

@@ -20,15 +20,13 @@ import type { NodeHealthDTO } from './NodeHealthDTO';
 export interface NodeHealthInfoDTO {
     /**
      *
-     * @type {NodeHealthDTO}
-     * @memberof NodeHealthInfoDTO
      */
     status: NodeHealthDTO;
 }
 /**
  * Check if a given object implements the NodeHealthInfoDTO interface.
  */
-export declare function instanceOfNodeHealthInfoDTO(value: Record<string, any>): value is NodeHealthInfoDTO;
+export declare function instanceOfNodeHealthInfoDTO(value: object): value is NodeHealthInfoDTO;
 export declare function NodeHealthInfoDTOFromJSON(json: any): NodeHealthInfoDTO;
 export declare function NodeHealthInfoDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): NodeHealthInfoDTO;
 export declare function NodeHealthInfoDTOToJSON(json: any): NodeHealthInfoDTO;

package/esm/api/models/NodeIdentityEqualityStrategy.js

@@ -18,7 +18,7 @@
  */
 export const NodeIdentityEqualityStrategy = {
     Host: 'host',
-    PublicKey: 'public-key'
+    PublicKey: 'public-key',
 };
 export function instanceOfNodeIdentityEqualityStrategy(value) {
     for (const key in NodeIdentityEqualityStrategy) {

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

@@ -20,20 +20,14 @@ import type { NetworkTypeEnum } from './NetworkTypeEnum';
 export interface NodeInfoDTO {
     /**
      * Version of the application.
-     * @type {number}
-     * @memberof NodeInfoDTO
      */
     version: number;
     /**
      * 256-bit public key encoded as a hexadecimal string (64 hex characters).
-     * @type {string}
-     * @memberof NodeInfoDTO
      */
     publicKey: string;
     /**
      * 256-bit hash encoded as a 64-character hexadecimal string.
-     * @type {string}
-     * @memberof NodeInfoDTO
      */
     networkGenerationHashSeed: string;
     /**
@@ -53,45 +47,33 @@ export interface NodeInfoDTO {
      * - `7` = Peer, API and Voting.
      * - `65` = IPv4 and Peer.
      *
-     * @type {number}
-     * @memberof NodeInfoDTO
      */
     roles: number;
     /**
      * Port used for the communication.
-     * @type {number}
-     * @memberof NodeInfoDTO
      */
     port: number;
     /**
      *
-     * @type {NetworkTypeEnum}
-     * @memberof NodeInfoDTO
      */
     networkIdentifier: NetworkTypeEnum;
     /**
      * Node friendly name.
-     * @type {string}
-     * @memberof NodeInfoDTO
      */
     friendlyName: string;
     /**
      * Node IP address.
-     * @type {string}
-     * @memberof NodeInfoDTO
      */
     host: string;
     /**
      * 256-bit public key encoded as a hexadecimal string (64 hex characters).
-     * @type {string}
-     * @memberof NodeInfoDTO
      */
     nodePublicKey?: string;
 }
 /**
  * Check if a given object implements the NodeInfoDTO interface.
  */
-export declare function instanceOfNodeInfoDTO(value: Record<string, any>): value is NodeInfoDTO;
+export declare function instanceOfNodeInfoDTO(value: object): value is NodeInfoDTO;
 export declare function NodeInfoDTOFromJSON(json: any): NodeInfoDTO;
 export declare function NodeInfoDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): NodeInfoDTO;
 export declare function NodeInfoDTOToJSON(json: any): NodeInfoDTO;

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

@@ -18,21 +18,17 @@ import type { LinkActionEnum } from './LinkActionEnum';
 export interface NodeKeyLinkTransactionBodyDTO {
     /**
      * 256-bit public key encoded as a hexadecimal string (64 hex characters).
-     * @type {string}
-     * @memberof NodeKeyLinkTransactionBodyDTO
      */
     linkedPublicKey: string;
     /**
      *
-     * @type {LinkActionEnum}
-     * @memberof NodeKeyLinkTransactionBodyDTO
      */
     linkAction: LinkActionEnum;
 }
 /**
  * Check if a given object implements the NodeKeyLinkTransactionBodyDTO interface.
  */
-export declare function instanceOfNodeKeyLinkTransactionBodyDTO(value: Record<string, any>): value is NodeKeyLinkTransactionBodyDTO;
+export declare function instanceOfNodeKeyLinkTransactionBodyDTO(value: object): value is NodeKeyLinkTransactionBodyDTO;
 export declare function NodeKeyLinkTransactionBodyDTOFromJSON(json: any): NodeKeyLinkTransactionBodyDTO;
 export declare function NodeKeyLinkTransactionBodyDTOFromJSONTyped(json: any, ignoreDiscriminator: boolean): NodeKeyLinkTransactionBodyDTO;
 export declare function NodeKeyLinkTransactionBodyDTOToJSON(json: any): NodeKeyLinkTransactionBodyDTO;