This cluster supports all NetworkCommissioning 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<{
        connectMaxTimeSeconds: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                wiFiNetworkInterface: boolean;
            }, {
                threadNetworkInterface: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        interfaceEnabled: WritableAttribute<boolean, any>;
        lastConnectErrorValue: Attribute<null | number, any>;
        lastNetworkId: Attribute<null | Uint8Array, any>;
        lastNetworkingStatus: Attribute<null | NetworkCommissioning.NetworkCommissioningStatus, any>;
        maxNetworks: FixedAttribute<number, any>;
        networks: Attribute<TypeFromFields<{
            connected: FieldType<boolean>;
            networkId: FieldType<Uint8Array>;
        }>[], any>;
        scanMaxTimeSeconds: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                wiFiNetworkInterface: boolean;
            }, {
                threadNetworkInterface: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        supportedThreadFeatures: FixedAttribute<TypeFromPartialBitSchema<{
            isBorderRouterCapable: BitFlag;
            isFullThreadDevice: BitFlag;
            isRouterCapable: BitFlag;
            isSleepyEndDeviceCapable: BitFlag;
            isSynchronizedSleepyEndDeviceCapable: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                threadNetworkInterface: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        supportedWiFiBands: FixedAttribute<NetworkCommissioning.WiFiBand[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                wiFiNetworkInterface: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        threadVersion: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                threadNetworkInterface: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    }, GlobalAttributes<{
        ethernetNetworkInterface: BitFlag;
        threadNetworkInterface: BitFlag;
        wiFiNetworkInterface: BitFlag;
    }>>;
    base: undefined;
    commands: {
        addOrUpdateThreadNetwork: Command<TypeFromFields<{
            breadcrumb: OptionalFieldType<number | bigint>;
            operationalDataset: FieldType<Uint8Array>;
        }>, TypeFromFields<{
            debugText: OptionalFieldType<string>;
            networkIndex: OptionalFieldType<number>;
            networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                threadNetworkInterface: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        addOrUpdateWiFiNetwork: Command<TypeFromFields<{
            breadcrumb: OptionalFieldType<number | bigint>;
            credentials: FieldType<Uint8Array>;
            ssid: FieldType<Uint8Array>;
        }>, TypeFromFields<{
            debugText: OptionalFieldType<string>;
            networkIndex: OptionalFieldType<number>;
            networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                wiFiNetworkInterface: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        connectNetwork: Command<TypeFromFields<{
            breadcrumb: OptionalFieldType<number | bigint>;
            networkId: FieldType<Uint8Array>;
        }>, TypeFromFields<{
            debugText: OptionalFieldType<string>;
            errorValue: FieldType<null | number>;
            networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                wiFiNetworkInterface: boolean;
            }, {
                threadNetworkInterface: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        removeNetwork: Command<TypeFromFields<{
            breadcrumb: OptionalFieldType<number | bigint>;
            networkId: FieldType<Uint8Array>;
        }>, TypeFromFields<{
            debugText: OptionalFieldType<string>;
            networkIndex: OptionalFieldType<number>;
            networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                wiFiNetworkInterface: boolean;
            }, {
                threadNetworkInterface: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        reorderNetwork: Command<TypeFromFields<{
            breadcrumb: OptionalFieldType<number | bigint>;
            networkId: FieldType<Uint8Array>;
            networkIndex: FieldType<number>;
        }>, TypeFromFields<{
            debugText: OptionalFieldType<string>;
            networkIndex: OptionalFieldType<number>;
            networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                wiFiNetworkInterface: boolean;
            }, {
                threadNetworkInterface: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        scanNetworks: Command<TypeFromFields<{
            breadcrumb: OptionalFieldType<number | bigint>;
            ssid: OptionalFieldType<null | Uint8Array>;
        }>, TypeFromFields<{
            debugText: OptionalFieldType<string>;
            networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            threadScanResults: OptionalFieldType<TypeFromFields<{
                channel: OptionalFieldType<number>;
                extendedAddress: OptionalFieldType<Uint8Array>;
                extendedPanId: OptionalFieldType<(...) | (...)>;
                lqi: OptionalFieldType<number>;
                networkName: OptionalFieldType<string>;
                panId: OptionalFieldType<number>;
                rssi: OptionalFieldType<number>;
                version: OptionalFieldType<number>;
            }>[]>;
            wiFiScanResults: OptionalFieldType<TypeFromFields<{
                bssid: OptionalFieldType<Uint8Array>;
                channel: OptionalFieldType<number>;
                rssi: OptionalFieldType<number>;
                security: OptionalFieldType<TypeFromPartialBitSchema<(...)>>;
                ssid: OptionalFieldType<Uint8Array>;
                wiFiBand: OptionalFieldType<NetworkCommissioning.WiFiBand>;
            }>[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                wiFiNetworkInterface: boolean;
            }, {
                threadNetworkInterface: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {};
    extensions: undefined;
    features: {
        ethernetNetworkInterface: BitFlag;
        threadNetworkInterface: BitFlag;
        wiFiNetworkInterface: BitFlag;
    };
    id: Branded<49, "ClusterId">;
    name: "NetworkCommissioning";
    revision: 2;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            connectMaxTimeSeconds: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            interfaceEnabled: WritableAttribute<boolean, any>;
            lastConnectErrorValue: Attribute<null | number, any>;
            lastNetworkId: Attribute<null | Uint8Array, any>;
            lastNetworkingStatus: Attribute<null | NetworkCommissioning.NetworkCommissioningStatus, any>;
            maxNetworks: FixedAttribute<number, any>;
            networks: Attribute<TypeFromFields<{
                connected: FieldType<boolean>;
                networkId: FieldType<Uint8Array>;
            }>[], any>;
            scanMaxTimeSeconds: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedThreadFeatures: FixedAttribute<TypeFromPartialBitSchema<{
                isBorderRouterCapable: BitFlag;
                isFullThreadDevice: BitFlag;
                isRouterCapable: BitFlag;
                isSleepyEndDeviceCapable: BitFlag;
                isSynchronizedSleepyEndDeviceCapable: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedWiFiBands: FixedAttribute<NetworkCommissioning.WiFiBand[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            threadVersion: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            addOrUpdateThreadNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                operationalDataset: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            addOrUpdateWiFiNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                credentials: FieldType<Uint8Array>;
                ssid: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            connectNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                errorValue: FieldType<null | number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            removeNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            reorderNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
                networkIndex: FieldType<number>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scanNetworks: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                ssid: OptionalFieldType<null | Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
                threadScanResults: OptionalFieldType<TypeFromFields<(...)>[]>;
                wiFiScanResults: OptionalFieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            ethernetNetworkInterface: BitFlag;
            threadNetworkInterface: BitFlag;
            wiFiNetworkInterface: BitFlag;
        };
        id: 49;
        name: "NetworkCommissioning";
        revision: 2;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            connectMaxTimeSeconds: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            interfaceEnabled: WritableAttribute<boolean, any>;
            lastConnectErrorValue: Attribute<null | number, any>;
            lastNetworkId: Attribute<null | Uint8Array, any>;
            lastNetworkingStatus: Attribute<null | NetworkCommissioning.NetworkCommissioningStatus, any>;
            maxNetworks: FixedAttribute<number, any>;
            networks: Attribute<TypeFromFields<{
                connected: FieldType<boolean>;
                networkId: FieldType<Uint8Array>;
            }>[], any>;
            scanMaxTimeSeconds: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedThreadFeatures: FixedAttribute<TypeFromPartialBitSchema<{
                isBorderRouterCapable: BitFlag;
                isFullThreadDevice: BitFlag;
                isRouterCapable: BitFlag;
                isSleepyEndDeviceCapable: BitFlag;
                isSynchronizedSleepyEndDeviceCapable: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedWiFiBands: FixedAttribute<NetworkCommissioning.WiFiBand[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            threadVersion: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            addOrUpdateThreadNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                operationalDataset: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            addOrUpdateWiFiNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                credentials: FieldType<Uint8Array>;
                ssid: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            connectNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                errorValue: FieldType<null | number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            removeNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            reorderNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
                networkIndex: FieldType<number>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scanNetworks: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                ssid: OptionalFieldType<null | Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
                threadScanResults: OptionalFieldType<TypeFromFields<(...)>[]>;
                wiFiScanResults: OptionalFieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            ethernetNetworkInterface: BitFlag;
            threadNetworkInterface: BitFlag;
            wiFiNetworkInterface: BitFlag;
        };
        id: 49;
        name: "NetworkCommissioning";
        revision: 2;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            connectMaxTimeSeconds: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            interfaceEnabled: WritableAttribute<boolean, any>;
            lastConnectErrorValue: Attribute<null | number, any>;
            lastNetworkId: Attribute<null | Uint8Array, any>;
            lastNetworkingStatus: Attribute<null | NetworkCommissioning.NetworkCommissioningStatus, any>;
            maxNetworks: FixedAttribute<number, any>;
            networks: Attribute<TypeFromFields<{
                connected: FieldType<boolean>;
                networkId: FieldType<Uint8Array>;
            }>[], any>;
            scanMaxTimeSeconds: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedThreadFeatures: FixedAttribute<TypeFromPartialBitSchema<{
                isBorderRouterCapable: BitFlag;
                isFullThreadDevice: BitFlag;
                isRouterCapable: BitFlag;
                isSleepyEndDeviceCapable: BitFlag;
                isSynchronizedSleepyEndDeviceCapable: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedWiFiBands: FixedAttribute<NetworkCommissioning.WiFiBand[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            threadVersion: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            addOrUpdateThreadNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                operationalDataset: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            addOrUpdateWiFiNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                credentials: FieldType<Uint8Array>;
                ssid: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            connectNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                errorValue: FieldType<null | number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            removeNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            reorderNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
                networkIndex: FieldType<number>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scanNetworks: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                ssid: OptionalFieldType<null | Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
                threadScanResults: OptionalFieldType<TypeFromFields<(...)>[]>;
                wiFiScanResults: OptionalFieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            ethernetNetworkInterface: BitFlag;
            threadNetworkInterface: BitFlag;
            wiFiNetworkInterface: BitFlag;
        };
        id: 49;
        name: "NetworkCommissioning";
        revision: 2;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            connectMaxTimeSeconds: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            interfaceEnabled: WritableAttribute<boolean, any>;
            lastConnectErrorValue: Attribute<null | number, any>;
            lastNetworkId: Attribute<null | Uint8Array, any>;
            lastNetworkingStatus: Attribute<null | NetworkCommissioning.NetworkCommissioningStatus, any>;
            maxNetworks: FixedAttribute<number, any>;
            networks: Attribute<TypeFromFields<{
                connected: FieldType<boolean>;
                networkId: FieldType<Uint8Array>;
            }>[], any>;
            scanMaxTimeSeconds: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedThreadFeatures: FixedAttribute<TypeFromPartialBitSchema<{
                isBorderRouterCapable: BitFlag;
                isFullThreadDevice: BitFlag;
                isRouterCapable: BitFlag;
                isSleepyEndDeviceCapable: BitFlag;
                isSynchronizedSleepyEndDeviceCapable: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedWiFiBands: FixedAttribute<NetworkCommissioning.WiFiBand[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            threadVersion: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            addOrUpdateThreadNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                operationalDataset: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            addOrUpdateWiFiNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                credentials: FieldType<Uint8Array>;
                ssid: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            connectNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                errorValue: FieldType<null | number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            removeNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            reorderNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
                networkIndex: FieldType<number>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scanNetworks: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                ssid: OptionalFieldType<null | Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
                threadScanResults: OptionalFieldType<TypeFromFields<(...)>[]>;
                wiFiScanResults: OptionalFieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            ethernetNetworkInterface: BitFlag;
            threadNetworkInterface: BitFlag;
            wiFiNetworkInterface: BitFlag;
        };
        id: 49;
        name: "NetworkCommissioning";
        revision: 2;
    }>, SelectionT>;
}

Hierarchy (view full)

Properties

attributes: Merge<{
    connectMaxTimeSeconds: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            wiFiNetworkInterface: boolean;
        }, {
            threadNetworkInterface: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    interfaceEnabled: WritableAttribute<boolean, any>;
    lastConnectErrorValue: Attribute<null | number, any>;
    lastNetworkId: Attribute<null | Uint8Array, any>;
    lastNetworkingStatus: Attribute<null | NetworkCommissioning.NetworkCommissioningStatus, any>;
    maxNetworks: FixedAttribute<number, any>;
    networks: Attribute<TypeFromFields<{
        connected: FieldType<boolean>;
        networkId: FieldType<Uint8Array>;
    }>[], any>;
    scanMaxTimeSeconds: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            wiFiNetworkInterface: boolean;
        }, {
            threadNetworkInterface: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    supportedThreadFeatures: FixedAttribute<TypeFromPartialBitSchema<{
        isBorderRouterCapable: BitFlag;
        isFullThreadDevice: BitFlag;
        isRouterCapable: BitFlag;
        isSleepyEndDeviceCapable: BitFlag;
        isSynchronizedSleepyEndDeviceCapable: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            threadNetworkInterface: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    supportedWiFiBands: FixedAttribute<NetworkCommissioning.WiFiBand[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            wiFiNetworkInterface: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    threadVersion: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            threadNetworkInterface: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}, GlobalAttributes<{
    ethernetNetworkInterface: BitFlag;
    threadNetworkInterface: BitFlag;
    wiFiNetworkInterface: BitFlag;
}>>

Type declaration

  • ReadonlyconnectMaxTimeSeconds: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            wiFiNetworkInterface: boolean;
        }, {
            threadNetworkInterface: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyinterfaceEnabled: WritableAttribute<boolean, any>

    Indicates whether the associated network interface is enabled or not. By default all network interfaces SHOULD be enabled during initial commissioning (InterfaceEnabled set to true).

    It is undefined what happens if InterfaceEnabled is written to false on the same interface as that which is used to write the value. In that case, it is possible that the Administrator would have to await expiry of the fail-safe, and associated recovery of network configuration to prior safe values, before being able to communicate with the node again (see Section 11.10.6.2, “ArmFailSafe Command”).

    It may be possible to disable Ethernet interfaces but it is implementation-defined. If not supported, a write to this attribute with a value of false shall fail with a status of INVALID_ACTION. When disabled, an Ethernet interface would longer employ media detection. That is, a simple unplug and replug of the cable shall NOT re-enable the interface.

    On Ethernet-only Nodes, there shall always be at least one of the Network Commissioning server cluster instances with InterfaceEnabled set to true.

    MatterSpecification.v13.Core § 11.9.6.5

  • ReadonlylastConnectErrorValue: Attribute<null | number, any>

    Indicates the ErrorValue used in the last failed attempt to connect to an operational network, using this interface, whether by invocation of the ConnectNetwork command or by

    autonomous connection after loss of connectivity or during initial establishment. If no such attempt was made, or no network configurations exist in the Networks attribute, then this attribute shall be set to null.

    If the last connection succeeded, as indicated by a value of Success in the LastNetworkingStatus attribute, then this field shall be set to null.

    This attribute is present to assist with error recovery during Network commissioning and to assist in non-concurrent networking commissioning flows.

    MatterSpecification.v13.Core § 11.9.6.8

  • ReadonlylastNetworkId: Attribute<null | Uint8Array, any>

    Indicates the NetworkID used in the last attempt to connect to an operational network, using this interface, whether by invocation of the ConnectNetwork command or by autonomous connection after loss of connectivity or during initial establishment. If no such attempt was made, or no network configurations exist in the Networks attribute, then this attribute shall be set to null.

    If a network configuration is removed from the Networks attribute using the RemoveNetwork command after a connection attempt, this field may indicate a NetworkID that is no longer configured on the Node.

    This attribute is present to assist with error recovery during Network commissioning and to assist in non-concurrent networking commissioning flows.

    MatterSpecification.v13.Core § 11.9.6.7

  • ReadonlylastNetworkingStatus: Attribute<null | NetworkCommissioning.NetworkCommissioningStatus, any>

    Indicates the status of the last attempt either scan or connect to an operational network, using this interface, whether by invocation of the ConnectNetwork command or by autonomous connection after loss of connectivity or during initial establishment. If no such attempt was made, or no network configurations exist in the Networks attribute, then this attribute shall be set to null.

    This attribute is present to assist with error recovery during Network commissioning and to assist in non-concurrent networking commissioning flows.

    MatterSpecification.v13.Core § 11.9.6.6

  • ReadonlymaxNetworks: FixedAttribute<number, any>

    This shall indicate the maximum number of network configuration entries that can be added, based on available device resources. The length of the Networks attribute shall be less than or equal to this value.

    MatterSpecification.v13.Core § 11.9.6.1

  • Readonlynetworks: Attribute<TypeFromFields<{
        connected: FieldType<boolean>;
        networkId: FieldType<Uint8Array>;
    }>[], any>

    Indicates the network configurations that are usable on the network interface represented by this cluster server instance.

    The order of configurations in the list reflects precedence. That is, any time the Node attempts to connect to the network it shall attempt to do so using the configurations in Networks Attribute in the order as they appear in the list.

    The order of list items shall only be modified by the AddOrUpdateThreadNetwork, AddOrUpdateWiFiNetwork and ReorderNetwork commands. In other words, the list shall be stable over time, unless mutated externally.

    Ethernet networks shall be automatically populated by the cluster server. Ethernet Network Commissioning Cluster instances shall always have exactly one NetworkInfoStruct instance in their Networks attribute. There shall be no way to add, update or remove Ethernet network configurations to those Cluster instances.

    MatterSpecification.v13.Core § 11.9.6.2

  • ReadonlyscanMaxTimeSeconds: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            wiFiNetworkInterface: boolean;
        }, {
            threadNetworkInterface: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlysupportedThreadFeatures: FixedAttribute<TypeFromPartialBitSchema<{
        isBorderRouterCapable: BitFlag;
        isFullThreadDevice: BitFlag;
        isRouterCapable: BitFlag;
        isSleepyEndDeviceCapable: BitFlag;
        isSynchronizedSleepyEndDeviceCapable: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            threadNetworkInterface: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlysupportedWiFiBands: FixedAttribute<NetworkCommissioning.WiFiBand[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            wiFiNetworkInterface: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlythreadVersion: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            threadNetworkInterface: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
base: undefined
commands: {
    addOrUpdateThreadNetwork: Command<TypeFromFields<{
        breadcrumb: OptionalFieldType<number | bigint>;
        operationalDataset: FieldType<Uint8Array>;
    }>, TypeFromFields<{
        debugText: OptionalFieldType<string>;
        networkIndex: OptionalFieldType<number>;
        networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            threadNetworkInterface: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    addOrUpdateWiFiNetwork: Command<TypeFromFields<{
        breadcrumb: OptionalFieldType<number | bigint>;
        credentials: FieldType<Uint8Array>;
        ssid: FieldType<Uint8Array>;
    }>, TypeFromFields<{
        debugText: OptionalFieldType<string>;
        networkIndex: OptionalFieldType<number>;
        networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            wiFiNetworkInterface: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    connectNetwork: Command<TypeFromFields<{
        breadcrumb: OptionalFieldType<number | bigint>;
        networkId: FieldType<Uint8Array>;
    }>, TypeFromFields<{
        debugText: OptionalFieldType<string>;
        errorValue: FieldType<null | number>;
        networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            wiFiNetworkInterface: boolean;
        }, {
            threadNetworkInterface: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    removeNetwork: Command<TypeFromFields<{
        breadcrumb: OptionalFieldType<number | bigint>;
        networkId: FieldType<Uint8Array>;
    }>, TypeFromFields<{
        debugText: OptionalFieldType<string>;
        networkIndex: OptionalFieldType<number>;
        networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            wiFiNetworkInterface: boolean;
        }, {
            threadNetworkInterface: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    reorderNetwork: Command<TypeFromFields<{
        breadcrumb: OptionalFieldType<number | bigint>;
        networkId: FieldType<Uint8Array>;
        networkIndex: FieldType<number>;
    }>, TypeFromFields<{
        debugText: OptionalFieldType<string>;
        networkIndex: OptionalFieldType<number>;
        networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            wiFiNetworkInterface: boolean;
        }, {
            threadNetworkInterface: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    scanNetworks: Command<TypeFromFields<{
        breadcrumb: OptionalFieldType<number | bigint>;
        ssid: OptionalFieldType<null | Uint8Array>;
    }>, TypeFromFields<{
        debugText: OptionalFieldType<string>;
        networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
        threadScanResults: OptionalFieldType<TypeFromFields<{
            channel: OptionalFieldType<number>;
            extendedAddress: OptionalFieldType<Uint8Array>;
            extendedPanId: OptionalFieldType<(...) | (...)>;
            lqi: OptionalFieldType<number>;
            networkName: OptionalFieldType<string>;
            panId: OptionalFieldType<number>;
            rssi: OptionalFieldType<number>;
            version: OptionalFieldType<number>;
        }>[]>;
        wiFiScanResults: OptionalFieldType<TypeFromFields<{
            bssid: OptionalFieldType<Uint8Array>;
            channel: OptionalFieldType<number>;
            rssi: OptionalFieldType<number>;
            security: OptionalFieldType<TypeFromPartialBitSchema<(...)>>;
            ssid: OptionalFieldType<Uint8Array>;
            wiFiBand: OptionalFieldType<NetworkCommissioning.WiFiBand>;
        }>[]>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            wiFiNetworkInterface: boolean;
        }, {
            threadNetworkInterface: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}
events: {}
extensions: undefined
features: {
    ethernetNetworkInterface: BitFlag;
    threadNetworkInterface: BitFlag;
    wiFiNetworkInterface: BitFlag;
}

Type declaration

  • ReadonlyethernetNetworkInterface: BitFlag

    EthernetNetworkInterface

    Ethernet related features

  • ReadonlythreadNetworkInterface: BitFlag

    ThreadNetworkInterface

    Thread related features

  • ReadonlywiFiNetworkInterface: BitFlag

    WiFiNetworkInterface

    Wi-Fi related features

id: Branded<49, "ClusterId">
name
revision
supportedFeatures: {}
unknown

Methods

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              connectMaxTimeSeconds: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }, {
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              interfaceEnabled: WritableAttribute<boolean, any>;
              lastConnectErrorValue: Attribute<null | number, any>;
              lastNetworkId: Attribute<null | Uint8Array, any>;
              lastNetworkingStatus: Attribute<null | NetworkCommissioning.NetworkCommissioningStatus, any>;
              maxNetworks: FixedAttribute<number, any>;
              networks: Attribute<TypeFromFields<{
                  connected: FieldType<boolean>;
                  networkId: FieldType<Uint8Array>;
              }>[], any>;
              scanMaxTimeSeconds: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }, {
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              supportedThreadFeatures: FixedAttribute<TypeFromPartialBitSchema<{
                  isBorderRouterCapable: BitFlag;
                  isFullThreadDevice: BitFlag;
                  isRouterCapable: BitFlag;
                  isSleepyEndDeviceCapable: BitFlag;
                  isSynchronizedSleepyEndDeviceCapable: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              supportedWiFiBands: FixedAttribute<NetworkCommissioning.WiFiBand[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              threadVersion: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              addOrUpdateThreadNetwork: Command<TypeFromFields<{
                  breadcrumb: OptionalFieldType<number | bigint>;
                  operationalDataset: FieldType<Uint8Array>;
              }>, TypeFromFields<{
                  debugText: OptionalFieldType<string>;
                  networkIndex: OptionalFieldType<number>;
                  networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              addOrUpdateWiFiNetwork: Command<TypeFromFields<{
                  breadcrumb: OptionalFieldType<number | bigint>;
                  credentials: FieldType<Uint8Array>;
                  ssid: FieldType<Uint8Array>;
              }>, TypeFromFields<{
                  debugText: OptionalFieldType<string>;
                  networkIndex: OptionalFieldType<number>;
                  networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              connectNetwork: Command<TypeFromFields<{
                  breadcrumb: OptionalFieldType<number | bigint>;
                  networkId: FieldType<Uint8Array>;
              }>, TypeFromFields<{
                  debugText: OptionalFieldType<string>;
                  errorValue: FieldType<null | number>;
                  networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }, {
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              removeNetwork: Command<TypeFromFields<{
                  breadcrumb: OptionalFieldType<number | bigint>;
                  networkId: FieldType<Uint8Array>;
              }>, TypeFromFields<{
                  debugText: OptionalFieldType<string>;
                  networkIndex: OptionalFieldType<number>;
                  networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }, {
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              reorderNetwork: Command<TypeFromFields<{
                  breadcrumb: OptionalFieldType<number | bigint>;
                  networkId: FieldType<Uint8Array>;
                  networkIndex: FieldType<number>;
              }>, TypeFromFields<{
                  debugText: OptionalFieldType<string>;
                  networkIndex: OptionalFieldType<number>;
                  networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }, {
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              scanNetworks: Command<TypeFromFields<{
                  breadcrumb: OptionalFieldType<number | bigint>;
                  ssid: OptionalFieldType<null | Uint8Array>;
              }>, TypeFromFields<{
                  debugText: OptionalFieldType<string>;
                  networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
                  threadScanResults: OptionalFieldType<TypeFromFields<(...)>[]>;
                  wiFiScanResults: OptionalFieldType<TypeFromFields<(...)>[]>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }, {
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              ethernetNetworkInterface: BitFlag;
              threadNetworkInterface: BitFlag;
              wiFiNetworkInterface: BitFlag;
          };
          id: 49;
          name: "NetworkCommissioning";
          revision: 2;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            connectMaxTimeSeconds: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            interfaceEnabled: WritableAttribute<boolean, any>;
            lastConnectErrorValue: Attribute<null | number, any>;
            lastNetworkId: Attribute<null | Uint8Array, any>;
            lastNetworkingStatus: Attribute<null | NetworkCommissioning.NetworkCommissioningStatus, any>;
            maxNetworks: FixedAttribute<number, any>;
            networks: Attribute<TypeFromFields<{
                connected: FieldType<boolean>;
                networkId: FieldType<Uint8Array>;
            }>[], any>;
            scanMaxTimeSeconds: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedThreadFeatures: FixedAttribute<TypeFromPartialBitSchema<{
                isBorderRouterCapable: BitFlag;
                isFullThreadDevice: BitFlag;
                isRouterCapable: BitFlag;
                isSleepyEndDeviceCapable: BitFlag;
                isSynchronizedSleepyEndDeviceCapable: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedWiFiBands: FixedAttribute<NetworkCommissioning.WiFiBand[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            threadVersion: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            addOrUpdateThreadNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                operationalDataset: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            addOrUpdateWiFiNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                credentials: FieldType<Uint8Array>;
                ssid: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            connectNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                errorValue: FieldType<null | number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            removeNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            reorderNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
                networkIndex: FieldType<number>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scanNetworks: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                ssid: OptionalFieldType<null | Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
                threadScanResults: OptionalFieldType<TypeFromFields<(...)>[]>;
                wiFiScanResults: OptionalFieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            ethernetNetworkInterface: BitFlag;
            threadNetworkInterface: BitFlag;
            wiFiNetworkInterface: BitFlag;
        };
        id: 49;
        name: "NetworkCommissioning";
        revision: 2;
    }>, AlterationsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              connectMaxTimeSeconds: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }, {
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              interfaceEnabled: WritableAttribute<boolean, any>;
              lastConnectErrorValue: Attribute<null | number, any>;
              lastNetworkId: Attribute<null | Uint8Array, any>;
              lastNetworkingStatus: Attribute<null | NetworkCommissioning.NetworkCommissioningStatus, any>;
              maxNetworks: FixedAttribute<number, any>;
              networks: Attribute<TypeFromFields<{
                  connected: FieldType<boolean>;
                  networkId: FieldType<Uint8Array>;
              }>[], any>;
              scanMaxTimeSeconds: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }, {
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              supportedThreadFeatures: FixedAttribute<TypeFromPartialBitSchema<{
                  isBorderRouterCapable: BitFlag;
                  isFullThreadDevice: BitFlag;
                  isRouterCapable: BitFlag;
                  isSleepyEndDeviceCapable: BitFlag;
                  isSynchronizedSleepyEndDeviceCapable: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              supportedWiFiBands: FixedAttribute<NetworkCommissioning.WiFiBand[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              threadVersion: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              addOrUpdateThreadNetwork: Command<TypeFromFields<{
                  breadcrumb: OptionalFieldType<number | bigint>;
                  operationalDataset: FieldType<Uint8Array>;
              }>, TypeFromFields<{
                  debugText: OptionalFieldType<string>;
                  networkIndex: OptionalFieldType<number>;
                  networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              addOrUpdateWiFiNetwork: Command<TypeFromFields<{
                  breadcrumb: OptionalFieldType<number | bigint>;
                  credentials: FieldType<Uint8Array>;
                  ssid: FieldType<Uint8Array>;
              }>, TypeFromFields<{
                  debugText: OptionalFieldType<string>;
                  networkIndex: OptionalFieldType<number>;
                  networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              connectNetwork: Command<TypeFromFields<{
                  breadcrumb: OptionalFieldType<number | bigint>;
                  networkId: FieldType<Uint8Array>;
              }>, TypeFromFields<{
                  debugText: OptionalFieldType<string>;
                  errorValue: FieldType<null | number>;
                  networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }, {
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              removeNetwork: Command<TypeFromFields<{
                  breadcrumb: OptionalFieldType<number | bigint>;
                  networkId: FieldType<Uint8Array>;
              }>, TypeFromFields<{
                  debugText: OptionalFieldType<string>;
                  networkIndex: OptionalFieldType<number>;
                  networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }, {
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              reorderNetwork: Command<TypeFromFields<{
                  breadcrumb: OptionalFieldType<number | bigint>;
                  networkId: FieldType<Uint8Array>;
                  networkIndex: FieldType<number>;
              }>, TypeFromFields<{
                  debugText: OptionalFieldType<string>;
                  networkIndex: OptionalFieldType<number>;
                  networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }, {
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              scanNetworks: Command<TypeFromFields<{
                  breadcrumb: OptionalFieldType<number | bigint>;
                  ssid: OptionalFieldType<null | Uint8Array>;
              }>, TypeFromFields<{
                  debugText: OptionalFieldType<string>;
                  networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
                  threadScanResults: OptionalFieldType<TypeFromFields<(...)>[]>;
                  wiFiScanResults: OptionalFieldType<TypeFromFields<(...)>[]>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }, {
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              ethernetNetworkInterface: BitFlag;
              threadNetworkInterface: BitFlag;
              wiFiNetworkInterface: BitFlag;
          };
          id: 49;
          name: "NetworkCommissioning";
          revision: 2;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            connectMaxTimeSeconds: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            interfaceEnabled: WritableAttribute<boolean, any>;
            lastConnectErrorValue: Attribute<null | number, any>;
            lastNetworkId: Attribute<null | Uint8Array, any>;
            lastNetworkingStatus: Attribute<null | NetworkCommissioning.NetworkCommissioningStatus, any>;
            maxNetworks: FixedAttribute<number, any>;
            networks: Attribute<TypeFromFields<{
                connected: FieldType<boolean>;
                networkId: FieldType<Uint8Array>;
            }>[], any>;
            scanMaxTimeSeconds: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedThreadFeatures: FixedAttribute<TypeFromPartialBitSchema<{
                isBorderRouterCapable: BitFlag;
                isFullThreadDevice: BitFlag;
                isRouterCapable: BitFlag;
                isSleepyEndDeviceCapable: BitFlag;
                isSynchronizedSleepyEndDeviceCapable: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedWiFiBands: FixedAttribute<NetworkCommissioning.WiFiBand[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            threadVersion: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            addOrUpdateThreadNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                operationalDataset: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            addOrUpdateWiFiNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                credentials: FieldType<Uint8Array>;
                ssid: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            connectNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                errorValue: FieldType<null | number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            removeNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            reorderNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
                networkIndex: FieldType<number>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scanNetworks: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                ssid: OptionalFieldType<null | Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
                threadScanResults: OptionalFieldType<TypeFromFields<(...)>[]>;
                wiFiScanResults: OptionalFieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            ethernetNetworkInterface: BitFlag;
            threadNetworkInterface: BitFlag;
            wiFiNetworkInterface: BitFlag;
        };
        id: 49;
        name: "NetworkCommissioning";
        revision: 2;
    }>, FlagsT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          connectMaxTimeSeconds?: number;
          interfaceEnabled: boolean;
          lastConnectErrorValue: null | number;
          lastNetworkId: null | {};
          lastNetworkingStatus: null | number;
          maxNetworks: number;
          networks: {
              connected: boolean;
              networkId: {};
          }[];
          scanMaxTimeSeconds?: number;
          supportedThreadFeatures?: {
              isBorderRouterCapable?: boolean;
              isFullThreadDevice?: boolean;
              isRouterCapable?: boolean;
              isSleepyEndDeviceCapable?: boolean;
              isSynchronizedSleepyEndDeviceCapable?: boolean;
          };
          supportedWiFiBands?: number[];
          threadVersion?: number;
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            connectMaxTimeSeconds: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            interfaceEnabled: WritableAttribute<boolean, any>;
            lastConnectErrorValue: Attribute<null | number, any>;
            lastNetworkId: Attribute<null | Uint8Array, any>;
            lastNetworkingStatus: Attribute<null | NetworkCommissioning.NetworkCommissioningStatus, any>;
            maxNetworks: FixedAttribute<number, any>;
            networks: Attribute<TypeFromFields<{
                connected: FieldType<boolean>;
                networkId: FieldType<Uint8Array>;
            }>[], any>;
            scanMaxTimeSeconds: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedThreadFeatures: FixedAttribute<TypeFromPartialBitSchema<{
                isBorderRouterCapable: BitFlag;
                isFullThreadDevice: BitFlag;
                isRouterCapable: BitFlag;
                isSleepyEndDeviceCapable: BitFlag;
                isSynchronizedSleepyEndDeviceCapable: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedWiFiBands: FixedAttribute<NetworkCommissioning.WiFiBand[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            threadVersion: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            addOrUpdateThreadNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                operationalDataset: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            addOrUpdateWiFiNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                credentials: FieldType<Uint8Array>;
                ssid: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            connectNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                errorValue: FieldType<null | number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            removeNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            reorderNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
                networkIndex: FieldType<number>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scanNetworks: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                ssid: OptionalFieldType<null | Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
                threadScanResults: OptionalFieldType<TypeFromFields<(...)>[]>;
                wiFiScanResults: OptionalFieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            ethernetNetworkInterface: BitFlag;
            threadNetworkInterface: BitFlag;
            wiFiNetworkInterface: BitFlag;
        };
        id: 49;
        name: "NetworkCommissioning";
        revision: 2;
    }>, ValuesT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              connectMaxTimeSeconds: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }, {
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              interfaceEnabled: WritableAttribute<boolean, any>;
              lastConnectErrorValue: Attribute<null | number, any>;
              lastNetworkId: Attribute<null | Uint8Array, any>;
              lastNetworkingStatus: Attribute<null | NetworkCommissioning.NetworkCommissioningStatus, any>;
              maxNetworks: FixedAttribute<number, any>;
              networks: Attribute<TypeFromFields<{
                  connected: FieldType<boolean>;
                  networkId: FieldType<Uint8Array>;
              }>[], any>;
              scanMaxTimeSeconds: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }, {
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              supportedThreadFeatures: FixedAttribute<TypeFromPartialBitSchema<{
                  isBorderRouterCapable: BitFlag;
                  isFullThreadDevice: BitFlag;
                  isRouterCapable: BitFlag;
                  isSleepyEndDeviceCapable: BitFlag;
                  isSynchronizedSleepyEndDeviceCapable: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              supportedWiFiBands: FixedAttribute<NetworkCommissioning.WiFiBand[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              threadVersion: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              addOrUpdateThreadNetwork: Command<TypeFromFields<{
                  breadcrumb: OptionalFieldType<number | bigint>;
                  operationalDataset: FieldType<Uint8Array>;
              }>, TypeFromFields<{
                  debugText: OptionalFieldType<string>;
                  networkIndex: OptionalFieldType<number>;
                  networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              addOrUpdateWiFiNetwork: Command<TypeFromFields<{
                  breadcrumb: OptionalFieldType<number | bigint>;
                  credentials: FieldType<Uint8Array>;
                  ssid: FieldType<Uint8Array>;
              }>, TypeFromFields<{
                  debugText: OptionalFieldType<string>;
                  networkIndex: OptionalFieldType<number>;
                  networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              connectNetwork: Command<TypeFromFields<{
                  breadcrumb: OptionalFieldType<number | bigint>;
                  networkId: FieldType<Uint8Array>;
              }>, TypeFromFields<{
                  debugText: OptionalFieldType<string>;
                  errorValue: FieldType<null | number>;
                  networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }, {
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              removeNetwork: Command<TypeFromFields<{
                  breadcrumb: OptionalFieldType<number | bigint>;
                  networkId: FieldType<Uint8Array>;
              }>, TypeFromFields<{
                  debugText: OptionalFieldType<string>;
                  networkIndex: OptionalFieldType<number>;
                  networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }, {
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              reorderNetwork: Command<TypeFromFields<{
                  breadcrumb: OptionalFieldType<number | bigint>;
                  networkId: FieldType<Uint8Array>;
                  networkIndex: FieldType<number>;
              }>, TypeFromFields<{
                  debugText: OptionalFieldType<string>;
                  networkIndex: OptionalFieldType<number>;
                  networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }, {
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              scanNetworks: Command<TypeFromFields<{
                  breadcrumb: OptionalFieldType<number | bigint>;
                  ssid: OptionalFieldType<null | Uint8Array>;
              }>, TypeFromFields<{
                  debugText: OptionalFieldType<string>;
                  networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
                  threadScanResults: OptionalFieldType<TypeFromFields<(...)>[]>;
                  wiFiScanResults: OptionalFieldType<TypeFromFields<(...)>[]>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wiFiNetworkInterface: boolean;
                  }, {
                      threadNetworkInterface: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              ethernetNetworkInterface: BitFlag;
              threadNetworkInterface: BitFlag;
              wiFiNetworkInterface: BitFlag;
          };
          id: 49;
          name: "NetworkCommissioning";
          revision: 2;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            connectMaxTimeSeconds: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            interfaceEnabled: WritableAttribute<boolean, any>;
            lastConnectErrorValue: Attribute<null | number, any>;
            lastNetworkId: Attribute<null | Uint8Array, any>;
            lastNetworkingStatus: Attribute<null | NetworkCommissioning.NetworkCommissioningStatus, any>;
            maxNetworks: FixedAttribute<number, any>;
            networks: Attribute<TypeFromFields<{
                connected: FieldType<boolean>;
                networkId: FieldType<Uint8Array>;
            }>[], any>;
            scanMaxTimeSeconds: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedThreadFeatures: FixedAttribute<TypeFromPartialBitSchema<{
                isBorderRouterCapable: BitFlag;
                isFullThreadDevice: BitFlag;
                isRouterCapable: BitFlag;
                isSleepyEndDeviceCapable: BitFlag;
                isSynchronizedSleepyEndDeviceCapable: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedWiFiBands: FixedAttribute<NetworkCommissioning.WiFiBand[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            threadVersion: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            addOrUpdateThreadNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                operationalDataset: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            addOrUpdateWiFiNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                credentials: FieldType<Uint8Array>;
                ssid: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            connectNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                errorValue: FieldType<null | number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            removeNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            reorderNetwork: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                networkId: FieldType<Uint8Array>;
                networkIndex: FieldType<number>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkIndex: OptionalFieldType<number>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scanNetworks: Command<TypeFromFields<{
                breadcrumb: OptionalFieldType<number | bigint>;
                ssid: OptionalFieldType<null | Uint8Array>;
            }>, TypeFromFields<{
                debugText: OptionalFieldType<string>;
                networkingStatus: FieldType<NetworkCommissioning.NetworkCommissioningStatus>;
                threadScanResults: OptionalFieldType<TypeFromFields<(...)>[]>;
                wiFiScanResults: OptionalFieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wiFiNetworkInterface: boolean;
                }, {
                    threadNetworkInterface: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            ethernetNetworkInterface: BitFlag;
            threadNetworkInterface: BitFlag;
            wiFiNetworkInterface: BitFlag;
        };
        id: 49;
        name: "NetworkCommissioning";
        revision: 2;
    }>, SelectionT>