Variable CompleteInstanceConst

Type declaration

• Readonlyattributes: {
      acceptedCommandList: Attribute<.[], never>;
      activeNetworkFaultsList: Attribute<ThreadNetworkDiagnostics.NetworkFault[], any>;
      activeTimestamp: OptionalAttribute<number | bigint | null, any>;
      attachAttemptCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              mleCounts: boolean;
          }];
      };
      attributeList: Attribute<.[], never>;
      betterPartitionAttachAttemptCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              mleCounts: boolean;
          }];
      };
      channel: Attribute<number | null, any>;
      channelPage0Mask: Attribute<Uint8Array | null, any>;
      childRoleCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              mleCounts: boolean;
          }];
      };
      clusterRevision: Attribute<number, never>;
      dataVersion: Attribute<number | null, any>;
      delay: OptionalAttribute<number | null, any>;
      detachedRoleCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              mleCounts: boolean;
          }];
      };
      extendedPanId: Attribute<number | bigint | null, any>;
      featureMap: Attribute<TypeFromPartialBitSchema, never>;
      generatedCommandList: Attribute<.[], never>;
      leaderRoleCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              mleCounts: boolean;
          }];
      };
      leaderRouterId: Attribute<number | null, any>;
      meshLocalPrefix: Attribute<Uint8Array | null, any>;
      neighborTable: Attribute<TypeFromFields[], any>;
      networkName: Attribute<string | null, any>;
      operationalDatasetComponents: Attribute<TypeFromFields | null, any>;
      overrunCount: Attribute<number | bigint, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              errorCounts: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      panId: Attribute<number | null, any>;
      parentChangeCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              mleCounts: boolean;
          }];
      };
      partitionId: Attribute<number | null, any>;
      partitionIdChangeCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              mleCounts: boolean;
          }];
      };
      pendingTimestamp: OptionalAttribute<number | bigint | null, any>;
      routerRoleCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              mleCounts: boolean;
          }];
      };
      routeTable: Attribute<TypeFromFields[], any>;
      routingRole: Attribute<ThreadNetworkDiagnostics.RoutingRole | null, any>;
      rxAddressFilteredCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      rxBeaconCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      rxBeaconRequestCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      rxBroadcastCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      rxDataCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      rxDataPollCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      rxDestAddrFilteredCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      rxDuplicatedCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      rxErrFcsCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      rxErrInvalidSrcAddrCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      rxErrNoFrameCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      rxErrOtherCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      rxErrSecCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      rxErrUnknownNeighborCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      rxOtherCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      rxTotalCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      rxUnicastCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      securityPolicy: Attribute<TypeFromFields | null, any>;
      stableDataVersion: Attribute<number | null, any>;
      txAckedCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      txAckRequestedCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      txBeaconCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      txBeaconRequestCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      txBroadcastCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      txDataCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      txDataPollCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      txDirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      txErrAbortCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      txErrBusyChannelCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      txErrCcaCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      txIndirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      txNoAckRequestedCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      txOtherCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      txRetryCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      txTotalCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      txUnicastCount: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              macCounts: boolean;
          }];
      };
      weighting: Attribute<number | null, any>;
  }

  • ReadonlyacceptedCommandList: Attribute<.[], never>

  • ReadonlyactiveNetworkFaultsList: Attribute<ThreadNetworkDiagnostics.NetworkFault[], any>

  • ReadonlyactiveTimestamp: OptionalAttribute<number | bigint | null, any>

  • ReadonlyattachAttemptCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            mleCounts: boolean;
        }];
    }

  • ReadonlyattributeList: Attribute<.[], never>

  • ReadonlybetterPartitionAttachAttemptCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            mleCounts: boolean;
        }];
    }

  • Readonlychannel: Attribute<number | null, any>

  • ReadonlychannelPage0Mask: Attribute<Uint8Array | null, any>

  • ReadonlychildRoleCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            mleCounts: boolean;
        }];
    }

  • ReadonlyclusterRevision: Attribute<number, never>

  • ReadonlydataVersion: Attribute<number | null, any>

  • Readonlydelay: OptionalAttribute<number | null, any>

  • ReadonlydetachedRoleCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            mleCounts: boolean;
        }];
    }

  • ReadonlyextendedPanId: Attribute<number | bigint | null, any>

  • ReadonlyfeatureMap: Attribute<TypeFromPartialBitSchema, never>

  • ReadonlygeneratedCommandList: Attribute<.[], never>

  • ReadonlyleaderRoleCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            mleCounts: boolean;
        }];
    }

  • ReadonlyleaderRouterId: Attribute<number | null, any>

  • ReadonlymeshLocalPrefix: Attribute<Uint8Array | null, any>

  • ReadonlyneighborTable: Attribute<TypeFromFields[], any>

  • ReadonlynetworkName: Attribute<string | null, any>

  • ReadonlyoperationalDatasetComponents: Attribute<TypeFromFields | null, any>

  • ReadonlyoverrunCount: Attribute<number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            errorCounts: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlypanId: Attribute<number | null, any>

  • ReadonlyparentChangeCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            mleCounts: boolean;
        }];
    }

  • ReadonlypartitionId: Attribute<number | null, any>

  • ReadonlypartitionIdChangeCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            mleCounts: boolean;
        }];
    }

  • ReadonlypendingTimestamp: OptionalAttribute<number | bigint | null, any>

  • ReadonlyrouterRoleCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            mleCounts: boolean;
        }];
    }

  • ReadonlyrouteTable: Attribute<TypeFromFields[], any>

  • ReadonlyroutingRole: Attribute<ThreadNetworkDiagnostics.RoutingRole | null, any>

  • ReadonlyrxAddressFilteredCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlyrxBeaconCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlyrxBeaconRequestCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlyrxBroadcastCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlyrxDataCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlyrxDataPollCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlyrxDestAddrFilteredCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlyrxDuplicatedCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlyrxErrFcsCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlyrxErrInvalidSrcAddrCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlyrxErrNoFrameCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlyrxErrOtherCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlyrxErrSecCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlyrxErrUnknownNeighborCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlyrxOtherCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlyrxTotalCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlyrxUnicastCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlysecurityPolicy: Attribute<TypeFromFields | null, any>

  • ReadonlystableDataVersion: Attribute<number | null, any>

  • ReadonlytxAckedCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlytxAckRequestedCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlytxBeaconCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlytxBeaconRequestCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlytxBroadcastCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlytxDataCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlytxDataPollCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlytxDirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlytxErrAbortCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlytxErrBusyChannelCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlytxErrCcaCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlytxIndirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlytxNoAckRequestedCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlytxOtherCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlytxRetryCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlytxTotalCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • ReadonlytxUnicastCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    }

  • Readonlyweighting: Attribute<number | null, any>

