Interface Complete

This cluster supports all ThreadNetworkDiagnostics features. It may support illegal feature combinations.

If you use this cluster you must manually specify which features are active and ensure the set of active features is legal per the Matter specification.

interface Complete {
    attributes: Merge<{
        acceptedCommandList: Attribute<CommandId[], never>;
        activeNetworkFaultsList: Attribute<ThreadNetworkDiagnostics.NetworkFault[], any>;
        activeTimestamp: OptionalAttribute<null | number | bigint, any>;
        attachAttemptCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        attributeList: Attribute<AttributeId[], never>;
        betterPartitionAttachAttemptCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        channel: Attribute<null | number, any>;
        channelPage0Mask: Attribute<null | Uint8Array, any>;
        childRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        clusterRevision: Attribute<number, never>;
        dataVersion: Attribute<null | number, any>;
        delay: OptionalAttribute<null | number, any>;
        detachedRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        extendedPanId: Attribute<null | number | bigint, any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            errorCounts: BitFlag;
            macCounts: BitFlag;
            mleCounts: BitFlag;
            packetCounts: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        leaderRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        leaderRouterId: Attribute<null | number, any>;
        meshLocalPrefix: Attribute<null | Uint8Array, any>;
        neighborTable: Attribute<TypeFromFields<{
            age: FieldType<number>;
            averageRssi: FieldType<null | number>;
            extAddress: FieldType<number | bigint>;
            frameErrorRate: FieldType<number>;
            fullNetworkData: FieldType<boolean>;
            fullThreadDevice: FieldType<boolean>;
            isChild: FieldType<boolean>;
            lastRssi: FieldType<null | number>;
            linkFrameCounter: FieldType<number>;
            lqi: FieldType<number>;
            messageErrorRate: FieldType<number>;
            mleFrameCounter: FieldType<number>;
            rloc16: FieldType<number>;
            rxOnWhenIdle: FieldType<boolean>;
        }>[], any>;
        networkName: Attribute<null | string, any>;
        operationalDatasetComponents: Attribute<null | TypeFromFields<{
            activeTimestampPresent: FieldType<boolean>;
            channelMaskPresent: FieldType<boolean>;
            channelPresent: FieldType<boolean>;
            delayPresent: FieldType<boolean>;
            extendedPanIdPresent: FieldType<boolean>;
            masterKeyPresent: FieldType<boolean>;
            meshLocalPrefixPresent: FieldType<boolean>;
            networkNamePresent: FieldType<boolean>;
            panIdPresent: FieldType<boolean>;
            pendingTimestampPresent: FieldType<boolean>;
            pskcPresent: FieldType<boolean>;
            securityPolicyPresent: FieldType<boolean>;
        }>, any>;
        overrunCount: Attribute<number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                errorCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        panId: Attribute<null | number, any>;
        parentChangeCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        partitionId: Attribute<null | number, any>;
        partitionIdChangeCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        pendingTimestamp: OptionalAttribute<null | number | bigint, any>;
        routerRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        routeTable: Attribute<TypeFromFields<{
            age: FieldType<number>;
            allocated: FieldType<boolean>;
            extAddress: FieldType<number | bigint>;
            linkEstablished: FieldType<boolean>;
            lqiIn: FieldType<number>;
            lqiOut: FieldType<number>;
            nextHop: FieldType<number>;
            pathCost: FieldType<number>;
            rloc16: FieldType<number>;
            routerId: FieldType<number>;
        }>[], any>;
        routingRole: Attribute<null | ThreadNetworkDiagnostics.RoutingRole, any>;
        rxAddressFilteredCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBeaconCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBeaconRequestCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBroadcastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDataCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDataPollCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDestAddrFilteredCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDuplicatedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrFcsCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrInvalidSrcAddrCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrNoFrameCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrSecCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrUnknownNeighborCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxTotalCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxUnicastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        securityPolicy: Attribute<null | TypeFromFields<{
            flags: FieldType<number>;
            rotationTime: FieldType<number>;
        }>, any>;
        stableDataVersion: Attribute<null | number, any>;
        txAckedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txAckRequestedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBeaconCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBeaconRequestCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBroadcastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDataCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDataPollCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrAbortCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrBusyChannelCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrCcaCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txIndirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txNoAckRequestedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txRetryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txTotalCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txUnicastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        weighting: Attribute<null | number, any>;
    }, GlobalAttributes<{
        errorCounts: BitFlag;
        macCounts: BitFlag;
        mleCounts: BitFlag;
        packetCounts: BitFlag;
    }>>;
    base: undefined;
    commands: {
        resetCounts: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                errorCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        connectionStatus: OptionalEvent<TypeFromFields<{
            connectionStatus: FieldType<ThreadNetworkDiagnostics.ConnectionStatus>;
        }>, any>;
        networkFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
            previous: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
        }>, any>;
    };
    extensions: undefined;
    features: {
        errorCounts: BitFlag;
        macCounts: BitFlag;
        mleCounts: BitFlag;
        packetCounts: BitFlag;
    };
    id: Branded<Branded<53, "ClusterId">, "ClusterId">;
    name: "ThreadNetworkDiagnostics";
    revision: 2;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            activeNetworkFaultsList: Attribute<ThreadNetworkDiagnostics.NetworkFault[], any>;
            activeTimestamp: OptionalAttribute<null | number | bigint, any>;
            attachAttemptCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            attributeList: Attribute<AttributeId[], never>;
            betterPartitionAttachAttemptCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            channel: Attribute<null | number, any>;
            channelPage0Mask: Attribute<null | Uint8Array, any>;
            childRoleCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            clusterRevision: Attribute<number, never>;
            dataVersion: Attribute<null | number, any>;
            delay: OptionalAttribute<null | number, any>;
            detachedRoleCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            extendedPanId: Attribute<null | number | bigint, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                errorCounts: BitFlag;
                macCounts: BitFlag;
                mleCounts: BitFlag;
                packetCounts: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            leaderRoleCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            leaderRouterId: Attribute<null | number, any>;
            meshLocalPrefix: Attribute<null | Uint8Array, any>;
            neighborTable: Attribute<TypeFromFields<{
                age: FieldType<number>;
                averageRssi: FieldType<null | number>;
                extAddress: FieldType<number | bigint>;
                frameErrorRate: FieldType<number>;
                fullNetworkData: FieldType<boolean>;
                fullThreadDevice: FieldType<boolean>;
                isChild: FieldType<boolean>;
                lastRssi: FieldType<null | number>;
                linkFrameCounter: FieldType<number>;
                lqi: FieldType<number>;
                messageErrorRate: FieldType<number>;
                mleFrameCounter: FieldType<number>;
                rloc16: FieldType<number>;
                rxOnWhenIdle: FieldType<boolean>;
            }>[], any>;
            networkName: Attribute<null | string, any>;
            operationalDatasetComponents: Attribute<null | TypeFromFields<{
                activeTimestampPresent: FieldType<boolean>;
                channelMaskPresent: FieldType<boolean>;
                channelPresent: FieldType<boolean>;
                delayPresent: FieldType<boolean>;
                extendedPanIdPresent: FieldType<boolean>;
                masterKeyPresent: FieldType<boolean>;
                meshLocalPrefixPresent: FieldType<boolean>;
                networkNamePresent: FieldType<boolean>;
                panIdPresent: FieldType<boolean>;
                pendingTimestampPresent: FieldType<boolean>;
                pskcPresent: FieldType<boolean>;
                securityPolicyPresent: FieldType<boolean>;
            }>, any>;
            overrunCount: Attribute<number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            panId: Attribute<null | number, any>;
            parentChangeCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            partitionId: Attribute<null | number, any>;
            partitionIdChangeCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            pendingTimestamp: OptionalAttribute<null | number | bigint, any>;
            routerRoleCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            routeTable: Attribute<TypeFromFields<{
                age: FieldType<number>;
                allocated: FieldType<boolean>;
                extAddress: FieldType<number | bigint>;
                linkEstablished: FieldType<boolean>;
                lqiIn: FieldType<number>;
                lqiOut: FieldType<number>;
                nextHop: FieldType<number>;
                pathCost: FieldType<number>;
                rloc16: FieldType<number>;
                routerId: FieldType<number>;
            }>[], any>;
            routingRole: Attribute<null | ThreadNetworkDiagnostics.RoutingRole, any>;
            rxAddressFilteredCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxBeaconCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxBeaconRequestCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxBroadcastCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxDataCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxDataPollCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxDestAddrFilteredCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxDuplicatedCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrFcsCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrInvalidSrcAddrCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrNoFrameCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrOtherCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrSecCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrUnknownNeighborCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxOtherCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxTotalCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxUnicastCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            securityPolicy: Attribute<null | TypeFromFields<{
                flags: FieldType<number>;
                rotationTime: FieldType<number>;
            }>, any>;
            stableDataVersion: Attribute<null | number, any>;
            txAckedCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txAckRequestedCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txBeaconCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txBeaconRequestCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txBroadcastCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txDataCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txDataPollCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txDirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txErrAbortCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txErrBusyChannelCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txErrCcaCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txIndirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txNoAckRequestedCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txOtherCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txRetryCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txTotalCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txUnicastCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            weighting: Attribute<null | number, any>;
        };
        commands: {
            resetCounts: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            connectionStatus: OptionalEvent<TypeFromFields<{
                connectionStatus: FieldType<ThreadNetworkDiagnostics.ConnectionStatus>;
            }>, any>;
            networkFaultChange: OptionalEvent<TypeFromFields<{
                current: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
                previous: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
            }>, any>;
        };
        features: {
            errorCounts: BitFlag;
            macCounts: BitFlag;
            mleCounts: BitFlag;
            packetCounts: BitFlag;
        };
        id: Branded<53, "ClusterId">;
        name: "ThreadNetworkDiagnostics";
        revision: 2;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            activeNetworkFaultsList: Attribute<ThreadNetworkDiagnostics.NetworkFault[], any>;
            activeTimestamp: OptionalAttribute<null | number | bigint, any>;
            attachAttemptCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            attributeList: Attribute<AttributeId[], never>;
            betterPartitionAttachAttemptCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            channel: Attribute<null | number, any>;
            channelPage0Mask: Attribute<null | Uint8Array, any>;
            childRoleCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            clusterRevision: Attribute<number, never>;
            dataVersion: Attribute<null | number, any>;
            delay: OptionalAttribute<null | number, any>;
            detachedRoleCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            extendedPanId: Attribute<null | number | bigint, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                errorCounts: BitFlag;
                macCounts: BitFlag;
                mleCounts: BitFlag;
                packetCounts: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            leaderRoleCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            leaderRouterId: Attribute<null | number, any>;
            meshLocalPrefix: Attribute<null | Uint8Array, any>;
            neighborTable: Attribute<TypeFromFields<{
                age: FieldType<number>;
                averageRssi: FieldType<null | number>;
                extAddress: FieldType<number | bigint>;
                frameErrorRate: FieldType<number>;
                fullNetworkData: FieldType<boolean>;
                fullThreadDevice: FieldType<boolean>;
                isChild: FieldType<boolean>;
                lastRssi: FieldType<null | number>;
                linkFrameCounter: FieldType<number>;
                lqi: FieldType<number>;
                messageErrorRate: FieldType<number>;
                mleFrameCounter: FieldType<number>;
                rloc16: FieldType<number>;
                rxOnWhenIdle: FieldType<boolean>;
            }>[], any>;
            networkName: Attribute<null | string, any>;
            operationalDatasetComponents: Attribute<null | TypeFromFields<{
                activeTimestampPresent: FieldType<boolean>;
                channelMaskPresent: FieldType<boolean>;
                channelPresent: FieldType<boolean>;
                delayPresent: FieldType<boolean>;
                extendedPanIdPresent: FieldType<boolean>;
                masterKeyPresent: FieldType<boolean>;
                meshLocalPrefixPresent: FieldType<boolean>;
                networkNamePresent: FieldType<boolean>;
                panIdPresent: FieldType<boolean>;
                pendingTimestampPresent: FieldType<boolean>;
                pskcPresent: FieldType<boolean>;
                securityPolicyPresent: FieldType<boolean>;
            }>, any>;
            overrunCount: Attribute<number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            panId: Attribute<null | number, any>;
            parentChangeCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            partitionId: Attribute<null | number, any>;
            partitionIdChangeCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            pendingTimestamp: OptionalAttribute<null | number | bigint, any>;
            routerRoleCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            routeTable: Attribute<TypeFromFields<{
                age: FieldType<number>;
                allocated: FieldType<boolean>;
                extAddress: FieldType<number | bigint>;
                linkEstablished: FieldType<boolean>;
                lqiIn: FieldType<number>;
                lqiOut: FieldType<number>;
                nextHop: FieldType<number>;
                pathCost: FieldType<number>;
                rloc16: FieldType<number>;
                routerId: FieldType<number>;
            }>[], any>;
            routingRole: Attribute<null | ThreadNetworkDiagnostics.RoutingRole, any>;
            rxAddressFilteredCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxBeaconCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxBeaconRequestCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxBroadcastCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxDataCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxDataPollCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxDestAddrFilteredCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxDuplicatedCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrFcsCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrInvalidSrcAddrCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrNoFrameCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrOtherCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrSecCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrUnknownNeighborCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxOtherCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxTotalCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxUnicastCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            securityPolicy: Attribute<null | TypeFromFields<{
                flags: FieldType<number>;
                rotationTime: FieldType<number>;
            }>, any>;
            stableDataVersion: Attribute<null | number, any>;
            txAckedCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txAckRequestedCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txBeaconCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txBeaconRequestCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txBroadcastCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txDataCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txDataPollCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txDirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txErrAbortCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txErrBusyChannelCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txErrCcaCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txIndirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txNoAckRequestedCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txOtherCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txRetryCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txTotalCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txUnicastCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            weighting: Attribute<null | number, any>;
        };
        commands: {
            resetCounts: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            connectionStatus: OptionalEvent<TypeFromFields<{
                connectionStatus: FieldType<ThreadNetworkDiagnostics.ConnectionStatus>;
            }>, any>;
            networkFaultChange: OptionalEvent<TypeFromFields<{
                current: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
                previous: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
            }>, any>;
        };
        features: {
            errorCounts: BitFlag;
            macCounts: BitFlag;
            mleCounts: BitFlag;
            packetCounts: BitFlag;
        };
        id: Branded<53, "ClusterId">;
        name: "ThreadNetworkDiagnostics";
        revision: 2;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            activeNetworkFaultsList: Attribute<ThreadNetworkDiagnostics.NetworkFault[], any>;
            activeTimestamp: OptionalAttribute<null | number | bigint, any>;
            attachAttemptCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            attributeList: Attribute<AttributeId[], never>;
            betterPartitionAttachAttemptCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            channel: Attribute<null | number, any>;
            channelPage0Mask: Attribute<null | Uint8Array, any>;
            childRoleCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            clusterRevision: Attribute<number, never>;
            dataVersion: Attribute<null | number, any>;
            delay: OptionalAttribute<null | number, any>;
            detachedRoleCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            extendedPanId: Attribute<null | number | bigint, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                errorCounts: BitFlag;
                macCounts: BitFlag;
                mleCounts: BitFlag;
                packetCounts: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            leaderRoleCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            leaderRouterId: Attribute<null | number, any>;
            meshLocalPrefix: Attribute<null | Uint8Array, any>;
            neighborTable: Attribute<TypeFromFields<{
                age: FieldType<number>;
                averageRssi: FieldType<null | number>;
                extAddress: FieldType<number | bigint>;
                frameErrorRate: FieldType<number>;
                fullNetworkData: FieldType<boolean>;
                fullThreadDevice: FieldType<boolean>;
                isChild: FieldType<boolean>;
                lastRssi: FieldType<null | number>;
                linkFrameCounter: FieldType<number>;
                lqi: FieldType<number>;
                messageErrorRate: FieldType<number>;
                mleFrameCounter: FieldType<number>;
                rloc16: FieldType<number>;
                rxOnWhenIdle: FieldType<boolean>;
            }>[], any>;
            networkName: Attribute<null | string, any>;
            operationalDatasetComponents: Attribute<null | TypeFromFields<{
                activeTimestampPresent: FieldType<boolean>;
                channelMaskPresent: FieldType<boolean>;
                channelPresent: FieldType<boolean>;
                delayPresent: FieldType<boolean>;
                extendedPanIdPresent: FieldType<boolean>;
                masterKeyPresent: FieldType<boolean>;
                meshLocalPrefixPresent: FieldType<boolean>;
                networkNamePresent: FieldType<boolean>;
                panIdPresent: FieldType<boolean>;
                pendingTimestampPresent: FieldType<boolean>;
                pskcPresent: FieldType<boolean>;
                securityPolicyPresent: FieldType<boolean>;
            }>, any>;
            overrunCount: Attribute<number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            panId: Attribute<null | number, any>;
            parentChangeCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            partitionId: Attribute<null | number, any>;
            partitionIdChangeCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            pendingTimestamp: OptionalAttribute<null | number | bigint, any>;
            routerRoleCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            routeTable: Attribute<TypeFromFields<{
                age: FieldType<number>;
                allocated: FieldType<boolean>;
                extAddress: FieldType<number | bigint>;
                linkEstablished: FieldType<boolean>;
                lqiIn: FieldType<number>;
                lqiOut: FieldType<number>;
                nextHop: FieldType<number>;
                pathCost: FieldType<number>;
                rloc16: FieldType<number>;
                routerId: FieldType<number>;
            }>[], any>;
            routingRole: Attribute<null | ThreadNetworkDiagnostics.RoutingRole, any>;
            rxAddressFilteredCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxBeaconCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxBeaconRequestCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxBroadcastCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxDataCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxDataPollCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxDestAddrFilteredCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxDuplicatedCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrFcsCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrInvalidSrcAddrCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrNoFrameCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrOtherCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrSecCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrUnknownNeighborCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxOtherCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxTotalCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxUnicastCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            securityPolicy: Attribute<null | TypeFromFields<{
                flags: FieldType<number>;
                rotationTime: FieldType<number>;
            }>, any>;
            stableDataVersion: Attribute<null | number, any>;
            txAckedCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txAckRequestedCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txBeaconCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txBeaconRequestCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txBroadcastCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txDataCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txDataPollCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txDirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txErrAbortCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txErrBusyChannelCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txErrCcaCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txIndirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txNoAckRequestedCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txOtherCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txRetryCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txTotalCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txUnicastCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            weighting: Attribute<null | number, any>;
        };
        commands: {
            resetCounts: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            connectionStatus: OptionalEvent<TypeFromFields<{
                connectionStatus: FieldType<ThreadNetworkDiagnostics.ConnectionStatus>;
            }>, any>;
            networkFaultChange: OptionalEvent<TypeFromFields<{
                current: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
                previous: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
            }>, any>;
        };
        features: {
            errorCounts: BitFlag;
            macCounts: BitFlag;
            mleCounts: BitFlag;
            packetCounts: BitFlag;
        };
        id: Branded<53, "ClusterId">;
        name: "ThreadNetworkDiagnostics";
        revision: 2;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            activeNetworkFaultsList: Attribute<ThreadNetworkDiagnostics.NetworkFault[], any>;
            activeTimestamp: OptionalAttribute<null | number | bigint, any>;
            attachAttemptCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            attributeList: Attribute<AttributeId[], never>;
            betterPartitionAttachAttemptCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            channel: Attribute<null | number, any>;
            channelPage0Mask: Attribute<null | Uint8Array, any>;
            childRoleCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            clusterRevision: Attribute<number, never>;
            dataVersion: Attribute<null | number, any>;
            delay: OptionalAttribute<null | number, any>;
            detachedRoleCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            extendedPanId: Attribute<null | number | bigint, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                errorCounts: BitFlag;
                macCounts: BitFlag;
                mleCounts: BitFlag;
                packetCounts: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            leaderRoleCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            leaderRouterId: Attribute<null | number, any>;
            meshLocalPrefix: Attribute<null | Uint8Array, any>;
            neighborTable: Attribute<TypeFromFields<{
                age: FieldType<number>;
                averageRssi: FieldType<null | number>;
                extAddress: FieldType<number | bigint>;
                frameErrorRate: FieldType<number>;
                fullNetworkData: FieldType<boolean>;
                fullThreadDevice: FieldType<boolean>;
                isChild: FieldType<boolean>;
                lastRssi: FieldType<null | number>;
                linkFrameCounter: FieldType<number>;
                lqi: FieldType<number>;
                messageErrorRate: FieldType<number>;
                mleFrameCounter: FieldType<number>;
                rloc16: FieldType<number>;
                rxOnWhenIdle: FieldType<boolean>;
            }>[], any>;
            networkName: Attribute<null | string, any>;
            operationalDatasetComponents: Attribute<null | TypeFromFields<{
                activeTimestampPresent: FieldType<boolean>;
                channelMaskPresent: FieldType<boolean>;
                channelPresent: FieldType<boolean>;
                delayPresent: FieldType<boolean>;
                extendedPanIdPresent: FieldType<boolean>;
                masterKeyPresent: FieldType<boolean>;
                meshLocalPrefixPresent: FieldType<boolean>;
                networkNamePresent: FieldType<boolean>;
                panIdPresent: FieldType<boolean>;
                pendingTimestampPresent: FieldType<boolean>;
                pskcPresent: FieldType<boolean>;
                securityPolicyPresent: FieldType<boolean>;
            }>, any>;
            overrunCount: Attribute<number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            panId: Attribute<null | number, any>;
            parentChangeCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            partitionId: Attribute<null | number, any>;
            partitionIdChangeCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            pendingTimestamp: OptionalAttribute<null | number | bigint, any>;
            routerRoleCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    mleCounts: boolean;
                }];
            };
            routeTable: Attribute<TypeFromFields<{
                age: FieldType<number>;
                allocated: FieldType<boolean>;
                extAddress: FieldType<number | bigint>;
                linkEstablished: FieldType<boolean>;
                lqiIn: FieldType<number>;
                lqiOut: FieldType<number>;
                nextHop: FieldType<number>;
                pathCost: FieldType<number>;
                rloc16: FieldType<number>;
                routerId: FieldType<number>;
            }>[], any>;
            routingRole: Attribute<null | ThreadNetworkDiagnostics.RoutingRole, any>;
            rxAddressFilteredCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxBeaconCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxBeaconRequestCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxBroadcastCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxDataCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxDataPollCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxDestAddrFilteredCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxDuplicatedCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrFcsCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrInvalidSrcAddrCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrNoFrameCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrOtherCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrSecCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxErrUnknownNeighborCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxOtherCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxTotalCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            rxUnicastCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            securityPolicy: Attribute<null | TypeFromFields<{
                flags: FieldType<number>;
                rotationTime: FieldType<number>;
            }>, any>;
            stableDataVersion: Attribute<null | number, any>;
            txAckedCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txAckRequestedCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txBeaconCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txBeaconRequestCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txBroadcastCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txDataCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txDataPollCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txDirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txErrAbortCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txErrBusyChannelCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txErrCcaCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txIndirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txNoAckRequestedCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txOtherCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txRetryCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txTotalCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            txUnicastCount: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    macCounts: boolean;
                }];
            };
            weighting: Attribute<null | number, any>;
        };
        commands: {
            resetCounts: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            connectionStatus: OptionalEvent<TypeFromFields<{
                connectionStatus: FieldType<ThreadNetworkDiagnostics.ConnectionStatus>;
            }>, any>;
            networkFaultChange: OptionalEvent<TypeFromFields<{
                current: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
                previous: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
            }>, any>;
        };
        features: {
            errorCounts: BitFlag;
            macCounts: BitFlag;
            mleCounts: BitFlag;
            packetCounts: BitFlag;
        };
        id: Branded<53, "ClusterId">;
        name: "ThreadNetworkDiagnostics";
        revision: 2;
    }>, SelectionT>;
}

Hierarchy (view full)

Identity<typeof ThreadNetworkDiagnostics.CompleteInstance>
- Complete

Index

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: Merge<{
    acceptedCommandList: Attribute<CommandId[], never>;
    activeNetworkFaultsList: Attribute<ThreadNetworkDiagnostics.NetworkFault[], any>;
    activeTimestamp: OptionalAttribute<null | number | bigint, any>;
    attachAttemptCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            mleCounts: boolean;
        }];
    };
    attributeList: Attribute<AttributeId[], never>;
    betterPartitionAttachAttemptCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            mleCounts: boolean;
        }];
    };
    channel: Attribute<null | number, any>;
    channelPage0Mask: Attribute<null | Uint8Array, any>;
    childRoleCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            mleCounts: boolean;
        }];
    };
    clusterRevision: Attribute<number, never>;
    dataVersion: Attribute<null | number, any>;
    delay: OptionalAttribute<null | number, any>;
    detachedRoleCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            mleCounts: boolean;
        }];
    };
    extendedPanId: Attribute<null | number | bigint, any>;
    featureMap: Attribute<TypeFromPartialBitSchema<{
        errorCounts: BitFlag;
        macCounts: BitFlag;
        mleCounts: BitFlag;
        packetCounts: BitFlag;
    }>, never>;
    generatedCommandList: Attribute<CommandId[], never>;
    leaderRoleCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            mleCounts: boolean;
        }];
    };
    leaderRouterId: Attribute<null | number, any>;
    meshLocalPrefix: Attribute<null | Uint8Array, any>;
    neighborTable: Attribute<TypeFromFields<{
        age: FieldType<number>;
        averageRssi: FieldType<null | number>;
        extAddress: FieldType<number | bigint>;
        frameErrorRate: FieldType<number>;
        fullNetworkData: FieldType<boolean>;
        fullThreadDevice: FieldType<boolean>;
        isChild: FieldType<boolean>;
        lastRssi: FieldType<null | number>;
        linkFrameCounter: FieldType<number>;
        lqi: FieldType<number>;
        messageErrorRate: FieldType<number>;
        mleFrameCounter: FieldType<number>;
        rloc16: FieldType<number>;
        rxOnWhenIdle: FieldType<boolean>;
    }>[], any>;
    networkName: Attribute<null | string, any>;
    operationalDatasetComponents: Attribute<null | TypeFromFields<{
        activeTimestampPresent: FieldType<boolean>;
        channelMaskPresent: FieldType<boolean>;
        channelPresent: FieldType<boolean>;
        delayPresent: FieldType<boolean>;
        extendedPanIdPresent: FieldType<boolean>;
        masterKeyPresent: FieldType<boolean>;
        meshLocalPrefixPresent: FieldType<boolean>;
        networkNamePresent: FieldType<boolean>;
        panIdPresent: FieldType<boolean>;
        pendingTimestampPresent: FieldType<boolean>;
        pskcPresent: FieldType<boolean>;
        securityPolicyPresent: FieldType<boolean>;
    }>, any>;
    overrunCount: Attribute<number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            errorCounts: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    panId: Attribute<null | number, any>;
    parentChangeCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            mleCounts: boolean;
        }];
    };
    partitionId: Attribute<null | number, any>;
    partitionIdChangeCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            mleCounts: boolean;
        }];
    };
    pendingTimestamp: OptionalAttribute<null | number | bigint, any>;
    routerRoleCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            mleCounts: boolean;
        }];
    };
    routeTable: Attribute<TypeFromFields<{
        age: FieldType<number>;
        allocated: FieldType<boolean>;
        extAddress: FieldType<number | bigint>;
        linkEstablished: FieldType<boolean>;
        lqiIn: FieldType<number>;
        lqiOut: FieldType<number>;
        nextHop: FieldType<number>;
        pathCost: FieldType<number>;
        rloc16: FieldType<number>;
        routerId: FieldType<number>;
    }>[], any>;
    routingRole: Attribute<null | ThreadNetworkDiagnostics.RoutingRole, any>;
    rxAddressFilteredCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    rxBeaconCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    rxBeaconRequestCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    rxBroadcastCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    rxDataCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    rxDataPollCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    rxDestAddrFilteredCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    rxDuplicatedCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    rxErrFcsCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    rxErrInvalidSrcAddrCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    rxErrNoFrameCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    rxErrOtherCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    rxErrSecCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    rxErrUnknownNeighborCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    rxOtherCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    rxTotalCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    rxUnicastCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    securityPolicy: Attribute<null | TypeFromFields<{
        flags: FieldType<number>;
        rotationTime: FieldType<number>;
    }>, any>;
    stableDataVersion: Attribute<null | number, any>;
    txAckedCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    txAckRequestedCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    txBeaconCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    txBeaconRequestCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    txBroadcastCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    txDataCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    txDataPollCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    txDirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    txErrAbortCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    txErrBusyChannelCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    txErrCcaCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    txIndirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    txNoAckRequestedCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    txOtherCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    txRetryCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    txTotalCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    txUnicastCount: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            macCounts: boolean;
        }];
    };
    weighting: Attribute<null | number, any>;
}, GlobalAttributes<{
    errorCounts: BitFlag;
    macCounts: BitFlag;
    mleCounts: BitFlag;
    packetCounts: BitFlag;
}>>

