Interface Cluster

The Ethernet Network Diagnostics Cluster provides a means to acquire standardized diagnostics metrics that may be used by a Node to assist a user or Administrator in diagnosing potential problems. The Ethernet Network Diagnostics Cluster attempts to centralize all metrics that are relevant to a potential Ethernet connection to a Node.

EthernetNetworkDiagnosticsCluster supports optional features that you can enable with the EthernetNetworkDiagnosticsCluster.with() factory method.

See

MatterSpecification.v13.Core § 11.16

interface Cluster {
    attributes: Merge<{
        carrierDetect: OptionalAttribute<null | boolean, any>;
        fullDuplex: OptionalAttribute<null | boolean, any>;
        phyRate: OptionalAttribute<null | EthernetNetworkDiagnostics.PhyRate, any>;
        timeSinceReset: OptionalAttribute<number | bigint, any>;
    }, GlobalAttributes<{
        errorCounts: BitFlag;
        packetCounts: BitFlag;
    }>>;
    base: undefined;
    commands: {};
    events: {};
    extensions: readonly [{
        component: {
            attributes: {
                packetRxCount: Attribute<number | bigint, any>;
                packetTxCount: Attribute<number | bigint, any>;
            };
        };
        flags: {
            packetCounts: true;
        };
    }, {
        component: {
            attributes: {
                collisionCount: Attribute<number | bigint, any>;
                overrunCount: Attribute<number | bigint, any>;
                txErrCount: Attribute<number | bigint, any>;
            };
        };
        flags: {
            errorCounts: true;
        };
    }, {
        component: {
            commands: {
                resetCounts: Command<void, void, any>;
            };
        };
        flags: {
            packetCounts: true;
        };
    }, {
        component: {
            commands: {
                resetCounts: Command<void, void, any>;
            };
        };
        flags: {
            errorCounts: true;
        };
    }];
    features: {
        errorCounts: BitFlag;
        packetCounts: BitFlag;
    };
    id: Branded<55, "ClusterId">;
    name: "EthernetNetworkDiagnostics";
    revision: 1;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            carrierDetect: OptionalAttribute<null | boolean, any>;
            fullDuplex: OptionalAttribute<null | boolean, any>;
            phyRate: OptionalAttribute<null | EthernetNetworkDiagnostics.PhyRate, any>;
            timeSinceReset: OptionalAttribute<number | bigint, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    packetRxCount: Attribute<number | bigint, any>;
                    packetTxCount: Attribute<number | bigint, any>;
                };
            };
            flags: {
                packetCounts: true;
            };
        }, {
            component: {
                attributes: {
                    collisionCount: Attribute<number | bigint, any>;
                    overrunCount: Attribute<number | bigint, any>;
                    txErrCount: Attribute<number | bigint, any>;
                };
            };
            flags: {
                errorCounts: true;
            };
        }, {
            component: {
                commands: {
                    resetCounts: Command<void, void, any>;
                };
            };
            flags: {
                packetCounts: true;
            };
        }, {
            component: {
                commands: {
                    resetCounts: Command<void, void, any>;
                };
            };
            flags: {
                errorCounts: true;
            };
        }];
        features: {
            errorCounts: BitFlag;
            packetCounts: BitFlag;
        };
        id: 55;
        name: "EthernetNetworkDiagnostics";
        revision: 1;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            carrierDetect: OptionalAttribute<null | boolean, any>;
            fullDuplex: OptionalAttribute<null | boolean, any>;
            phyRate: OptionalAttribute<null | EthernetNetworkDiagnostics.PhyRate, any>;
            timeSinceReset: OptionalAttribute<number | bigint, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    packetRxCount: Attribute<number | bigint, any>;
                    packetTxCount: Attribute<number | bigint, any>;
                };
            };
            flags: {
                packetCounts: true;
            };
        }, {
            component: {
                attributes: {
                    collisionCount: Attribute<number | bigint, any>;
                    overrunCount: Attribute<number | bigint, any>;
                    txErrCount: Attribute<number | bigint, any>;
                };
            };
            flags: {
                errorCounts: true;
            };
        }, {
            component: {
                commands: {
                    resetCounts: Command<void, void, any>;
                };
            };
            flags: {
                packetCounts: true;
            };
        }, {
            component: {
                commands: {
                    resetCounts: Command<void, void, any>;
                };
            };
            flags: {
                errorCounts: true;
            };
        }];
        features: {
            errorCounts: BitFlag;
            packetCounts: BitFlag;
        };
        id: 55;
        name: "EthernetNetworkDiagnostics";
        revision: 1;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            carrierDetect: OptionalAttribute<null | boolean, any>;
            fullDuplex: OptionalAttribute<null | boolean, any>;
            phyRate: OptionalAttribute<null | EthernetNetworkDiagnostics.PhyRate, any>;
            timeSinceReset: OptionalAttribute<number | bigint, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    packetRxCount: Attribute<number | bigint, any>;
                    packetTxCount: Attribute<number | bigint, any>;
                };
            };
            flags: {
                packetCounts: true;
            };
        }, {
            component: {
                attributes: {
                    collisionCount: Attribute<number | bigint, any>;
                    overrunCount: Attribute<number | bigint, any>;
                    txErrCount: Attribute<number | bigint, any>;
                };
            };
            flags: {
                errorCounts: true;
            };
        }, {
            component: {
                commands: {
                    resetCounts: Command<void, void, any>;
                };
            };
            flags: {
                packetCounts: true;
            };
        }, {
            component: {
                commands: {
                    resetCounts: Command<void, void, any>;
                };
            };
            flags: {
                errorCounts: true;
            };
        }];
        features: {
            errorCounts: BitFlag;
            packetCounts: BitFlag;
        };
        id: 55;
        name: "EthernetNetworkDiagnostics";
        revision: 1;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            carrierDetect: OptionalAttribute<null | boolean, any>;
            fullDuplex: OptionalAttribute<null | boolean, any>;
            phyRate: OptionalAttribute<null | EthernetNetworkDiagnostics.PhyRate, any>;
            timeSinceReset: OptionalAttribute<number | bigint, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    packetRxCount: Attribute<number | bigint, any>;
                    packetTxCount: Attribute<number | bigint, any>;
                };
            };
            flags: {
                packetCounts: true;
            };
        }, {
            component: {
                attributes: {
                    collisionCount: Attribute<number | bigint, any>;
                    overrunCount: Attribute<number | bigint, any>;
                    txErrCount: Attribute<number | bigint, any>;
                };
            };
            flags: {
                errorCounts: true;
            };
        }, {
            component: {
                commands: {
                    resetCounts: Command<void, void, any>;
                };
            };
            flags: {
                packetCounts: true;
            };
        }, {
            component: {
                commands: {
                    resetCounts: Command<void, void, any>;
                };
            };
            flags: {
                errorCounts: true;
            };
        }];
        features: {
            errorCounts: BitFlag;
            packetCounts: BitFlag;
        };
        id: 55;
        name: "EthernetNetworkDiagnostics";
        revision: 1;
    }>, SelectionT>;
}

