Interface Complete

This cluster supports all WiFiNetworkDiagnostics 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>;
        attributeList: Attribute<AttributeId[], never>;
        beaconLostCount: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                errorCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        beaconRxCount: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                packetCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        bssid: Attribute<null | Uint8Array, any>;
        channelNumber: Attribute<null | number, any>;
        clusterRevision: Attribute<number, never>;
        currentMaxRate: OptionalAttribute<null | number | bigint, any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            errorCounts: BitFlag;
            packetCounts: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        overrunCount: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                errorCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        packetMulticastRxCount: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                packetCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        packetMulticastTxCount: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                packetCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        packetUnicastRxCount: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                packetCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        packetUnicastTxCount: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                packetCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        rssi: Attribute<null | number, any>;
        securityType: Attribute<null | WiFiNetworkDiagnostics.SecurityType, any>;
        wiFiVersion: Attribute<null | WiFiNetworkDiagnostics.WiFiVersion, any>;
    }, GlobalAttributes<{
        errorCounts: BitFlag;
        packetCounts: BitFlag;
    }>>;
    base: undefined;
    commands: {
        resetCounts: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                errorCounts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        associationFailure: OptionalEvent<TypeFromFields<{
            associationFailureCause: FieldType<WiFiNetworkDiagnostics.AssociationFailureCause>;
            status: FieldType<number>;
        }>, any>;
        connectionStatus: OptionalEvent<TypeFromFields<{
            connectionStatus: FieldType<WiFiNetworkDiagnostics.ConnectionStatus>;
        }>, any>;
        disconnection: OptionalEvent<TypeFromFields<{
            reasonCode: FieldType<number>;
        }>, any>;
    };
    extensions: undefined;
    features: {
        errorCounts: BitFlag;
        packetCounts: BitFlag;
    };
    id: Branded<Branded<54, "ClusterId">, "ClusterId">;
    name: "WiFiNetworkDiagnostics";
    revision: 1;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            beaconLostCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            beaconRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            bssid: Attribute<null | Uint8Array, any>;
            channelNumber: Attribute<null | number, any>;
            clusterRevision: Attribute<number, never>;
            currentMaxRate: OptionalAttribute<null | number | bigint, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                errorCounts: BitFlag;
                packetCounts: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            overrunCount: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rssi: Attribute<null | number, any>;
            securityType: Attribute<null | WiFiNetworkDiagnostics.SecurityType, any>;
            wiFiVersion: Attribute<null | WiFiNetworkDiagnostics.WiFiVersion, any>;
        };
        commands: {
            resetCounts: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            associationFailure: OptionalEvent<TypeFromFields<{
                associationFailureCause: FieldType<WiFiNetworkDiagnostics.AssociationFailureCause>;
                status: FieldType<number>;
            }>, any>;
            connectionStatus: OptionalEvent<TypeFromFields<{
                connectionStatus: FieldType<WiFiNetworkDiagnostics.ConnectionStatus>;
            }>, any>;
            disconnection: OptionalEvent<TypeFromFields<{
                reasonCode: FieldType<number>;
            }>, any>;
        };
        features: {
            errorCounts: BitFlag;
            packetCounts: BitFlag;
        };
        id: Branded<54, "ClusterId">;
        name: "WiFiNetworkDiagnostics";
        revision: 1;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            beaconLostCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            beaconRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            bssid: Attribute<null | Uint8Array, any>;
            channelNumber: Attribute<null | number, any>;
            clusterRevision: Attribute<number, never>;
            currentMaxRate: OptionalAttribute<null | number | bigint, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                errorCounts: BitFlag;
                packetCounts: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            overrunCount: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rssi: Attribute<null | number, any>;
            securityType: Attribute<null | WiFiNetworkDiagnostics.SecurityType, any>;
            wiFiVersion: Attribute<null | WiFiNetworkDiagnostics.WiFiVersion, any>;
        };
        commands: {
            resetCounts: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            associationFailure: OptionalEvent<TypeFromFields<{
                associationFailureCause: FieldType<WiFiNetworkDiagnostics.AssociationFailureCause>;
                status: FieldType<number>;
            }>, any>;
            connectionStatus: OptionalEvent<TypeFromFields<{
                connectionStatus: FieldType<WiFiNetworkDiagnostics.ConnectionStatus>;
            }>, any>;
            disconnection: OptionalEvent<TypeFromFields<{
                reasonCode: FieldType<number>;
            }>, any>;
        };
        features: {
            errorCounts: BitFlag;
            packetCounts: BitFlag;
        };
        id: Branded<54, "ClusterId">;
        name: "WiFiNetworkDiagnostics";
        revision: 1;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            beaconLostCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            beaconRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            bssid: Attribute<null | Uint8Array, any>;
            channelNumber: Attribute<null | number, any>;
            clusterRevision: Attribute<number, never>;
            currentMaxRate: OptionalAttribute<null | number | bigint, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                errorCounts: BitFlag;
                packetCounts: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            overrunCount: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rssi: Attribute<null | number, any>;
            securityType: Attribute<null | WiFiNetworkDiagnostics.SecurityType, any>;
            wiFiVersion: Attribute<null | WiFiNetworkDiagnostics.WiFiVersion, any>;
        };
        commands: {
            resetCounts: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            associationFailure: OptionalEvent<TypeFromFields<{
                associationFailureCause: FieldType<WiFiNetworkDiagnostics.AssociationFailureCause>;
                status: FieldType<number>;
            }>, any>;
            connectionStatus: OptionalEvent<TypeFromFields<{
                connectionStatus: FieldType<WiFiNetworkDiagnostics.ConnectionStatus>;
            }>, any>;
            disconnection: OptionalEvent<TypeFromFields<{
                reasonCode: FieldType<number>;
            }>, any>;
        };
        features: {
            errorCounts: BitFlag;
            packetCounts: BitFlag;
        };
        id: Branded<54, "ClusterId">;
        name: "WiFiNetworkDiagnostics";
        revision: 1;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            beaconLostCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            beaconRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            bssid: Attribute<null | Uint8Array, any>;
            channelNumber: Attribute<null | number, any>;
            clusterRevision: Attribute<number, never>;
            currentMaxRate: OptionalAttribute<null | number | bigint, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                errorCounts: BitFlag;
                packetCounts: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            overrunCount: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rssi: Attribute<null | number, any>;
            securityType: Attribute<null | WiFiNetworkDiagnostics.SecurityType, any>;
            wiFiVersion: Attribute<null | WiFiNetworkDiagnostics.WiFiVersion, any>;
        };
        commands: {
            resetCounts: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            associationFailure: OptionalEvent<TypeFromFields<{
                associationFailureCause: FieldType<WiFiNetworkDiagnostics.AssociationFailureCause>;
                status: FieldType<number>;
            }>, any>;
            connectionStatus: OptionalEvent<TypeFromFields<{
                connectionStatus: FieldType<WiFiNetworkDiagnostics.ConnectionStatus>;
            }>, any>;
            disconnection: OptionalEvent<TypeFromFields<{
                reasonCode: FieldType<number>;
            }>, any>;
        };
        features: {
            errorCounts: BitFlag;
            packetCounts: BitFlag;
        };
        id: Branded<54, "ClusterId">;
        name: "WiFiNetworkDiagnostics";
        revision: 1;
    }>, SelectionT>;
}