base

base: undefined

commands

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

events

events: {
    connectionStatus: OptionalEvent<TypeFromFields<{
        connectionStatus: FieldType<ThreadNetworkDiagnostics.ConnectionStatus>;
    }>, any>;
    networkFaultChange: OptionalEvent<TypeFromFields<{
        current: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
        previous: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
    }>, any>;
}

Type declaration

ReadonlyconnectionStatus: OptionalEvent<TypeFromFields<{
connectionStatus: FieldType<ThreadNetworkDiagnostics.ConnectionStatus>;
}>, 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<{
current: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
previous: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
}>, 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

extensions

extensions: undefined

features

features: {
    errorCounts: BitFlag;
    macCounts: BitFlag;
    mleCounts: BitFlag;
    packetCounts: BitFlag;
}

Type declaration

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.

id

id: Branded<Branded<53, "ClusterId">, "ClusterId">

name

revision

supportedFeatures

supportedFeatures: {}

unknown

Methods

alter

alter<const AlterationsT>(alterations): WithAlterations<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeNetworkFaultsList: Attribute<ThreadNetworkDiagnostics.NetworkFault[], any>;
        activeTimestamp: OptionalAttribute<null | number | bigint, any>;
        attachAttemptCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        attributeList: Attribute<AttributeId[], never>;
        betterPartitionAttachAttemptCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        channel: Attribute<null | number, any>;
        channelPage0Mask: Attribute<null | Uint8Array, any>;
        childRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        clusterRevision: Attribute<number, never>;
        dataVersion: Attribute<null | number, any>;
        delay: OptionalAttribute<null | number, any>;
        detachedRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        extendedPanId: Attribute<null | number | bigint, any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            errorCounts: BitFlag;
            macCounts: BitFlag;
            mleCounts: BitFlag;
            packetCounts: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        leaderRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        leaderRouterId: Attribute<null | number, any>;
        meshLocalPrefix: Attribute<null | Uint8Array, any>;
        neighborTable: Attribute<TypeFromFields<{
            age: FieldType<number>;
            averageRssi: FieldType<null | number>;
            extAddress: FieldType<number | bigint>;
            frameErrorRate: FieldType<number>;
            fullNetworkData: FieldType<boolean>;
            fullThreadDevice: FieldType<boolean>;
            isChild: FieldType<boolean>;
            lastRssi: FieldType<null | number>;
            linkFrameCounter: FieldType<number>;
            lqi: FieldType<number>;
            messageErrorRate: FieldType<number>;
            mleFrameCounter: FieldType<number>;
            rloc16: FieldType<number>;
            rxOnWhenIdle: FieldType<boolean>;
        }>[], any>;
        networkName: Attribute<null | string, any>;
        operationalDatasetComponents: Attribute<null | TypeFromFields<{
            activeTimestampPresent: FieldType<boolean>;
            channelMaskPresent: FieldType<boolean>;
            channelPresent: FieldType<boolean>;
            delayPresent: FieldType<boolean>;
            extendedPanIdPresent: FieldType<boolean>;
            masterKeyPresent: FieldType<boolean>;
            meshLocalPrefixPresent: FieldType<boolean>;
            networkNamePresent: FieldType<boolean>;
            panIdPresent: FieldType<boolean>;
            pendingTimestampPresent: FieldType<boolean>;
            pskcPresent: FieldType<boolean>;
            securityPolicyPresent: FieldType<boolean>;
        }>, any>;
        overrunCount: Attribute<number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                errorCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        panId: Attribute<null | number, any>;
        parentChangeCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        partitionId: Attribute<null | number, any>;
        partitionIdChangeCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        pendingTimestamp: OptionalAttribute<null | number | bigint, any>;
        routerRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        routeTable: Attribute<TypeFromFields<{
            age: FieldType<number>;
            allocated: FieldType<boolean>;
            extAddress: FieldType<number | bigint>;
            linkEstablished: FieldType<boolean>;
            lqiIn: FieldType<number>;
            lqiOut: FieldType<number>;
            nextHop: FieldType<number>;
            pathCost: FieldType<number>;
            rloc16: FieldType<number>;
            routerId: FieldType<number>;
        }>[], any>;
        routingRole: Attribute<null | ThreadNetworkDiagnostics.RoutingRole, any>;
        rxAddressFilteredCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBeaconCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBeaconRequestCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBroadcastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDataCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDataPollCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDestAddrFilteredCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDuplicatedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrFcsCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrInvalidSrcAddrCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrNoFrameCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrSecCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrUnknownNeighborCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxTotalCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxUnicastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        securityPolicy: Attribute<null | TypeFromFields<{
            flags: FieldType<number>;
            rotationTime: FieldType<number>;
        }>, any>;
        stableDataVersion: Attribute<null | number, any>;
        txAckedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txAckRequestedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBeaconCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBeaconRequestCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBroadcastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDataCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDataPollCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrAbortCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrBusyChannelCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrCcaCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txIndirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txNoAckRequestedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txRetryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txTotalCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txUnicastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        weighting: Attribute<null | number, any>;
    };
    commands: {
        resetCounts: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                errorCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        connectionStatus: OptionalEvent<TypeFromFields<{
            connectionStatus: FieldType<ThreadNetworkDiagnostics.ConnectionStatus>;
        }>, any>;
        networkFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
            previous: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
        }>, any>;
    };
    features: {
        errorCounts: BitFlag;
        macCounts: BitFlag;
        mleCounts: BitFlag;
        packetCounts: BitFlag;
    };
    id: Branded<53, "ClusterId">;
    name: "ThreadNetworkDiagnostics";
    revision: 2;
}>, AlterationsT>
Modify elements using ElementModifier.alter.
Type Parameters
- const AlterationsT extends Alterations<Of<{
      attributes: {
          acceptedCommandList: Attribute<CommandId[], never>;
          activeNetworkFaultsList: Attribute<ThreadNetworkDiagnostics.NetworkFault[], any>;
          activeTimestamp: OptionalAttribute<null | number | bigint, any>;
          attachAttemptCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          attributeList: Attribute<AttributeId[], never>;
          betterPartitionAttachAttemptCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          channel: Attribute<null | number, any>;
          channelPage0Mask: Attribute<null | Uint8Array, any>;
          childRoleCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          clusterRevision: Attribute<number, never>;
          dataVersion: Attribute<null | number, any>;
          delay: OptionalAttribute<null | number, any>;
          detachedRoleCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          extendedPanId: Attribute<null | number | bigint, any>;
          featureMap: Attribute<TypeFromPartialBitSchema<{
              errorCounts: BitFlag;
              macCounts: BitFlag;
              mleCounts: BitFlag;
              packetCounts: BitFlag;
          }>, never>;
          generatedCommandList: Attribute<CommandId[], never>;
          leaderRoleCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          leaderRouterId: Attribute<null | number, any>;
          meshLocalPrefix: Attribute<null | Uint8Array, any>;
          neighborTable: Attribute<TypeFromFields<{
              age: FieldType<number>;
              averageRssi: FieldType<null | number>;
              extAddress: FieldType<number | bigint>;
              frameErrorRate: FieldType<number>;
              fullNetworkData: FieldType<boolean>;
              fullThreadDevice: FieldType<boolean>;
              isChild: FieldType<boolean>;
              lastRssi: FieldType<null | number>;
              linkFrameCounter: FieldType<number>;
              lqi: FieldType<number>;
              messageErrorRate: FieldType<number>;
              mleFrameCounter: FieldType<number>;
              rloc16: FieldType<number>;
              rxOnWhenIdle: FieldType<boolean>;
          }>[], any>;
          networkName: Attribute<null | string, any>;
          operationalDatasetComponents: Attribute<null | TypeFromFields<{
              activeTimestampPresent: FieldType<boolean>;
              channelMaskPresent: FieldType<boolean>;
              channelPresent: FieldType<boolean>;
              delayPresent: FieldType<boolean>;
              extendedPanIdPresent: FieldType<boolean>;
              masterKeyPresent: FieldType<boolean>;
              meshLocalPrefixPresent: FieldType<boolean>;
              networkNamePresent: FieldType<boolean>;
              panIdPresent: FieldType<boolean>;
              pendingTimestampPresent: FieldType<boolean>;
              pskcPresent: FieldType<boolean>;
              securityPolicyPresent: FieldType<boolean>;
          }>, any>;
          overrunCount: Attribute<number | bigint, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  errorCounts: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          panId: Attribute<null | number, any>;
          parentChangeCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          partitionId: Attribute<null | number, any>;
          partitionIdChangeCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          pendingTimestamp: OptionalAttribute<null | number | bigint, any>;
          routerRoleCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          routeTable: Attribute<TypeFromFields<{
              age: FieldType<number>;
              allocated: FieldType<boolean>;
              extAddress: FieldType<number | bigint>;
              linkEstablished: FieldType<boolean>;
              lqiIn: FieldType<number>;
              lqiOut: FieldType<number>;
              nextHop: FieldType<number>;
              pathCost: FieldType<number>;
              rloc16: FieldType<number>;
              routerId: FieldType<number>;
          }>[], any>;
          routingRole: Attribute<null | ThreadNetworkDiagnostics.RoutingRole, any>;
          rxAddressFilteredCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxBeaconCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxBeaconRequestCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxBroadcastCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxDataCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxDataPollCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxDestAddrFilteredCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxDuplicatedCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxErrFcsCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxErrInvalidSrcAddrCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxErrNoFrameCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxErrOtherCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxErrSecCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxErrUnknownNeighborCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxOtherCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxTotalCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxUnicastCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          securityPolicy: Attribute<null | TypeFromFields<{
              flags: FieldType<number>;
              rotationTime: FieldType<number>;
          }>, any>;
          stableDataVersion: Attribute<null | number, any>;
          txAckedCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txAckRequestedCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txBeaconCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txBeaconRequestCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txBroadcastCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txDataCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txDataPollCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txDirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txErrAbortCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txErrBusyChannelCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txErrCcaCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txIndirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txNoAckRequestedCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txOtherCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txRetryCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txTotalCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txUnicastCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          weighting: Attribute<null | number, any>;
      };
      commands: {
          resetCounts: Command<void, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  errorCounts: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      events: {
          connectionStatus: OptionalEvent<TypeFromFields<{
              connectionStatus: FieldType<ThreadNetworkDiagnostics.ConnectionStatus>;
          }>, any>;
          networkFaultChange: OptionalEvent<TypeFromFields<{
              current: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
              previous: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
          }>, any>;
      };
      features: {
          errorCounts: BitFlag;
          macCounts: BitFlag;
          mleCounts: BitFlag;
          packetCounts: BitFlag;
      };
      id: Branded<53, "ClusterId">;
      name: "ThreadNetworkDiagnostics";
      revision: 2;
  }>>
Parameters
- alterations: AlterationsT
Returns WithAlterations<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeNetworkFaultsList: Attribute<ThreadNetworkDiagnostics.NetworkFault[], any>;
        activeTimestamp: OptionalAttribute<null | number | bigint, any>;
        attachAttemptCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        attributeList: Attribute<AttributeId[], never>;
        betterPartitionAttachAttemptCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        channel: Attribute<null | number, any>;
        channelPage0Mask: Attribute<null | Uint8Array, any>;
        childRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        clusterRevision: Attribute<number, never>;
        dataVersion: Attribute<null | number, any>;
        delay: OptionalAttribute<null | number, any>;
        detachedRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        extendedPanId: Attribute<null | number | bigint, any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            errorCounts: BitFlag;
            macCounts: BitFlag;
            mleCounts: BitFlag;
            packetCounts: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        leaderRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        leaderRouterId: Attribute<null | number, any>;
        meshLocalPrefix: Attribute<null | Uint8Array, any>;
        neighborTable: Attribute<TypeFromFields<{
            age: FieldType<number>;
            averageRssi: FieldType<null | number>;
            extAddress: FieldType<number | bigint>;
            frameErrorRate: FieldType<number>;
            fullNetworkData: FieldType<boolean>;
            fullThreadDevice: FieldType<boolean>;
            isChild: FieldType<boolean>;
            lastRssi: FieldType<null | number>;
            linkFrameCounter: FieldType<number>;
            lqi: FieldType<number>;
            messageErrorRate: FieldType<number>;
            mleFrameCounter: FieldType<number>;
            rloc16: FieldType<number>;
            rxOnWhenIdle: FieldType<boolean>;
        }>[], any>;
        networkName: Attribute<null | string, any>;
        operationalDatasetComponents: Attribute<null | TypeFromFields<{
            activeTimestampPresent: FieldType<boolean>;
            channelMaskPresent: FieldType<boolean>;
            channelPresent: FieldType<boolean>;
            delayPresent: FieldType<boolean>;
            extendedPanIdPresent: FieldType<boolean>;
            masterKeyPresent: FieldType<boolean>;
            meshLocalPrefixPresent: FieldType<boolean>;
            networkNamePresent: FieldType<boolean>;
            panIdPresent: FieldType<boolean>;
            pendingTimestampPresent: FieldType<boolean>;
            pskcPresent: FieldType<boolean>;
            securityPolicyPresent: FieldType<boolean>;
        }>, any>;
        overrunCount: Attribute<number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                errorCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        panId: Attribute<null | number, any>;
        parentChangeCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        partitionId: Attribute<null | number, any>;
        partitionIdChangeCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        pendingTimestamp: OptionalAttribute<null | number | bigint, any>;
        routerRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        routeTable: Attribute<TypeFromFields<{
            age: FieldType<number>;
            allocated: FieldType<boolean>;
            extAddress: FieldType<number | bigint>;
            linkEstablished: FieldType<boolean>;
            lqiIn: FieldType<number>;
            lqiOut: FieldType<number>;
            nextHop: FieldType<number>;
            pathCost: FieldType<number>;
            rloc16: FieldType<number>;
            routerId: FieldType<number>;
        }>[], any>;
        routingRole: Attribute<null | ThreadNetworkDiagnostics.RoutingRole, any>;
        rxAddressFilteredCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBeaconCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBeaconRequestCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBroadcastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDataCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDataPollCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDestAddrFilteredCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDuplicatedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrFcsCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrInvalidSrcAddrCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrNoFrameCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrSecCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrUnknownNeighborCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxTotalCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxUnicastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        securityPolicy: Attribute<null | TypeFromFields<{
            flags: FieldType<number>;
            rotationTime: FieldType<number>;
        }>, any>;
        stableDataVersion: Attribute<null | number, any>;
        txAckedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txAckRequestedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBeaconCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBeaconRequestCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBroadcastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDataCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDataPollCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrAbortCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrBusyChannelCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrCcaCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txIndirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txNoAckRequestedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txRetryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txTotalCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txUnicastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        weighting: Attribute<null | number, any>;
    };
    commands: {
        resetCounts: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                errorCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        connectionStatus: OptionalEvent<TypeFromFields<{
            connectionStatus: FieldType<ThreadNetworkDiagnostics.ConnectionStatus>;
        }>, any>;
        networkFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
            previous: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
        }>, any>;
    };
    features: {
        errorCounts: BitFlag;
        macCounts: BitFlag;
        mleCounts: BitFlag;
        packetCounts: BitFlag;
    };
    id: Branded<53, "ClusterId">;
    name: "ThreadNetworkDiagnostics";
    revision: 2;
}>, AlterationsT>
Inherited from Identity.alter
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:37