Hierarchy (view full)

Identity<typeof EthernetNetworkDiagnostics.ClusterInstance>
- Cluster

Index

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: Merge<{
    carrierDetect: OptionalAttribute<null | boolean, any>;
    fullDuplex: OptionalAttribute<null | boolean, any>;
    phyRate: OptionalAttribute<null | EthernetNetworkDiagnostics.PhyRate, any>;
    timeSinceReset: OptionalAttribute<number | bigint, any>;
}, GlobalAttributes<{
    errorCounts: BitFlag;
    packetCounts: BitFlag;
}>>

Type declaration

ReadonlycarrierDetect: OptionalAttribute<null | boolean, any>
The CarrierDetect attribute shall indicate the value of the Carrier Detect control signal present on the ethernet network interface. A value of null shall indicate that the interface is not currently configured or operational.

See
MatterSpecification.v13.Core § 11.16.6.8
ReadonlyfullDuplex: OptionalAttribute<null | boolean, any>
The FullDuplex attribute shall indicate if the Node is currently utilizing the full-duplex operating mode. A value of null shall indicate that the interface is not currently configured or operational.

See
MatterSpecification.v13.Core § 11.16.6.2
ReadonlyphyRate: OptionalAttribute<null | EthernetNetworkDiagnostics.PhyRate, any>
The PHYRate attribute shall indicate the current nominal, usable speed at the top of the physical layer of the Node. A value of null shall indicate that the interface is not currently configured or operational.

