Struct epp_proxy::grpc::epp_proto::epp_proxy_client::EppProxyClient

pub struct EppProxyClient<T> { /* private fields */ }

Implementations

impl EppProxyClient<Channel>

pub async fn connect<D>(dst: D) -> Result<Self, Error> where
    D: TryInto<Endpoint>,
    D::Error: Into<StdError>, 

Attempt to create a new client by connecting to a given endpoint.

impl<T> EppProxyClient<T> where
    T: GrpcService<BoxBody>,
    T::ResponseBody: Body + Send + 'static,
    T::Error: Into<StdError>,
    <T::ResponseBody as Body>::Error: Into<StdError> + Send, 

pub fn new(inner: T) -> Self

pub fn with_interceptor<F>(
    inner: T,
    interceptor: F
) -> EppProxyClient<InterceptedService<T, F>> where
    F: Interceptor,
    T: Service<Request<BoxBody>, Response = Response<<T as GrpcService<BoxBody>>::ResponseBody>>,
    <T as Service<Request<BoxBody>>>::Error: Into<StdError> + Send + Sync, 

pub fn send_gzip(self) -> Self

Compress requests with gzip.

This requires the server to support it otherwise it might respond with an error.

pub fn accept_gzip(self) -> Self

Enable decompressing responses with gzip.

pub async fn domain_check(
    &mut self,
    request: impl IntoRequest<DomainCheckRequest>
) -> Result<Response<DomainCheckReply>, Status>

pub async fn domain_claims_check(
    &mut self,
    request: impl IntoRequest<DomainClaimsCheckRequest>
) -> Result<Response<DomainClaimsCheckReply>, Status>

pub async fn domain_trademark_check(
    &mut self,
    request: impl IntoRequest<DomainTrademarkCheckRequest>
) -> Result<Response<DomainClaimsCheckReply>, Status>

pub async fn domain_info(
    &mut self,
    request: impl IntoRequest<DomainInfoRequest>
) -> Result<Response<DomainInfoReply>, Status>

pub async fn domain_create(
    &mut self,
    request: impl IntoRequest<DomainCreateRequest>
) -> Result<Response<DomainCreateReply>, Status>

pub async fn domain_delete(
    &mut self,
    request: impl IntoRequest<DomainDeleteRequest>
) -> Result<Response<DomainDeleteReply>, Status>

pub async fn domain_update(
    &mut self,
    request: impl IntoRequest<DomainUpdateRequest>
) -> Result<Response<DomainUpdateReply>, Status>

pub async fn domain_renew(
    &mut self,
    request: impl IntoRequest<DomainRenewRequest>
) -> Result<Response<DomainRenewReply>, Status>

pub async fn domain_transfer_query(
    &mut self,
    request: impl IntoRequest<DomainTransferQueryRequest>
) -> Result<Response<DomainTransferReply>, Status>

pub async fn domain_transfer_request(
    &mut self,
    request: impl IntoRequest<DomainTransferRequestRequest>
) -> Result<Response<DomainTransferReply>, Status>

pub async fn domain_transfer_cancel(
    &mut self,
    request: impl IntoRequest<DomainTransferAcceptRejectRequest>
) -> Result<Response<DomainTransferReply>, Status>

pub async fn domain_transfer_accept(
    &mut self,
    request: impl IntoRequest<DomainTransferAcceptRejectRequest>
) -> Result<Response<DomainTransferReply>, Status>

pub async fn domain_transfer_reject(
    &mut self,
    request: impl IntoRequest<DomainTransferAcceptRejectRequest>
) -> Result<Response<DomainTransferReply>, Status>

pub async fn domain_restore_request(
    &mut self,
    request: impl IntoRequest<RequestRequest>
) -> Result<Response<RestoreReply>, Status>

pub async fn domain_sync(
    &mut self,
    request: impl IntoRequest<DomainSyncRequest>
) -> Result<Response<DomainUpdateReply>, Status>

pub async fn host_check(
    &mut self,
    request: impl IntoRequest<HostCheckRequest>
) -> Result<Response<HostCheckReply>, Status>

pub async fn host_info(
    &mut self,
    request: impl IntoRequest<HostInfoRequest>
) -> Result<Response<HostInfoReply>, Status>

pub async fn host_create(
    &mut self,
    request: impl IntoRequest<HostCreateRequest>
) -> Result<Response<HostCreateReply>, Status>

pub async fn host_delete(
    &mut self,
    request: impl IntoRequest<HostDeleteRequest>
) -> Result<Response<HostDeleteReply>, Status>

pub async fn host_update(
    &mut self,
    request: impl IntoRequest<HostUpdateRequest>
) -> Result<Response<HostUpdateReply>, Status>

pub async fn contact_check(
    &mut self,
    request: impl IntoRequest<ContactCheckRequest>
) -> Result<Response<ContactCheckReply>, Status>

pub async fn contact_info(
    &mut self,
    request: impl IntoRequest<ContactInfoRequest>
) -> Result<Response<ContactInfoReply>, Status>

pub async fn contact_create(
    &mut self,
    request: impl IntoRequest<ContactCreateRequest>
) -> Result<Response<ContactCreateReply>, Status>

pub async fn contact_delete(
    &mut self,
    request: impl IntoRequest<ContactDeleteRequest>
) -> Result<Response<ContactDeleteReply>, Status>

pub async fn contact_update(
    &mut self,
    request: impl IntoRequest<ContactUpdateRequest>
) -> Result<Response<ContactUpdateReply>, Status>

