zz_gen_client.go

// Code generated by gen/gen_test.go DO NOT EDIT.

package namesilo

import (
	"context"
)

// AddAccountFunds Execute operation addAccountFunds.
func (c *Client) AddAccountFunds(ctx context.Context, params *AddAccountFundsParams) (*AddAccountFunds, error) {
	op := &AddAccountFunds{}

	err := c.do(ctx, "addAccountFunds", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// AddAutoRenewal Execute operation addAutoRenewal.
func (c *Client) AddAutoRenewal(ctx context.Context, params *AddAutoRenewalParams) (*AddAutoRenewal, error) {
	op := &AddAutoRenewal{}

	err := c.do(ctx, "addAutoRenewal", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// AddPrivacy Execute operation addPrivacy.
func (c *Client) AddPrivacy(ctx context.Context, params *AddPrivacyParams) (*AddPrivacy, error) {
	op := &AddPrivacy{}

	err := c.do(ctx, "addPrivacy", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// AddRegisteredNameServer Execute operation addRegisteredNameServer.
func (c *Client) AddRegisteredNameServer(ctx context.Context, params *AddRegisteredNameServerParams) (*AddRegisteredNameServer, error) {
	op := &AddRegisteredNameServer{}

	err := c.do(ctx, "addRegisteredNameServer", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// BidAuction Execute operation bidAuction.
func (c *Client) BidAuction(ctx context.Context, params *BidAuctionParams) (*BidAuction, error) {
	op := &BidAuction{}

	err := c.do(ctx, "bidAuction", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// BuyNowAuction Execute operation buyNowAuction.
func (c *Client) BuyNowAuction(ctx context.Context, params *BuyNowAuctionParams) (*BuyNowAuction, error) {
	op := &BuyNowAuction{}

	err := c.do(ctx, "buyNowAuction", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// ChangeNameServers Execute operation changeNameServers.
func (c *Client) ChangeNameServers(ctx context.Context, params *ChangeNameServersParams) (*ChangeNameServers, error) {
	op := &ChangeNameServers{}

	err := c.do(ctx, "changeNameServers", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// CheckRegisterAvailability Execute operation checkRegisterAvailability.
func (c *Client) CheckRegisterAvailability(ctx context.Context, params *CheckRegisterAvailabilityParams) (*CheckRegisterAvailability, error) {
	op := &CheckRegisterAvailability{}

	err := c.do(ctx, "checkRegisterAvailability", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// CheckTransferAvailability Execute operation checkTransferAvailability.
func (c *Client) CheckTransferAvailability(ctx context.Context, params *CheckTransferAvailabilityParams) (*CheckTransferAvailability, error) {
	op := &CheckTransferAvailability{}

	err := c.do(ctx, "checkTransferAvailability", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// CheckTransferStatus Execute operation checkTransferStatus.
func (c *Client) CheckTransferStatus(ctx context.Context, params *CheckTransferStatusParams) (*CheckTransferStatus, error) {
	op := &CheckTransferStatus{}

	err := c.do(ctx, "checkTransferStatus", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// ConfigureEmailForward Execute operation configureEmailForward.
func (c *Client) ConfigureEmailForward(ctx context.Context, params *ConfigureEmailForwardParams) (*ConfigureEmailForward, error) {
	op := &ConfigureEmailForward{}

	err := c.do(ctx, "configureEmailForward", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// ContactAdd Execute operation contactAdd.
func (c *Client) ContactAdd(ctx context.Context, params *ContactAddParams) (*ContactAdd, error) {
	op := &ContactAdd{}

	err := c.do(ctx, "contactAdd", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// ContactDelete Execute operation contactDelete.
func (c *Client) ContactDelete(ctx context.Context, params *ContactDeleteParams) (*ContactDelete, error) {
	op := &ContactDelete{}

	err := c.do(ctx, "contactDelete", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// ContactDomainAssociate Execute operation contactDomainAssociate.
func (c *Client) ContactDomainAssociate(ctx context.Context, params *ContactDomainAssociateParams) (*ContactDomainAssociate, error) {
	op := &ContactDomainAssociate{}

	err := c.do(ctx, "contactDomainAssociate", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// ContactList Execute operation contactList.
func (c *Client) ContactList(ctx context.Context, params *ContactListParams) (*ContactList, error) {
	op := &ContactList{}

	err := c.do(ctx, "contactList", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// ContactUpdate Execute operation contactUpdate.
func (c *Client) ContactUpdate(ctx context.Context, params *ContactUpdateParams) (*ContactUpdate, error) {
	op := &ContactUpdate{}

	err := c.do(ctx, "contactUpdate", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// CountExpiringDomains Execute operation countExpiringDomains.
func (c *Client) CountExpiringDomains(ctx context.Context, params *CountExpiringDomainsParams) (*CountExpiringDomains, error) {
	op := &CountExpiringDomains{}

	err := c.do(ctx, "countExpiringDomains", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// DeleteEmailForward Execute operation deleteEmailForward.
func (c *Client) DeleteEmailForward(ctx context.Context, params *DeleteEmailForwardParams) (*DeleteEmailForward, error) {
	op := &DeleteEmailForward{}

	err := c.do(ctx, "deleteEmailForward", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// DeleteRegisteredNameServer Execute operation deleteRegisteredNameServer.
func (c *Client) DeleteRegisteredNameServer(ctx context.Context, params *DeleteRegisteredNameServerParams) (*DeleteRegisteredNameServer, error) {
	op := &DeleteRegisteredNameServer{}

	err := c.do(ctx, "deleteRegisteredNameServer", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// DnsAddRecord Execute operation dnsAddRecord.
func (c *Client) DnsAddRecord(ctx context.Context, params *DnsAddRecordParams) (*DnsAddRecord, error) {
	op := &DnsAddRecord{}

	err := c.do(ctx, "dnsAddRecord", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// DnsDeleteRecord Execute operation dnsDeleteRecord.
func (c *Client) DnsDeleteRecord(ctx context.Context, params *DnsDeleteRecordParams) (*DnsDeleteRecord, error) {
	op := &DnsDeleteRecord{}

	err := c.do(ctx, "dnsDeleteRecord", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// DnsListRecords Execute operation dnsListRecords.
func (c *Client) DnsListRecords(ctx context.Context, params *DnsListRecordsParams) (*DnsListRecords, error) {
	op := &DnsListRecords{}

	err := c.do(ctx, "dnsListRecords", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// DnsSecAddRecord Execute operation dnsSecAddRecord.
func (c *Client) DnsSecAddRecord(ctx context.Context, params *DnsSecAddRecordParams) (*DnsSecAddRecord, error) {
	op := &DnsSecAddRecord{}

	err := c.do(ctx, "dnsSecAddRecord", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// DnsSecDeleteRecord Execute operation dnsSecDeleteRecord.
func (c *Client) DnsSecDeleteRecord(ctx context.Context, params *DnsSecDeleteRecordParams) (*DnsSecDeleteRecord, error) {
	op := &DnsSecDeleteRecord{}

	err := c.do(ctx, "dnsSecDeleteRecord", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// DnsSecListRecords Execute operation dnsSecListRecords.
func (c *Client) DnsSecListRecords(ctx context.Context, params *DnsSecListRecordsParams) (*DnsSecListRecords, error) {
	op := &DnsSecListRecords{}

	err := c.do(ctx, "dnsSecListRecords", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// DnsUpdateRecord Execute operation dnsUpdateRecord.
func (c *Client) DnsUpdateRecord(ctx context.Context, params *DnsUpdateRecordParams) (*DnsUpdateRecord, error) {
	op := &DnsUpdateRecord{}

	err := c.do(ctx, "dnsUpdateRecord", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// DomainForward Execute operation domainForward.
func (c *Client) DomainForward(ctx context.Context, params *DomainForwardParams) (*DomainForward, error) {
	op := &DomainForward{}

	err := c.do(ctx, "domainForward", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// DomainForwardSubDomain Execute operation domainForwardSubDomain.
func (c *Client) DomainForwardSubDomain(ctx context.Context, params *DomainForwardSubDomainParams) (*DomainForwardSubDomain, error) {
	op := &DomainForwardSubDomain{}

	err := c.do(ctx, "domainForwardSubDomain", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// DomainForwardSubDomainDelete Execute operation domainForwardSubDomainDelete.
func (c *Client) DomainForwardSubDomainDelete(ctx context.Context, params *DomainForwardSubDomainDeleteParams) (*DomainForwardSubDomainDelete, error) {
	op := &DomainForwardSubDomainDelete{}

	err := c.do(ctx, "domainForwardSubDomainDelete", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// DomainLock Execute operation domainLock.
func (c *Client) DomainLock(ctx context.Context, params *DomainLockParams) (*DomainLock, error) {
	op := &DomainLock{}

	err := c.do(ctx, "domainLock", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// DomainPush Execute operation domainPush.
func (c *Client) DomainPush(ctx context.Context, params *DomainPushParams) (*DomainPush, error) {
	op := &DomainPush{}

	err := c.do(ctx, "domainPush", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// DomainUnlock Execute operation domainUnlock.
func (c *Client) DomainUnlock(ctx context.Context, params *DomainUnlockParams) (*DomainUnlock, error) {
	op := &DomainUnlock{}

	err := c.do(ctx, "domainUnlock", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// EmailVerification Execute operation emailVerification.
func (c *Client) EmailVerification(ctx context.Context, params *EmailVerificationParams) (*EmailVerification, error) {
	op := &EmailVerification{}

	err := c.do(ctx, "emailVerification", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// GetAccountBalance Execute operation getAccountBalance.
func (c *Client) GetAccountBalance(ctx context.Context, params *GetAccountBalanceParams) (*GetAccountBalance, error) {
	op := &GetAccountBalance{}

	err := c.do(ctx, "getAccountBalance", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// GetDomainInfo Execute operation getDomainInfo.
func (c *Client) GetDomainInfo(ctx context.Context, params *GetDomainInfoParams) (*GetDomainInfo, error) {
	op := &GetDomainInfo{}

	err := c.do(ctx, "getDomainInfo", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// GetPrices Execute operation getPrices.
func (c *Client) GetPrices(ctx context.Context, params *GetPricesParams) (*GetPrices, error) {
	op := &GetPrices{}

	err := c.do(ctx, "getPrices", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// ListAuctions Execute operation listAuctions.
func (c *Client) ListAuctions(ctx context.Context, params *ListAuctionsParams) (*ListAuctions, error) {
	op := &ListAuctions{}

	err := c.do(ctx, "listAuctions", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// ListDomains Execute operation listDomains.
func (c *Client) ListDomains(ctx context.Context, params *ListDomainsParams) (*ListDomains, error) {
	op := &ListDomains{}

	err := c.do(ctx, "listDomains", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// ListEmailForwards Execute operation listEmailForwards.
func (c *Client) ListEmailForwards(ctx context.Context, params *ListEmailForwardsParams) (*ListEmailForwards, error) {
	op := &ListEmailForwards{}

	err := c.do(ctx, "listEmailForwards", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// ListExpiringDomains Execute operation listExpiringDomains.
func (c *Client) ListExpiringDomains(ctx context.Context, params *ListExpiringDomainsParams) (*ListExpiringDomains, error) {
	op := &ListExpiringDomains{}

	err := c.do(ctx, "listExpiringDomains", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// ListOrders Execute operation listOrders.
func (c *Client) ListOrders(ctx context.Context, params *ListOrdersParams) (*ListOrders, error) {
	op := &ListOrders{}

	err := c.do(ctx, "listOrders", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// ListRegisteredNameServers Execute operation listRegisteredNameServers.
func (c *Client) ListRegisteredNameServers(ctx context.Context, params *ListRegisteredNameServersParams) (*ListRegisteredNameServers, error) {
	op := &ListRegisteredNameServers{}

	err := c.do(ctx, "listRegisteredNameServers", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// MarketplaceActiveSalesOverview Execute operation marketplaceActiveSalesOverview.
func (c *Client) MarketplaceActiveSalesOverview(ctx context.Context, params *MarketplaceActiveSalesOverviewParams) (*MarketplaceActiveSalesOverview, error) {
	op := &MarketplaceActiveSalesOverview{}

	err := c.do(ctx, "marketplaceActiveSalesOverview", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// MarketplaceAddOrModifySale Execute operation marketplaceAddOrModifySale.
func (c *Client) MarketplaceAddOrModifySale(ctx context.Context, params *MarketplaceAddOrModifySaleParams) (*MarketplaceAddOrModifySale, error) {
	op := &MarketplaceAddOrModifySale{}

	err := c.do(ctx, "marketplaceAddOrModifySale", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// MarketplaceLandingPageUpdate Execute operation marketplaceLandingPageUpdate.
func (c *Client) MarketplaceLandingPageUpdate(ctx context.Context, params *MarketplaceLandingPageUpdateParams) (*MarketplaceLandingPageUpdate, error) {
	op := &MarketplaceLandingPageUpdate{}

	err := c.do(ctx, "marketplaceLandingPageUpdate", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// ModifyRegisteredNameServer Execute operation modifyRegisteredNameServer.
func (c *Client) ModifyRegisteredNameServer(ctx context.Context, params *ModifyRegisteredNameServerParams) (*ModifyRegisteredNameServer, error) {
	op := &ModifyRegisteredNameServer{}

	err := c.do(ctx, "modifyRegisteredNameServer", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// OrderDetails Execute operation orderDetails.
func (c *Client) OrderDetails(ctx context.Context, params *OrderDetailsParams) (*OrderDetails, error) {
	op := &OrderDetails{}

	err := c.do(ctx, "orderDetails", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// PortfolioAdd Execute operation portfolioAdd.
func (c *Client) PortfolioAdd(ctx context.Context, params *PortfolioAddParams) (*PortfolioAdd, error) {
	op := &PortfolioAdd{}

	err := c.do(ctx, "portfolioAdd", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// PortfolioDelete Execute operation portfolioDelete.
func (c *Client) PortfolioDelete(ctx context.Context, params *PortfolioDeleteParams) (*PortfolioDelete, error) {
	op := &PortfolioDelete{}

	err := c.do(ctx, "portfolioDelete", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// PortfolioDomainAssociate Execute operation portfolioDomainAssociate.
func (c *Client) PortfolioDomainAssociate(ctx context.Context, params *PortfolioDomainAssociateParams) (*PortfolioDomainAssociate, error) {
	op := &PortfolioDomainAssociate{}

	err := c.do(ctx, "portfolioDomainAssociate", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// PortfolioList Execute operation portfolioList.
func (c *Client) PortfolioList(ctx context.Context, params *PortfolioListParams) (*PortfolioList, error) {
	op := &PortfolioList{}

	err := c.do(ctx, "portfolioList", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// RegisterDomain Execute operation registerDomain.
func (c *Client) RegisterDomain(ctx context.Context, params *RegisterDomainParams) (*RegisterDomain, error) {
	op := &RegisterDomain{}

	err := c.do(ctx, "registerDomain", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// RegisterDomainDrop Execute operation registerDomainDrop.
func (c *Client) RegisterDomainDrop(ctx context.Context, params *RegisterDomainDropParams) (*RegisterDomainDrop, error) {
	op := &RegisterDomainDrop{}

	err := c.do(ctx, "registerDomainDrop", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// RegistrantVerificationStatus Execute operation registrantVerificationStatus.
func (c *Client) RegistrantVerificationStatus(ctx context.Context, params *RegistrantVerificationStatusParams) (*RegistrantVerificationStatus, error) {
	op := &RegistrantVerificationStatus{}

	err := c.do(ctx, "registrantVerificationStatus", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// RemoveAutoRenewal Execute operation removeAutoRenewal.
func (c *Client) RemoveAutoRenewal(ctx context.Context, params *RemoveAutoRenewalParams) (*RemoveAutoRenewal, error) {
	op := &RemoveAutoRenewal{}

	err := c.do(ctx, "removeAutoRenewal", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// RemovePrivacy Execute operation removePrivacy.
func (c *Client) RemovePrivacy(ctx context.Context, params *RemovePrivacyParams) (*RemovePrivacy, error) {
	op := &RemovePrivacy{}

	err := c.do(ctx, "removePrivacy", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// RenewDomain Execute operation renewDomain.
func (c *Client) RenewDomain(ctx context.Context, params *RenewDomainParams) (*RenewDomain, error) {
	op := &RenewDomain{}

	err := c.do(ctx, "renewDomain", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// RetrieveAuthCode Execute operation retrieveAuthCode.
func (c *Client) RetrieveAuthCode(ctx context.Context, params *RetrieveAuthCodeParams) (*RetrieveAuthCode, error) {
	op := &RetrieveAuthCode{}

	err := c.do(ctx, "retrieveAuthCode", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// TransferDomain Execute operation transferDomain.
func (c *Client) TransferDomain(ctx context.Context, params *TransferDomainParams) (*TransferDomain, error) {
	op := &TransferDomain{}

	err := c.do(ctx, "transferDomain", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// TransferUpdateChangeEPPCode Execute operation transferUpdateChangeEPPCode.
func (c *Client) TransferUpdateChangeEPPCode(ctx context.Context, params *TransferUpdateChangeEPPCodeParams) (*TransferUpdateChangeEPPCode, error) {
	op := &TransferUpdateChangeEPPCode{}

	err := c.do(ctx, "transferUpdateChangeEPPCode", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// TransferUpdateResendAdminEmail Execute operation transferUpdateResendAdminEmail.
func (c *Client) TransferUpdateResendAdminEmail(ctx context.Context, params *TransferUpdateResendAdminEmailParams) (*TransferUpdateResendAdminEmail, error) {
	op := &TransferUpdateResendAdminEmail{}

	err := c.do(ctx, "transferUpdateResendAdminEmail", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// TransferUpdateResubmitToRegistry Execute operation transferUpdateResubmitToRegistry.
func (c *Client) TransferUpdateResubmitToRegistry(ctx context.Context, params *TransferUpdateResubmitToRegistryParams) (*TransferUpdateResubmitToRegistry, error) {
	op := &TransferUpdateResubmitToRegistry{}

	err := c.do(ctx, "transferUpdateResubmitToRegistry", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// ViewAuction Execute operation viewAuction.
func (c *Client) ViewAuction(ctx context.Context, params *ViewAuctionParams) (*ViewAuction, error) {
	op := &ViewAuction{}

	err := c.do(ctx, "viewAuction", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// ViewAuctionHistory Execute operation viewAuctionHistory.
func (c *Client) ViewAuctionHistory(ctx context.Context, params *ViewAuctionHistoryParams) (*ViewAuctionHistory, error) {
	op := &ViewAuctionHistory{}

	err := c.do(ctx, "viewAuctionHistory", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// ViewAuctions Execute operation viewAuctions.
func (c *Client) ViewAuctions(ctx context.Context, params *ViewAuctionsParams) (*ViewAuctions, error) {
	op := &ViewAuctions{}

	err := c.do(ctx, "viewAuctions", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// WatchAuction Execute operation watchAuction.
func (c *Client) WatchAuction(ctx context.Context, params *WatchAuctionParams) (*WatchAuction, error) {
	op := &WatchAuction{}

	err := c.do(ctx, "watchAuction", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}

// WhoisInfo Execute operation whoisInfo.
func (c *Client) WhoisInfo(ctx context.Context, params *WhoisInfoParams) (*WhoisInfo, error) {
	op := &WhoisInfo{}

	err := c.do(ctx, "whoisInfo", params, op)
	if err != nil {
		return nil, err
	}

	return op, checkReply(op.Reply)
}