See
MatterSpecification.v13.Core § 11.16.6.1
ReadonlytimeSinceReset: OptionalAttribute<number | bigint, any>
The TimeSinceReset attribute shall indicate the duration of time, in minutes, that it has been since the ethernet network interface has reset for any reason.

See
MatterSpecification.v13.Core § 11.16.6.9

base

base: undefined

commands

commands: {}

events

events: {}

extensions

extensions: readonly [{
    component: {
        attributes: {
            packetRxCount: Attribute<number | bigint, any>;
            packetTxCount: Attribute<number | bigint, any>;
        };
    };
    flags: {
        packetCounts: true;
    };
}, {
    component: {
        attributes: {
            collisionCount: Attribute<number | bigint, any>;
            overrunCount: Attribute<number | bigint, any>;
            txErrCount: Attribute<number | bigint, any>;
        };
    };
    flags: {
        errorCounts: true;
    };
}, {
    component: {
        commands: {
            resetCounts: Command<void, void, any>;
        };
    };
    flags: {
        packetCounts: true;
    };
}, {
    component: {
        commands: {
            resetCounts: Command<void, void, any>;
        };
    };
    flags: {
        errorCounts: true;
    };
}]

features

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

Type declaration

ReadonlyerrorCounts: BitFlag
ErrorCounts

Node makes available the counts for the number of errors that have occurred during the reception and transmission of packets on the ethernet interface.
ReadonlypacketCounts: BitFlag
PacketCounts

Node makes available the counts for the number of received and transmitted packets on the ethernet interface.

id

id: Branded<55, "ClusterId">

name

revision

supportedFeatures

supportedFeatures: {}

unknown

Methods

alter

alter<const AlterationsT>(alterations): WithAlterations<Of<{
    attributes: {
        carrierDetect: OptionalAttribute<null | boolean, any>;
        fullDuplex: OptionalAttribute<null | boolean, any>;
        phyRate: OptionalAttribute<null | EthernetNetworkDiagnostics.PhyRate, any>;
        timeSinceReset: OptionalAttribute<number | bigint, any>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                packetRxCount: Attribute<number | bigint, any>;
                packetTxCount: Attribute<number | bigint, any>;
            };
        };
        flags: {
            packetCounts: true;
        };
    }, {
        component: {
            attributes: {
                collisionCount: Attribute<number | bigint, any>;
                overrunCount: Attribute<number | bigint, any>;
                txErrCount: Attribute<number | bigint, any>;
            };
        };
        flags: {
            errorCounts: true;
        };
    }, {
        component: {
            commands: {
                resetCounts: Command<void, void, any>;
            };
        };
        flags: {
            packetCounts: true;
        };
    }, {
        component: {
            commands: {
                resetCounts: Command<void, void, any>;
            };
        };
        flags: {
            errorCounts: true;
        };
    }];
    features: {
        errorCounts: BitFlag;
        packetCounts: BitFlag;
    };
    id: 55;
    name: "EthernetNetworkDiagnostics";
    revision: 1;
}>, AlterationsT>
Modify elements using ElementModifier.alter.
Type Parameters
- const AlterationsT extends Alterations<Of<{
      attributes: {
          carrierDetect: OptionalAttribute<null | boolean, any>;
          fullDuplex: OptionalAttribute<null | boolean, any>;
          phyRate: OptionalAttribute<null | EthernetNetworkDiagnostics.PhyRate, any>;
          timeSinceReset: OptionalAttribute<number | bigint, any>;
      };
      extensions: readonly [{
          component: {
              attributes: {
                  packetRxCount: Attribute<number | bigint, any>;
                  packetTxCount: Attribute<number | bigint, any>;
              };
          };
          flags: {
              packetCounts: true;
          };
      }, {
          component: {
              attributes: {
                  collisionCount: Attribute<number | bigint, any>;
                  overrunCount: Attribute<number | bigint, any>;
                  txErrCount: Attribute<number | bigint, any>;
              };
          };
          flags: {
              errorCounts: true;
          };
      }, {
          component: {
              commands: {
                  resetCounts: Command<void, void, any>;
              };
          };
          flags: {
              packetCounts: true;
          };
      }, {
          component: {
              commands: {
                  resetCounts: Command<void, void, any>;
              };
          };
          flags: {
              errorCounts: true;
          };
      }];
      features: {
          errorCounts: BitFlag;
          packetCounts: BitFlag;
      };
      id: 55;
      name: "EthernetNetworkDiagnostics";
      revision: 1;
  }>>