pub async fn contact_transfer_query(
    &mut self,
    request: impl IntoRequest<ContactTransferQueryRequest>
) -> Result<Response<ContactTransferReply>, Status>

pub async fn contact_transfer_request(
    &mut self,
    request: impl IntoRequest<ContactTransferRequestRequest>
) -> Result<Response<ContactTransferReply>, Status>

pub async fn contact_transfer_accept(
    &mut self,
    request: impl IntoRequest<ContactTransferRequestRequest>
) -> Result<Response<ContactTransferReply>, Status>

pub async fn contact_transfer_reject(
    &mut self,
    request: impl IntoRequest<ContactTransferRequestRequest>
) -> Result<Response<ContactTransferReply>, Status>

pub async fn maintenance_list(
    &mut self,
    request: impl IntoRequest<RegistryInfo>
) -> Result<Response<MaintenanceListReply>, Status>

pub async fn maintenance_info(
    &mut self,
    request: impl IntoRequest<MaintenanceInfoRequest>
) -> Result<Response<MaintenanceInfoReply>, Status>

pub async fn poll(
    &mut self,
    request: impl IntoStreamingRequest<Message = PollAck>
) -> Result<Response<Streaming<PollReply>>, Status>

pub async fn nominet_tag_list(
    &mut self,
    request: impl IntoRequest<RegistryInfo>
) -> Result<Response<NominetTagListReply>, Status>

pub async fn nominet_accept(
    &mut self,
    request: impl IntoRequest<HandshakeAcceptRequest>
) -> Result<Response<HandshakeReply>, Status>

pub async fn nominet_reject(
    &mut self,
    request: impl IntoRequest<HandshakeRejectRequest>
) -> Result<Response<HandshakeReply>, Status>

pub async fn nominet_release(
    &mut self,
    request: impl IntoRequest<ReleaseRequest>
) -> Result<Response<ReleaseReply>, Status>

pub async fn nominet_contact_validate(
    &mut self,
    request: impl IntoRequest<ContactValidateRequest>
) -> Result<Response<ContactValidateReply>, Status>

pub async fn nominet_lock(
    &mut self,
    request: impl IntoRequest<LockRequest>
) -> Result<Response<LockReply>, Status>

pub async fn nominet_unlock(
    &mut self,
    request: impl IntoRequest<LockRequest>
) -> Result<Response<LockReply>, Status>

pub async fn balance_info(
    &mut self,
    request: impl IntoRequest<RegistryInfo>
) -> Result<Response<BalanceReply>, Status>

pub async fn hit_points_info(
    &mut self,
    request: impl IntoRequest<RegistryInfo>
) -> Result<Response<HitPointsReply>, Status>

pub async fn registration_limit_info(
    &mut self,
    request: impl IntoRequest<RegistryInfo>
) -> Result<Response<RegistrationLimitReply>, Status>

pub async fn dns_quality_info(
    &mut self,
    request: impl IntoRequest<DnsQualityRequest>
) -> Result<Response<DnsQualityReply>, Status>

pub async fn dnssec_eligibility_info(
    &mut self,
    request: impl IntoRequest<DnssecEligibilityRequest>
) -> Result<Response<DnssecEligibilityReply>, Status>

pub async fn tmch_mark_check(
    &mut self,
    request: impl IntoRequest<MarkCheckRequest>
) -> Result<Response<MarkCheckResponse>, Status>

pub async fn tmch_mark_create(
    &mut self,
    request: impl IntoRequest<MarkCreateRequest>
) -> Result<Response<MarkCreateResponse>, Status>

pub async fn tmch_mark_info(
    &mut self,
    request: impl IntoRequest<MarkInfoRequest>
) -> Result<Response<MarkInfoResponse>, Status>

pub async fn tmch_mark_smd_info(
    &mut self,
    request: impl IntoRequest<MarkInfoRequest>
) -> Result<Response<MarkSmdInfoResponse>, Status>

pub async fn tmch_mark_encoded_smd_info(
    &mut self,
    request: impl IntoRequest<MarkInfoRequest>
) -> Result<Response<MarkSmdInfoResponse>, Status>

pub async fn tmch_mark_file_info(
    &mut self,
    request: impl IntoRequest<MarkInfoRequest>
) -> Result<Response<MarkSmdInfoResponse>, Status>

pub async fn tmch_mark_update(
    &mut self,
    request: impl IntoRequest<MarkUpdateRequest>
) -> Result<Response<MarkUpdateResponse>, Status>

pub async fn tmch_mark_renew(
    &mut self,
    request: impl IntoRequest<MarkRenewRequest>
) -> Result<Response<MarkRenewResponse>, Status>

pub async fn tmch_mark_transfer_initiate(
    &mut self,
    request: impl IntoRequest<MarkTransferInitiateRequest>
) -> Result<Response<MarkTransferInitiateResponse>, Status>

pub async fn tmch_mark_transfer(
    &mut self,
    request: impl IntoRequest<MarkTransferRequest>
) -> Result<Response<MarkTransferResponse>, Status>

pub async fn dac_domain(
    &mut self,
    request: impl IntoRequest<DomainRequest>
) -> Result<Response<DomainResponse>, Status>

pub async fn dac_usage(
    &mut self,
    request: impl IntoRequest<UsageRequest>
) -> Result<Response<UsageResponse>, Status>

pub async fn dac_limits(
    &mut self,
    request: impl IntoRequest<UsageRequest>
) -> Result<Response<UsageResponse>, Status>

Trait Implementations

impl<T: Clone> Clone for EppProxyClient<T>

fn clone(&self) -> EppProxyClient<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for EppProxyClient<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.