Variable CompleteInstanceConst

Type declaration

• Readonlyattributes: {
      acceptedCommandList: Attribute<.[], never>;
      activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              rechargeable: boolean;
          }];
      };
      activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              battery: boolean;
          }];
      };
      activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              wired: boolean;
          }];
      };
      attributeList: Attribute<.[], never>;
      batAnsiDesignation: OptionalFixedAttribute<string, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              replaceable: boolean;
          }];
      };
      batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              replaceable: boolean;
          }];
      };
      batCapacity: OptionalFixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              replaceable: boolean;
          }, {
              rechargeable: boolean;
          }];
      };
      batChargeLevel: Attribute<PowerSource.BatChargeLevel, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              battery: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      batChargeState: Attribute<PowerSource.BatChargeState, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              rechargeable: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      batChargingCurrent: OptionalAttribute<number | null, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              rechargeable: boolean;
          }];
      };
      batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              replaceable: boolean;
          }];
      };
      batFunctionalWhileCharging: Attribute<boolean, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              rechargeable: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      batIecDesignation: OptionalFixedAttribute<string, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              replaceable: boolean;
          }];
      };
      batPercentRemaining: OptionalAttribute<number | null, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              battery: boolean;
          }];
      };
      batPresent: OptionalAttribute<boolean, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              battery: boolean;
          }];
      };
      batQuantity: FixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              replaceable: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              battery: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      batReplacementDescription: FixedAttribute<string, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              replaceable: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      batReplacementNeeded: Attribute<boolean, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              battery: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      batTimeRemaining: OptionalAttribute<number | null, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              battery: boolean;
          }];
      };
      batTimeToFullCharge: OptionalAttribute<number | null, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              rechargeable: boolean;
          }];
      };
      batVoltage: OptionalAttribute<number | null, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              battery: boolean;
          }];
      };
      clusterRevision: Attribute<number, never>;
      description: FixedAttribute<string, any>;
      endpointList: Attribute<EndpointNumber[], any>;
      featureMap: Attribute<TypeFromPartialBitSchema, never>;
      generatedCommandList: Attribute<.[], never>;
      order: Attribute<number, any>;
      status: Attribute<PowerSource.PowerSourceStatus, any>;
      wiredAssessedCurrent: OptionalAttribute<number | null, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              wired: boolean;
          }];
      };
      wiredAssessedInputFrequency: OptionalAttribute<number | null, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              wired: boolean;
          }];
      };
      wiredAssessedInputVoltage: OptionalAttribute<number | null, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              wired: boolean;
          }];
      };
      wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              wired: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      wiredMaximumCurrent: OptionalFixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              wired: boolean;
          }];
      };
      wiredNominalVoltage: OptionalFixedAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              wired: boolean;
          }];
      };
      wiredPresent: OptionalAttribute<boolean, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              wired: boolean;
          }];
      };
  }

  • ReadonlyacceptedCommandList: Attribute<.[], never>

  • ReadonlyactiveBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            rechargeable: boolean;
        }];
    }

  • ReadonlyactiveBatFaults: OptionalAttribute<PowerSource.BatFault[], any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            battery: boolean;
        }];
    }

  • ReadonlyactiveWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            wired: boolean;
        }];
    }

  • ReadonlyattributeList: Attribute<.[], never>

  • ReadonlybatAnsiDesignation: OptionalFixedAttribute<string, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            replaceable: boolean;
        }];
    }

  • ReadonlybatApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            replaceable: boolean;
        }];
    }

  • ReadonlybatCapacity: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            replaceable: boolean;
        }, {
            rechargeable: boolean;
        }];
    }

  • ReadonlybatChargeLevel: Attribute<PowerSource.BatChargeLevel, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            battery: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlybatChargeState: Attribute<PowerSource.BatChargeState, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            rechargeable: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

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

  • ReadonlybatCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            replaceable: boolean;
        }];
    }

  • ReadonlybatFunctionalWhileCharging: Attribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            rechargeable: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlybatIecDesignation: OptionalFixedAttribute<string, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            replaceable: boolean;
        }];
    }

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

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

  • ReadonlybatQuantity: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            replaceable: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlybatReplaceability: FixedAttribute<PowerSource.BatReplaceability, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            battery: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlybatReplacementDescription: FixedAttribute<string, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            replaceable: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlybatReplacementNeeded: Attribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            battery: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

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

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

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

  • ReadonlyclusterRevision: Attribute<number, never>

  • Readonlydescription: FixedAttribute<string, any>

  • ReadonlyendpointList: Attribute<EndpointNumber[], any>

  • ReadonlyfeatureMap: Attribute<TypeFromPartialBitSchema, never>

  • ReadonlygeneratedCommandList: Attribute<.[], never>

  • Readonlyorder: Attribute<number, any>

  • Readonlystatus: Attribute<PowerSource.PowerSourceStatus, any>

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

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

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

  • ReadonlywiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            wired: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlywiredMaximumCurrent: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            wired: boolean;
        }];
    }

  • ReadonlywiredNominalVoltage: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            wired: boolean;
        }];
    }

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

• Readonlyevents: {
      batChargeFaultChange: OptionalEvent<TypeFromFields, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              rechargeable: boolean;
          }];
      };
      batFaultChange: OptionalEvent<TypeFromFields, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              battery: boolean;
          }];
      };
      wiredFaultChange: OptionalEvent<TypeFromFields, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              wired: boolean;
          }];
      };
  }

  • ReadonlybatChargeFaultChange: OptionalEvent<TypeFromFields, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            rechargeable: boolean;
        }];
    }

  • ReadonlybatFaultChange: OptionalEvent<TypeFromFields, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            battery: boolean;
        }];
    }

  • ReadonlywiredFaultChange: OptionalEvent<TypeFromFields, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            wired: boolean;
        }];
    }

• Readonlyfeatures: {
      battery: BitFlag;
      rechargeable: BitFlag;
      replaceable: BitFlag;
      wired: BitFlag;
  }

  • Readonlybattery: BitFlag

    Battery

    A battery power source

  • Readonlyrechargeable: BitFlag

    Rechargeable

    A rechargeable battery power source

  • Readonlyreplaceable: BitFlag

    Replaceable

    A replaceable battery power source

  • Readonlywired: BitFlag

    Wired

    A wired power source

• Readonlyid: @matter/general

• Readonlyname: "PowerSource"

• Readonlyrevision: 2