Parameters
- alterations: AlterationsT
Returns WithAlterations<Of<{
    attributes: {
        carrierDetect: OptionalAttribute<null | boolean, any>;
        fullDuplex: OptionalAttribute<null | boolean, any>;
        phyRate: OptionalAttribute<null | EthernetNetworkDiagnostics.PhyRate, any>;
        timeSinceReset: OptionalAttribute<number | bigint, any>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                packetRxCount: Attribute<number | bigint, any>;
                packetTxCount: Attribute<number | bigint, any>;
            };
        };
        flags: {
            packetCounts: true;
        };
    }, {
        component: {
            attributes: {
                collisionCount: Attribute<number | bigint, any>;
                overrunCount: Attribute<number | bigint, any>;
                txErrCount: Attribute<number | bigint, any>;
            };
        };
        flags: {
            errorCounts: true;
        };
    }, {
        component: {
            commands: {
                resetCounts: Command<void, void, any>;
            };
        };
        flags: {
            packetCounts: true;
        };
    }, {
        component: {
            commands: {
                resetCounts: Command<void, void, any>;
            };
        };
        flags: {
            errorCounts: true;
        };
    }];
    features: {
        errorCounts: BitFlag;
        packetCounts: BitFlag;
    };
    id: 55;
    name: "EthernetNetworkDiagnostics";
    revision: 1;
}>, AlterationsT>
Inherited from Identity.alter
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:37

enable