enable

enable<const FlagsT>(flags): WithFlags<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeNetworkFaultsList: Attribute<ThreadNetworkDiagnostics.NetworkFault[], any>;
        activeTimestamp: OptionalAttribute<null | number | bigint, any>;
        attachAttemptCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        attributeList: Attribute<AttributeId[], never>;
        betterPartitionAttachAttemptCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        channel: Attribute<null | number, any>;
        channelPage0Mask: Attribute<null | Uint8Array, any>;
        childRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        clusterRevision: Attribute<number, never>;
        dataVersion: Attribute<null | number, any>;
        delay: OptionalAttribute<null | number, any>;
        detachedRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        extendedPanId: Attribute<null | number | bigint, any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            errorCounts: BitFlag;
            macCounts: BitFlag;
            mleCounts: BitFlag;
            packetCounts: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        leaderRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        leaderRouterId: Attribute<null | number, any>;
        meshLocalPrefix: Attribute<null | Uint8Array, any>;
        neighborTable: Attribute<TypeFromFields<{
            age: FieldType<number>;
            averageRssi: FieldType<null | number>;
            extAddress: FieldType<number | bigint>;
            frameErrorRate: FieldType<number>;
            fullNetworkData: FieldType<boolean>;
            fullThreadDevice: FieldType<boolean>;
            isChild: FieldType<boolean>;
            lastRssi: FieldType<null | number>;
            linkFrameCounter: FieldType<number>;
            lqi: FieldType<number>;
            messageErrorRate: FieldType<number>;
            mleFrameCounter: FieldType<number>;
            rloc16: FieldType<number>;
            rxOnWhenIdle: FieldType<boolean>;
        }>[], any>;
        networkName: Attribute<null | string, any>;
        operationalDatasetComponents: Attribute<null | TypeFromFields<{
            activeTimestampPresent: FieldType<boolean>;
            channelMaskPresent: FieldType<boolean>;
            channelPresent: FieldType<boolean>;
            delayPresent: FieldType<boolean>;
            extendedPanIdPresent: FieldType<boolean>;
            masterKeyPresent: FieldType<boolean>;
            meshLocalPrefixPresent: FieldType<boolean>;
            networkNamePresent: FieldType<boolean>;
            panIdPresent: FieldType<boolean>;
            pendingTimestampPresent: FieldType<boolean>;
            pskcPresent: FieldType<boolean>;
            securityPolicyPresent: FieldType<boolean>;
        }>, any>;
        overrunCount: Attribute<number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                errorCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        panId: Attribute<null | number, any>;
        parentChangeCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        partitionId: Attribute<null | number, any>;
        partitionIdChangeCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        pendingTimestamp: OptionalAttribute<null | number | bigint, any>;
        routerRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        routeTable: Attribute<TypeFromFields<{
            age: FieldType<number>;
            allocated: FieldType<boolean>;
            extAddress: FieldType<number | bigint>;
            linkEstablished: FieldType<boolean>;
            lqiIn: FieldType<number>;
            lqiOut: FieldType<number>;
            nextHop: FieldType<number>;
            pathCost: FieldType<number>;
            rloc16: FieldType<number>;
            routerId: FieldType<number>;
        }>[], any>;
        routingRole: Attribute<null | ThreadNetworkDiagnostics.RoutingRole, any>;
        rxAddressFilteredCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBeaconCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBeaconRequestCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBroadcastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDataCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDataPollCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDestAddrFilteredCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDuplicatedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrFcsCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrInvalidSrcAddrCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrNoFrameCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrSecCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrUnknownNeighborCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxTotalCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxUnicastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        securityPolicy: Attribute<null | TypeFromFields<{
            flags: FieldType<number>;
            rotationTime: FieldType<number>;
        }>, any>;
        stableDataVersion: Attribute<null | number, any>;
        txAckedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txAckRequestedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBeaconCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBeaconRequestCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBroadcastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDataCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDataPollCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrAbortCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrBusyChannelCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrCcaCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txIndirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txNoAckRequestedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txRetryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txTotalCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txUnicastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        weighting: Attribute<null | number, any>;
    };
    commands: {
        resetCounts: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                errorCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        connectionStatus: OptionalEvent<TypeFromFields<{
            connectionStatus: FieldType<ThreadNetworkDiagnostics.ConnectionStatus>;
        }>, any>;
        networkFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
            previous: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
        }>, any>;
    };
    features: {
        errorCounts: BitFlag;
        macCounts: BitFlag;
        mleCounts: BitFlag;
        packetCounts: BitFlag;
    };
    id: Branded<53, "ClusterId">;
    name: "ThreadNetworkDiagnostics";
    revision: 2;
}>, FlagsT>
Modify elements using ElementModifier.enable.
Type Parameters
- const FlagsT extends ElementFlags<Of<{
      attributes: {
          acceptedCommandList: Attribute<CommandId[], never>;
          activeNetworkFaultsList: Attribute<ThreadNetworkDiagnostics.NetworkFault[], any>;
          activeTimestamp: OptionalAttribute<null | number | bigint, any>;
          attachAttemptCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          attributeList: Attribute<AttributeId[], never>;
          betterPartitionAttachAttemptCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          channel: Attribute<null | number, any>;
          channelPage0Mask: Attribute<null | Uint8Array, any>;
          childRoleCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          clusterRevision: Attribute<number, never>;
          dataVersion: Attribute<null | number, any>;
          delay: OptionalAttribute<null | number, any>;
          detachedRoleCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          extendedPanId: Attribute<null | number | bigint, any>;
          featureMap: Attribute<TypeFromPartialBitSchema<{
              errorCounts: BitFlag;
              macCounts: BitFlag;
              mleCounts: BitFlag;
              packetCounts: BitFlag;
          }>, never>;
          generatedCommandList: Attribute<CommandId[], never>;
          leaderRoleCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          leaderRouterId: Attribute<null | number, any>;
          meshLocalPrefix: Attribute<null | Uint8Array, any>;
          neighborTable: Attribute<TypeFromFields<{
              age: FieldType<number>;
              averageRssi: FieldType<null | number>;
              extAddress: FieldType<number | bigint>;
              frameErrorRate: FieldType<number>;
              fullNetworkData: FieldType<boolean>;
              fullThreadDevice: FieldType<boolean>;
              isChild: FieldType<boolean>;
              lastRssi: FieldType<null | number>;
              linkFrameCounter: FieldType<number>;
              lqi: FieldType<number>;
              messageErrorRate: FieldType<number>;
              mleFrameCounter: FieldType<number>;
              rloc16: FieldType<number>;
              rxOnWhenIdle: FieldType<boolean>;
          }>[], any>;
          networkName: Attribute<null | string, any>;
          operationalDatasetComponents: Attribute<null | TypeFromFields<{
              activeTimestampPresent: FieldType<boolean>;
              channelMaskPresent: FieldType<boolean>;
              channelPresent: FieldType<boolean>;
              delayPresent: FieldType<boolean>;
              extendedPanIdPresent: FieldType<boolean>;
              masterKeyPresent: FieldType<boolean>;
              meshLocalPrefixPresent: FieldType<boolean>;
              networkNamePresent: FieldType<boolean>;
              panIdPresent: FieldType<boolean>;
              pendingTimestampPresent: FieldType<boolean>;
              pskcPresent: FieldType<boolean>;
              securityPolicyPresent: FieldType<boolean>;
          }>, any>;
          overrunCount: Attribute<number | bigint, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  errorCounts: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          panId: Attribute<null | number, any>;
          parentChangeCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          partitionId: Attribute<null | number, any>;
          partitionIdChangeCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          pendingTimestamp: OptionalAttribute<null | number | bigint, any>;
          routerRoleCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          routeTable: Attribute<TypeFromFields<{
              age: FieldType<number>;
              allocated: FieldType<boolean>;
              extAddress: FieldType<number | bigint>;
              linkEstablished: FieldType<boolean>;
              lqiIn: FieldType<number>;
              lqiOut: FieldType<number>;
              nextHop: FieldType<number>;
              pathCost: FieldType<number>;
              rloc16: FieldType<number>;
              routerId: FieldType<number>;
          }>[], any>;
          routingRole: Attribute<null | ThreadNetworkDiagnostics.RoutingRole, any>;
          rxAddressFilteredCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxBeaconCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxBeaconRequestCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxBroadcastCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxDataCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxDataPollCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxDestAddrFilteredCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxDuplicatedCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxErrFcsCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxErrInvalidSrcAddrCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxErrNoFrameCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxErrOtherCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxErrSecCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxErrUnknownNeighborCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxOtherCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxTotalCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxUnicastCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          securityPolicy: Attribute<null | TypeFromFields<{
              flags: FieldType<number>;
              rotationTime: FieldType<number>;
          }>, any>;
          stableDataVersion: Attribute<null | number, any>;
          txAckedCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txAckRequestedCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txBeaconCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txBeaconRequestCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txBroadcastCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txDataCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txDataPollCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txDirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txErrAbortCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txErrBusyChannelCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txErrCcaCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txIndirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txNoAckRequestedCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txOtherCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txRetryCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txTotalCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txUnicastCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          weighting: Attribute<null | number, any>;
      };
      commands: {
          resetCounts: Command<void, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  errorCounts: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      events: {
          connectionStatus: OptionalEvent<TypeFromFields<{
              connectionStatus: FieldType<ThreadNetworkDiagnostics.ConnectionStatus>;
          }>, any>;
          networkFaultChange: OptionalEvent<TypeFromFields<{
              current: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
              previous: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
          }>, any>;
      };
      features: {
          errorCounts: BitFlag;
          macCounts: BitFlag;
          mleCounts: BitFlag;
          packetCounts: BitFlag;
      };
      id: Branded<53, "ClusterId">;
      name: "ThreadNetworkDiagnostics";
      revision: 2;
  }>>
Parameters
- flags: FlagsT
Returns WithFlags<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeNetworkFaultsList: Attribute<ThreadNetworkDiagnostics.NetworkFault[], any>;
        activeTimestamp: OptionalAttribute<null | number | bigint, any>;
        attachAttemptCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        attributeList: Attribute<AttributeId[], never>;
        betterPartitionAttachAttemptCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        channel: Attribute<null | number, any>;
        channelPage0Mask: Attribute<null | Uint8Array, any>;
        childRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        clusterRevision: Attribute<number, never>;
        dataVersion: Attribute<null | number, any>;
        delay: OptionalAttribute<null | number, any>;
        detachedRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        extendedPanId: Attribute<null | number | bigint, any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            errorCounts: BitFlag;
            macCounts: BitFlag;
            mleCounts: BitFlag;
            packetCounts: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        leaderRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        leaderRouterId: Attribute<null | number, any>;
        meshLocalPrefix: Attribute<null | Uint8Array, any>;
        neighborTable: Attribute<TypeFromFields<{
            age: FieldType<number>;
            averageRssi: FieldType<null | number>;
            extAddress: FieldType<number | bigint>;
            frameErrorRate: FieldType<number>;
            fullNetworkData: FieldType<boolean>;
            fullThreadDevice: FieldType<boolean>;
            isChild: FieldType<boolean>;
            lastRssi: FieldType<null | number>;
            linkFrameCounter: FieldType<number>;
            lqi: FieldType<number>;
            messageErrorRate: FieldType<number>;
            mleFrameCounter: FieldType<number>;
            rloc16: FieldType<number>;
            rxOnWhenIdle: FieldType<boolean>;
        }>[], any>;
        networkName: Attribute<null | string, any>;
        operationalDatasetComponents: Attribute<null | TypeFromFields<{
            activeTimestampPresent: FieldType<boolean>;
            channelMaskPresent: FieldType<boolean>;
            channelPresent: FieldType<boolean>;
            delayPresent: FieldType<boolean>;
            extendedPanIdPresent: FieldType<boolean>;
            masterKeyPresent: FieldType<boolean>;
            meshLocalPrefixPresent: FieldType<boolean>;
            networkNamePresent: FieldType<boolean>;
            panIdPresent: FieldType<boolean>;
            pendingTimestampPresent: FieldType<boolean>;
            pskcPresent: FieldType<boolean>;
            securityPolicyPresent: FieldType<boolean>;
        }>, any>;
        overrunCount: Attribute<number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                errorCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        panId: Attribute<null | number, any>;
        parentChangeCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        partitionId: Attribute<null | number, any>;
        partitionIdChangeCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        pendingTimestamp: OptionalAttribute<null | number | bigint, any>;
        routerRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        routeTable: Attribute<TypeFromFields<{
            age: FieldType<number>;
            allocated: FieldType<boolean>;
            extAddress: FieldType<number | bigint>;
            linkEstablished: FieldType<boolean>;
            lqiIn: FieldType<number>;
            lqiOut: FieldType<number>;
            nextHop: FieldType<number>;
            pathCost: FieldType<number>;
            rloc16: FieldType<number>;
            routerId: FieldType<number>;
        }>[], any>;
        routingRole: Attribute<null | ThreadNetworkDiagnostics.RoutingRole, any>;
        rxAddressFilteredCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBeaconCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBeaconRequestCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBroadcastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDataCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDataPollCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDestAddrFilteredCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDuplicatedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrFcsCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrInvalidSrcAddrCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrNoFrameCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrSecCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrUnknownNeighborCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxTotalCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxUnicastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        securityPolicy: Attribute<null | TypeFromFields<{
            flags: FieldType<number>;
            rotationTime: FieldType<number>;
        }>, any>;
        stableDataVersion: Attribute<null | number, any>;
        txAckedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txAckRequestedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBeaconCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBeaconRequestCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBroadcastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDataCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDataPollCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrAbortCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrBusyChannelCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrCcaCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txIndirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txNoAckRequestedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txRetryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txTotalCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txUnicastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        weighting: Attribute<null | number, any>;
    };
    commands: {
        resetCounts: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                errorCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        connectionStatus: OptionalEvent<TypeFromFields<{
            connectionStatus: FieldType<ThreadNetworkDiagnostics.ConnectionStatus>;
        }>, any>;
        networkFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
            previous: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
        }>, any>;
    };
    features: {
        errorCounts: BitFlag;
        macCounts: BitFlag;
        mleCounts: BitFlag;
        packetCounts: BitFlag;
    };
    id: Branded<53, "ClusterId">;
    name: "ThreadNetworkDiagnostics";
    revision: 2;
}>, FlagsT>
Inherited from Identity.enable
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:45

