Struct Client 

pub struct Client<E: ProtocolError> { /* private fields */ }

The OCPP client engine, generic over one version’s protocol error type. OCPP1_6Client and OCPP2_0_1Client are just Client<OCPP1_6Error> / Client<OCPP2_0_1Error> - the dispatch/timeout/error machinery below is written once and shared by every version.

Implementations

impl<E: ProtocolError> Client<E>

pub fn from_transport( sink: Box<dyn TransportSink>, stream: Box<dyn TransportStream>, timeout: Duration, executor: Box<dyn Executor>, timer: Box<dyn Timer>, ) -> Self

Build a client over any transport - the WebSocket adapter used by connect_1_6 is just one implementation of TransportSink/TransportStream; tests and non-WebSocket transports (an embedded framed link, an in-memory fake for unit tests) construct a client the same way. executor/timer are likewise pluggable: the tokio-runtime feature provides TokioExecutor/TokioTimer; embedded users supply their own (e.g. backed by embassy-executor/embassy-time).

pub fn from_transport_with_reconnect( sink: Box<dyn TransportSink>, stream: Box<dyn TransportStream>, timeout: Duration, executor: Box<dyn Executor>, timer: Box<dyn Timer>, reconnector: Option<Box<dyn Reconnector>>, reconnect_policy: ReconnectPolicy, ) -> Self

Same as Client::from_transport, but with automatic reconnect: when the transport closes (TransportStream::recv returns Ok(None)/Err(_)), the background read loop calls reconnector.connect() (backing off per reconnect_policy between failed attempts) instead of exiting, and swaps in the new transport once one succeeds. reconnector: None reproduces from_transport’s behavior - the read loop exits on disconnect and the client goes quiet. connect_1_6/connect_2_0_1/connect_2_1 use this constructor with a WebSocket-backed Reconnector.

pub async fn call<A: Action>( &self, request: A::Request, ) -> Result<A::Response, ClientError<E>>

Send a CALL for A and wait for the matching CALLRESULT/CALLERROR.

pub async fn on<A, F, FF>(&self, callback: F)