enable<const FlagsT>(flags): WithFlags<Of<{
    attributes: {
        carrierDetect: OptionalAttribute<null | boolean, any>;
        fullDuplex: OptionalAttribute<null | boolean, any>;
        phyRate: OptionalAttribute<null | EthernetNetworkDiagnostics.PhyRate, any>;
        timeSinceReset: OptionalAttribute<number | bigint, any>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                packetRxCount: Attribute<number | bigint, any>;
                packetTxCount: Attribute<number | bigint, any>;
            };
        };
        flags: {
            packetCounts: true;
        };
    }, {
        component: {
            attributes: {
                collisionCount: Attribute<number | bigint, any>;
                overrunCount: Attribute<number | bigint, any>;
                txErrCount: Attribute<number | bigint, any>;
            };
        };
        flags: {
            errorCounts: true;
        };
    }, {
        component: {
            commands: {
                resetCounts: Command<void, void, any>;
            };
        };
        flags: {
            packetCounts: true;
        };
    }, {
        component: {
            commands: {
                resetCounts: Command<void, void, any>;
            };
        };
        flags: {
            errorCounts: true;
        };
    }];
    features: {
        errorCounts: BitFlag;
        packetCounts: BitFlag;
    };
    id: 55;
    name: "EthernetNetworkDiagnostics";
    revision: 1;
}>, FlagsT>
Modify elements using ElementModifier.enable.
Type Parameters
- const FlagsT extends ElementFlags<Of<{
      attributes: {
          carrierDetect: OptionalAttribute<null | boolean, any>;
          fullDuplex: OptionalAttribute<null | boolean, any>;
          phyRate: OptionalAttribute<null | EthernetNetworkDiagnostics.PhyRate, any>;
          timeSinceReset: OptionalAttribute<number | bigint, any>;
      };
      extensions: readonly [{
          component: {
              attributes: {
                  packetRxCount: Attribute<number | bigint, any>;
                  packetTxCount: Attribute<number | bigint, any>;
              };
          };
          flags: {
              packetCounts: true;
          };
      }, {
          component: {
              attributes: {
                  collisionCount: Attribute<number | bigint, any>;
                  overrunCount: Attribute<number | bigint, any>;
                  txErrCount: Attribute<number | bigint, any>;
              };
          };
          flags: {
              errorCounts: true;
          };
      }, {
          component: {
              commands: {
                  resetCounts: Command<void, void, any>;
              };
          };
          flags: {
              packetCounts: true;
          };
      }, {
          component: {
              commands: {
                  resetCounts: Command<void, void, any>;
              };
          };
          flags: {
              errorCounts: true;
          };
      }];
      features: {
          errorCounts: BitFlag;
          packetCounts: BitFlag;
      };
      id: 55;
      name: "EthernetNetworkDiagnostics";
      revision: 1;
  }>>
Parameters
- flags: FlagsT
Returns WithFlags<Of<{
    attributes: {
        carrierDetect: OptionalAttribute<null | boolean, any>;
        fullDuplex: OptionalAttribute<null | boolean, any>;
        phyRate: OptionalAttribute<null | EthernetNetworkDiagnostics.PhyRate, any>;
        timeSinceReset: OptionalAttribute<number | bigint, any>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                packetRxCount: Attribute<number | bigint, any>;
                packetTxCount: Attribute<number | bigint, any>;
            };
        };
        flags: {
            packetCounts: true;
        };
    }, {
        component: {
            attributes: {
                collisionCount: Attribute<number | bigint, any>;
                overrunCount: Attribute<number | bigint, any>;
                txErrCount: Attribute<number | bigint, any>;
            };
        };
        flags: {
            errorCounts: true;
        };
    }, {
        component: {
            commands: {
                resetCounts: Command<void, void, any>;
            };
        };
        flags: {
            packetCounts: true;
        };
    }, {
        component: {
            commands: {
                resetCounts: Command<void, void, any>;
            };
        };
        flags: {
            errorCounts: true;
        };
    }];
    features: {
        errorCounts: BitFlag;
        packetCounts: BitFlag;
    };
    id: 55;
    name: "EthernetNetworkDiagnostics";
    revision: 1;
}>, FlagsT>
Inherited from Identity.enable
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:45

set