set

set<const ValuesT>(values): WithValues<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeNetworkFaultsList: Attribute<ThreadNetworkDiagnostics.NetworkFault[], any>;
        activeTimestamp: OptionalAttribute<null | number | bigint, any>;
        attachAttemptCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        attributeList: Attribute<AttributeId[], never>;
        betterPartitionAttachAttemptCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        channel: Attribute<null | number, any>;
        channelPage0Mask: Attribute<null | Uint8Array, any>;
        childRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        clusterRevision: Attribute<number, never>;
        dataVersion: Attribute<null | number, any>;
        delay: OptionalAttribute<null | number, any>;
        detachedRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        extendedPanId: Attribute<null | number | bigint, any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            errorCounts: BitFlag;
            macCounts: BitFlag;
            mleCounts: BitFlag;
            packetCounts: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        leaderRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        leaderRouterId: Attribute<null | number, any>;
        meshLocalPrefix: Attribute<null | Uint8Array, any>;
        neighborTable: Attribute<TypeFromFields<{
            age: FieldType<number>;
            averageRssi: FieldType<null | number>;
            extAddress: FieldType<number | bigint>;
            frameErrorRate: FieldType<number>;
            fullNetworkData: FieldType<boolean>;
            fullThreadDevice: FieldType<boolean>;
            isChild: FieldType<boolean>;
            lastRssi: FieldType<null | number>;
            linkFrameCounter: FieldType<number>;
            lqi: FieldType<number>;
            messageErrorRate: FieldType<number>;
            mleFrameCounter: FieldType<number>;
            rloc16: FieldType<number>;
            rxOnWhenIdle: FieldType<boolean>;
        }>[], any>;
        networkName: Attribute<null | string, any>;
        operationalDatasetComponents: Attribute<null | TypeFromFields<{
            activeTimestampPresent: FieldType<boolean>;
            channelMaskPresent: FieldType<boolean>;
            channelPresent: FieldType<boolean>;
            delayPresent: FieldType<boolean>;
            extendedPanIdPresent: FieldType<boolean>;
            masterKeyPresent: FieldType<boolean>;
            meshLocalPrefixPresent: FieldType<boolean>;
            networkNamePresent: FieldType<boolean>;
            panIdPresent: FieldType<boolean>;
            pendingTimestampPresent: FieldType<boolean>;
            pskcPresent: FieldType<boolean>;
            securityPolicyPresent: FieldType<boolean>;
        }>, any>;
        overrunCount: Attribute<number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                errorCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        panId: Attribute<null | number, any>;
        parentChangeCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        partitionId: Attribute<null | number, any>;
        partitionIdChangeCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        pendingTimestamp: OptionalAttribute<null | number | bigint, any>;
        routerRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        routeTable: Attribute<TypeFromFields<{
            age: FieldType<number>;
            allocated: FieldType<boolean>;
            extAddress: FieldType<number | bigint>;
            linkEstablished: FieldType<boolean>;
            lqiIn: FieldType<number>;
            lqiOut: FieldType<number>;
            nextHop: FieldType<number>;
            pathCost: FieldType<number>;
            rloc16: FieldType<number>;
            routerId: FieldType<number>;
        }>[], any>;
        routingRole: Attribute<null | ThreadNetworkDiagnostics.RoutingRole, any>;
        rxAddressFilteredCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBeaconCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBeaconRequestCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBroadcastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDataCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDataPollCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDestAddrFilteredCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDuplicatedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrFcsCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrInvalidSrcAddrCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrNoFrameCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrSecCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrUnknownNeighborCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxTotalCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxUnicastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        securityPolicy: Attribute<null | TypeFromFields<{
            flags: FieldType<number>;
            rotationTime: FieldType<number>;
        }>, any>;
        stableDataVersion: Attribute<null | number, any>;
        txAckedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txAckRequestedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBeaconCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBeaconRequestCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBroadcastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDataCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDataPollCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrAbortCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrBusyChannelCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrCcaCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txIndirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txNoAckRequestedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txRetryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txTotalCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txUnicastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        weighting: Attribute<null | number, any>;
    };
    commands: {
        resetCounts: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                errorCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        connectionStatus: OptionalEvent<TypeFromFields<{
            connectionStatus: FieldType<ThreadNetworkDiagnostics.ConnectionStatus>;
        }>, any>;
        networkFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
            previous: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
        }>, any>;
    };
    features: {
        errorCounts: BitFlag;
        macCounts: BitFlag;
        mleCounts: BitFlag;
        packetCounts: BitFlag;
    };
    id: Branded<53, "ClusterId">;
    name: "ThreadNetworkDiagnostics";
    revision: 2;
}>, ValuesT>
Modify elements using ElementModifier.set.
Type Parameters
- const ValuesT extends {
      activeNetworkFaultsList: number[];
      activeTimestamp?: null | number | bigint;
      attachAttemptCount?: number;
      betterPartitionAttachAttemptCount?: number;
      channel: null | number;
      channelPage0Mask: null | {};
      childRoleCount?: number;
      dataVersion: null | number;
      delay?: null | number;
      detachedRoleCount?: number;
      extendedPanId: null | number | bigint;
      leaderRoleCount?: number;
      leaderRouterId: null | number;
      meshLocalPrefix: null | {};
      neighborTable: {
          age: number;
          averageRssi: null | number;
          extAddress: number | bigint;
          frameErrorRate: number;
          fullNetworkData: boolean;
          fullThreadDevice: boolean;
          isChild: boolean;
          lastRssi: null | number;
          linkFrameCounter: number;
          lqi: number;
          messageErrorRate: number;
          mleFrameCounter: number;
          rloc16: number;
          rxOnWhenIdle: boolean;
      }[];
      networkName: null | string;
      operationalDatasetComponents: null | {
          activeTimestampPresent: boolean;
          channelMaskPresent: boolean;
          channelPresent: boolean;
          delayPresent: boolean;
          extendedPanIdPresent: boolean;
          masterKeyPresent: boolean;
          meshLocalPrefixPresent: boolean;
          networkNamePresent: boolean;
          panIdPresent: boolean;
          pendingTimestampPresent: boolean;
          pskcPresent: boolean;
          securityPolicyPresent: boolean;
      };
      overrunCount?: number | bigint;
      panId: null | number;
      parentChangeCount?: number;
      partitionId: null | number;
      partitionIdChangeCount?: number;
      pendingTimestamp?: null | number | bigint;
      routerRoleCount?: number;
      routeTable: {
          age: number;
          allocated: boolean;
          extAddress: number | bigint;
          linkEstablished: boolean;
          lqiIn: number;
          lqiOut: number;
          nextHop: number;
          pathCost: number;
          rloc16: number;
          routerId: number;
      }[];
      routingRole: null | number;
      rxAddressFilteredCount?: number;
      rxBeaconCount?: number;
      rxBeaconRequestCount?: number;
      rxBroadcastCount?: number;
      rxDataCount?: number;
      rxDataPollCount?: number;
      rxDestAddrFilteredCount?: number;
      rxDuplicatedCount?: number;
      rxErrFcsCount?: number;
      rxErrInvalidSrcAddrCount?: number;
      rxErrNoFrameCount?: number;
      rxErrOtherCount?: number;
      rxErrSecCount?: number;
      rxErrUnknownNeighborCount?: number;
      rxOtherCount?: number;
      rxTotalCount?: number;
      rxUnicastCount?: number;
      securityPolicy: null | {
          flags: number;
          rotationTime: number;
      };
      stableDataVersion: null | number;
      txAckedCount?: number;
      txAckRequestedCount?: number;
      txBeaconCount?: number;
      txBeaconRequestCount?: number;
      txBroadcastCount?: number;
      txDataCount?: number;
      txDataPollCount?: number;
      txDirectMaxRetryExpiryCount?: number;
      txErrAbortCount?: number;
      txErrBusyChannelCount?: number;
      txErrCcaCount?: number;
      txIndirectMaxRetryExpiryCount?: number;
      txNoAckRequestedCount?: number;
      txOtherCount?: number;
      txRetryCount?: number;
      txTotalCount?: number;
      txUnicastCount?: number;
      weighting: null | number;
  }