• Readonlycommands: {
      resetCounts: Command<void, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              errorCounts: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
  }

  • ReadonlyresetCounts: Command<void, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            errorCounts: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

• Readonlyevents: {
      connectionStatus: OptionalEvent<TypeFromFields, any>;
      networkFaultChange: OptionalEvent<TypeFromFields, any>;
  }

  • ReadonlyconnectionStatus: OptionalEvent<TypeFromFields, any>

    The ConnectionStatus Event shall indicate that a Node’s connection status to a Thread network has changed.

    See

    MatterSpecification.v13.Core § 11.14.8.2

  • ReadonlynetworkFaultChange: OptionalEvent<TypeFromFields, any>

    The NetworkFaultChange Event shall indicate a change in the set of network faults currently detected by the Node.

    See

    MatterSpecification.v13.Core § 11.14.8.1

• Readonlyfeatures: {
      errorCounts: BitFlag;
      macCounts: BitFlag;
      mleCounts: BitFlag;
      packetCounts: BitFlag;
  }

  • ReadonlyerrorCounts: BitFlag

    ErrorCounts

    Server supports the counts for the number of errors that have occurred during the reception and transmission of packets on the Thread interface.

  • ReadonlymacCounts: BitFlag

    MacCounts

    Server supports the counts for various MAC layer happenings.

  • ReadonlymleCounts: BitFlag

    MleCounts

    Server supports the counts for various MLE layer happenings.

  • ReadonlypacketCounts: BitFlag

    PacketCounts

    Server supports the counts for the number of received and transmitted packets on the Thread interface.

• Readonlyid: @matter/general

• Readonlyname: "ThreadNetworkDiagnostics"

• Readonlyrevision: 2