Hierarchy (view full)

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>;
    attributeList: Attribute<AttributeId[], never>;
    beaconLostCount: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            errorCounts: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    beaconRxCount: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            packetCounts: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    bssid: Attribute<null | Uint8Array, any>;
    channelNumber: Attribute<null | number, any>;
    clusterRevision: Attribute<number, never>;
    currentMaxRate: OptionalAttribute<null | number | bigint, any>;
    featureMap: Attribute<TypeFromPartialBitSchema<{
        errorCounts: BitFlag;
        packetCounts: BitFlag;
    }>, never>;
    generatedCommandList: Attribute<CommandId[], never>;
    overrunCount: Attribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            errorCounts: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    packetMulticastRxCount: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            packetCounts: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    packetMulticastTxCount: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            packetCounts: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    packetUnicastRxCount: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            packetCounts: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    packetUnicastTxCount: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            packetCounts: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    rssi: Attribute<null | number, any>;
    securityType: Attribute<null | WiFiNetworkDiagnostics.SecurityType, any>;
    wiFiVersion: Attribute<null | WiFiNetworkDiagnostics.WiFiVersion, any>;
}, GlobalAttributes<{
    errorCounts: 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: {
    associationFailure: OptionalEvent<TypeFromFields<{
        associationFailureCause: FieldType<WiFiNetworkDiagnostics.AssociationFailureCause>;
        status: FieldType<number>;
    }>, any>;
    connectionStatus: OptionalEvent<TypeFromFields<{
        connectionStatus: FieldType<WiFiNetworkDiagnostics.ConnectionStatus>;
    }>, any>;
    disconnection: OptionalEvent<TypeFromFields<{
        reasonCode: FieldType<number>;
    }>, any>;
}

Type declaration

  • ReadonlyassociationFailure: OptionalEvent<TypeFromFields<{
        associationFailureCause: FieldType<WiFiNetworkDiagnostics.AssociationFailureCause>;
        status: FieldType<number>;
    }>, any>

    The AssociationFailure event shall indicate that a Node has attempted to connect, or reconnect, to a Wi-Fi access point, but is unable to successfully associate or authenticate, after exhausting all internal retries of its supplicant.

    See

    MatterSpecification.v13.Core § 11.15.8.2

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

    The ConnectionStatus Event shall indicate that a Node’s connection status to a Wi-Fi network has changed. Connected, in this context, shall mean that a Node acting as a Wi-Fi station is successfully associated to a Wi-Fi Access Point.

    See

    MatterSpecification.v13.Core § 11.15.8.3

  • Readonlydisconnection: OptionalEvent<TypeFromFields<{
        reasonCode: FieldType<number>;
    }>, any>

    The Disconnection Event shall indicate that a Node’s Wi-Fi connection has been disconnected as a result of de-authenticated or dis-association and indicates the reason.

    See

    MatterSpecification.v13.Core § 11.15.8.1

extensions

extensions: undefined

features

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

Type declaration

  • ReadonlyerrorCounts: BitFlag

    ErrorCounts

    Node makes available the counts for the number of errors that have occurred during the reception and transmission of packets on the Wi-Fi interface.

  • ReadonlypacketCounts: BitFlag

    PacketCounts

    Node makes available the counts for the number of received and transmitted packets on the Wi-Fi interface.

id

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

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            beaconLostCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            beaconRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            bssid: Attribute<null | Uint8Array, any>;
            channelNumber: Attribute<null | number, any>;
            clusterRevision: Attribute<number, never>;
            currentMaxRate: OptionalAttribute<null | number | bigint, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                errorCounts: BitFlag;
                packetCounts: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            overrunCount: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rssi: Attribute<null | number, any>;
            securityType: Attribute<null | WiFiNetworkDiagnostics.SecurityType, any>;
            wiFiVersion: Attribute<null | WiFiNetworkDiagnostics.WiFiVersion, any>;
        };
        commands: {
            resetCounts: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            associationFailure: OptionalEvent<TypeFromFields<{
                associationFailureCause: FieldType<WiFiNetworkDiagnostics.AssociationFailureCause>;
                status: FieldType<number>;
            }>, any>;
            connectionStatus: OptionalEvent<TypeFromFields<{
                connectionStatus: FieldType<WiFiNetworkDiagnostics.ConnectionStatus>;
            }>, any>;
            disconnection: OptionalEvent<TypeFromFields<{
                reasonCode: FieldType<number>;
            }>, any>;
        };
        features: {
            errorCounts: BitFlag;
            packetCounts: BitFlag;
        };
        id: Branded<54, "ClusterId">;
        name: "WiFiNetworkDiagnostics";
        revision: 1;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              attributeList: Attribute<AttributeId[], never>;
              beaconLostCount: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      errorCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              beaconRxCount: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      packetCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              bssid: Attribute<null | Uint8Array, any>;
              channelNumber: Attribute<null | number, any>;
              clusterRevision: Attribute<number, never>;
              currentMaxRate: OptionalAttribute<null | number | bigint, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  errorCounts: BitFlag;
                  packetCounts: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              overrunCount: Attribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      errorCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              packetMulticastRxCount: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      packetCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              packetMulticastTxCount: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      packetCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              packetUnicastRxCount: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      packetCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              packetUnicastTxCount: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      packetCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              rssi: Attribute<null | number, any>;
              securityType: Attribute<null | WiFiNetworkDiagnostics.SecurityType, any>;
              wiFiVersion: Attribute<null | WiFiNetworkDiagnostics.WiFiVersion, any>;
          };
          commands: {
              resetCounts: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      errorCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          events: {
              associationFailure: OptionalEvent<TypeFromFields<{
                  associationFailureCause: FieldType<WiFiNetworkDiagnostics.AssociationFailureCause>;
                  status: FieldType<number>;
              }>, any>;
              connectionStatus: OptionalEvent<TypeFromFields<{
                  connectionStatus: FieldType<WiFiNetworkDiagnostics.ConnectionStatus>;
              }>, any>;
              disconnection: OptionalEvent<TypeFromFields<{
                  reasonCode: FieldType<number>;
              }>, any>;
          };
          features: {
              errorCounts: BitFlag;
              packetCounts: BitFlag;
          };
          id: Branded<54, "ClusterId">;
          name: "WiFiNetworkDiagnostics";
          revision: 1;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            beaconLostCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            beaconRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            bssid: Attribute<null | Uint8Array, any>;
            channelNumber: Attribute<null | number, any>;
            clusterRevision: Attribute<number, never>;
            currentMaxRate: OptionalAttribute<null | number | bigint, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                errorCounts: BitFlag;
                packetCounts: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            overrunCount: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rssi: Attribute<null | number, any>;
            securityType: Attribute<null | WiFiNetworkDiagnostics.SecurityType, any>;
            wiFiVersion: Attribute<null | WiFiNetworkDiagnostics.WiFiVersion, any>;
        };
        commands: {
            resetCounts: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            associationFailure: OptionalEvent<TypeFromFields<{
                associationFailureCause: FieldType<WiFiNetworkDiagnostics.AssociationFailureCause>;
                status: FieldType<number>;
            }>, any>;
            connectionStatus: OptionalEvent<TypeFromFields<{
                connectionStatus: FieldType<WiFiNetworkDiagnostics.ConnectionStatus>;
            }>, any>;
            disconnection: OptionalEvent<TypeFromFields<{
                reasonCode: FieldType<number>;
            }>, any>;
        };
        features: {
            errorCounts: BitFlag;
            packetCounts: BitFlag;
        };
        id: Branded<54, "ClusterId">;
        name: "WiFiNetworkDiagnostics";
        revision: 1;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            beaconLostCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            beaconRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            bssid: Attribute<null | Uint8Array, any>;
            channelNumber: Attribute<null | number, any>;
            clusterRevision: Attribute<number, never>;
            currentMaxRate: OptionalAttribute<null | number | bigint, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                errorCounts: BitFlag;
                packetCounts: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            overrunCount: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rssi: Attribute<null | number, any>;
            securityType: Attribute<null | WiFiNetworkDiagnostics.SecurityType, any>;
            wiFiVersion: Attribute<null | WiFiNetworkDiagnostics.WiFiVersion, any>;
        };
        commands: {
            resetCounts: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            associationFailure: OptionalEvent<TypeFromFields<{
                associationFailureCause: FieldType<WiFiNetworkDiagnostics.AssociationFailureCause>;
                status: FieldType<number>;
            }>, any>;
            connectionStatus: OptionalEvent<TypeFromFields<{
                connectionStatus: FieldType<WiFiNetworkDiagnostics.ConnectionStatus>;
            }>, any>;
            disconnection: OptionalEvent<TypeFromFields<{
                reasonCode: FieldType<number>;
            }>, any>;
        };
        features: {
            errorCounts: BitFlag;
            packetCounts: BitFlag;
        };
        id: Branded<54, "ClusterId">;
        name: "WiFiNetworkDiagnostics";
        revision: 1;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              attributeList: Attribute<AttributeId[], never>;
              beaconLostCount: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      errorCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              beaconRxCount: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      packetCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              bssid: Attribute<null | Uint8Array, any>;
              channelNumber: Attribute<null | number, any>;
              clusterRevision: Attribute<number, never>;
              currentMaxRate: OptionalAttribute<null | number | bigint, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  errorCounts: BitFlag;
                  packetCounts: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              overrunCount: Attribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      errorCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              packetMulticastRxCount: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      packetCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              packetMulticastTxCount: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      packetCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              packetUnicastRxCount: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      packetCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              packetUnicastTxCount: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      packetCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              rssi: Attribute<null | number, any>;
              securityType: Attribute<null | WiFiNetworkDiagnostics.SecurityType, any>;
              wiFiVersion: Attribute<null | WiFiNetworkDiagnostics.WiFiVersion, any>;
          };
          commands: {
              resetCounts: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      errorCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          events: {
              associationFailure: OptionalEvent<TypeFromFields<{
                  associationFailureCause: FieldType<WiFiNetworkDiagnostics.AssociationFailureCause>;
                  status: FieldType<number>;
              }>, any>;
              connectionStatus: OptionalEvent<TypeFromFields<{
                  connectionStatus: FieldType<WiFiNetworkDiagnostics.ConnectionStatus>;
              }>, any>;
              disconnection: OptionalEvent<TypeFromFields<{
                  reasonCode: FieldType<number>;
              }>, any>;
          };
          features: {
              errorCounts: BitFlag;
              packetCounts: BitFlag;
          };
          id: Branded<54, "ClusterId">;
          name: "WiFiNetworkDiagnostics";
          revision: 1;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            beaconLostCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            beaconRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            bssid: Attribute<null | Uint8Array, any>;
            channelNumber: Attribute<null | number, any>;
            clusterRevision: Attribute<number, never>;
            currentMaxRate: OptionalAttribute<null | number | bigint, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                errorCounts: BitFlag;
                packetCounts: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            overrunCount: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rssi: Attribute<null | number, any>;
            securityType: Attribute<null | WiFiNetworkDiagnostics.SecurityType, any>;
            wiFiVersion: Attribute<null | WiFiNetworkDiagnostics.WiFiVersion, any>;
        };
        commands: {
            resetCounts: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            associationFailure: OptionalEvent<TypeFromFields<{
                associationFailureCause: FieldType<WiFiNetworkDiagnostics.AssociationFailureCause>;
                status: FieldType<number>;
            }>, any>;
            connectionStatus: OptionalEvent<TypeFromFields<{
                connectionStatus: FieldType<WiFiNetworkDiagnostics.ConnectionStatus>;
            }>, any>;
            disconnection: OptionalEvent<TypeFromFields<{
                reasonCode: FieldType<number>;
            }>, any>;
        };
        features: {
            errorCounts: BitFlag;
            packetCounts: BitFlag;
        };
        id: Branded<54, "ClusterId">;
        name: "WiFiNetworkDiagnostics";
        revision: 1;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            beaconLostCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            beaconRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            bssid: Attribute<null | Uint8Array, any>;
            channelNumber: Attribute<null | number, any>;
            clusterRevision: Attribute<number, never>;
            currentMaxRate: OptionalAttribute<null | number | bigint, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                errorCounts: BitFlag;
                packetCounts: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            overrunCount: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rssi: Attribute<null | number, any>;
            securityType: Attribute<null | WiFiNetworkDiagnostics.SecurityType, any>;
            wiFiVersion: Attribute<null | WiFiNetworkDiagnostics.WiFiVersion, any>;
        };
        commands: {
            resetCounts: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            associationFailure: OptionalEvent<TypeFromFields<{
                associationFailureCause: FieldType<WiFiNetworkDiagnostics.AssociationFailureCause>;
                status: FieldType<number>;
            }>, any>;
            connectionStatus: OptionalEvent<TypeFromFields<{
                connectionStatus: FieldType<WiFiNetworkDiagnostics.ConnectionStatus>;
            }>, any>;
            disconnection: OptionalEvent<TypeFromFields<{
                reasonCode: FieldType<number>;
            }>, any>;
        };
        features: {
            errorCounts: BitFlag;
            packetCounts: BitFlag;
        };
        id: Branded<54, "ClusterId">;
        name: "WiFiNetworkDiagnostics";
        revision: 1;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          beaconLostCount?: null | number;
          beaconRxCount?: null | number;
          bssid: null | {};
          channelNumber: null | number;
          currentMaxRate?: null | number | bigint;
          overrunCount?: null | number | bigint;
          packetMulticastRxCount?: null | number;
          packetMulticastTxCount?: null | number;
          packetUnicastRxCount?: null | number;
          packetUnicastTxCount?: null | number;
          rssi: null | number;
          securityType: null | number;
          wiFiVersion: null | number;
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            beaconLostCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            beaconRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            bssid: Attribute<null | Uint8Array, any>;
            channelNumber: Attribute<null | number, any>;
            clusterRevision: Attribute<number, never>;
            currentMaxRate: OptionalAttribute<null | number | bigint, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                errorCounts: BitFlag;
                packetCounts: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            overrunCount: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rssi: Attribute<null | number, any>;
            securityType: Attribute<null | WiFiNetworkDiagnostics.SecurityType, any>;
            wiFiVersion: Attribute<null | WiFiNetworkDiagnostics.WiFiVersion, any>;
        };
        commands: {
            resetCounts: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            associationFailure: OptionalEvent<TypeFromFields<{
                associationFailureCause: FieldType<WiFiNetworkDiagnostics.AssociationFailureCause>;
                status: FieldType<number>;
            }>, any>;
            connectionStatus: OptionalEvent<TypeFromFields<{
                connectionStatus: FieldType<WiFiNetworkDiagnostics.ConnectionStatus>;
            }>, any>;
            disconnection: OptionalEvent<TypeFromFields<{
                reasonCode: FieldType<number>;
            }>, any>;
        };
        features: {
            errorCounts: BitFlag;
            packetCounts: BitFlag;
        };
        id: Branded<54, "ClusterId">;
        name: "WiFiNetworkDiagnostics";
        revision: 1;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            beaconLostCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            beaconRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            bssid: Attribute<null | Uint8Array, any>;
            channelNumber: Attribute<null | number, any>;
            clusterRevision: Attribute<number, never>;
            currentMaxRate: OptionalAttribute<null | number | bigint, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                errorCounts: BitFlag;
                packetCounts: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            overrunCount: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rssi: Attribute<null | number, any>;
            securityType: Attribute<null | WiFiNetworkDiagnostics.SecurityType, any>;
            wiFiVersion: Attribute<null | WiFiNetworkDiagnostics.WiFiVersion, any>;
        };
        commands: {
            resetCounts: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            associationFailure: OptionalEvent<TypeFromFields<{
                associationFailureCause: FieldType<WiFiNetworkDiagnostics.AssociationFailureCause>;
                status: FieldType<number>;
            }>, any>;
            connectionStatus: OptionalEvent<TypeFromFields<{
                connectionStatus: FieldType<WiFiNetworkDiagnostics.ConnectionStatus>;
            }>, any>;
            disconnection: OptionalEvent<TypeFromFields<{
                reasonCode: FieldType<number>;
            }>, any>;
        };
        features: {
            errorCounts: BitFlag;
            packetCounts: BitFlag;
        };
        id: Branded<54, "ClusterId">;
        name: "WiFiNetworkDiagnostics";
        revision: 1;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              attributeList: Attribute<AttributeId[], never>;
              beaconLostCount: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      errorCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              beaconRxCount: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      packetCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              bssid: Attribute<null | Uint8Array, any>;
              channelNumber: Attribute<null | number, any>;
              clusterRevision: Attribute<number, never>;
              currentMaxRate: OptionalAttribute<null | number | bigint, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  errorCounts: BitFlag;
                  packetCounts: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              overrunCount: Attribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      errorCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              packetMulticastRxCount: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      packetCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              packetMulticastTxCount: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      packetCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              packetUnicastRxCount: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      packetCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              packetUnicastTxCount: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      packetCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              rssi: Attribute<null | number, any>;
              securityType: Attribute<null | WiFiNetworkDiagnostics.SecurityType, any>;
              wiFiVersion: Attribute<null | WiFiNetworkDiagnostics.WiFiVersion, any>;
          };
          commands: {
              resetCounts: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      errorCounts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          events: {
              associationFailure: OptionalEvent<TypeFromFields<{
                  associationFailureCause: FieldType<WiFiNetworkDiagnostics.AssociationFailureCause>;
                  status: FieldType<number>;
              }>, any>;
              connectionStatus: OptionalEvent<TypeFromFields<{
                  connectionStatus: FieldType<WiFiNetworkDiagnostics.ConnectionStatus>;
              }>, any>;
              disconnection: OptionalEvent<TypeFromFields<{
                  reasonCode: FieldType<number>;
              }>, any>;
          };
          features: {
              errorCounts: BitFlag;
              packetCounts: BitFlag;
          };
          id: Branded<54, "ClusterId">;
          name: "WiFiNetworkDiagnostics";
          revision: 1;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            beaconLostCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            beaconRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            bssid: Attribute<null | Uint8Array, any>;
            channelNumber: Attribute<null | number, any>;
            clusterRevision: Attribute<number, never>;
            currentMaxRate: OptionalAttribute<null | number | bigint, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                errorCounts: BitFlag;
                packetCounts: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            overrunCount: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetMulticastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastRxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            packetUnicastTxCount: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    packetCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rssi: Attribute<null | number, any>;
            securityType: Attribute<null | WiFiNetworkDiagnostics.SecurityType, any>;
            wiFiVersion: Attribute<null | WiFiNetworkDiagnostics.WiFiVersion, any>;
        };
        commands: {
            resetCounts: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    errorCounts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            associationFailure: OptionalEvent<TypeFromFields<{
                associationFailureCause: FieldType<WiFiNetworkDiagnostics.AssociationFailureCause>;
                status: FieldType<number>;
            }>, any>;
            connectionStatus: OptionalEvent<TypeFromFields<{
                connectionStatus: FieldType<WiFiNetworkDiagnostics.ConnectionStatus>;
            }>, any>;
            disconnection: OptionalEvent<TypeFromFields<{
                reasonCode: FieldType<number>;
            }>, any>;
        };
        features: {
            errorCounts: BitFlag;
            packetCounts: BitFlag;
        };
        id: Branded<54, "ClusterId">;
        name: "WiFiNetworkDiagnostics";
        revision: 1;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods