Variable CompleteInstanceConst

Type declaration

• Readonlyattributes: {
      acceptedCommandList: Attribute<.[], never>;
      approximateEvEfficiency: OptionalWritableAttribute<number | null, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              chargingPreferences: boolean;
          }];
      };
      attributeList: Attribute<.[], never>;
      batteryCapacity: Attribute<number | bigint | null, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              soCReporting: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      chargingEnabledUntil: Attribute<number | null, any>;
      circuitCapacity: Attribute<number | bigint, any>;
      clusterRevision: Attribute<number, never>;
      dischargingEnabledUntil: Attribute<number | null, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              v2X: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      faultState: Attribute<EnergyEvse.FaultState, any>;
      featureMap: Attribute<TypeFromPartialBitSchema, never>;
      generatedCommandList: Attribute<.[], never>;
      maximumChargeCurrent: Attribute<number | bigint, any>;
      maximumDischargeCurrent: Attribute<number | bigint, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              v2X: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      minimumChargeCurrent: Attribute<number | bigint, any>;
      nextChargeRequiredEnergy: Attribute<number | bigint | null, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              chargingPreferences: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      nextChargeStartTime: Attribute<number | null, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              chargingPreferences: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      nextChargeTargetSoC: Attribute<number | null, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              chargingPreferences: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      nextChargeTargetTime: Attribute<number | null, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              chargingPreferences: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      randomizationDelayWindow: OptionalWritableAttribute<number, any>;
      sessionDuration: Attribute<number | null, any>;
      sessionEnergyCharged: Attribute<number | bigint | null, any>;
      sessionEnergyDischarged: Attribute<number | bigint | null, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              v2X: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      sessionId: Attribute<number | null, any>;
      state: Attribute<EnergyEvse.State | null, any>;
      stateOfCharge: Attribute<number | null, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              soCReporting: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      supplyState: Attribute<EnergyEvse.SupplyState, any>;
      userMaximumChargeCurrent: OptionalWritableAttribute<number | bigint, any>;
      vehicleId: Attribute<string | null, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              plugAndCharge: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
  }

  • ReadonlyacceptedCommandList: Attribute<.[], never>

  • ReadonlyapproximateEvEfficiency: OptionalWritableAttribute<number | null, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            chargingPreferences: boolean;
        }];
    }

  • ReadonlyattributeList: Attribute<.[], never>

  • ReadonlybatteryCapacity: Attribute<number | bigint | null, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            soCReporting: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlychargingEnabledUntil: Attribute<number | null, any>

  • ReadonlycircuitCapacity: Attribute<number | bigint, any>

  • ReadonlyclusterRevision: Attribute<number, never>

  • ReadonlydischargingEnabledUntil: Attribute<number | null, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            v2X: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlyfaultState: Attribute<EnergyEvse.FaultState, any>

  • ReadonlyfeatureMap: Attribute<TypeFromPartialBitSchema, never>

  • ReadonlygeneratedCommandList: Attribute<.[], never>

  • ReadonlymaximumChargeCurrent: Attribute<number | bigint, any>

  • ReadonlymaximumDischargeCurrent: Attribute<number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            v2X: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlyminimumChargeCurrent: Attribute<number | bigint, any>

  • ReadonlynextChargeRequiredEnergy: Attribute<number | bigint | null, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            chargingPreferences: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlynextChargeStartTime: Attribute<number | null, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            chargingPreferences: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlynextChargeTargetSoC: Attribute<number | null, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            chargingPreferences: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlynextChargeTargetTime: Attribute<number | null, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            chargingPreferences: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlyrandomizationDelayWindow: OptionalWritableAttribute<number, any>

  • ReadonlysessionDuration: Attribute<number | null, any>

  • ReadonlysessionEnergyCharged: Attribute<number | bigint | null, any>

  • ReadonlysessionEnergyDischarged: Attribute<number | bigint | null, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            v2X: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlysessionId: Attribute<number | null, any>

  • Readonlystate: Attribute<EnergyEvse.State | null, any>

  • ReadonlystateOfCharge: Attribute<number | null, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            soCReporting: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlysupplyState: Attribute<EnergyEvse.SupplyState, any>

  • ReadonlyuserMaximumChargeCurrent: OptionalWritableAttribute<number | bigint, any>

  • ReadonlyvehicleId: Attribute<string | null, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            plugAndCharge: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

• Readonlycommands: {
      clearTargets: Command<void, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              chargingPreferences: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      disable: Command<void, void, any>;
      enableCharging: Command<TypeFromFields, void, any>;
      enableDischarging: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              v2X: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      getTargets: Command<void, TypeFromFields, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              chargingPreferences: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      setTargets: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              chargingPreferences: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      startDiagnostics: OptionalCommand<void, void, any>;
  }

  • ReadonlyclearTargets: Command<void, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            chargingPreferences: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • Readonlydisable: Command<void, void, any>

    Allows a client to disable the EVSE from charging and discharging.

    See

    MatterSpecification.v13.Cluster § 9.3.9.1

  • ReadonlyenableCharging: Command<TypeFromFields, void, any>

    Allows a client to enable the EVSE to charge an EV.

    See

    MatterSpecification.v13.Cluster § 9.3.9.2

  • ReadonlyenableDischarging: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            v2X: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlygetTargets: Command<void, TypeFromFields, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            chargingPreferences: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlysetTargets: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            chargingPreferences: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlystartDiagnostics: OptionalCommand<void, void, any>

    Allows a client to put the EVSE into a self-diagnostics mode.

    See

    MatterSpecification.v13.Cluster § 9.3.9.4