Parameters
- values: ValuesT
Returns WithValues<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeNetworkFaultsList: Attribute<ThreadNetworkDiagnostics.NetworkFault[], any>;
        activeTimestamp: OptionalAttribute<null | number | bigint, any>;
        attachAttemptCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        attributeList: Attribute<AttributeId[], never>;
        betterPartitionAttachAttemptCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        channel: Attribute<null | number, any>;
        channelPage0Mask: Attribute<null | Uint8Array, any>;
        childRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        clusterRevision: Attribute<number, never>;
        dataVersion: Attribute<null | number, any>;
        delay: OptionalAttribute<null | number, any>;
        detachedRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        extendedPanId: Attribute<null | number | bigint, any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            errorCounts: BitFlag;
            macCounts: BitFlag;
            mleCounts: BitFlag;
            packetCounts: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        leaderRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        leaderRouterId: Attribute<null | number, any>;
        meshLocalPrefix: Attribute<null | Uint8Array, any>;
        neighborTable: Attribute<TypeFromFields<{
            age: FieldType<number>;
            averageRssi: FieldType<null | number>;
            extAddress: FieldType<number | bigint>;
            frameErrorRate: FieldType<number>;
            fullNetworkData: FieldType<boolean>;
            fullThreadDevice: FieldType<boolean>;
            isChild: FieldType<boolean>;
            lastRssi: FieldType<null | number>;
            linkFrameCounter: FieldType<number>;
            lqi: FieldType<number>;
            messageErrorRate: FieldType<number>;
            mleFrameCounter: FieldType<number>;
            rloc16: FieldType<number>;
            rxOnWhenIdle: FieldType<boolean>;
        }>[], any>;
        networkName: Attribute<null | string, any>;
        operationalDatasetComponents: Attribute<null | TypeFromFields<{
            activeTimestampPresent: FieldType<boolean>;
            channelMaskPresent: FieldType<boolean>;
            channelPresent: FieldType<boolean>;
            delayPresent: FieldType<boolean>;
            extendedPanIdPresent: FieldType<boolean>;
            masterKeyPresent: FieldType<boolean>;
            meshLocalPrefixPresent: FieldType<boolean>;
            networkNamePresent: FieldType<boolean>;
            panIdPresent: FieldType<boolean>;
            pendingTimestampPresent: FieldType<boolean>;
            pskcPresent: FieldType<boolean>;
            securityPolicyPresent: FieldType<boolean>;
        }>, any>;
        overrunCount: Attribute<number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                errorCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        panId: Attribute<null | number, any>;
        parentChangeCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        partitionId: Attribute<null | number, any>;
        partitionIdChangeCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        pendingTimestamp: OptionalAttribute<null | number | bigint, any>;
        routerRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        routeTable: Attribute<TypeFromFields<{
            age: FieldType<number>;
            allocated: FieldType<boolean>;
            extAddress: FieldType<number | bigint>;
            linkEstablished: FieldType<boolean>;
            lqiIn: FieldType<number>;
            lqiOut: FieldType<number>;
            nextHop: FieldType<number>;
            pathCost: FieldType<number>;
            rloc16: FieldType<number>;
            routerId: FieldType<number>;
        }>[], any>;
        routingRole: Attribute<null | ThreadNetworkDiagnostics.RoutingRole, any>;
        rxAddressFilteredCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBeaconCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBeaconRequestCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBroadcastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDataCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDataPollCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDestAddrFilteredCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDuplicatedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrFcsCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrInvalidSrcAddrCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrNoFrameCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrSecCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrUnknownNeighborCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxTotalCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxUnicastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        securityPolicy: Attribute<null | TypeFromFields<{
            flags: FieldType<number>;
            rotationTime: FieldType<number>;
        }>, any>;
        stableDataVersion: Attribute<null | number, any>;
        txAckedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txAckRequestedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBeaconCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBeaconRequestCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBroadcastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDataCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDataPollCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrAbortCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrBusyChannelCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrCcaCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txIndirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txNoAckRequestedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txRetryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txTotalCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txUnicastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        weighting: Attribute<null | number, any>;
    };
    commands: {
        resetCounts: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                errorCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        connectionStatus: OptionalEvent<TypeFromFields<{
            connectionStatus: FieldType<ThreadNetworkDiagnostics.ConnectionStatus>;
        }>, any>;
        networkFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
            previous: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
        }>, any>;
    };
    features: {
        errorCounts: BitFlag;
        macCounts: BitFlag;
        mleCounts: BitFlag;
        packetCounts: BitFlag;
    };
    id: Branded<53, "ClusterId">;
    name: "ThreadNetworkDiagnostics";
    revision: 2;
}>, ValuesT>
Inherited from Identity.set
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:41