set<const ValuesT>(values): WithValues<Of<{
    attributes: {
        carrierDetect: OptionalAttribute<null | boolean, any>;
        fullDuplex: OptionalAttribute<null | boolean, any>;
        phyRate: OptionalAttribute<null | EthernetNetworkDiagnostics.PhyRate, any>;
        timeSinceReset: OptionalAttribute<number | bigint, any>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                packetRxCount: Attribute<number | bigint, any>;
                packetTxCount: Attribute<number | bigint, any>;
            };
        };
        flags: {
            packetCounts: true;
        };
    }, {
        component: {
            attributes: {
                collisionCount: Attribute<number | bigint, any>;
                overrunCount: Attribute<number | bigint, any>;
                txErrCount: Attribute<number | bigint, any>;
            };
        };
        flags: {
            errorCounts: true;
        };
    }, {
        component: {
            commands: {
                resetCounts: Command<void, void, any>;
            };
        };
        flags: {
            packetCounts: true;
        };
    }, {
        component: {
            commands: {
                resetCounts: Command<void, void, any>;
            };
        };
        flags: {
            errorCounts: true;
        };
    }];
    features: {
        errorCounts: BitFlag;
        packetCounts: BitFlag;
    };
    id: 55;
    name: "EthernetNetworkDiagnostics";
    revision: 1;
}>, ValuesT>
Modify elements using ElementModifier.set.
Type Parameters
- const ValuesT extends {
      carrierDetect?: null | boolean;
      fullDuplex?: null | boolean;
      phyRate?: null | number;
      timeSinceReset?: number | bigint;
  }
Parameters
- values: ValuesT
Returns WithValues<Of<{
    attributes: {
        carrierDetect: OptionalAttribute<null | boolean, any>;
        fullDuplex: OptionalAttribute<null | boolean, any>;
        phyRate: OptionalAttribute<null | EthernetNetworkDiagnostics.PhyRate, any>;
        timeSinceReset: OptionalAttribute<number | bigint, any>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                packetRxCount: Attribute<number | bigint, any>;
                packetTxCount: Attribute<number | bigint, any>;
            };
        };
        flags: {
            packetCounts: true;
        };
    }, {
        component: {
            attributes: {
                collisionCount: Attribute<number | bigint, any>;
                overrunCount: Attribute<number | bigint, any>;
                txErrCount: Attribute<number | bigint, any>;
            };
        };
        flags: {
            errorCounts: true;
        };
    }, {
        component: {
            commands: {
                resetCounts: Command<void, void, any>;
            };
        };
        flags: {
            packetCounts: true;
        };
    }, {
        component: {
            commands: {
                resetCounts: Command<void, void, any>;
            };
        };
        flags: {
            errorCounts: true;
        };
    }];
    features: {
        errorCounts: BitFlag;
        packetCounts: BitFlag;
    };
    id: 55;
    name: "EthernetNetworkDiagnostics";
    revision: 1;
}>, ValuesT>
Inherited from Identity.set
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:41

with

with<const SelectionT>(...selection): Of<Of<{
    attributes: {
        carrierDetect: OptionalAttribute<null | boolean, any>;
        fullDuplex: OptionalAttribute<null | boolean, any>;
        phyRate: OptionalAttribute<null | EthernetNetworkDiagnostics.PhyRate, any>;
        timeSinceReset: OptionalAttribute<number | bigint, any>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                packetRxCount: Attribute<number | bigint, any>;
                packetTxCount: Attribute<number | bigint, any>;
            };
        };
        flags: {
            packetCounts: true;
        };
    }, {
        component: {
            attributes: {
                collisionCount: Attribute<number | bigint, any>;
                overrunCount: Attribute<number | bigint, any>;
                txErrCount: Attribute<number | bigint, any>;
            };
        };
        flags: {
            errorCounts: true;
        };
    }, {
        component: {
            commands: {
                resetCounts: Command<void, void, any>;
            };
        };
        flags: {
            packetCounts: true;
        };
    }, {
        component: {
            commands: {
                resetCounts: Command<void, void, any>;
            };
        };
        flags: {
            errorCounts: true;
        };
    }];
    features: {
        errorCounts: BitFlag;
        packetCounts: BitFlag;
    };
    id: 55;
    name: "EthernetNetworkDiagnostics";
    revision: 1;
}>, SelectionT>
Select features using ClusterComposer.compose.
Type Parameters
- const SelectionT extends FeatureSelection<Of<{
      attributes: {
          carrierDetect: OptionalAttribute<null | boolean, any>;
          fullDuplex: OptionalAttribute<null | boolean, any>;
          phyRate: OptionalAttribute<null | EthernetNetworkDiagnostics.PhyRate, any>;
          timeSinceReset: OptionalAttribute<number | bigint, any>;
      };
      extensions: readonly [{
          component: {
              attributes: {
                  packetRxCount: Attribute<number | bigint, any>;
                  packetTxCount: Attribute<number | bigint, any>;
              };
          };
          flags: {
              packetCounts: true;
          };
      }, {
          component: {
              attributes: {
                  collisionCount: Attribute<number | bigint, any>;
                  overrunCount: Attribute<number | bigint, any>;
                  txErrCount: Attribute<number | bigint, any>;
              };
          };
          flags: {
              errorCounts: true;
          };
      }, {
          component: {
              commands: {
                  resetCounts: Command<void, void, any>;
              };
          };
          flags: {
              packetCounts: true;
          };
      }, {
          component: {
              commands: {
                  resetCounts: Command<void, void, any>;
              };
          };
          flags: {
              errorCounts: true;
          };
      }];
      features: {
          errorCounts: BitFlag;
          packetCounts: BitFlag;
      };
      id: 55;
      name: "EthernetNetworkDiagnostics";
      revision: 1;
  }>>