• Readonlyevents: {
      energyTransferStarted: Event<TypeFromFields, any>;
      energyTransferStopped: Event<TypeFromFields, any>;
      evConnected: Event<TypeFromFields, any>;
      evNotDetected: Event<TypeFromFields, any>;
      fault: Event<TypeFromFields, any>;
      rfid: OptionalEvent<TypeFromFields, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              rfid: boolean;
          }];
      };
  }

  • ReadonlyenergyTransferStarted: Event<TypeFromFields, any>

    This event shall be generated when the EV starts charging or discharging.

    See

    MatterSpecification.v13.Cluster § 9.3.10.3

  • ReadonlyenergyTransferStopped: Event<TypeFromFields, any>

    This event shall be generated when the EV stops charging or discharging.

    See

    MatterSpecification.v13.Cluster § 9.3.10.4

  • ReadonlyevConnected: Event<TypeFromFields, any>

    This event shall be generated when the EV is plugged in.

    See

    MatterSpecification.v13.Cluster § 9.3.10.1

  • ReadonlyevNotDetected: Event<TypeFromFields, any>

    This event shall be generated when the EV is unplugged or not detected (having been previously plugged in). When the vehicle is unplugged then the session is ended.

    See

    MatterSpecification.v13.Cluster § 9.3.10.2

  • Readonlyfault: Event<TypeFromFields, any>

    If the EVSE detects a fault it shall generate a Fault Event. The SupplyState attribute shall be set to DisabledError and the type of fault detected by the EVSE shall be stored in the FaultState attribute.

    This event shall be generated when the FaultState changes from any error state. i.e. if it changes from NoError to any other state and if the error then clears, this would generate 2 events.

    It is assumed that the fault will be cleared locally on the EVSE device. When all faults have been cleared, the EVSE device shall set the FaultState attribute to NoError and the SupplyState attribute shall be set back to its previous state.

    See

    MatterSpecification.v13.Cluster § 9.3.10.5

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

• Readonlyfeatures: {
      chargingPreferences: BitFlag;
      plugAndCharge: BitFlag;
      rfid: BitFlag;
      soCReporting: BitFlag;
      v2X: BitFlag;
  }

  • ReadonlychargingPreferences: BitFlag

    ChargingPreferences

    Since some EVSEs cannot obtain the SoC from the vehicle, some EV charging solutions allow the consumer to specify a daily charging target (for adding energy to the EV’s battery). This feature allows the consumer to specify how many miles or km of additional range they need for their typical daily commute. This range requirement can be converted into a daily energy demand with a target charging completion time.

    The EVSE itself may use this information (or may allow a controller such as an EMS) to compute an

    optimized charging schedule.

    An EVSE device may implement the Device Energy Management cluster PFR (Power Forecast Reporting) and FA (Forecast Adjustment) features. This can help a controller (such as an EMS) to optimize the EVSE against other ESAs. For example, a solar PV ESA may share its Forecast and allow the EVSE to know the best time to charge so that any excess solar generation is used to charge the EV.

    EVSE devices that support the Device Energy Management cluster’s FA feature can have their charging profiles set by a controller device such as an EMS. For example, if the EVSE advertises a simple power forecast which allows the EMS to adjust over a wide range of power and time durations, then the EVSE may allow the EMS to propose a revised optimized forecast (which is the charging profile).

    See the Device Energy Management Cluster for more details.

    See

    MatterSpecification.v13.Cluster § 9.3.4.1

  • ReadonlyplugAndCharge: BitFlag

    PlugAndCharge

    If the EVSE supports PLC, it may be able to support the Plug and Charge feature. e.g. this may allow the vehicle ID to be obtained which may allow an energy management system to track energy usage per vehicle (e.g. to give the owner an indicative cost of charging, or for work place charging).

    If the EVSE supports the Plug and Charge feature, it will only work if a compatible EV is connected.

    See

    MatterSpecification.v13.Cluster § 9.3.4.3

  • Readonlyrfid: BitFlag

    Rfid

    If the EVSE is fitted with an RFID reader, it may be possible to obtain the User or Vehicle ID from an RFID card. This may be used to record a charging session against a specific charging account, and may optionally be used to authorize a charging session.

    An RFID event can be generated when a user taps an RFID card onto the RFID reader. The event must be subscribed to by the EVSE Management cluster client. This client may use this to enable the EV to charge or discharge. The lookup and authorization of RIFD UID is outside the scope of this cluster.

    See

    MatterSpecification.v13.Cluster § 9.3.4.4

  • ReadonlysoCReporting: BitFlag

    SoCReporting

    Vehicles and EVSEs which support ISO 15118 may allow the vehicle to report its battery size and state of charge. If the EVSE supports PLC it may have a vehicle connected which optionally supports reporting of its battery size and current State of Charge (SoC).

    If the EVSE supports reporting of State of Charge this feature will only work if a compatible EV is connected.

    Note some EVSEs may use other undefined mechanisms to obtain vehicle State of Charge outside the scope of this cluster.

    See

    MatterSpecification.v13.Cluster § 9.3.4.2

  • Readonlyv2X: BitFlag

    V2X

    If the EVSE can support bi-directional charging, it may be possible to request that the vehicle can discharge to the home or grid.

    See

    MatterSpecification.v13.Cluster § 9.3.4.5

• Readonlyid: @matter/general

• Readonlyname: "EnergyEvse"

• Readonlyrevision: 2