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 fn from_transport_with_config( sink: Box<dyn TransportSink>, stream: Box<dyn TransportStream>, executor: Box<dyn Executor>, timer: Box<dyn Timer>, config: ClientConfig, ) -> Self

The constructor the other two delegate to: everything optional lives in ClientConfig instead of a growing positional parameter list.

Spawns two background tasks on executor: the read loop, and a keepalive task. The keepalive task is spawned even when config.keepalive is Disabled, where it simply parks until someone calls Client::set_ping_interval - otherwise a client built with keepalive off could never have it turned on later, which is exactly what a CSMS writing WebSocketPingInterval needs to do.

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 wait_for<A, F, FF>( &self, callback: F, ) -> Result<A::Request, ClientError<E>>

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

Wait for exactly one CALL for action A (bounded by the client’s timeout), answer it with callback, and return the parsed request. Only useful in tests.

The registration is removed again on the way out, whichever way that is. Leaving it in place left the action bound to a channel with no reader, so any later CALL for it was queued and silently forgotten - the peer got no CALLRESULT and no CALLERROR either, which looks exactly like the client having hung.

Note this does not restore a handler that Client::on had registered for the same action beforehand; registering replaces, as on’s own docs say.

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>>

Send one ping and wait for the matching pong, bounded by the client’s timeout.

The pong is matched by correlation token, not arrival order: the ping carries an 8-byte token as its payload and only a pong echoing that exact payload resolves this call. RFC 6455 requires peers to echo ping payloads, so this is exact against any compliant server; a pong that echoes something else is ignored, and this call times out.

This is the manual, one-shot ping. For scheduled keepalive - including detecting a peer that has stopped answering and forcing a redial - see Client::set_ping_interval and KeepaliveBehavior.

pub async fn pending_request_count(&self) -> usize

How many requests are still waiting for a CALLRESULT/CALLERROR.

Test-only instrumentation: this table is bookkeeping that should return to zero once every request has either been answered or given up, and a leak in it is otherwise invisible from outside - it shows up only as memory growth on a charge point that has been running for weeks. tests/ocpp_1_6_bookkeeping.rs asserts on it.

pub async fn pending_ping_count(&self) -> usize

How many pings are still waiting for a pong. Test-only, same rationale as Client::pending_request_count.

pub fn ping_interval(&self) -> Option<Duration>

The keepalive ping interval currently in force, or None when keepalive is off.

This is the value to report for OCPPCommCtrlr.WebSocketPingInterval (2.0.1/2.1) or the WebSocketPingInterval configuration key (1.6) - None maps to the spec’s 0. Cheap and non-blocking, so a GetVariables/GetConfiguration handler can call it directly.

pub fn set_ping_interval(&self, interval: Option<Duration>)

Change the keepalive ping interval on a live connection, for a CSMS writing WebSocketPingInterval via SetVariables/ChangeConfiguration.

None - or Some(Duration::ZERO), matching the spec’s 0 - disables pinging. Takes effect immediately: the keepalive task is woken rather than finishing the interval it was already waiting out, so shortening a 1-hour interval doesn’t take up to an hour to apply. Enabling works even on a client built with KeepaliveBehavior::Disabled.

pub fn force_reconnect(&self)

Abandon the current transport and redial, without waiting for it to notice it is dead.

This is what keepalive escalates to after KeepalivePolicy::max_missed unanswered pings, exposed because a caller with its own liveness signal (an application-level heartbeat going unanswered, say) has the same problem. A half-open TCP connection can otherwise keep the read loop parked until the OS timeout, which no amount of protocol-level bookkeeping can shorten.

No-op when the client was built without a reconnector: there would be nothing to redial with, and dropping the current connection anyway would just make the client deaf.

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>>

Shut this client down for good: close the transport, stop the read loop, stop keepalive, and do not redial.