Parameters
- Rest...selection: SelectionT
Returns Of<Of<{
    attributes: {
        carrierDetect: OptionalAttribute<null | boolean, any>;
        fullDuplex: OptionalAttribute<null | boolean, any>;
        phyRate: OptionalAttribute<null | EthernetNetworkDiagnostics.PhyRate, any>;
        timeSinceReset: OptionalAttribute<number | bigint, any>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                packetRxCount: Attribute<number | bigint, any>;
                packetTxCount: Attribute<number | bigint, any>;
            };
        };
        flags: {
            packetCounts: true;
        };
    }, {
        component: {
            attributes: {
                collisionCount: Attribute<number | bigint, any>;
                overrunCount: Attribute<number | bigint, any>;
                txErrCount: Attribute<number | bigint, any>;
            };
        };
        flags: {
            errorCounts: true;
        };
    }, {
        component: {
            commands: {
                resetCounts: Command<void, void, any>;
            };
        };
        flags: {
            packetCounts: true;
        };
    }, {
        component: {
            commands: {
                resetCounts: Command<void, void, any>;
            };
        };
        flags: {
            errorCounts: true;
        };
    }];
    features: {
        errorCounts: BitFlag;
        packetCounts: BitFlag;
    };
    id: 55;
    name: "EthernetNetworkDiagnostics";
    revision: 1;
}>, SelectionT>
Inherited from Identity.with
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:33

Interface Cluster

See

Hierarchy (view full)

Index

Properties

Methods

Properties

attributes

Type declaration

ReadonlycarrierDetect: OptionalAttribute<null | boolean, any>

See

ReadonlyfullDuplex: OptionalAttribute<null | boolean, any>

See

ReadonlyphyRate: OptionalAttribute<null | EthernetNetworkDiagnostics.PhyRate, any>

See

ReadonlytimeSinceReset: OptionalAttribute<number | bigint, any>

See

base

commands

events

extensions

features

Type declaration

ReadonlyerrorCounts: BitFlag

ReadonlypacketCounts: BitFlag

id

name

revision

supportedFeatures

unknown

Methods

alter

Type Parameters

Parameters

enable

Type Parameters

Parameters

set

Type Parameters

Parameters

with

Type Parameters

Parameters

Settings

On This Page

`Readonly`carrierDetect: OptionalAttribute<null | boolean, any>

`Readonly`fullDuplex: OptionalAttribute<null | boolean, any>

`Readonly`phyRate: OptionalAttribute<null | EthernetNetworkDiagnostics.PhyRate, any>

`Readonly`timeSinceReset: OptionalAttribute<number | bigint, any>

`Readonly`errorCounts: BitFlag

`Readonly`packetCounts: BitFlag