with

with<const SelectionT>(...selection): Of<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeNetworkFaultsList: Attribute<ThreadNetworkDiagnostics.NetworkFault[], any>;
        activeTimestamp: OptionalAttribute<null | number | bigint, any>;
        attachAttemptCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        attributeList: Attribute<AttributeId[], never>;
        betterPartitionAttachAttemptCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        channel: Attribute<null | number, any>;
        channelPage0Mask: Attribute<null | Uint8Array, any>;
        childRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        clusterRevision: Attribute<number, never>;
        dataVersion: Attribute<null | number, any>;
        delay: OptionalAttribute<null | number, any>;
        detachedRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        extendedPanId: Attribute<null | number | bigint, any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            errorCounts: BitFlag;
            macCounts: BitFlag;
            mleCounts: BitFlag;
            packetCounts: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        leaderRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        leaderRouterId: Attribute<null | number, any>;
        meshLocalPrefix: Attribute<null | Uint8Array, any>;
        neighborTable: Attribute<TypeFromFields<{
            age: FieldType<number>;
            averageRssi: FieldType<null | number>;
            extAddress: FieldType<number | bigint>;
            frameErrorRate: FieldType<number>;
            fullNetworkData: FieldType<boolean>;
            fullThreadDevice: FieldType<boolean>;
            isChild: FieldType<boolean>;
            lastRssi: FieldType<null | number>;
            linkFrameCounter: FieldType<number>;
            lqi: FieldType<number>;
            messageErrorRate: FieldType<number>;
            mleFrameCounter: FieldType<number>;
            rloc16: FieldType<number>;
            rxOnWhenIdle: FieldType<boolean>;
        }>[], any>;
        networkName: Attribute<null | string, any>;
        operationalDatasetComponents: Attribute<null | TypeFromFields<{
            activeTimestampPresent: FieldType<boolean>;
            channelMaskPresent: FieldType<boolean>;
            channelPresent: FieldType<boolean>;
            delayPresent: FieldType<boolean>;
            extendedPanIdPresent: FieldType<boolean>;
            masterKeyPresent: FieldType<boolean>;
            meshLocalPrefixPresent: FieldType<boolean>;
            networkNamePresent: FieldType<boolean>;
            panIdPresent: FieldType<boolean>;
            pendingTimestampPresent: FieldType<boolean>;
            pskcPresent: FieldType<boolean>;
            securityPolicyPresent: FieldType<boolean>;
        }>, any>;
        overrunCount: Attribute<number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                errorCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        panId: Attribute<null | number, any>;
        parentChangeCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        partitionId: Attribute<null | number, any>;
        partitionIdChangeCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        pendingTimestamp: OptionalAttribute<null | number | bigint, any>;
        routerRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        routeTable: Attribute<TypeFromFields<{
            age: FieldType<number>;
            allocated: FieldType<boolean>;
            extAddress: FieldType<number | bigint>;
            linkEstablished: FieldType<boolean>;
            lqiIn: FieldType<number>;
            lqiOut: FieldType<number>;
            nextHop: FieldType<number>;
            pathCost: FieldType<number>;
            rloc16: FieldType<number>;
            routerId: FieldType<number>;
        }>[], any>;
        routingRole: Attribute<null | ThreadNetworkDiagnostics.RoutingRole, any>;
        rxAddressFilteredCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBeaconCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBeaconRequestCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBroadcastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDataCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDataPollCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDestAddrFilteredCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDuplicatedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrFcsCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrInvalidSrcAddrCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrNoFrameCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrSecCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrUnknownNeighborCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxTotalCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxUnicastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        securityPolicy: Attribute<null | TypeFromFields<{
            flags: FieldType<number>;
            rotationTime: FieldType<number>;
        }>, any>;
        stableDataVersion: Attribute<null | number, any>;
        txAckedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txAckRequestedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBeaconCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBeaconRequestCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBroadcastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDataCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDataPollCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrAbortCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrBusyChannelCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrCcaCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txIndirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txNoAckRequestedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txRetryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txTotalCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txUnicastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        weighting: Attribute<null | number, any>;
    };
    commands: {
        resetCounts: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                errorCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        connectionStatus: OptionalEvent<TypeFromFields<{
            connectionStatus: FieldType<ThreadNetworkDiagnostics.ConnectionStatus>;
        }>, any>;
        networkFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
            previous: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
        }>, any>;
    };
    features: {
        errorCounts: BitFlag;
        macCounts: BitFlag;
        mleCounts: BitFlag;
        packetCounts: BitFlag;
    };
    id: Branded<53, "ClusterId">;
    name: "ThreadNetworkDiagnostics";
    revision: 2;
}>, SelectionT>
Select features using ClusterComposer.compose.
Type Parameters
- const SelectionT extends FeatureSelection<Of<{
      attributes: {
          acceptedCommandList: Attribute<CommandId[], never>;
          activeNetworkFaultsList: Attribute<ThreadNetworkDiagnostics.NetworkFault[], any>;
          activeTimestamp: OptionalAttribute<null | number | bigint, any>;
          attachAttemptCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          attributeList: Attribute<AttributeId[], never>;
          betterPartitionAttachAttemptCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          channel: Attribute<null | number, any>;
          channelPage0Mask: Attribute<null | Uint8Array, any>;
          childRoleCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          clusterRevision: Attribute<number, never>;
          dataVersion: Attribute<null | number, any>;
          delay: OptionalAttribute<null | number, any>;
          detachedRoleCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          extendedPanId: Attribute<null | number | bigint, any>;
          featureMap: Attribute<TypeFromPartialBitSchema<{
              errorCounts: BitFlag;
              macCounts: BitFlag;
              mleCounts: BitFlag;
              packetCounts: BitFlag;
          }>, never>;
          generatedCommandList: Attribute<CommandId[], never>;
          leaderRoleCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          leaderRouterId: Attribute<null | number, any>;
          meshLocalPrefix: Attribute<null | Uint8Array, any>;
          neighborTable: Attribute<TypeFromFields<{
              age: FieldType<number>;
              averageRssi: FieldType<null | number>;
              extAddress: FieldType<number | bigint>;
              frameErrorRate: FieldType<number>;
              fullNetworkData: FieldType<boolean>;
              fullThreadDevice: FieldType<boolean>;
              isChild: FieldType<boolean>;
              lastRssi: FieldType<null | number>;
              linkFrameCounter: FieldType<number>;
              lqi: FieldType<number>;
              messageErrorRate: FieldType<number>;
              mleFrameCounter: FieldType<number>;
              rloc16: FieldType<number>;
              rxOnWhenIdle: FieldType<boolean>;
          }>[], any>;
          networkName: Attribute<null | string, any>;
          operationalDatasetComponents: Attribute<null | TypeFromFields<{
              activeTimestampPresent: FieldType<boolean>;
              channelMaskPresent: FieldType<boolean>;
              channelPresent: FieldType<boolean>;
              delayPresent: FieldType<boolean>;
              extendedPanIdPresent: FieldType<boolean>;
              masterKeyPresent: FieldType<boolean>;
              meshLocalPrefixPresent: FieldType<boolean>;
              networkNamePresent: FieldType<boolean>;
              panIdPresent: FieldType<boolean>;
              pendingTimestampPresent: FieldType<boolean>;
              pskcPresent: FieldType<boolean>;
              securityPolicyPresent: FieldType<boolean>;
          }>, any>;
          overrunCount: Attribute<number | bigint, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  errorCounts: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          panId: Attribute<null | number, any>;
          parentChangeCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          partitionId: Attribute<null | number, any>;
          partitionIdChangeCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          pendingTimestamp: OptionalAttribute<null | number | bigint, any>;
          routerRoleCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  mleCounts: boolean;
              }];
          };
          routeTable: Attribute<TypeFromFields<{
              age: FieldType<number>;
              allocated: FieldType<boolean>;
              extAddress: FieldType<number | bigint>;
              linkEstablished: FieldType<boolean>;
              lqiIn: FieldType<number>;
              lqiOut: FieldType<number>;
              nextHop: FieldType<number>;
              pathCost: FieldType<number>;
              rloc16: FieldType<number>;
              routerId: FieldType<number>;
          }>[], any>;
          routingRole: Attribute<null | ThreadNetworkDiagnostics.RoutingRole, any>;
          rxAddressFilteredCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxBeaconCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxBeaconRequestCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxBroadcastCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxDataCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxDataPollCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxDestAddrFilteredCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxDuplicatedCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxErrFcsCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxErrInvalidSrcAddrCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxErrNoFrameCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxErrOtherCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxErrSecCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxErrUnknownNeighborCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxOtherCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxTotalCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          rxUnicastCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          securityPolicy: Attribute<null | TypeFromFields<{
              flags: FieldType<number>;
              rotationTime: FieldType<number>;
          }>, any>;
          stableDataVersion: Attribute<null | number, any>;
          txAckedCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txAckRequestedCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txBeaconCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txBeaconRequestCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txBroadcastCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txDataCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txDataPollCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txDirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txErrAbortCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txErrBusyChannelCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txErrCcaCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txIndirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txNoAckRequestedCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txOtherCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txRetryCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txTotalCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          txUnicastCount: OptionalAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  macCounts: boolean;
              }];
          };
          weighting: Attribute<null | number, any>;
      };
      commands: {
          resetCounts: Command<void, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  errorCounts: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      events: {
          connectionStatus: OptionalEvent<TypeFromFields<{
              connectionStatus: FieldType<ThreadNetworkDiagnostics.ConnectionStatus>;
          }>, any>;
          networkFaultChange: OptionalEvent<TypeFromFields<{
              current: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
              previous: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
          }>, any>;
      };
      features: {
          errorCounts: BitFlag;
          macCounts: BitFlag;
          mleCounts: BitFlag;
          packetCounts: BitFlag;
      };
      id: Branded<53, "ClusterId">;
      name: "ThreadNetworkDiagnostics";
      revision: 2;
  }>>