where A: Action, F: FnMut(A::Request, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<A::Response, E>> + Send,

Register a handler for CALLs the other side sends for action A. Replaces any previously registered handler for the same action.

pub async fn send_notification<A: SendAction>( &self, payload: A::Payload, ) -> Result<(), ClientError<E>>

Send a SEND (OCPP-J 2.1 only) fire-and-forget message: writes the frame and returns as soon as the transport accepts it - no waiter, no timeout, since the spec forbids the receiver from ever replying to a SEND.

pub async fn on_notification<A, F, FF>(&self, callback: F)

where A: SendAction, F: FnMut(A::Payload, Self) -> FF + Send + Sync + 'static, FF: Future<Output = ()> + Send,

Register a handler for SEND (OCPP-J 2.1 only) messages of action A. Unlike Client::on, callback returns nothing - the spec forbids replying to a SEND, so there’s no response to send back. Replaces any previously registered handler for the same action.

pub async fn send_ping(&self) -> Result<(), ClientError<E>>

pub async fn on_ping<F: FnMut(Self) -> FF + Send + Sync + 'static, FF: Future<Output = ()> + Send>( &self, callback: F, )

pub async fn on_reconnect<F: FnMut(Self) -> FF + Send + Sync + 'static, FF: Future<Output = ()> + Send>( &self, callback: F, )

Register a callback that fires every time the background read loop redials successfully after a disconnect (see Client::from_transport_with_reconnect). Never fires for the initial connection, only for later reconnects - the initial Client is already handed back post-connect, so callers run their own post-connect setup (e.g. BootNotification) right after connect_1_6/from_transport_with_reconnect returns. This is the hook for redoing that setup (or resyncing any other session state) after a dropped-and-restored connection; this crate does not re-run BootNotification or replay any state on its own.

pub async fn disconnect(&self) -> Result<(), ClientError<E>>

impl Client<OCPP1_6Error>

pub async fn send_authorize( &self, request: AuthorizeRequest, ) -> Result<AuthorizeResponse, ClientError<OCPP1_6Error>>

pub async fn on_authorize<F, FF>(&self, callback: F)

where F: FnMut(AuthorizeRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<AuthorizeResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_boot_notification( &self, request: BootNotificationRequest, ) -> Result<BootNotificationResponse, ClientError<OCPP1_6Error>>

pub async fn on_boot_notification<F, FF>(&self, callback: F)

where F: FnMut(BootNotificationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<BootNotificationResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_cancel_reservation( &self, request: CancelReservationRequest, ) -> Result<CancelReservationResponse, ClientError<OCPP1_6Error>>

pub async fn on_cancel_reservation<F, FF>(&self, callback: F)

where F: FnMut(CancelReservationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<CancelReservationResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_change_availability( &self, request: ChangeAvailabilityRequest, ) -> Result<ChangeAvailabilityResponse, ClientError<OCPP1_6Error>>

pub async fn on_change_availability<F, FF>(&self, callback: F)

where F: FnMut(ChangeAvailabilityRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ChangeAvailabilityResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_change_configuration( &self, request: ChangeConfigurationRequest, ) -> Result<ChangeConfigurationResponse, ClientError<OCPP1_6Error>>

pub async fn on_change_configuration<F, FF>(&self, callback: F)

where F: FnMut(ChangeConfigurationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ChangeConfigurationResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_clear_cache( &self, request: ClearCacheRequest, ) -> Result<ClearCacheResponse, ClientError<OCPP1_6Error>>

pub async fn on_clear_cache<F, FF>(&self, callback: F)

where F: FnMut(ClearCacheRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ClearCacheResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_clear_charging_profile( &self, request: ClearChargingProfileRequest, ) -> Result<ClearChargingProfileResponse, ClientError<OCPP1_6Error>>

pub async fn on_clear_charging_profile<F, FF>(&self, callback: F)

where F: FnMut(ClearChargingProfileRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ClearChargingProfileResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_data_transfer( &self, request: DataTransferRequest, ) -> Result<DataTransferResponse, ClientError<OCPP1_6Error>>

pub async fn on_data_transfer<F, FF>(&self, callback: F)

where F: FnMut(DataTransferRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<DataTransferResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_diagnostics_status_notification( &self, request: DiagnosticsStatusNotificationRequest, ) -> Result<DiagnosticsStatusNotificationResponse, ClientError<OCPP1_6Error>>

pub async fn on_diagnostics_status_notification<F, FF>(&self, callback: F)

where F: FnMut(DiagnosticsStatusNotificationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<DiagnosticsStatusNotificationResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_firmware_status_notification( &self, request: FirmwareStatusNotificationRequest, ) -> Result<FirmwareStatusNotificationResponse, ClientError<OCPP1_6Error>>

pub async fn on_firmware_status_notification<F, FF>(&self, callback: F)

where F: FnMut(FirmwareStatusNotificationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<FirmwareStatusNotificationResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_get_composite_schedule( &self, request: GetCompositeScheduleRequest, ) -> Result<GetCompositeScheduleResponse, ClientError<OCPP1_6Error>>

pub async fn on_get_composite_schedule<F, FF>(&self, callback: F)

where F: FnMut(GetCompositeScheduleRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetCompositeScheduleResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_get_configuration( &self, request: GetConfigurationRequest, ) -> Result<GetConfigurationResponse, ClientError<OCPP1_6Error>>

pub async fn on_get_configuration<F, FF>(&self, callback: F)

where F: FnMut(GetConfigurationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetConfigurationResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_get_diagnostics( &self, request: GetDiagnosticsRequest, ) -> Result<GetDiagnosticsResponse, ClientError<OCPP1_6Error>>

pub async fn on_get_diagnostics<F, FF>(&self, callback: F)

where F: FnMut(GetDiagnosticsRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetDiagnosticsResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_get_local_list_version( &self, request: GetLocalListVersionRequest, ) -> Result<GetLocalListVersionResponse, ClientError<OCPP1_6Error>>

pub async fn on_get_local_list_version<F, FF>(&self, callback: F)

where F: FnMut(GetLocalListVersionRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetLocalListVersionResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_heartbeat( &self, request: HeartbeatRequest, ) -> Result<HeartbeatResponse, ClientError<OCPP1_6Error>>

pub async fn on_heartbeat<F, FF>(&self, callback: F)

where F: FnMut(HeartbeatRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<HeartbeatResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_meter_values( &self, request: MeterValuesRequest, ) -> Result<MeterValuesResponse, ClientError<OCPP1_6Error>>

pub async fn on_meter_values<F, FF>(&self, callback: F)

where F: FnMut(MeterValuesRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<MeterValuesResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_remote_start_transaction( &self, request: RemoteStartTransactionRequest, ) -> Result<RemoteStartTransactionResponse, ClientError<OCPP1_6Error>>

pub async fn on_remote_start_transaction<F, FF>(&self, callback: F)

where F: FnMut(RemoteStartTransactionRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<RemoteStartTransactionResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_remote_stop_transaction( &self, request: RemoteStopTransactionRequest, ) -> Result<RemoteStopTransactionResponse, ClientError<OCPP1_6Error>>

pub async fn on_remote_stop_transaction<F, FF>(&self, callback: F)

where F: FnMut(RemoteStopTransactionRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<RemoteStopTransactionResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_reserve_now( &self, request: ReserveNowRequest, ) -> Result<ReserveNowResponse, ClientError<OCPP1_6Error>>

pub async fn on_reserve_now<F, FF>(&self, callback: F)

where F: FnMut(ReserveNowRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ReserveNowResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_reset( &self, request: ResetRequest, ) -> Result<ResetResponse, ClientError<OCPP1_6Error>>

pub async fn on_reset<F, FF>(&self, callback: F)

where F: FnMut(ResetRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ResetResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_send_local_list( &self, request: SendLocalListRequest, ) -> Result<SendLocalListResponse, ClientError<OCPP1_6Error>>

pub async fn on_send_local_list<F, FF>(&self, callback: F)

where F: FnMut(SendLocalListRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SendLocalListResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_set_charging_profile( &self, request: SetChargingProfileRequest, ) -> Result<SetChargingProfileResponse, ClientError<OCPP1_6Error>>

pub async fn on_set_charging_profile<F, FF>(&self, callback: F)

where F: FnMut(SetChargingProfileRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SetChargingProfileResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_start_transaction( &self, request: StartTransactionRequest, ) -> Result<StartTransactionResponse, ClientError<OCPP1_6Error>>

pub async fn on_start_transaction<F, FF>(&self, callback: F)

where F: FnMut(StartTransactionRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<StartTransactionResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_status_notification( &self, request: StatusNotificationRequest, ) -> Result<StatusNotificationResponse, ClientError<OCPP1_6Error>>

pub async fn on_status_notification<F, FF>(&self, callback: F)

where F: FnMut(StatusNotificationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<StatusNotificationResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_stop_transaction( &self, request: StopTransactionRequest, ) -> Result<StopTransactionResponse, ClientError<OCPP1_6Error>>

pub async fn on_stop_transaction<F, FF>(&self, callback: F)

where F: FnMut(StopTransactionRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<StopTransactionResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_trigger_message( &self, request: TriggerMessageRequest, ) -> Result<TriggerMessageResponse, ClientError<OCPP1_6Error>>

pub async fn on_trigger_message<F, FF>(&self, callback: F)

where F: FnMut(TriggerMessageRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<TriggerMessageResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_unlock_connector( &self, request: UnlockConnectorRequest, ) -> Result<UnlockConnectorResponse, ClientError<OCPP1_6Error>>

pub async fn on_unlock_connector<F, FF>(&self, callback: F)

where F: FnMut(UnlockConnectorRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<UnlockConnectorResponse, OCPP1_6Error>> + Send,

impl Client<OCPP1_6Error>

pub async fn send_update_firmware( &self, request: UpdateFirmwareRequest, ) -> Result<UpdateFirmwareResponse, ClientError<OCPP1_6Error>>

pub async fn on_update_firmware<F, FF>(&self, callback: F)

where F: FnMut(UpdateFirmwareRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<UpdateFirmwareResponse, OCPP1_6Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_authorize( &self, request: AuthorizeRequest, ) -> Result<AuthorizeResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_authorize<F, FF>(&self, callback: F)

where F: FnMut(AuthorizeRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<AuthorizeResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_boot_notification( &self, request: BootNotificationRequest, ) -> Result<BootNotificationResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_boot_notification<F, FF>(&self, callback: F)

where F: FnMut(BootNotificationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<BootNotificationResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_cancel_reservation( &self, request: CancelReservationRequest, ) -> Result<CancelReservationResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_cancel_reservation<F, FF>(&self, callback: F)

where F: FnMut(CancelReservationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<CancelReservationResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_certificate_signed( &self, request: CertificateSignedRequest, ) -> Result<CertificateSignedResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_certificate_signed<F, FF>(&self, callback: F)

where F: FnMut(CertificateSignedRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<CertificateSignedResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_change_availability( &self, request: ChangeAvailabilityRequest, ) -> Result<ChangeAvailabilityResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_change_availability<F, FF>(&self, callback: F)

where F: FnMut(ChangeAvailabilityRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ChangeAvailabilityResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_clear_cache( &self, request: ClearCacheRequest, ) -> Result<ClearCacheResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_clear_cache<F, FF>(&self, callback: F)

where F: FnMut(ClearCacheRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ClearCacheResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_clear_charging_profile( &self, request: ClearChargingProfileRequest, ) -> Result<ClearChargingProfileResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_clear_charging_profile<F, FF>(&self, callback: F)

where F: FnMut(ClearChargingProfileRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ClearChargingProfileResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_clear_display_message( &self, request: ClearDisplayMessageRequest, ) -> Result<ClearDisplayMessageResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_clear_display_message<F, FF>(&self, callback: F)

where F: FnMut(ClearDisplayMessageRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ClearDisplayMessageResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_clear_variable_monitoring( &self, request: ClearVariableMonitoringRequest, ) -> Result<ClearVariableMonitoringResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_clear_variable_monitoring<F, FF>(&self, callback: F)

where F: FnMut(ClearVariableMonitoringRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ClearVariableMonitoringResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_cleared_charging_limit( &self, request: ClearedChargingLimitRequest, ) -> Result<ClearedChargingLimitResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_cleared_charging_limit<F, FF>(&self, callback: F)

where F: FnMut(ClearedChargingLimitRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ClearedChargingLimitResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_cost_updated( &self, request: CostUpdatedRequest, ) -> Result<CostUpdatedResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_cost_updated<F, FF>(&self, callback: F)

where F: FnMut(CostUpdatedRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<CostUpdatedResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_customer_information( &self, request: CustomerInformationRequest, ) -> Result<CustomerInformationResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_customer_information<F, FF>(&self, callback: F)

where F: FnMut(CustomerInformationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<CustomerInformationResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_data_transfer( &self, request: DataTransferRequest, ) -> Result<DataTransferResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_data_transfer<F, FF>(&self, callback: F)

where F: FnMut(DataTransferRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<DataTransferResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_delete_certificate( &self, request: DeleteCertificateRequest, ) -> Result<DeleteCertificateResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_delete_certificate<F, FF>(&self, callback: F)

where F: FnMut(DeleteCertificateRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<DeleteCertificateResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_firmware_status_notification( &self, request: FirmwareStatusNotificationRequest, ) -> Result<FirmwareStatusNotificationResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_firmware_status_notification<F, FF>(&self, callback: F)

where F: FnMut(FirmwareStatusNotificationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<FirmwareStatusNotificationResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_get_15118_ev_certificate( &self, request: Get15118EVCertificateRequest, ) -> Result<Get15118EVCertificateResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_get_15118_ev_certificate<F, FF>(&self, callback: F)

where F: FnMut(Get15118EVCertificateRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<Get15118EVCertificateResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_get_base_report( &self, request: GetBaseReportRequest, ) -> Result<GetBaseReportResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_get_base_report<F, FF>(&self, callback: F)

where F: FnMut(GetBaseReportRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetBaseReportResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_get_certificate_status( &self, request: GetCertificateStatusRequest, ) -> Result<GetCertificateStatusResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_get_certificate_status<F, FF>(&self, callback: F)

where F: FnMut(GetCertificateStatusRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetCertificateStatusResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_get_charging_profiles( &self, request: GetChargingProfilesRequest, ) -> Result<GetChargingProfilesResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_get_charging_profiles<F, FF>(&self, callback: F)

where F: FnMut(GetChargingProfilesRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetChargingProfilesResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_get_composite_schedule( &self, request: GetCompositeScheduleRequest, ) -> Result<GetCompositeScheduleResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_get_composite_schedule<F, FF>(&self, callback: F)

where F: FnMut(GetCompositeScheduleRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetCompositeScheduleResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_get_display_messages( &self, request: GetDisplayMessagesRequest, ) -> Result<GetDisplayMessagesResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_get_display_messages<F, FF>(&self, callback: F)

where F: FnMut(GetDisplayMessagesRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetDisplayMessagesResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_get_installed_certificate_ids( &self, request: GetInstalledCertificateIdsRequest, ) -> Result<GetInstalledCertificateIdsResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_get_installed_certificate_ids<F, FF>(&self, callback: F)

where F: FnMut(GetInstalledCertificateIdsRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetInstalledCertificateIdsResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_get_local_list_version( &self, request: GetLocalListVersionRequest, ) -> Result<GetLocalListVersionResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_get_local_list_version<F, FF>(&self, callback: F)

where F: FnMut(GetLocalListVersionRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetLocalListVersionResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_get_log( &self, request: GetLogRequest, ) -> Result<GetLogResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_get_log<F, FF>(&self, callback: F)

where F: FnMut(GetLogRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetLogResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_get_monitoring_report( &self, request: GetMonitoringReportRequest, ) -> Result<GetMonitoringReportResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_get_monitoring_report<F, FF>(&self, callback: F)

where F: FnMut(GetMonitoringReportRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetMonitoringReportResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_get_report( &self, request: GetReportRequest, ) -> Result<GetReportResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_get_report<F, FF>(&self, callback: F)

where F: FnMut(GetReportRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetReportResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_get_transaction_status( &self, request: GetTransactionStatusRequest, ) -> Result<GetTransactionStatusResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_get_transaction_status<F, FF>(&self, callback: F)

where F: FnMut(GetTransactionStatusRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetTransactionStatusResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_get_variables( &self, request: GetVariablesRequest, ) -> Result<GetVariablesResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_get_variables<F, FF>(&self, callback: F)

where F: FnMut(GetVariablesRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetVariablesResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_heartbeat( &self, request: HeartbeatRequest, ) -> Result<HeartbeatResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_heartbeat<F, FF>(&self, callback: F)

where F: FnMut(HeartbeatRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<HeartbeatResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_install_certificate( &self, request: InstallCertificateRequest, ) -> Result<InstallCertificateResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_install_certificate<F, FF>(&self, callback: F)

where F: FnMut(InstallCertificateRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<InstallCertificateResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_log_status_notification( &self, request: LogStatusNotificationRequest, ) -> Result<LogStatusNotificationResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_log_status_notification<F, FF>(&self, callback: F)

where F: FnMut(LogStatusNotificationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<LogStatusNotificationResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_meter_values( &self, request: MeterValuesRequest, ) -> Result<MeterValuesResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_meter_values<F, FF>(&self, callback: F)

where F: FnMut(MeterValuesRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<MeterValuesResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_notify_charging_limit( &self, request: NotifyChargingLimitRequest, ) -> Result<NotifyChargingLimitResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_notify_charging_limit<F, FF>(&self, callback: F)

where F: FnMut(NotifyChargingLimitRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<NotifyChargingLimitResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_notify_customer_information( &self, request: NotifyCustomerInformationRequest, ) -> Result<NotifyCustomerInformationResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_notify_customer_information<F, FF>(&self, callback: F)

where F: FnMut(NotifyCustomerInformationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<NotifyCustomerInformationResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_notify_display_messages( &self, request: NotifyDisplayMessagesRequest, ) -> Result<NotifyDisplayMessagesResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_notify_display_messages<F, FF>(&self, callback: F)

where F: FnMut(NotifyDisplayMessagesRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<NotifyDisplayMessagesResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_notify_ev_charging_needs( &self, request: NotifyEVChargingNeedsRequest, ) -> Result<NotifyEVChargingNeedsResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_notify_ev_charging_needs<F, FF>(&self, callback: F)

where F: FnMut(NotifyEVChargingNeedsRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<NotifyEVChargingNeedsResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_notify_ev_charging_schedule( &self, request: NotifyEVChargingScheduleRequest, ) -> Result<NotifyEVChargingScheduleResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_notify_ev_charging_schedule<F, FF>(&self, callback: F)

where F: FnMut(NotifyEVChargingScheduleRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<NotifyEVChargingScheduleResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_notify_event( &self, request: NotifyEventRequest, ) -> Result<NotifyEventResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_notify_event<F, FF>(&self, callback: F)

where F: FnMut(NotifyEventRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<NotifyEventResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_notify_monitoring_report( &self, request: NotifyMonitoringReportRequest, ) -> Result<NotifyMonitoringReportResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_notify_monitoring_report<F, FF>(&self, callback: F)

where F: FnMut(NotifyMonitoringReportRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<NotifyMonitoringReportResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_notify_report( &self, request: NotifyReportRequest, ) -> Result<NotifyReportResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_notify_report<F, FF>(&self, callback: F)

where F: FnMut(NotifyReportRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<NotifyReportResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_publish_firmware( &self, request: PublishFirmwareRequest, ) -> Result<PublishFirmwareResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_publish_firmware<F, FF>(&self, callback: F)

where F: FnMut(PublishFirmwareRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<PublishFirmwareResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_publish_firmware_status_notification( &self, request: PublishFirmwareStatusNotificationRequest, ) -> Result<PublishFirmwareStatusNotificationResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_publish_firmware_status_notification<F, FF>(&self, callback: F)

where F: FnMut(PublishFirmwareStatusNotificationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<PublishFirmwareStatusNotificationResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_report_charging_profiles( &self, request: ReportChargingProfilesRequest, ) -> Result<ReportChargingProfilesResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_report_charging_profiles<F, FF>(&self, callback: F)

where F: FnMut(ReportChargingProfilesRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ReportChargingProfilesResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_request_start_transaction( &self, request: RequestStartTransactionRequest, ) -> Result<RequestStartTransactionResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_request_start_transaction<F, FF>(&self, callback: F)

where F: FnMut(RequestStartTransactionRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<RequestStartTransactionResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_request_stop_transaction( &self, request: RequestStopTransactionRequest, ) -> Result<RequestStopTransactionResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_request_stop_transaction<F, FF>(&self, callback: F)

where F: FnMut(RequestStopTransactionRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<RequestStopTransactionResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_reservation_status_update( &self, request: ReservationStatusUpdateRequest, ) -> Result<ReservationStatusUpdateResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_reservation_status_update<F, FF>(&self, callback: F)

where F: FnMut(ReservationStatusUpdateRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ReservationStatusUpdateResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_reserve_now( &self, request: ReserveNowRequest, ) -> Result<ReserveNowResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_reserve_now<F, FF>(&self, callback: F)

where F: FnMut(ReserveNowRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ReserveNowResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_reset( &self, request: ResetRequest, ) -> Result<ResetResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_reset<F, FF>(&self, callback: F)

where F: FnMut(ResetRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ResetResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_security_event_notification( &self, request: SecurityEventNotificationRequest, ) -> Result<SecurityEventNotificationResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_security_event_notification<F, FF>(&self, callback: F)

where F: FnMut(SecurityEventNotificationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SecurityEventNotificationResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_send_local_list( &self, request: SendLocalListRequest, ) -> Result<SendLocalListResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_send_local_list<F, FF>(&self, callback: F)

where F: FnMut(SendLocalListRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SendLocalListResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_set_charging_profile( &self, request: SetChargingProfileRequest, ) -> Result<SetChargingProfileResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_set_charging_profile<F, FF>(&self, callback: F)

where F: FnMut(SetChargingProfileRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SetChargingProfileResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_set_display_message( &self, request: SetDisplayMessageRequest, ) -> Result<SetDisplayMessageResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_set_display_message<F, FF>(&self, callback: F)

where F: FnMut(SetDisplayMessageRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SetDisplayMessageResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_set_monitoring_base( &self, request: SetMonitoringBaseRequest, ) -> Result<SetMonitoringBaseResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_set_monitoring_base<F, FF>(&self, callback: F)

where F: FnMut(SetMonitoringBaseRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SetMonitoringBaseResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_set_monitoring_level( &self, request: SetMonitoringLevelRequest, ) -> Result<SetMonitoringLevelResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_set_monitoring_level<F, FF>(&self, callback: F)

where F: FnMut(SetMonitoringLevelRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SetMonitoringLevelResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_set_network_profile( &self, request: SetNetworkProfileRequest, ) -> Result<SetNetworkProfileResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_set_network_profile<F, FF>(&self, callback: F)

where F: FnMut(SetNetworkProfileRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SetNetworkProfileResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_set_variable_monitoring( &self, request: SetVariableMonitoringRequest, ) -> Result<SetVariableMonitoringResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_set_variable_monitoring<F, FF>(&self, callback: F)

where F: FnMut(SetVariableMonitoringRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SetVariableMonitoringResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_set_variables( &self, request: SetVariablesRequest, ) -> Result<SetVariablesResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_set_variables<F, FF>(&self, callback: F)

where F: FnMut(SetVariablesRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SetVariablesResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_sign_certificate( &self, request: SignCertificateRequest, ) -> Result<SignCertificateResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_sign_certificate<F, FF>(&self, callback: F)

where F: FnMut(SignCertificateRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SignCertificateResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_status_notification( &self, request: StatusNotificationRequest, ) -> Result<StatusNotificationResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_status_notification<F, FF>(&self, callback: F)

where F: FnMut(StatusNotificationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<StatusNotificationResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_transaction_event( &self, request: TransactionEventRequest, ) -> Result<TransactionEventResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_transaction_event<F, FF>(&self, callback: F)

where F: FnMut(TransactionEventRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<TransactionEventResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_trigger_message( &self, request: TriggerMessageRequest, ) -> Result<TriggerMessageResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_trigger_message<F, FF>(&self, callback: F)

where F: FnMut(TriggerMessageRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<TriggerMessageResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_unlock_connector( &self, request: UnlockConnectorRequest, ) -> Result<UnlockConnectorResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_unlock_connector<F, FF>(&self, callback: F)

where F: FnMut(UnlockConnectorRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<UnlockConnectorResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_unpublish_firmware( &self, request: UnpublishFirmwareRequest, ) -> Result<UnpublishFirmwareResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_unpublish_firmware<F, FF>(&self, callback: F)

where F: FnMut(UnpublishFirmwareRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<UnpublishFirmwareResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_0_1Error>

pub async fn send_update_firmware( &self, request: UpdateFirmwareRequest, ) -> Result<UpdateFirmwareResponse, ClientError<OCPP2_0_1Error>>

pub async fn on_update_firmware<F, FF>(&self, callback: F)

where F: FnMut(UpdateFirmwareRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<UpdateFirmwareResponse, OCPP2_0_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_adjust_periodic_event_stream( &self, request: AdjustPeriodicEventStreamRequest, ) -> Result<AdjustPeriodicEventStreamResponse, ClientError<OCPP2_1Error>>

pub async fn on_adjust_periodic_event_stream<F, FF>(&self, callback: F)

where F: FnMut(AdjustPeriodicEventStreamRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<AdjustPeriodicEventStreamResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_afrr_signal( &self, request: AFRRSignalRequest, ) -> Result<AFRRSignalResponse, ClientError<OCPP2_1Error>>

pub async fn on_afrr_signal<F, FF>(&self, callback: F)

where F: FnMut(AFRRSignalRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<AFRRSignalResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_authorize( &self, request: AuthorizeRequest, ) -> Result<AuthorizeResponse, ClientError<OCPP2_1Error>>

pub async fn on_authorize<F, FF>(&self, callback: F)

where F: FnMut(AuthorizeRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<AuthorizeResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_battery_swap( &self, request: BatterySwapRequest, ) -> Result<BatterySwapResponse, ClientError<OCPP2_1Error>>

pub async fn on_battery_swap<F, FF>(&self, callback: F)

where F: FnMut(BatterySwapRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<BatterySwapResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_boot_notification( &self, request: BootNotificationRequest, ) -> Result<BootNotificationResponse, ClientError<OCPP2_1Error>>

pub async fn on_boot_notification<F, FF>(&self, callback: F)

where F: FnMut(BootNotificationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<BootNotificationResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_cancel_reservation( &self, request: CancelReservationRequest, ) -> Result<CancelReservationResponse, ClientError<OCPP2_1Error>>

pub async fn on_cancel_reservation<F, FF>(&self, callback: F)

where F: FnMut(CancelReservationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<CancelReservationResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_certificate_signed( &self, request: CertificateSignedRequest, ) -> Result<CertificateSignedResponse, ClientError<OCPP2_1Error>>

pub async fn on_certificate_signed<F, FF>(&self, callback: F)

where F: FnMut(CertificateSignedRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<CertificateSignedResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_change_availability( &self, request: ChangeAvailabilityRequest, ) -> Result<ChangeAvailabilityResponse, ClientError<OCPP2_1Error>>

pub async fn on_change_availability<F, FF>(&self, callback: F)

where F: FnMut(ChangeAvailabilityRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ChangeAvailabilityResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_change_transaction_tariff( &self, request: ChangeTransactionTariffRequest, ) -> Result<ChangeTransactionTariffResponse, ClientError<OCPP2_1Error>>

pub async fn on_change_transaction_tariff<F, FF>(&self, callback: F)

where F: FnMut(ChangeTransactionTariffRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ChangeTransactionTariffResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_clear_cache( &self, request: ClearCacheRequest, ) -> Result<ClearCacheResponse, ClientError<OCPP2_1Error>>

pub async fn on_clear_cache<F, FF>(&self, callback: F)

where F: FnMut(ClearCacheRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ClearCacheResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_clear_charging_profile( &self, request: ClearChargingProfileRequest, ) -> Result<ClearChargingProfileResponse, ClientError<OCPP2_1Error>>

pub async fn on_clear_charging_profile<F, FF>(&self, callback: F)

where F: FnMut(ClearChargingProfileRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ClearChargingProfileResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_clear_der_control( &self, request: ClearDERControlRequest, ) -> Result<ClearDERControlResponse, ClientError<OCPP2_1Error>>

pub async fn on_clear_der_control<F, FF>(&self, callback: F)

where F: FnMut(ClearDERControlRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ClearDERControlResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_clear_display_message( &self, request: ClearDisplayMessageRequest, ) -> Result<ClearDisplayMessageResponse, ClientError<OCPP2_1Error>>

pub async fn on_clear_display_message<F, FF>(&self, callback: F)

where F: FnMut(ClearDisplayMessageRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ClearDisplayMessageResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_clear_tariffs( &self, request: ClearTariffsRequest, ) -> Result<ClearTariffsResponse, ClientError<OCPP2_1Error>>

pub async fn on_clear_tariffs<F, FF>(&self, callback: F)

where F: FnMut(ClearTariffsRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ClearTariffsResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_clear_variable_monitoring( &self, request: ClearVariableMonitoringRequest, ) -> Result<ClearVariableMonitoringResponse, ClientError<OCPP2_1Error>>

pub async fn on_clear_variable_monitoring<F, FF>(&self, callback: F)

where F: FnMut(ClearVariableMonitoringRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ClearVariableMonitoringResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_cleared_charging_limit( &self, request: ClearedChargingLimitRequest, ) -> Result<ClearedChargingLimitResponse, ClientError<OCPP2_1Error>>

pub async fn on_cleared_charging_limit<F, FF>(&self, callback: F)

where F: FnMut(ClearedChargingLimitRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ClearedChargingLimitResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_close_periodic_event_stream( &self, request: ClosePeriodicEventStreamRequest, ) -> Result<ClosePeriodicEventStreamResponse, ClientError<OCPP2_1Error>>

pub async fn on_close_periodic_event_stream<F, FF>(&self, callback: F)

where F: FnMut(ClosePeriodicEventStreamRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ClosePeriodicEventStreamResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_cost_updated( &self, request: CostUpdatedRequest, ) -> Result<CostUpdatedResponse, ClientError<OCPP2_1Error>>

pub async fn on_cost_updated<F, FF>(&self, callback: F)

where F: FnMut(CostUpdatedRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<CostUpdatedResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_customer_information( &self, request: CustomerInformationRequest, ) -> Result<CustomerInformationResponse, ClientError<OCPP2_1Error>>

pub async fn on_customer_information<F, FF>(&self, callback: F)

where F: FnMut(CustomerInformationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<CustomerInformationResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_data_transfer( &self, request: DataTransferRequest, ) -> Result<DataTransferResponse, ClientError<OCPP2_1Error>>

pub async fn on_data_transfer<F, FF>(&self, callback: F)

where F: FnMut(DataTransferRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<DataTransferResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_delete_certificate( &self, request: DeleteCertificateRequest, ) -> Result<DeleteCertificateResponse, ClientError<OCPP2_1Error>>

pub async fn on_delete_certificate<F, FF>(&self, callback: F)

where F: FnMut(DeleteCertificateRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<DeleteCertificateResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_firmware_status_notification( &self, request: FirmwareStatusNotificationRequest, ) -> Result<FirmwareStatusNotificationResponse, ClientError<OCPP2_1Error>>

pub async fn on_firmware_status_notification<F, FF>(&self, callback: F)

where F: FnMut(FirmwareStatusNotificationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<FirmwareStatusNotificationResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_get_15118_ev_certificate( &self, request: Get15118EVCertificateRequest, ) -> Result<Get15118EVCertificateResponse, ClientError<OCPP2_1Error>>

pub async fn on_get_15118_ev_certificate<F, FF>(&self, callback: F)

where F: FnMut(Get15118EVCertificateRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<Get15118EVCertificateResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_get_base_report( &self, request: GetBaseReportRequest, ) -> Result<GetBaseReportResponse, ClientError<OCPP2_1Error>>

pub async fn on_get_base_report<F, FF>(&self, callback: F)

where F: FnMut(GetBaseReportRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetBaseReportResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_get_certificate_chain_status( &self, request: GetCertificateChainStatusRequest, ) -> Result<GetCertificateChainStatusResponse, ClientError<OCPP2_1Error>>

pub async fn on_get_certificate_chain_status<F, FF>(&self, callback: F)

where F: FnMut(GetCertificateChainStatusRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetCertificateChainStatusResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_get_certificate_status( &self, request: GetCertificateStatusRequest, ) -> Result<GetCertificateStatusResponse, ClientError<OCPP2_1Error>>

pub async fn on_get_certificate_status<F, FF>(&self, callback: F)

where F: FnMut(GetCertificateStatusRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetCertificateStatusResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_get_charging_profiles( &self, request: GetChargingProfilesRequest, ) -> Result<GetChargingProfilesResponse, ClientError<OCPP2_1Error>>

pub async fn on_get_charging_profiles<F, FF>(&self, callback: F)

where F: FnMut(GetChargingProfilesRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetChargingProfilesResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_get_composite_schedule( &self, request: GetCompositeScheduleRequest, ) -> Result<GetCompositeScheduleResponse, ClientError<OCPP2_1Error>>

pub async fn on_get_composite_schedule<F, FF>(&self, callback: F)

where F: FnMut(GetCompositeScheduleRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetCompositeScheduleResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_get_der_control( &self, request: GetDERControlRequest, ) -> Result<GetDERControlResponse, ClientError<OCPP2_1Error>>

pub async fn on_get_der_control<F, FF>(&self, callback: F)

where F: FnMut(GetDERControlRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetDERControlResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_get_display_messages( &self, request: GetDisplayMessagesRequest, ) -> Result<GetDisplayMessagesResponse, ClientError<OCPP2_1Error>>

pub async fn on_get_display_messages<F, FF>(&self, callback: F)

where F: FnMut(GetDisplayMessagesRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetDisplayMessagesResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_get_installed_certificate_ids( &self, request: GetInstalledCertificateIdsRequest, ) -> Result<GetInstalledCertificateIdsResponse, ClientError<OCPP2_1Error>>

pub async fn on_get_installed_certificate_ids<F, FF>(&self, callback: F)

where F: FnMut(GetInstalledCertificateIdsRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetInstalledCertificateIdsResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_get_local_list_version( &self, request: GetLocalListVersionRequest, ) -> Result<GetLocalListVersionResponse, ClientError<OCPP2_1Error>>

pub async fn on_get_local_list_version<F, FF>(&self, callback: F)

where F: FnMut(GetLocalListVersionRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetLocalListVersionResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_get_log( &self, request: GetLogRequest, ) -> Result<GetLogResponse, ClientError<OCPP2_1Error>>

pub async fn on_get_log<F, FF>(&self, callback: F)

where F: FnMut(GetLogRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetLogResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_get_monitoring_report( &self, request: GetMonitoringReportRequest, ) -> Result<GetMonitoringReportResponse, ClientError<OCPP2_1Error>>

pub async fn on_get_monitoring_report<F, FF>(&self, callback: F)

where F: FnMut(GetMonitoringReportRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetMonitoringReportResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_get_periodic_event_stream( &self, request: GetPeriodicEventStreamRequest, ) -> Result<GetPeriodicEventStreamResponse, ClientError<OCPP2_1Error>>

pub async fn on_get_periodic_event_stream<F, FF>(&self, callback: F)

where F: FnMut(GetPeriodicEventStreamRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetPeriodicEventStreamResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_get_report( &self, request: GetReportRequest, ) -> Result<GetReportResponse, ClientError<OCPP2_1Error>>

pub async fn on_get_report<F, FF>(&self, callback: F)

where F: FnMut(GetReportRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetReportResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_get_tariffs( &self, request: GetTariffsRequest, ) -> Result<GetTariffsResponse, ClientError<OCPP2_1Error>>

pub async fn on_get_tariffs<F, FF>(&self, callback: F)

where F: FnMut(GetTariffsRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetTariffsResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_get_transaction_status( &self, request: GetTransactionStatusRequest, ) -> Result<GetTransactionStatusResponse, ClientError<OCPP2_1Error>>

pub async fn on_get_transaction_status<F, FF>(&self, callback: F)

where F: FnMut(GetTransactionStatusRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetTransactionStatusResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_get_variables( &self, request: GetVariablesRequest, ) -> Result<GetVariablesResponse, ClientError<OCPP2_1Error>>

pub async fn on_get_variables<F, FF>(&self, callback: F)

where F: FnMut(GetVariablesRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetVariablesResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_heartbeat( &self, request: HeartbeatRequest, ) -> Result<HeartbeatResponse, ClientError<OCPP2_1Error>>

pub async fn on_heartbeat<F, FF>(&self, callback: F)

where F: FnMut(HeartbeatRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<HeartbeatResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_install_certificate( &self, request: InstallCertificateRequest, ) -> Result<InstallCertificateResponse, ClientError<OCPP2_1Error>>

pub async fn on_install_certificate<F, FF>(&self, callback: F)

where F: FnMut(InstallCertificateRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<InstallCertificateResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_log_status_notification( &self, request: LogStatusNotificationRequest, ) -> Result<LogStatusNotificationResponse, ClientError<OCPP2_1Error>>

pub async fn on_log_status_notification<F, FF>(&self, callback: F)

where F: FnMut(LogStatusNotificationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<LogStatusNotificationResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_meter_values( &self, request: MeterValuesRequest, ) -> Result<MeterValuesResponse, ClientError<OCPP2_1Error>>

pub async fn on_meter_values<F, FF>(&self, callback: F)

where F: FnMut(MeterValuesRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<MeterValuesResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_notify_allowed_energy_transfer( &self, request: NotifyAllowedEnergyTransferRequest, ) -> Result<NotifyAllowedEnergyTransferResponse, ClientError<OCPP2_1Error>>

pub async fn on_notify_allowed_energy_transfer<F, FF>(&self, callback: F)

where F: FnMut(NotifyAllowedEnergyTransferRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<NotifyAllowedEnergyTransferResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_notify_charging_limit( &self, request: NotifyChargingLimitRequest, ) -> Result<NotifyChargingLimitResponse, ClientError<OCPP2_1Error>>

pub async fn on_notify_charging_limit<F, FF>(&self, callback: F)

where F: FnMut(NotifyChargingLimitRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<NotifyChargingLimitResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_notify_customer_information( &self, request: NotifyCustomerInformationRequest, ) -> Result<NotifyCustomerInformationResponse, ClientError<OCPP2_1Error>>

pub async fn on_notify_customer_information<F, FF>(&self, callback: F)

where F: FnMut(NotifyCustomerInformationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<NotifyCustomerInformationResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_notify_der_alarm( &self, request: NotifyDERAlarmRequest, ) -> Result<NotifyDERAlarmResponse, ClientError<OCPP2_1Error>>

pub async fn on_notify_der_alarm<F, FF>(&self, callback: F)

where F: FnMut(NotifyDERAlarmRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<NotifyDERAlarmResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_notify_der_start_stop( &self, request: NotifyDERStartStopRequest, ) -> Result<NotifyDERStartStopResponse, ClientError<OCPP2_1Error>>

pub async fn on_notify_der_start_stop<F, FF>(&self, callback: F)

where F: FnMut(NotifyDERStartStopRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<NotifyDERStartStopResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_notify_display_messages( &self, request: NotifyDisplayMessagesRequest, ) -> Result<NotifyDisplayMessagesResponse, ClientError<OCPP2_1Error>>

pub async fn on_notify_display_messages<F, FF>(&self, callback: F)

where F: FnMut(NotifyDisplayMessagesRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<NotifyDisplayMessagesResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_notify_ev_charging_needs( &self, request: NotifyEVChargingNeedsRequest, ) -> Result<NotifyEVChargingNeedsResponse, ClientError<OCPP2_1Error>>

pub async fn on_notify_ev_charging_needs<F, FF>(&self, callback: F)

where F: FnMut(NotifyEVChargingNeedsRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<NotifyEVChargingNeedsResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_notify_ev_charging_schedule( &self, request: NotifyEVChargingScheduleRequest, ) -> Result<NotifyEVChargingScheduleResponse, ClientError<OCPP2_1Error>>

pub async fn on_notify_ev_charging_schedule<F, FF>(&self, callback: F)

where F: FnMut(NotifyEVChargingScheduleRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<NotifyEVChargingScheduleResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_notify_event( &self, request: NotifyEventRequest, ) -> Result<NotifyEventResponse, ClientError<OCPP2_1Error>>

pub async fn on_notify_event<F, FF>(&self, callback: F)

where F: FnMut(NotifyEventRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<NotifyEventResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_notify_monitoring_report( &self, request: NotifyMonitoringReportRequest, ) -> Result<NotifyMonitoringReportResponse, ClientError<OCPP2_1Error>>

pub async fn on_notify_monitoring_report<F, FF>(&self, callback: F)

where F: FnMut(NotifyMonitoringReportRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<NotifyMonitoringReportResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_notify_report( &self, request: NotifyReportRequest, ) -> Result<NotifyReportResponse, ClientError<OCPP2_1Error>>

pub async fn on_notify_report<F, FF>(&self, callback: F)

where F: FnMut(NotifyReportRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<NotifyReportResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_notify_periodic_event_stream( &self, payload: NotifyPeriodicEventStream, ) -> Result<(), ClientError<OCPP2_1Error>>

pub async fn on_notify_periodic_event_stream<F, FF>(&self, callback: F)

where F: FnMut(NotifyPeriodicEventStream, Self) -> FF + Send + Sync + 'static, FF: Future<Output = ()> + Send,

impl Client<OCPP2_1Error>

pub async fn send_notify_priority_charging( &self, request: NotifyPriorityChargingRequest, ) -> Result<NotifyPriorityChargingResponse, ClientError<OCPP2_1Error>>

pub async fn on_notify_priority_charging<F, FF>(&self, callback: F)

where F: FnMut(NotifyPriorityChargingRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<NotifyPriorityChargingResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_notify_settlement( &self, request: NotifySettlementRequest, ) -> Result<NotifySettlementResponse, ClientError<OCPP2_1Error>>

pub async fn on_notify_settlement<F, FF>(&self, callback: F)

where F: FnMut(NotifySettlementRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<NotifySettlementResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_notify_web_payment_started( &self, request: NotifyWebPaymentStartedRequest, ) -> Result<NotifyWebPaymentStartedResponse, ClientError<OCPP2_1Error>>

pub async fn on_notify_web_payment_started<F, FF>(&self, callback: F)

where F: FnMut(NotifyWebPaymentStartedRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<NotifyWebPaymentStartedResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_open_periodic_event_stream( &self, request: OpenPeriodicEventStreamRequest, ) -> Result<OpenPeriodicEventStreamResponse, ClientError<OCPP2_1Error>>

pub async fn on_open_periodic_event_stream<F, FF>(&self, callback: F)

where F: FnMut(OpenPeriodicEventStreamRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<OpenPeriodicEventStreamResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_publish_firmware( &self, request: PublishFirmwareRequest, ) -> Result<PublishFirmwareResponse, ClientError<OCPP2_1Error>>

pub async fn on_publish_firmware<F, FF>(&self, callback: F)

where F: FnMut(PublishFirmwareRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<PublishFirmwareResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_publish_firmware_status_notification( &self, request: PublishFirmwareStatusNotificationRequest, ) -> Result<PublishFirmwareStatusNotificationResponse, ClientError<OCPP2_1Error>>

pub async fn on_publish_firmware_status_notification<F, FF>(&self, callback: F)

where F: FnMut(PublishFirmwareStatusNotificationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<PublishFirmwareStatusNotificationResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_pull_dynamic_schedule_update( &self, request: PullDynamicScheduleUpdateRequest, ) -> Result<PullDynamicScheduleUpdateResponse, ClientError<OCPP2_1Error>>

pub async fn on_pull_dynamic_schedule_update<F, FF>(&self, callback: F)

where F: FnMut(PullDynamicScheduleUpdateRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<PullDynamicScheduleUpdateResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_report_charging_profiles( &self, request: ReportChargingProfilesRequest, ) -> Result<ReportChargingProfilesResponse, ClientError<OCPP2_1Error>>

pub async fn on_report_charging_profiles<F, FF>(&self, callback: F)

where F: FnMut(ReportChargingProfilesRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ReportChargingProfilesResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_report_der_control( &self, request: ReportDERControlRequest, ) -> Result<ReportDERControlResponse, ClientError<OCPP2_1Error>>

pub async fn on_report_der_control<F, FF>(&self, callback: F)

where F: FnMut(ReportDERControlRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ReportDERControlResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_request_battery_swap( &self, request: RequestBatterySwapRequest, ) -> Result<RequestBatterySwapResponse, ClientError<OCPP2_1Error>>

pub async fn on_request_battery_swap<F, FF>(&self, callback: F)

where F: FnMut(RequestBatterySwapRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<RequestBatterySwapResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_request_start_transaction( &self, request: RequestStartTransactionRequest, ) -> Result<RequestStartTransactionResponse, ClientError<OCPP2_1Error>>

pub async fn on_request_start_transaction<F, FF>(&self, callback: F)

where F: FnMut(RequestStartTransactionRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<RequestStartTransactionResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_request_stop_transaction( &self, request: RequestStopTransactionRequest, ) -> Result<RequestStopTransactionResponse, ClientError<OCPP2_1Error>>

pub async fn on_request_stop_transaction<F, FF>(&self, callback: F)

where F: FnMut(RequestStopTransactionRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<RequestStopTransactionResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_reservation_status_update( &self, request: ReservationStatusUpdateRequest, ) -> Result<ReservationStatusUpdateResponse, ClientError<OCPP2_1Error>>

pub async fn on_reservation_status_update<F, FF>(&self, callback: F)

where F: FnMut(ReservationStatusUpdateRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ReservationStatusUpdateResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_reserve_now( &self, request: ReserveNowRequest, ) -> Result<ReserveNowResponse, ClientError<OCPP2_1Error>>

pub async fn on_reserve_now<F, FF>(&self, callback: F)

where F: FnMut(ReserveNowRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ReserveNowResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_reset( &self, request: ResetRequest, ) -> Result<ResetResponse, ClientError<OCPP2_1Error>>

pub async fn on_reset<F, FF>(&self, callback: F)

where F: FnMut(ResetRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ResetResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_security_event_notification( &self, request: SecurityEventNotificationRequest, ) -> Result<SecurityEventNotificationResponse, ClientError<OCPP2_1Error>>

pub async fn on_security_event_notification<F, FF>(&self, callback: F)

where F: FnMut(SecurityEventNotificationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SecurityEventNotificationResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_send_local_list( &self, request: SendLocalListRequest, ) -> Result<SendLocalListResponse, ClientError<OCPP2_1Error>>

pub async fn on_send_local_list<F, FF>(&self, callback: F)

where F: FnMut(SendLocalListRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SendLocalListResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_set_charging_profile( &self, request: SetChargingProfileRequest, ) -> Result<SetChargingProfileResponse, ClientError<OCPP2_1Error>>

pub async fn on_set_charging_profile<F, FF>(&self, callback: F)

where F: FnMut(SetChargingProfileRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SetChargingProfileResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_set_default_tariff( &self, request: SetDefaultTariffRequest, ) -> Result<SetDefaultTariffResponse, ClientError<OCPP2_1Error>>

pub async fn on_set_default_tariff<F, FF>(&self, callback: F)

where F: FnMut(SetDefaultTariffRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SetDefaultTariffResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_set_der_control( &self, request: SetDERControlRequest, ) -> Result<SetDERControlResponse, ClientError<OCPP2_1Error>>

pub async fn on_set_der_control<F, FF>(&self, callback: F)

where F: FnMut(SetDERControlRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SetDERControlResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_set_display_message( &self, request: SetDisplayMessageRequest, ) -> Result<SetDisplayMessageResponse, ClientError<OCPP2_1Error>>

pub async fn on_set_display_message<F, FF>(&self, callback: F)

where F: FnMut(SetDisplayMessageRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SetDisplayMessageResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_set_monitoring_base( &self, request: SetMonitoringBaseRequest, ) -> Result<SetMonitoringBaseResponse, ClientError<OCPP2_1Error>>

pub async fn on_set_monitoring_base<F, FF>(&self, callback: F)

where F: FnMut(SetMonitoringBaseRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SetMonitoringBaseResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_set_monitoring_level( &self, request: SetMonitoringLevelRequest, ) -> Result<SetMonitoringLevelResponse, ClientError<OCPP2_1Error>>

pub async fn on_set_monitoring_level<F, FF>(&self, callback: F)

where F: FnMut(SetMonitoringLevelRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SetMonitoringLevelResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_set_network_profile( &self, request: SetNetworkProfileRequest, ) -> Result<SetNetworkProfileResponse, ClientError<OCPP2_1Error>>

pub async fn on_set_network_profile<F, FF>(&self, callback: F)

where F: FnMut(SetNetworkProfileRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SetNetworkProfileResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_set_variable_monitoring( &self, request: SetVariableMonitoringRequest, ) -> Result<SetVariableMonitoringResponse, ClientError<OCPP2_1Error>>

pub async fn on_set_variable_monitoring<F, FF>(&self, callback: F)

where F: FnMut(SetVariableMonitoringRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SetVariableMonitoringResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_set_variables( &self, request: SetVariablesRequest, ) -> Result<SetVariablesResponse, ClientError<OCPP2_1Error>>

pub async fn on_set_variables<F, FF>(&self, callback: F)

where F: FnMut(SetVariablesRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SetVariablesResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_sign_certificate( &self, request: SignCertificateRequest, ) -> Result<SignCertificateResponse, ClientError<OCPP2_1Error>>

pub async fn on_sign_certificate<F, FF>(&self, callback: F)

where F: FnMut(SignCertificateRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SignCertificateResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_status_notification( &self, request: StatusNotificationRequest, ) -> Result<StatusNotificationResponse, ClientError<OCPP2_1Error>>

pub async fn on_status_notification<F, FF>(&self, callback: F)

where F: FnMut(StatusNotificationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<StatusNotificationResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_transaction_event( &self, request: TransactionEventRequest, ) -> Result<TransactionEventResponse, ClientError<OCPP2_1Error>>

pub async fn on_transaction_event<F, FF>(&self, callback: F)

where F: FnMut(TransactionEventRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<TransactionEventResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_trigger_message( &self, request: TriggerMessageRequest, ) -> Result<TriggerMessageResponse, ClientError<OCPP2_1Error>>

pub async fn on_trigger_message<F, FF>(&self, callback: F)

where F: FnMut(TriggerMessageRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<TriggerMessageResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_unlock_connector( &self, request: UnlockConnectorRequest, ) -> Result<UnlockConnectorResponse, ClientError<OCPP2_1Error>>

pub async fn on_unlock_connector<F, FF>(&self, callback: F)

where F: FnMut(UnlockConnectorRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<UnlockConnectorResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_unpublish_firmware( &self, request: UnpublishFirmwareRequest, ) -> Result<UnpublishFirmwareResponse, ClientError<OCPP2_1Error>>

pub async fn on_unpublish_firmware<F, FF>(&self, callback: F)

where F: FnMut(UnpublishFirmwareRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<UnpublishFirmwareResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_update_dynamic_schedule( &self, request: UpdateDynamicScheduleRequest, ) -> Result<UpdateDynamicScheduleResponse, ClientError<OCPP2_1Error>>

pub async fn on_update_dynamic_schedule<F, FF>(&self, callback: F)

where F: FnMut(UpdateDynamicScheduleRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<UpdateDynamicScheduleResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_update_firmware( &self, request: UpdateFirmwareRequest, ) -> Result<UpdateFirmwareResponse, ClientError<OCPP2_1Error>>

pub async fn on_update_firmware<F, FF>(&self, callback: F)

where F: FnMut(UpdateFirmwareRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<UpdateFirmwareResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_use_priority_charging( &self, request: UsePriorityChargingRequest, ) -> Result<UsePriorityChargingResponse, ClientError<OCPP2_1Error>>

pub async fn on_use_priority_charging<F, FF>(&self, callback: F)

where F: FnMut(UsePriorityChargingRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<UsePriorityChargingResponse, OCPP2_1Error>> + Send,

impl Client<OCPP2_1Error>

pub async fn send_vat_number_validation( &self, request: VatNumberValidationRequest, ) -> Result<VatNumberValidationResponse, ClientError<OCPP2_1Error>>

pub async fn on_vat_number_validation<F, FF>(&self, callback: F)

where F: FnMut(VatNumberValidationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<VatNumberValidationResponse, OCPP2_1Error>> + Send,

Trait Implementations

impl<E: ProtocolError> Clone for Client<E>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.