The shutdown is sticky and takes precedence over every automatic recovery path. That matters because closing the transport looks exactly like a dropped connection from the read loop’s side - it previously produced an EOF the reconnector dutifully redialled, so on the default crate::ConnectOptions (reconnect enabled) there was no way to stop a client at all. After this returns:

• the read loop has been told to exit rather than redial, whether it was parked in recv or sees the EOF from the close;
• the keepalive task stops pinging, and Client::set_ping_interval cannot restart it;
• Client::force_reconnect is a no-op;
• further call/send_*/send_ping return ClientError::Closed instead of writing to a dead transport and waiting out the timeout.

Idempotent: calling it again is a no-op returning Ok(()). Reconnecting afterwards means building a new Client.

This only covers deliberate shutdown. An unrequested drop is still redialled as before.

pub fn is_closed(&self) -> bool

Whether Client::disconnect has been called.

This reflects deliberate shutdown only - it stays false while a connection is dropped and being redialled, because such a client is still live and will resume on its own. There is deliberately no “is the socket up right now” accessor: it would be stale the moment it returned, and Client::on_reconnect is the reliable way to observe reconnection.

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,

pub async fn wait_for_authorize<F, FF>( &self, callback: F, ) -> Result<AuthorizeRequest, ClientError<OCPP1_6Error>>

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,

pub async fn wait_for_boot_notification<F, FF>( &self, callback: F, ) -> Result<BootNotificationRequest, ClientError<OCPP1_6Error>>

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,

pub async fn wait_for_cancel_reservation<F, FF>( &self, callback: F, ) -> Result<CancelReservationRequest, ClientError<OCPP1_6Error>>

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_certificate_signed( &self, request: CertificateSignedRequest, ) -> Result<CertificateSignedResponse, ClientError<OCPP1_6Error>>

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, OCPP1_6Error>> + Send,

pub async fn wait_for_certificate_signed<F, FF>( &self, callback: F, ) -> Result<CertificateSignedRequest, ClientError<OCPP1_6Error>>