Parameters
- Rest...selection: SelectionT
Returns Of<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeNetworkFaultsList: Attribute<ThreadNetworkDiagnostics.NetworkFault[], any>;
        activeTimestamp: OptionalAttribute<null | number | bigint, any>;
        attachAttemptCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        attributeList: Attribute<AttributeId[], never>;
        betterPartitionAttachAttemptCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        channel: Attribute<null | number, any>;
        channelPage0Mask: Attribute<null | Uint8Array, any>;
        childRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        clusterRevision: Attribute<number, never>;
        dataVersion: Attribute<null | number, any>;
        delay: OptionalAttribute<null | number, any>;
        detachedRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        extendedPanId: Attribute<null | number | bigint, any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            errorCounts: BitFlag;
            macCounts: BitFlag;
            mleCounts: BitFlag;
            packetCounts: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        leaderRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        leaderRouterId: Attribute<null | number, any>;
        meshLocalPrefix: Attribute<null | Uint8Array, any>;
        neighborTable: Attribute<TypeFromFields<{
            age: FieldType<number>;
            averageRssi: FieldType<null | number>;
            extAddress: FieldType<number | bigint>;
            frameErrorRate: FieldType<number>;
            fullNetworkData: FieldType<boolean>;
            fullThreadDevice: FieldType<boolean>;
            isChild: FieldType<boolean>;
            lastRssi: FieldType<null | number>;
            linkFrameCounter: FieldType<number>;
            lqi: FieldType<number>;
            messageErrorRate: FieldType<number>;
            mleFrameCounter: FieldType<number>;
            rloc16: FieldType<number>;
            rxOnWhenIdle: FieldType<boolean>;
        }>[], any>;
        networkName: Attribute<null | string, any>;
        operationalDatasetComponents: Attribute<null | TypeFromFields<{
            activeTimestampPresent: FieldType<boolean>;
            channelMaskPresent: FieldType<boolean>;
            channelPresent: FieldType<boolean>;
            delayPresent: FieldType<boolean>;
            extendedPanIdPresent: FieldType<boolean>;
            masterKeyPresent: FieldType<boolean>;
            meshLocalPrefixPresent: FieldType<boolean>;
            networkNamePresent: FieldType<boolean>;
            panIdPresent: FieldType<boolean>;
            pendingTimestampPresent: FieldType<boolean>;
            pskcPresent: FieldType<boolean>;
            securityPolicyPresent: FieldType<boolean>;
        }>, any>;
        overrunCount: Attribute<number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                errorCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        panId: Attribute<null | number, any>;
        parentChangeCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        partitionId: Attribute<null | number, any>;
        partitionIdChangeCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        pendingTimestamp: OptionalAttribute<null | number | bigint, any>;
        routerRoleCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                mleCounts: boolean;
            }];
        };
        routeTable: Attribute<TypeFromFields<{
            age: FieldType<number>;
            allocated: FieldType<boolean>;
            extAddress: FieldType<number | bigint>;
            linkEstablished: FieldType<boolean>;
            lqiIn: FieldType<number>;
            lqiOut: FieldType<number>;
            nextHop: FieldType<number>;
            pathCost: FieldType<number>;
            rloc16: FieldType<number>;
            routerId: FieldType<number>;
        }>[], any>;
        routingRole: Attribute<null | ThreadNetworkDiagnostics.RoutingRole, any>;
        rxAddressFilteredCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBeaconCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBeaconRequestCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxBroadcastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDataCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDataPollCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDestAddrFilteredCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxDuplicatedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrFcsCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrInvalidSrcAddrCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrNoFrameCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrSecCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxErrUnknownNeighborCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxTotalCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        rxUnicastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        securityPolicy: Attribute<null | TypeFromFields<{
            flags: FieldType<number>;
            rotationTime: FieldType<number>;
        }>, any>;
        stableDataVersion: Attribute<null | number, any>;
        txAckedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txAckRequestedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBeaconCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBeaconRequestCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txBroadcastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDataCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDataPollCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txDirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrAbortCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrBusyChannelCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txErrCcaCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txIndirectMaxRetryExpiryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txNoAckRequestedCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txOtherCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txRetryCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txTotalCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        txUnicastCount: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                macCounts: boolean;
            }];
        };
        weighting: Attribute<null | number, any>;
    };
    commands: {
        resetCounts: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                errorCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        connectionStatus: OptionalEvent<TypeFromFields<{
            connectionStatus: FieldType<ThreadNetworkDiagnostics.ConnectionStatus>;
        }>, any>;
        networkFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
            previous: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
        }>, any>;
    };
    features: {
        errorCounts: BitFlag;
        macCounts: BitFlag;
        mleCounts: BitFlag;
        packetCounts: BitFlag;
    };
    id: Branded<53, "ClusterId">;
    name: "ThreadNetworkDiagnostics";
    revision: 2;
}>, SelectionT>
Inherited from Identity.with
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:33

Interface Complete

Hierarchy (view full)

Index

Properties

Methods

Properties

attributes

base

commands

events

Type declaration

ReadonlyconnectionStatus: OptionalEvent<TypeFromFields<{ connectionStatus: FieldType<ThreadNetworkDiagnostics.ConnectionStatus>; }>, any>

See

ReadonlynetworkFaultChange: OptionalEvent<TypeFromFields<{ current: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>; previous: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>; }>, any>

See

extensions

features

Type declaration

ReadonlyerrorCounts: BitFlag

ReadonlymacCounts: BitFlag

ReadonlymleCounts: BitFlag

ReadonlypacketCounts: BitFlag

id

name

revision

supportedFeatures

unknown

Methods

alter

Type Parameters

Parameters

enable

Type Parameters

Parameters

set

Type Parameters

Parameters

with

Type Parameters

Parameters

Settings

On This Page

`Readonly`connectionStatus: OptionalEvent<TypeFromFields<{
connectionStatus: FieldType<ThreadNetworkDiagnostics.ConnectionStatus>;
}>, any>

`Readonly`networkFaultChange: OptionalEvent<TypeFromFields<{
current: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
previous: FieldType<ThreadNetworkDiagnostics.NetworkFault[]>;
}>, any>

`Readonly`errorCounts: BitFlag

`Readonly`macCounts: BitFlag

`Readonly`mleCounts: BitFlag

`Readonly`packetCounts: BitFlag