where F: FnMut(CertificateSignedRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<CertificateSignedResponse, 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,

pub async fn wait_for_change_availability<F, FF>( &self, callback: F, ) -> Result<ChangeAvailabilityRequest, ClientError<OCPP1_6Error>>

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,

pub async fn wait_for_change_configuration<F, FF>( &self, callback: F, ) -> Result<ChangeConfigurationRequest, ClientError<OCPP1_6Error>>

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,

pub async fn wait_for_clear_cache<F, FF>( &self, callback: F, ) -> Result<ClearCacheRequest, ClientError<OCPP1_6Error>>

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,

pub async fn wait_for_clear_charging_profile<F, FF>( &self, callback: F, ) -> Result<ClearChargingProfileRequest, ClientError<OCPP1_6Error>>

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,

pub async fn wait_for_data_transfer<F, FF>( &self, callback: F, ) -> Result<DataTransferRequest, ClientError<OCPP1_6Error>>

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_delete_certificate( &self, request: DeleteCertificateRequest, ) -> Result<DeleteCertificateResponse, ClientError<OCPP1_6Error>>

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, OCPP1_6Error>> + Send,

pub async fn wait_for_delete_certificate<F, FF>( &self, callback: F, ) -> Result<DeleteCertificateRequest, ClientError<OCPP1_6Error>>

where F: FnMut(DeleteCertificateRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<DeleteCertificateResponse, 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,

pub async fn wait_for_diagnostics_status_notification<F, FF>( &self, callback: F, ) -> Result<DiagnosticsStatusNotificationRequest, ClientError<OCPP1_6Error>>

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_extended_trigger_message( &self, request: ExtendedTriggerMessageRequest, ) -> Result<ExtendedTriggerMessageResponse, ClientError<OCPP1_6Error>>

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

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

pub async fn wait_for_extended_trigger_message<F, FF>( &self, callback: F, ) -> Result<ExtendedTriggerMessageRequest, ClientError<OCPP1_6Error>>

where F: FnMut(ExtendedTriggerMessageRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<ExtendedTriggerMessageResponse, 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,

pub async fn wait_for_firmware_status_notification<F, FF>( &self, callback: F, ) -> Result<FirmwareStatusNotificationRequest, ClientError<OCPP1_6Error>>

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,

pub async fn wait_for_get_composite_schedule<F, FF>( &self, callback: F, ) -> Result<GetCompositeScheduleRequest, ClientError<OCPP1_6Error>>

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,

pub async fn wait_for_get_configuration<F, FF>( &self, callback: F, ) -> Result<GetConfigurationRequest, ClientError<OCPP1_6Error>>

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,

pub async fn wait_for_get_diagnostics<F, FF>( &self, callback: F, ) -> Result<GetDiagnosticsRequest, ClientError<OCPP1_6Error>>

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_installed_certificate_ids( &self, request: GetInstalledCertificateIdsRequest, ) -> Result<GetInstalledCertificateIdsResponse, ClientError<OCPP1_6Error>>

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, OCPP1_6Error>> + Send,

pub async fn wait_for_get_installed_certificate_ids<F, FF>( &self, callback: F, ) -> Result<GetInstalledCertificateIdsRequest, ClientError<OCPP1_6Error>>

where F: FnMut(GetInstalledCertificateIdsRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetInstalledCertificateIdsResponse, 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,

pub async fn wait_for_get_local_list_version<F, FF>( &self, callback: F, ) -> Result<GetLocalListVersionRequest, ClientError<OCPP1_6Error>>

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_get_log( &self, request: GetLogRequest, ) -> Result<GetLogResponse, ClientError<OCPP1_6Error>>

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, OCPP1_6Error>> + Send,

pub async fn wait_for_get_log<F, FF>( &self, callback: F, ) -> Result<GetLogRequest, ClientError<OCPP1_6Error>>

where F: FnMut(GetLogRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<GetLogResponse, 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,

pub async fn wait_for_heartbeat<F, FF>( &self, callback: F, ) -> Result<HeartbeatRequest, ClientError<OCPP1_6Error>>

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_install_certificate( &self, request: InstallCertificateRequest, ) -> Result<InstallCertificateResponse, ClientError<OCPP1_6Error>>

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, OCPP1_6Error>> + Send,

pub async fn wait_for_install_certificate<F, FF>( &self, callback: F, ) -> Result<InstallCertificateRequest, ClientError<OCPP1_6Error>>

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

impl Client<OCPP1_6Error>

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

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, OCPP1_6Error>> + Send,

pub async fn wait_for_log_status_notification<F, FF>( &self, callback: F, ) -> Result<LogStatusNotificationRequest, ClientError<OCPP1_6Error>>

where F: FnMut(LogStatusNotificationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<LogStatusNotificationResponse, 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,

pub async fn wait_for_meter_values<F, FF>( &self, callback: F, ) -> Result<MeterValuesRequest, ClientError<OCPP1_6Error>>

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,

pub async fn wait_for_remote_start_transaction<F, FF>( &self, callback: F, ) -> Result<RemoteStartTransactionRequest, ClientError<OCPP1_6Error>>

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,

pub async fn wait_for_remote_stop_transaction<F, FF>( &self, callback: F, ) -> Result<RemoteStopTransactionRequest, ClientError<OCPP1_6Error>>

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,

pub async fn wait_for_reserve_now<F, FF>( &self, callback: F, ) -> Result<ReserveNowRequest, ClientError<OCPP1_6Error>>

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,

pub async fn wait_for_reset<F, FF>( &self, callback: F, ) -> Result<ResetRequest, ClientError<OCPP1_6Error>>

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_security_event_notification( &self, request: SecurityEventNotificationRequest, ) -> Result<SecurityEventNotificationResponse, ClientError<OCPP1_6Error>>

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, OCPP1_6Error>> + Send,

pub async fn wait_for_security_event_notification<F, FF>( &self, callback: F, ) -> Result<SecurityEventNotificationRequest, ClientError<OCPP1_6Error>>

where F: FnMut(SecurityEventNotificationRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SecurityEventNotificationResponse, 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,

pub async fn wait_for_send_local_list<F, FF>( &self, callback: F, ) -> Result<SendLocalListRequest, ClientError<OCPP1_6Error>>

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,

pub async fn wait_for_set_charging_profile<F, FF>( &self, callback: F, ) -> Result<SetChargingProfileRequest, ClientError<OCPP1_6Error>>

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_sign_certificate( &self, request: SignCertificateRequest, ) -> Result<SignCertificateResponse, ClientError<OCPP1_6Error>>

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, OCPP1_6Error>> + Send,

pub async fn wait_for_sign_certificate<F, FF>( &self, callback: F, ) -> Result<SignCertificateRequest, ClientError<OCPP1_6Error>>

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

impl Client<OCPP1_6Error>

pub async fn send_signed_firmware_status_notification( &self, request: SignedFirmwareStatusNotificationRequest, ) -> Result<SignedFirmwareStatusNotificationResponse, ClientError<OCPP1_6Error>>

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

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

pub async fn wait_for_signed_firmware_status_notification<F, FF>( &self, callback: F, ) -> Result<SignedFirmwareStatusNotificationRequest, ClientError<OCPP1_6Error>>

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

impl Client<OCPP1_6Error>

pub async fn send_signed_update_firmware( &self, request: SignedUpdateFirmwareRequest, ) -> Result<SignedUpdateFirmwareResponse, ClientError<OCPP1_6Error>>

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

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

pub async fn wait_for_signed_update_firmware<F, FF>( &self, callback: F, ) -> Result<SignedUpdateFirmwareRequest, ClientError<OCPP1_6Error>>

where F: FnMut(SignedUpdateFirmwareRequest, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<SignedUpdateFirmwareResponse, 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,

pub async fn wait_for_start_transaction<F, FF>( &self, callback: F, ) -> Result<StartTransactionRequest, ClientError<OCPP1_6Error>>

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,

pub async fn wait_for_status_notification<F, FF>( &self, callback: F, ) -> Result<StatusNotificationRequest, ClientError<OCPP1_6Error>>

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,

pub async fn wait_for_stop_transaction<F, FF>( &self, callback: F, ) -> Result<StopTransactionRequest, ClientError<OCPP1_6Error>>

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,

pub async fn wait_for_trigger_message<F, FF>( &self, callback: F, ) -> Result<TriggerMessageRequest, ClientError<OCPP1_6Error>>

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,

pub async fn wait_for_unlock_connector<F, FF>( &self, callback: F, ) -> Result<UnlockConnectorRequest, ClientError<OCPP1_6Error>>

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,

pub async fn wait_for_update_firmware<F, FF>( &self, callback: F, ) -> Result<UpdateFirmwareRequest, ClientError<OCPP1_6Error>>

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<CustomData>, ) -> Result<AuthorizeResponse<CustomData>, ClientError<OCPP2_0_1Error>>

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

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

pub async fn wait_for_authorize<F, FF>( &self, callback: F, ) -> Result<AuthorizeRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_boot_notification<F, FF>( &self, callback: F, ) -> Result<BootNotificationRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_cancel_reservation<F, FF>( &self, callback: F, ) -> Result<CancelReservationRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_certificate_signed<F, FF>( &self, callback: F, ) -> Result<CertificateSignedRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_change_availability<F, FF>( &self, callback: F, ) -> Result<ChangeAvailabilityRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_clear_cache<F, FF>( &self, callback: F, ) -> Result<ClearCacheRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_clear_charging_profile<F, FF>( &self, callback: F, ) -> Result<ClearChargingProfileRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_clear_display_message<F, FF>( &self, callback: F, ) -> Result<ClearDisplayMessageRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_clear_variable_monitoring<F, FF>( &self, callback: F, ) -> Result<ClearVariableMonitoringRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_cleared_charging_limit<F, FF>( &self, callback: F, ) -> Result<ClearedChargingLimitRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_cost_updated<F, FF>( &self, callback: F, ) -> Result<CostUpdatedRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_customer_information<F, FF>( &self, callback: F, ) -> Result<CustomerInformationRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_data_transfer<F, FF>( &self, callback: F, ) -> Result<DataTransferRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_delete_certificate<F, FF>( &self, callback: F, ) -> Result<DeleteCertificateRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_firmware_status_notification<F, FF>( &self, callback: F, ) -> Result<FirmwareStatusNotificationRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_get_15118_ev_certificate<F, FF>( &self, callback: F, ) -> Result<Get15118EVCertificateRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_get_base_report<F, FF>( &self, callback: F, ) -> Result<GetBaseReportRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_get_certificate_status<F, FF>( &self, callback: F, ) -> Result<GetCertificateStatusRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_get_charging_profiles<F, FF>( &self, callback: F, ) -> Result<GetChargingProfilesRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_get_composite_schedule<F, FF>( &self, callback: F, ) -> Result<GetCompositeScheduleRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_get_display_messages<F, FF>( &self, callback: F, ) -> Result<GetDisplayMessagesRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_get_installed_certificate_ids<F, FF>( &self, callback: F, ) -> Result<GetInstalledCertificateIdsRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_get_local_list_version<F, FF>( &self, callback: F, ) -> Result<GetLocalListVersionRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_get_log<F, FF>( &self, callback: F, ) -> Result<GetLogRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_get_monitoring_report<F, FF>( &self, callback: F, ) -> Result<GetMonitoringReportRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_get_report<F, FF>( &self, callback: F, ) -> Result<GetReportRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_get_transaction_status<F, FF>( &self, callback: F, ) -> Result<GetTransactionStatusRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_get_variables<F, FF>( &self, callback: F, ) -> Result<GetVariablesRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_heartbeat<F, FF>( &self, callback: F, ) -> Result<HeartbeatRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_install_certificate<F, FF>( &self, callback: F, ) -> Result<InstallCertificateRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_log_status_notification<F, FF>( &self, callback: F, ) -> Result<LogStatusNotificationRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_meter_values<F, FF>( &self, callback: F, ) -> Result<MeterValuesRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_notify_charging_limit<F, FF>( &self, callback: F, ) -> Result<NotifyChargingLimitRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_notify_customer_information<F, FF>( &self, callback: F, ) -> Result<NotifyCustomerInformationRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_notify_display_messages<F, FF>( &self, callback: F, ) -> Result<NotifyDisplayMessagesRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_notify_ev_charging_needs<F, FF>( &self, callback: F, ) -> Result<NotifyEVChargingNeedsRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_notify_ev_charging_schedule<F, FF>( &self, callback: F, ) -> Result<NotifyEVChargingScheduleRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_notify_event<F, FF>( &self, callback: F, ) -> Result<NotifyEventRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_notify_monitoring_report<F, FF>( &self, callback: F, ) -> Result<NotifyMonitoringReportRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_notify_report<F, FF>( &self, callback: F, ) -> Result<NotifyReportRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_publish_firmware<F, FF>( &self, callback: F, ) -> Result<PublishFirmwareRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_publish_firmware_status_notification<F, FF>( &self, callback: F, ) -> Result<PublishFirmwareStatusNotificationRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_report_charging_profiles<F, FF>( &self, callback: F, ) -> Result<ReportChargingProfilesRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_request_start_transaction<F, FF>( &self, callback: F, ) -> Result<RequestStartTransactionRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_request_stop_transaction<F, FF>( &self, callback: F, ) -> Result<RequestStopTransactionRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_reservation_status_update<F, FF>( &self, callback: F, ) -> Result<ReservationStatusUpdateRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_reserve_now<F, FF>( &self, callback: F, ) -> Result<ReserveNowRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_reset<F, FF>( &self, callback: F, ) -> Result<ResetRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_security_event_notification<F, FF>( &self, callback: F, ) -> Result<SecurityEventNotificationRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_send_local_list<F, FF>( &self, callback: F, ) -> Result<SendLocalListRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_set_charging_profile<F, FF>( &self, callback: F, ) -> Result<SetChargingProfileRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_set_display_message<F, FF>( &self, callback: F, ) -> Result<SetDisplayMessageRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_set_monitoring_base<F, FF>( &self, callback: F, ) -> Result<SetMonitoringBaseRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_set_monitoring_level<F, FF>( &self, callback: F, ) -> Result<SetMonitoringLevelRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_set_network_profile<F, FF>( &self, callback: F, ) -> Result<SetNetworkProfileRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_set_variable_monitoring<F, FF>( &self, callback: F, ) -> Result<SetVariableMonitoringRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_set_variables<F, FF>( &self, callback: F, ) -> Result<SetVariablesRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_sign_certificate<F, FF>( &self, callback: F, ) -> Result<SignCertificateRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_status_notification<F, FF>( &self, callback: F, ) -> Result<StatusNotificationRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_transaction_event<F, FF>( &self, callback: F, ) -> Result<TransactionEventRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_trigger_message<F, FF>( &self, callback: F, ) -> Result<TriggerMessageRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_unlock_connector<F, FF>( &self, callback: F, ) -> Result<UnlockConnectorRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_unpublish_firmware<F, FF>( &self, callback: F, ) -> Result<UnpublishFirmwareRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_0_1Error>

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

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

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

pub async fn wait_for_update_firmware<F, FF>( &self, callback: F, ) -> Result<UpdateFirmwareRequest<CustomData>, ClientError<OCPP2_0_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_adjust_periodic_event_stream<F, FF>( &self, callback: F, ) -> Result<AdjustPeriodicEventStreamRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_afrr_signal<F, FF>( &self, callback: F, ) -> Result<AFRRSignalRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_authorize<F, FF>( &self, callback: F, ) -> Result<AuthorizeRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_battery_swap<F, FF>( &self, callback: F, ) -> Result<BatterySwapRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_boot_notification<F, FF>( &self, callback: F, ) -> Result<BootNotificationRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_cancel_reservation<F, FF>( &self, callback: F, ) -> Result<CancelReservationRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_certificate_signed<F, FF>( &self, callback: F, ) -> Result<CertificateSignedRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_change_availability<F, FF>( &self, callback: F, ) -> Result<ChangeAvailabilityRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_change_transaction_tariff<F, FF>( &self, callback: F, ) -> Result<ChangeTransactionTariffRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_clear_cache<F, FF>( &self, callback: F, ) -> Result<ClearCacheRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_clear_charging_profile<F, FF>( &self, callback: F, ) -> Result<ClearChargingProfileRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_clear_der_control<F, FF>( &self, callback: F, ) -> Result<ClearDERControlRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_clear_display_message<F, FF>( &self, callback: F, ) -> Result<ClearDisplayMessageRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_clear_tariffs<F, FF>( &self, callback: F, ) -> Result<ClearTariffsRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_clear_variable_monitoring<F, FF>( &self, callback: F, ) -> Result<ClearVariableMonitoringRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_cleared_charging_limit<F, FF>( &self, callback: F, ) -> Result<ClearedChargingLimitRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_close_periodic_event_stream<F, FF>( &self, callback: F, ) -> Result<ClosePeriodicEventStreamRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_cost_updated<F, FF>( &self, callback: F, ) -> Result<CostUpdatedRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_customer_information<F, FF>( &self, callback: F, ) -> Result<CustomerInformationRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_data_transfer<F, FF>( &self, callback: F, ) -> Result<DataTransferRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_delete_certificate<F, FF>( &self, callback: F, ) -> Result<DeleteCertificateRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_firmware_status_notification<F, FF>( &self, callback: F, ) -> Result<FirmwareStatusNotificationRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_get_15118_ev_certificate<F, FF>( &self, callback: F, ) -> Result<Get15118EVCertificateRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_get_base_report<F, FF>( &self, callback: F, ) -> Result<GetBaseReportRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_get_certificate_chain_status<F, FF>( &self, callback: F, ) -> Result<GetCertificateChainStatusRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_get_certificate_status<F, FF>( &self, callback: F, ) -> Result<GetCertificateStatusRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_get_charging_profiles<F, FF>( &self, callback: F, ) -> Result<GetChargingProfilesRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_get_composite_schedule<F, FF>( &self, callback: F, ) -> Result<GetCompositeScheduleRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_get_der_control<F, FF>( &self, callback: F, ) -> Result<GetDERControlRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_get_display_messages<F, FF>( &self, callback: F, ) -> Result<GetDisplayMessagesRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_get_installed_certificate_ids<F, FF>( &self, callback: F, ) -> Result<GetInstalledCertificateIdsRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_get_local_list_version<F, FF>( &self, callback: F, ) -> Result<GetLocalListVersionRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_get_log<F, FF>( &self, callback: F, ) -> Result<GetLogRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_get_monitoring_report<F, FF>( &self, callback: F, ) -> Result<GetMonitoringReportRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_get_periodic_event_stream<F, FF>( &self, callback: F, ) -> Result<GetPeriodicEventStreamRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_get_report<F, FF>( &self, callback: F, ) -> Result<GetReportRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_get_tariffs<F, FF>( &self, callback: F, ) -> Result<GetTariffsRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_get_transaction_status<F, FF>( &self, callback: F, ) -> Result<GetTransactionStatusRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_get_variables<F, FF>( &self, callback: F, ) -> Result<GetVariablesRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_heartbeat<F, FF>( &self, callback: F, ) -> Result<HeartbeatRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_install_certificate<F, FF>( &self, callback: F, ) -> Result<InstallCertificateRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_log_status_notification<F, FF>( &self, callback: F, ) -> Result<LogStatusNotificationRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_meter_values<F, FF>( &self, callback: F, ) -> Result<MeterValuesRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_notify_allowed_energy_transfer<F, FF>( &self, callback: F, ) -> Result<NotifyAllowedEnergyTransferRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_notify_charging_limit<F, FF>( &self, callback: F, ) -> Result<NotifyChargingLimitRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_notify_customer_information<F, FF>( &self, callback: F, ) -> Result<NotifyCustomerInformationRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_notify_der_alarm<F, FF>( &self, callback: F, ) -> Result<NotifyDERAlarmRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_notify_der_start_stop<F, FF>( &self, callback: F, ) -> Result<NotifyDERStartStopRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_notify_display_messages<F, FF>( &self, callback: F, ) -> Result<NotifyDisplayMessagesRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_notify_ev_charging_needs<F, FF>( &self, callback: F, ) -> Result<NotifyEVChargingNeedsRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_notify_ev_charging_schedule<F, FF>( &self, callback: F, ) -> Result<NotifyEVChargingScheduleRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_notify_event<F, FF>( &self, callback: F, ) -> Result<NotifyEventRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_notify_monitoring_report<F, FF>( &self, callback: F, ) -> Result<NotifyMonitoringReportRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_notify_report<F, FF>( &self, callback: F, ) -> Result<NotifyReportRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_notify_priority_charging<F, FF>( &self, callback: F, ) -> Result<NotifyPriorityChargingRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_notify_settlement<F, FF>( &self, callback: F, ) -> Result<NotifySettlementRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_notify_web_payment_started<F, FF>( &self, callback: F, ) -> Result<NotifyWebPaymentStartedRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_open_periodic_event_stream<F, FF>( &self, callback: F, ) -> Result<OpenPeriodicEventStreamRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_publish_firmware<F, FF>( &self, callback: F, ) -> Result<PublishFirmwareRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_publish_firmware_status_notification<F, FF>( &self, callback: F, ) -> Result<PublishFirmwareStatusNotificationRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_pull_dynamic_schedule_update<F, FF>( &self, callback: F, ) -> Result<PullDynamicScheduleUpdateRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_report_charging_profiles<F, FF>( &self, callback: F, ) -> Result<ReportChargingProfilesRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_report_der_control<F, FF>( &self, callback: F, ) -> Result<ReportDERControlRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_request_battery_swap<F, FF>( &self, callback: F, ) -> Result<RequestBatterySwapRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_request_start_transaction<F, FF>( &self, callback: F, ) -> Result<RequestStartTransactionRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_request_stop_transaction<F, FF>( &self, callback: F, ) -> Result<RequestStopTransactionRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_reservation_status_update<F, FF>( &self, callback: F, ) -> Result<ReservationStatusUpdateRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_reserve_now<F, FF>( &self, callback: F, ) -> Result<ReserveNowRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_reset<F, FF>( &self, callback: F, ) -> Result<ResetRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_security_event_notification<F, FF>( &self, callback: F, ) -> Result<SecurityEventNotificationRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_send_local_list<F, FF>( &self, callback: F, ) -> Result<SendLocalListRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_set_charging_profile<F, FF>( &self, callback: F, ) -> Result<SetChargingProfileRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_set_default_tariff<F, FF>( &self, callback: F, ) -> Result<SetDefaultTariffRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_set_der_control<F, FF>( &self, callback: F, ) -> Result<SetDERControlRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_set_display_message<F, FF>( &self, callback: F, ) -> Result<SetDisplayMessageRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_set_monitoring_base<F, FF>( &self, callback: F, ) -> Result<SetMonitoringBaseRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_set_monitoring_level<F, FF>( &self, callback: F, ) -> Result<SetMonitoringLevelRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_set_network_profile<F, FF>( &self, callback: F, ) -> Result<SetNetworkProfileRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_set_variable_monitoring<F, FF>( &self, callback: F, ) -> Result<SetVariableMonitoringRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_set_variables<F, FF>( &self, callback: F, ) -> Result<SetVariablesRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_sign_certificate<F, FF>( &self, callback: F, ) -> Result<SignCertificateRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_status_notification<F, FF>( &self, callback: F, ) -> Result<StatusNotificationRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_transaction_event<F, FF>( &self, callback: F, ) -> Result<TransactionEventRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_trigger_message<F, FF>( &self, callback: F, ) -> Result<TriggerMessageRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_unlock_connector<F, FF>( &self, callback: F, ) -> Result<UnlockConnectorRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_unpublish_firmware<F, FF>( &self, callback: F, ) -> Result<UnpublishFirmwareRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_update_dynamic_schedule<F, FF>( &self, callback: F, ) -> Result<UpdateDynamicScheduleRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_update_firmware<F, FF>( &self, callback: F, ) -> Result<UpdateFirmwareRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_use_priority_charging<F, FF>( &self, callback: F, ) -> Result<UsePriorityChargingRequest<CustomData>, ClientError<OCPP2_1Error>>

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

impl Client<OCPP2_1Error>

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

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

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

pub async fn wait_for_vat_number_validation<F, FF>( &self, callback: F, ) -> Result<VatNumberValidationRequest<CustomData>, ClientError<OCPP2_1Error>>

where F: FnMut(VatNumberValidationRequest<CustomData>, Self) -> FF + Send + Sync + 'static, FF: Future<Output = Result<VatNumberValidationResponse<CustomData>, 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.