epp

package
v0.0.0-...-4718e07 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 25, 2024 License: MIT Imports: 7 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// CommandCheckType represents a check command.
	CommandCheckType string = "epp.command.check"

	// CommandCheckContactType represents a contact check command.
	CommandCheckContactType string = "epp.command.check.contact"

	// CommandCheckDomainType represents a domain check command.
	CommandCheckDomainType string = "epp.command.check.domain"

	// CommandCheckHostType represents a host check command.
	CommandCheckHostType string = "epp.command.check.host"
)
View Source 
const (
	// CommandCreateType represents a create command.
	CommandCreateType string = "epp.command.create"

	// CommandCreateContactType represents a contact creation request.
	CommandCreateContactType string = "epp.command.create.contact"

	// CommandCreateDomainType represents a domain creation request.
	CommandCreateDomainType string = "epp.command.create.domain"

	// CommandCreateHostType represents a host creation request.
	CommandCreateHostType string = "epp.command.create.host"
)
View Source 
const (
	// CommandDeleteType represents a delete command.
	CommandDeleteType string = "epp.command.delete"

	// CommandDeleteContactType represent a contact delete request.
	CommandDeleteContactType string = "epp.command.delete.contact"

	// CommandDeleteDomainType represent a domain delete request.
	CommandDeleteDomainType string = "epp.command.delete.domain"

	// CommandDeleteHostType represent a host delete request.
	CommandDeleteHostType string = "epp.command.delete.host"
)
View Source 
const (
	// DomainXMLNS represents the namespace used for XML Domain objects.
	DomainXMLNS string = "urn:ietf:params:xml:ns:domain-1.0"

	// DomainSchema represents the schama loccation for XML Domain objects.
	DomainSchema string = "urn:ietf:params:xml:ns:domain-1.0 domain-1.0.xsd"

	// HostXMLNS represents the namespace used for XML Host objects.
	HostXMLNS string = "urn:ietf:params:xml:ns:host-1.0"

	// HostSchema represents the schama loccation for XML Host objects.
	HostSchema string = "urn:ietf:params:xml:ns:host-1.0 host-1.0.xsd"

	// ContactXMLNS represents the namespace used for XML Contact objects.
	ContactXMLNS string = "urn:ietf:params:xml:ns:contact-1.0"

	// ContactSchema represents the schama loccation for XML Contact objects.
	ContactSchema string = "urn:ietf:params:xml:ns:contact-1.0 contact-1.0.xsd"

	// W3XMLNSxsi is the string that is presnet in the XMLNSxsi field for
	// EPP objects.
	W3XMLNSxsi string = "http://www.w3.org/2001/XMLSchema-instance"
)
View Source 
const (
	// StatusServerHold is a constant to represent the state where an
	// object is in a server hold.
	StatusServerHold string = "serverHold"

	// StatusClientHold is a constant to represents the state where an
	// object is in a client hold.
	StatusClientHold string = "clientHold"

	// StatusClientUpdateProhibited is a constant to represent the state
	// where object is update locked on the registrar side.
	StatusClientUpdateProhibited string = "clientUpdateProhibited"

	// StatusClientDeleteProhibited is a constant to represent the state
	// where object is delete locked on the registrar side.
	StatusClientDeleteProhibited string = "clientDeleteProhibited"

	// StatusClientRenewProhibited is a constant to represent the state
	// where object is renew locked on the registrar side.
	StatusClientRenewProhibited string = "clientRenewProhibited"

	// StatusClientTransferProhibited is a constant to represent the state
	// where object is transfer locked on the registrar side.
	StatusClientTransferProhibited string = "clientTransferProhibited"

	// StatusServerUpdateProhibited is a constant to represent the state
	// where object is update locked on the registry side.
	StatusServerUpdateProhibited string = "serverUpdateProhibited"

	// StatusServerDeleteProhibited is a constant to represent the state
	// where object is delete locked on the registry side.
	StatusServerDeleteProhibited string = "serverDeleteProhibited"

	// StatusServerRenewProhibited is a constant to represent the state
	// where object is renew locked on the registry side.
	StatusServerRenewProhibited string = "serverRenewProhibited"

	// StatusServerTransferProhibited is a constant to represent the state
	// where object is transfer locked on the registry side.
	StatusServerTransferProhibited string = "serverTransferProhibited"

	// StatusOK is a constant to represent the OK status for an object
	// when no other statuses are present.
	StatusOK string = "ok"

	// StatusLinked is a constant to represent if one object is linked to
	// some other object, often used as an indication that the object is
	// in use, an example would be a Host is linked to a Domain.
	StatusLinked string = "linked"

	// StatusPendingCreate is a constant to represent an object that is
	// pending creation.
	StatusPendingCreate string = "pendingCreate"

	// StatusPendingDelete is a constant to represent an object that is
	// pending deletion.
	StatusPendingDelete string = "pendingDelete"

	// StatusPendingTransfer is a constant to represent an object that is
	// pending transfer.
	StatusPendingTransfer string = "pendingTransfer"

	// StatusPendingUpdate is a constant to represent that an object has a
	// pending update.
	StatusPendingUpdate string = "pendingUpdate"

	// StatusPendingRenew is a constant to represent that an object has a
	// pending renewal.
	StatusPendingRenew string = "pendingRenew"
)
View Source 
const (
	// CommandInfoType represents a info command.
	CommandInfoType string = "epp.command.info"

	// CommandInfoContactType represents a contact info command.
	CommandInfoContactType string = "epp.command.info.contact"

	// CommandInfoDomainType represents a domain info command.
	CommandInfoDomainType string = "epp.command.info.domain"

	// CommandInfoHostType represents a host info command.
	CommandInfoHostType string = "epp.command.info.host"
)
View Source 
const (
	// CommandLoginType represents a login command.
	CommandLoginType string = "epp.command.login"

	// CommandLogoutType represents a logout command.
	CommandLogoutType string = "epp.command.logout"
)
View Source 
const (
	// CommandRenewType represents a renew command.
	CommandRenewType string = "epp.command.renew"

	// CommandRenewDomainType represents a domain renew request.
	CommandRenewDomainType string = "epp.command.renew.domain"
)
View Source 
const (
	// ResponseDomainType represents a <response> domain message.
	ResponseDomainType string = "epp.response.domain"

	// ResponseDomainCheckType represents a <response> domain check message.
	ResponseDomainCheckType string = "epp.response.domain.check"

	// ResponseDomainCreateType represents a <response> domain create message.
	ResponseDomainCreateType string = "epp.response.domain.create"

	// ResponseDomainInfoType represents a <response> domain info message.
	ResponseDomainInfoType string = "epp.response.domain.info"

	// ResponseDomainRenewType represents a <response> domain renew message.
	ResponseDomainRenewType string = "epp.response.domain.renew"

	// ResponseDomainTransferType represents a <response> domain transfer message.
	ResponseDomainTransferType string = "epp.response.domain.transfer"

	// ResponseHostType represents a <response> host message.
	ResponseHostType string = "epp.response.host"

	// ResponseHostCheckType represents a <response> host check message.
	ResponseHostCheckType string = "epp.response.host.check"

	// ResponseHostCreateType represents a <response> host create message.
	ResponseHostCreateType string = "epp.response.host.create"

	// ResponseHostInfoType represents a <response> host info message.
	ResponseHostInfoType string = "epp.response.host.info"

	// ResponseContactType represents a <response> contact message.
	ResponseContactType string = "epp.response.contact"

	// ResponseContactCheckType represents a <response> contact check message.
	ResponseContactCheckType string = "epp.response.contact.check"

	// ResponseContactCreateType represents a <response> contact create message.
	ResponseContactCreateType string = "epp.response.contact.create"

	// ResponseContactInfoType represents a <response> contact info message.
	ResponseContactInfoType string = "epp.response.contact.info"

	// ResponseContactTransferType represents a <response> contact transfer message.
	ResponseContactTransferType string = "epp.response.contact.transfer"
)
View Source 
const (

	// ResponseCode1000 represents the message associated with the 1000
	// response code.
	ResponseCode1000 string = "Command completed successfully"

	// ResponseCodeCommandSuccessful represents the response code for
	// Command completed successfully from the epp server.
	ResponseCodeCommandSuccessful int = 1000

	// ResponseCode1001 represents the message associated with the 1001
	// response code.
	ResponseCode1001 string = "Command completed successfully; action pending"

	// ResponseCodeCommandSuccessfulPending represents the response code
	// for Command completed successfully with action pending from the
	// epp server.
	ResponseCodeCommandSuccessfulPending int = 1001

	// ResponseCode1300 represents the message associated with the 1300
	// response code.
	ResponseCode1300 string = "Command completed successfully; no messages"

	// ResponseCodeCompletedNoMessages represents the response code
	// for Command completed successfully with no messages from the
	// epp server.
	ResponseCodeCompletedNoMessages int = 1300

	// ResponseCode1301 represents the message associated with the 1301
	// response code.
	ResponseCode1301 string = "Command completed successfully; ack to dequeue"

	// ResponseCodeCompletedAckToDequeue represents the response code
	// for Command completed successfully where a the message
	// received can be dequeued by an ack message.
	ResponseCodeCompletedAckToDequeue int = 1301

	// ResponseCode1500 represents the message associated with the 1500
	// response code.
	ResponseCode1500 string = "Command completed successfully; ending session"

	// ResponseCodeCompletedEndingSession represents the response code
	// for Command completed successfully, ending the session.
	ResponseCodeCompletedEndingSession int = 1500

	// ResponseCode2000 represents the message associated with the 2000
	// response code.
	ResponseCode2000 string = "Unknown command"

	// ResponseCodeUnknownCommand represents the response code for an
	// unknown command message.
	ResponseCodeUnknownCommand int = 2000

	// ResponseCode2001 represents the message associated with the 2001
	// response code.
	ResponseCode2001 string = "Command syntax error"

	// ResponseCodeCommandSyntaxError represents the response code for a
	// command syntax error message.
	ResponseCodeCommandSyntaxError int = 2001

	// ResponseCode2002 represents the message associated with the 2002
	// response code.
	ResponseCode2002 string = "Command use error"

	// ResponseCodeCommandUseError represnets the response code for a
	// command use error message.
	ResponseCodeCommandUseError int = 2002

	// ResponseCode2003 represents the message associated with the 2003
	// response code.
	ResponseCode2003 string = "Required parameter missing"

	// ResponseCodeRequireParameterMissing represents the response code
	// for a required parametere missing error message.
	ResponseCodeRequireParameterMissing int = 2003

	// ResponseCode2004 represents the message associated with the 2004
	// response code.
	ResponseCode2004 string = "Parameter value range error"

	// ResponseCodeParameterValueRangeError represnets the response code
	// for a parametere value range error message.
	ResponseCodeParameterValueRangeError int = 2004

	// ResponseCode2005 represents the message associated with the 2005
	// response code.
	ResponseCode2005 string = "Parameter value syntax error"

	// ResponseCodeParameterValueSyntaxError represnets the response code
	// for a parametere value syntax error message.
	ResponseCodeParameterValueSyntaxError int = 2005

	// ResponseCode2100 represents the message associated with the 1200
	// response code.
	ResponseCode2100 string = "Unimplemented protocol version"

	// ResponseCodeUnimplementedProtocolVersion represents the response
	// code for an unimplemented protocol version error message.
	ResponseCodeUnimplementedProtocolVersion int = 2100

	// ResponseCode2101 represents the message associated with the 2101
	// response code.
	ResponseCode2101 string = "Unimplemented command"

	// ResponseCodeUnimplementedCommand represents the response code for
	// an unimplemented command message.
	ResponseCodeUnimplementedCommand int = 2101

	// ResponseCode2102 represents the message associated with the 2102
	// response code.
	ResponseCode2102 string = "Unimplemented option"

	// ResponseCodeUnimplementedOption represents the response code for
	// an unimplemented option message.
	ResponseCodeUnimplementedOption int = 2102

	// ResponseCode2103 represents the message associated with the 2103
	// response code.
	ResponseCode2103 string = "Unimplemented extension"

	// ResponseCodeUnimplementedExtension represents the response code
	// for an unimlpemented extension message.
	ResponseCodeUnimplementedExtension int = 2103

	// ResponseCode2104 represents the message associated with the 2104
	// response code.
	ResponseCode2104 string = "Billing failure"

	// ResponseCodeBillingFailure represents the response code for a
	// billing failure message.
	ResponseCodeBillingFailure int = 2104

	// ResponseCode2105 represents the message associated with the 2105
	// response code.
	ResponseCode2105 string = "Object is not eligible for renewal"

	// ResponseCodeOjectNotEligibleForRenewal represents the response
	// code for a not eligible for renewal message.
	ResponseCodeOjectNotEligibleForRenewal int = 2105

	// ResponseCode2106 represents the message associated with the 2106
	// response code.
	ResponseCode2106 string = "Object is not eligible for transfer"

	// ResponseCodeObjectNotEligibleForTransfer represents the response
	// code for a not eligible for transfer message.
	ResponseCodeObjectNotEligibleForTransfer int = 2106

	// ResponseCode2200 represents the message associated with the 2200
	// response code.
	ResponseCode2200 string = "Authentication error"

	// ResponseCodeAuthenticationError represents the response code for
	// an authentication error message.
	ResponseCodeAuthenticationError int = 2200

	// ResponseCode2201 represents the message associated with the 2201
	// response code.
	ResponseCode2201 string = "Authorization error"

	// ResponseCodeAuthorizationError represents the response code for
	// an authorization error.
	ResponseCodeAuthorizationError int = 2201

	// ResponseCode2202 represents the message associated with the 2202
	// response code.
	ResponseCode2202 string = "Invalid authorization information"

	// ResponseCodeInvalidAuthorizationInformation represents the response
	// code for invalid authorization information messages.
	ResponseCodeInvalidAuthorizationInformation int = 2202

	// ResponseCode2300 represents the message associated with the 2300
	// response code.
	ResponseCode2300 string = "Object pending transfer"

	// ResponseCodeObjectPendingTransfer represnets the response code for
	// a object pending transfer message.
	ResponseCodeObjectPendingTransfer int = 2300

	// ResponseCode2301 represents the message associated with the 2301
	// response code.
	ResponseCode2301 string = "Object not pending transfer"

	// ResponseCodeObjectNotPendingTransfer represents the response code
	// for a object not pending transfer message.
	ResponseCodeObjectNotPendingTransfer int = 2301

	// ResponseCode2302 represents the message associated with the 2302
	// response code.
	ResponseCode2302 string = "Object exists"

	// ResponseCodeObjectExists represents the response code for a
	// object exists message.
	ResponseCodeObjectExists int = 2302

	// ResponseCode2303 represents the message associated with the 2303
	// response code.
	ResponseCode2303 string = "Object does not exist"

	// ResponseCodeObjectDoesNotExist represents a response code for a
	// object does not exist message.
	ResponseCodeObjectDoesNotExist int = 2303

	// ResponseCode2304 represents the message associated with the 2304
	// response code.
	ResponseCode2304 string = "Object status prohibits operation"

	// ResponseCodeObjectStatusProhibited represents the response code
	// for a object status prohibited operation message.
	ResponseCodeObjectStatusProhibited int = 2304

	// ResponseCode2305 represents the message associated with the 2305
	// response code.
	ResponseCode2305 string = "Object association prohibits operation"

	// ResponseCodeObjectAssociationProhibitsOperation represnets the
	// response code for a object association prohibits operation
	// message.
	ResponseCodeObjectAssociationProhibitsOperation int = 2305

	// ResponseCode2306 represents the message associated with the 2306
	// response code.
	ResponseCode2306 string = "Parameter value policy error"

	// ResponseCodeParameterValuePolicyError represents the response code
	// for a parameter value policy error message.
	ResponseCodeParameterValuePolicyError int = 2306

	// ResponseCode2307 represents the message associated with the 2307
	// response code.
	ResponseCode2307 string = "Unimplemented object service"

	// ResponseCodeUnimplementedObjectService represents the response code
	// for an unimplemented object service  message.
	ResponseCodeUnimplementedObjectService int = 2307

	// ResponseCode2308 represents the message associated with the 2308
	// response code.
	ResponseCode2308 string = "Data management policy violation"

	// ResponseCodeDataManagemnetPolicyViolation represents the response code
	// for a data management policy violation message.
	ResponseCodeDataManagemnetPolicyViolation int = 2308

	// ResponseCode2400 represents the message associated with the 2400
	// response code.
	ResponseCode2400 string = "Command failed"

	// ResponseCodeCommandFailed represents the response code for a
	// command failure message.
	ResponseCodeCommandFailed int = 2400

	// ResponseCode2500 represents the message associated with the 2500
	// response code.
	ResponseCode2500 string = "Command failed; server closing connection"

	// ResponseCodeCommandFailedClosing represents the response code for
	// a command failed, closing message.
	ResponseCodeCommandFailedClosing int = 2500

	// ResponseCode2501 represents the message associated with the 2501
	// response code.
	ResponseCode2501 string = "Authentication error; server closing connection"

	// ResponseCodeAuthorizationErrorClosing represnets the response code
	// for a Authentication error message that closes the connection.
	ResponseCodeAuthorizationErrorClosing int = 2501

	// ResponseCode2502 represents the message associated with the 2502
	// response code.
	ResponseCode2502 string = "Session limit exceeded; server closing connection"

	// ResponseCodeSessionLimitExceededClosing represents the response code
	// for session limit exceeded message that closes the connection.
	ResponseCodeSessionLimitExceededClosing int = 2502
)
View Source 
const (
	// CommandTransferType represents a transfer command.
	CommandTransferType string = "epp.command.transfer"

	// CommandTransferContactRequestType represnets a contact transfer request.
	CommandTransferContactRequestType string = "epp.command.transfer.contact.request"

	// CommandTransferContactQueryType represnets a contact transfer query.
	CommandTransferContactQueryType string = "epp.command.transfer.contact.query"

	// CommandTransferContactApproveType represnets a contact transfer approve.
	CommandTransferContactApproveType string = "epp.command.transfer.contact.approve"

	// CommandTransferContactRejectType represnets a contact transfer reject.
	CommandTransferContactRejectType string = "epp.command.transfer.contact.reject"

	// CommandTransferContactCancelType represnets a contact transfer cancel.
	CommandTransferContactCancelType string = "epp.command.transfer.contact.cancel"

	// CommandTransferDomainRequestType represnets a domain transfer request.
	CommandTransferDomainRequestType string = "epp.command.transfer.domain.request"

	// CommandTransferDomainQueryType represnets a domain transfer query.
	CommandTransferDomainQueryType string = "epp.command.transfer.domain.query"

	// CommandTransferDomainApproveType represnets a domain transfer approve.
	CommandTransferDomainApproveType string = "epp.command.transfer.domain.approve"

	// CommandTransferDomainRejectType represnets a domain transfer reject.
	CommandTransferDomainRejectType string = "epp.command.transfer.domain.reject"

	// CommandTransferDomainCancelType represnets a domain transfer cancel.
	CommandTransferDomainCancelType string = "epp.command.transfer.domain.cancel"
)
View Source 
const (
	// CommandUpdateType represents a update command.
	CommandUpdateType string = "epp.command.update"

	// CommandUpdateDomainType represent a domain update request.
	CommandUpdateDomainType string = "epp.command.update.domain"

	// CommandUpdateHostType represent a host update request.
	CommandUpdateHostType string = "epp.command.update.host"

	// CommandUpdateContactType represent a contact update request.
	CommandUpdateContactType string = "epp.command.update.contact"
)
View Source 
const CheckMessageType = "check"

CheckMessageType is used to indicate that a message is a check message.

View Source 
const (
	// CommandType represents a <command> message.
	CommandType string = "epp.command"
)
View Source 
const DefaultEPPPort int = 1700

DefaultEPPPort is the default port that servers will accept connections on.

View Source 
const EPPDateForamt = "2006-01-02"

EPPDateForamt is used when formating a date for an EPP message.

View Source 
const EPPTimeFormat = "2006-01-02T15:04:05.0000Z"

EPPTimeFormat is used when formating a time for EPP message.

View Source 
const EPPTimeFormat2 = "2006-01-02T15:04:05Z"

EPPTimeFormat2 is used when formating a time for EPP message.

View Source 
const (
	// GenericEPPType represents a <epp> message that is unknown.
	GenericEPPType string = "epp.generic"
)
View Source 
const (
	// GreetingType represents a <greeting> message.
	GreetingType string = "epp.greeting"
)
View Source 
const (
	// HelloType represents a <hello> message.
	HelloType string = "epp.hello"
)
View Source 
const InfoMessageType = "info"

InfoMessageType is used to indicate that a message is a info message.

View Source 
const (
	// PollType represents a <poll> command message.
	PollType string = "epp.command.poll"
)
View Source 
const (
	// ResponseType represents a <response> message.
	ResponseType string = "epp.response"
)

Variables

View Source 
var (
	// ErrNoTransctionFound indicates that no transaction was found in the EPP
	// request.
	ErrNoTransctionFound = errors.New("no transaction found")

	// ErrServerTransactionIDNotFound indicates that no server transaction id
	// was found in the response message.
	ErrServerTransactionIDNotFound = errors.New("no server transcation id found")
)
View Source 
var (
	// EPPLoginVersion is the current version of the login object for EPP sessions.
	EPPLoginVersion = "1.0"

	// EPPLoginLanguage indicates the language of the EPP session, which defaults to
	// english.
	EPPLoginLanguage = "en"
)
View Source 
var (
	// ErrNotDomainResponse indicates that the object treated as a domain
	// response was some other object.
	ErrNotDomainResponse = errors.New("not domain response")

	// ErrNotHostResponse indicates that the object treated as a host
	// response was some other object.
	ErrNotHostResponse = errors.New("not host response")

	// ErrNotContactResponse indicates that the object treated as a contact
	// response was some other object.
	ErrNotContactResponse = errors.New("not contact response")
)
View Source 
var EPPHeader = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n"

EPPHeader is appended to XML messages that are sent to the server.

View Source 
var ErrUnknownContactType = errors.New("unknown Contact Type")

ErrUnknownContactType indicates that the contact type was not supported by the package.

Functions

func DateTimeToDate 

func DateTimeToDate(dateTime string) (string, error)

DateTimeToDate is used to convert a date time to just a date.

func WireSplit 

func WireSplit(data []byte, _ bool) (advance int, token []byte, err error)

WireSplit is used by the bufio.Scanner to split epp messages apart before they are unmarshalled.

Types

type Check 

type Check struct {
	XMLName xml.Name `xml:"check" json:"-"`

	DomainChecks  []DomainCheck  `xml:"domain:check" json:"domain.check"`
	HostChecks    []HostCheck    `xml:"host:check" json:"host.check"`
	ContactChecks []ContactCheck `xml:"contact:check" json:"contact.check"`

	GenericChecks []GenericCheck `xml:"check" json:"check"`
}

Check is used to construct and receive <check> messages.

func (*Check) MessageType 

func (c *Check) MessageType() string

MessageType is used to determine what the contained message type is based on the objects that are present in the structure.

func (Check) TypedMessage 

func (c Check) TypedMessage() Check

TypedMessage is used to convert generic versions of the object into a typed version after it is parsed.

type CheckContact 

type CheckContact struct {
	XMLName xml.Name `xml:"contact:cd" json:"contact.cd"`
	ID      struct {
		Available int    `xml:"avail,attr" json:"avail"`
		Value     string `xml:",chardata" json:"value"`
	} `xml:"contact:id" json:"contact.id"`
}

CheckContact is used to receive an individual contact check response.

type CheckDomain 

type CheckDomain struct {
	XMLName xml.Name `xml:"domain:cd" json:"domain.cd"`
	Name    struct {
		Available int    `xml:"avail,attr" json:"avail"`
		Value     string `xml:",chardata" json:"value"`
	} `xml:"domain:name" json:"domain.name"`
	Reason string `xml:"urn:ietf:params:xml:ns:domain-1.0 reason,omitempty" json:"reason"`
}

CheckDomain is used to receive an individual domain check response.

type CheckHost 

type CheckHost struct {
	XMLName xml.Name `xml:"host:cd" json:"host.cd"`
	Name    struct {
		Available int    `xml:"avail,attr" json:"avail"`
		Value     string `xml:",chardata" json:"value"`
	} `xml:"host:name" json:"host.name"`
}

CheckHost is used to receive an individual host check response.

type CheckValueUntyped 

type CheckValueUntyped struct {
	XMLName xml.Name `xml:"cd" json:"-"`
	Name    struct {
		Available int    `xml:"avail,attr" json:"avail"`
		Value     string `xml:",chardata" json:"value"`
	} `xml:"name" json:"name"`
	ID struct {
		Available int    `xml:"avail,attr" json:"avail"`
		Value     string `xml:",chardata" json:"value"`
	} `xml:"id" json:"id"`
	Reason string `xml:"reason,omitempty" json:"reason"`
}

CheckValueUntyped is used to receive an individual domain check response.

func (CheckValueUntyped) ToCheckContact 

func (c CheckValueUntyped) ToCheckContact() CheckContact

ToCheckContact takes a CheckValueUntyped object and turns it into a CheckContact object with a type.

func (CheckValueUntyped) ToCheckDomain 

func (c CheckValueUntyped) ToCheckDomain() CheckDomain

ToCheckDomain takes a CheckValueUntyped object and turns it into a CheckDomain object with a type.

func (CheckValueUntyped) ToCheckHost 

func (c CheckValueUntyped) ToCheckHost() CheckHost

ToCheckHost takes a CheckValueUntyped object and turns it into a CheckHost object with a type.

type Command 

type Command struct {
	XMLName xml.Name `xml:"command" json:"-"`
	XMLNS   string   `xml:"xmlns,attr,omitempty" json:"xmlns"`

	LoginObject     *Login     `xml:"login" json:"login"`
	LogoutObject    *Logout    `xml:"logout" json:"logout"`
	CheckObject     *Check     `xml:"check" json:"check"`
	CreateObject    *Create    `xml:"create" json:"create"`
	InfoObject      *Info      `xml:"info" json:"info"`
	DeleteObject    *Delete    `xml:"delete" json:"delete"`
	UpdateObject    *Update    `xml:"update" json:"update"`
	TransferObject  *Transfer  `xml:"transfer" json:"transfer"`
	RenewObject     *Renew     `xml:"renew" json:"renew"`
	PollObject      *Poll      `xml:"poll" json:"poll"`
	ExtensionObject *Extension `xml:"extension" json:"extension"`

	TransactionID string `xml:"clTRID" json:"clTRID"`
}

Command is used to construct and receive <command> messages.

func (*Command) MessageType 

func (c *Command) MessageType() string

MessageType is used to determine what the contained message type is based on the objects that are present in the structure.

func (Command) TypedMessage 

func (c Command) TypedMessage() Command

TypedMessage is used to convert generic versions of the object into a typed version after it is parsed.

type ContactAuth 

type ContactAuth struct {
	Password string `xml:"contact:pw,omitempty" json:"contact.pw"`
}

ContactAuth is used to hold the auth password for a contact.

type ContactCheck 

type ContactCheck struct {
	XMLName              xml.Name `xml:"contact:check" json:"-"`
	XMLNSContact         string   `xml:"xmlns:contact,attr" json:"xmlns.contact"`
	XMLNSxsi             string   `xml:"xmlns:xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string   `xml:"xsi:schemaLocation,attr"  json:"xmlns.schemaLocation"`
	ContactIDs           []string `xml:"contact:id" json:"contact.id"`
}

ContactCheck is used to construct and receive <contact:check> messages.

type ContactChkDataResp 

type ContactChkDataResp struct {
	XMLNS               string         `xml:"xmlns:contact,attr" json:"xmlns.contact"`
	XMLNsSchemaLocation string         `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`
	ContactIDs          []CheckContact `xml:"host:cd" json:"host.cd"`
}

ContactChkDataResp is used to receive a check contact response.

type ContactCreDataResp 

type ContactCreDataResp struct {
	XMLNSContact        string `xml:"xmlns:contact,attr" json:"xmlns.contact"`
	XMLNsSchemaLocation string `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`
	ID                  string `xml:"contact:id" json:"contact.id"`
	CreateDate          string `xml:"contact:crDate" json:"crDate"`
}

ContactCreDataResp is the non generic form of GenericCreDataResp containing the server responses from the create request for the contact.

type ContactCreate 

type ContactCreate struct {
	XMLName              xml.Name `xml:"contact:create"  json:"-"`
	XMLNSContact         string   `xml:"xmlns:contact,attr" json:"xmlns.contact"`
	XMLNSxsi             string   `xml:"xmlns:xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string   `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`

	ID             string       `xml:"contact:id" json:"contact.id"`
	PostalInfoList []PostalInfo `xml:"contact:postalInfo" json:"contact.postalInfo"`
	VoiceNumber    PhoneNumber  `xml:"contact:voice" json:"voiceNumber"`
	FaxNumber      PhoneNumber  `xml:"contact:fax" json:"faxNumber"`
	Email          string       `xml:"contact:email" json:"contact.email"`
	ContactAuthObj *ContactAuth `xml:"contact:authInfo,omitempty" json:"contact.authInfo"`
}

ContactCreate is used to generate a create message for a contact.

type ContactDelete 

type ContactDelete struct {
	XMLName              xml.Name `xml:"contact:delete" json:"-"`
	XMLNSContact         string   `xml:"xmlns:contact,attr" json:"xmlns.contact"`
	XMLNSxsi             string   `xml:"xmlns:xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string   `xml:"xsi:schemaLocation,attr"  json:"xmlns.schemaLocation"`

	ContactID string `xml:"contact:id" json:"contact.id"`
}

ContactDelete is used to generate a delete message for a contact.

type ContactDisclose 

type ContactDisclose struct {
	Flag      int                 `xml:"flag,attr" json:"flag"`
	Names     []ContactTypedField `xml:"contact:name" json:"names"`
	Orgs      []ContactTypedField `xml:"contact:org" json:"orgs"`
	Addresses []ContactTypedField `xml:"contact:addr" json:"addresses"`
	Voice     string              `xml:"contact:voice" json:"voice"`
	Fax       string              `xml:"contact:fax" json:"fax"`
	Email     string              `xml:"contact:email" json:"email"`
}

ContactDisclose is used to represent a ContactDisclose section of a response with proper namespacing.

type ContactInfDataResp 

type ContactInfDataResp struct {
	XMLNSContact        string           `xml:"xmlns:contact,attr" json:"xmlns.contact"`
	XMLNsSchemaLocation string           `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`
	ID                  string           `xml:"contact:id" json:"contact.id"`
	ROID                string           `xml:"contact:roid" json:"contact.roid"`
	Status              []ContactStatus  `xml:"contact:status" json:"contact.status"`
	PostalInfos         []PostalInfo     `xml:"contact:postalInfo" json:"contact.postalInfo"`
	Voice               PhoneNumber      `xml:"contact:voice,omitempty" json:"contact.voice"`
	Fax                 PhoneNumber      `xml:"contact:fax,omitempty" json:"contact.fax"`
	Email               string           `xml:"contact:email" json:"contact.email"`
	ClientID            string           `xml:"contact:clID" json:"contact.clID"`
	CreateID            string           `xml:"contact:crID" json:"contact.crID"`
	CreateDate          string           `xml:"contact:crDate" json:"contact.crDate"`
	UpdateID            string           `xml:"contact:upID,omitempty" json:"contact.upID"`
	UpdateDate          string           `xml:"contact:upDate,omitempty" json:"contact.upDate"`
	TransferDate        string           `xml:"contact:trDate,omitempty" json:"contact.trDate"`
	AuthPW              *ContactAuth     `xml:"contact:authInfo,omitempty" json:"contact.authInfo"`
	ContactDisclose     *ContactDisclose `xml:"contact:disclose,omitempty" json:"contact.disclose"`
}

ContactInfDataResp is used to represent a contact:infData response object from the server.

type ContactInfo 

type ContactInfo struct {
	XMLName             xml.Name     `xml:"contact:info" json:"-"`
	XMLNS               string       `xml:"xmlns:contact,attr" json:"xmlns.contact"`
	XMLNSxsi            string       `xml:"xmlns:xsi,attr" json:"xmlns.xsi"`
	XMLNSSchemaLocation string       `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`
	ID                  string       `xml:"contact:id" json:"contact.id"`
	ContactAuthObj      *ContactAuth `xml:"contact:authInfo,omitempty" json:"contact.authInfo"`
}

ContactInfo is used to generate an info message for a contact.

type ContactStatus 

type ContactStatus struct {
	XMLName    xml.Name `xml:"contact:status" json:"-"`
	StatusFlag string   `xml:"s,attr" json:"status"`
}

ContactStatus is used to represent a status of a contact.

type ContactTransfer 

type ContactTransfer struct {
	XMLName              xml.Name `xml:"contact:transfer" json:"-"`
	XMLNSContact         string   `xml:"xmlns:contact,attr" json:"xmlns.contact"`
	XMLNSxsi             string   `xml:"xmlns:xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string   `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`

	ContactID string       `xml:"contact:id" json:"contact.id"`
	AuthInfo  *ContactAuth `xml:"contact:authInfo,omitempty" json:"contact.authInfo"`
}

ContactTransfer is used to generate a transfer message for a contact.

type ContactTrnDataResp 

type ContactTrnDataResp struct {
	XMLNSContact        string `xml:"xmlns:contact,attr" json:"xmlns.contact"`
	XMLNsSchemaLocation string `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`
	ID                  string `xml:"contact:id" json:"contact.id"`
	TrStatus            string `xml:"contact:trStatus" json:"contact.trStatus"`
	ReID                string `xml:"contact:reID" json:"contact.reID"`
	ReDate              string `xml:"contact:reDate" json:"contact.reDate"`
	AcID                string `xml:"contact:acID" json:"contact.acID"`
	AcDate              string `xml:"contact:acDate" json:"contact.acDate"`
}

ContactTrnDataResp is the non generic form of GenericTrnDataResp containing the server responses from the transfer request for the contact.

type ContactType 

type ContactType string

ContactType is a type to indicate which type a contact is. 

const (
	// Tech is used to indicate a technical contact.
	Tech ContactType = "tech"

	// Admin is used to indicate an administrative contact.
	Admin ContactType = "admin"

	// Billing is used to indicate an billing contact.
	Billing ContactType = "billing"
)

func ContactTypeFromString 

func ContactTypeFromString(ct string) (c ContactType, err error)

ContactTypeFromString takes a string describing a contact type and converts it into a ContactType object or returns an error of no matching type is found.

type ContactTypedField 

type ContactTypedField struct {
	Type string `xml:"type,attr" json:"type"`
}

ContactTypedField is used to receive a Contact identifier with a type (usually "loc" or "int") from the server.

type ContactUpdate 

type ContactUpdate struct {
	XMLName              xml.Name `xml:"contact:update" json:"-"`
	XMLNSContact         string   `xml:"xmlns:contact,attr" json:"xmlns.contact"`
	XMLNSxsi             string   `xml:"xmlns:xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string   `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`

	ContactID    string                 `xml:"contact:id" json:"contact.id"`
	AddObject    ContactUpdateAddRemove `xml:"contact:add" json:"contact.add"`
	RemoveObject ContactUpdateAddRemove `xml:"contact:rem" json:"contact.rem"`
	ChangeObject ContactUpdateChange    `xml:"contact:chg" json:"contact.chg"`
}

ContactUpdate is used to generate an update message for a contact.

type ContactUpdateAddRemove 

type ContactUpdateAddRemove struct {
	Statuses []ContactStatus `xml:"contact:status" json:"contact.status"`
}

ContactUpdateAddRemove is used to generate the add or rem portion of a contact update object.

func GetEPPContactUpdateAddRemove 

func GetEPPContactUpdateAddRemove(Statuses []string) ContactUpdateAddRemove

GetEPPContactUpdateAddRemove constructs the ContactUpdateAddRemove object used for adding or removing statuses from a contact.

type ContactUpdateChange 

type ContactUpdateChange struct {
	Postal      *PostalInfo  `xml:"contact:postalInfo,omitempty" json:"contact.postalInfo"`
	VoiceNumber *PhoneNumber `xml:"contact:voice,omitempty" json:"contact.voice"`
	FaxNumber   *PhoneNumber `xml:"contact:fax" json:"contact.fax"`
	Email       string       `xml:"contact:email,omitempty" json:"contact.email"`
	AuthInfo    *ContactAuth `xml:"contact:authInfo,omitempty" json:"contact.authInfo"`
}

ContactUpdateChange is used to generate the chg portion of a contact update object.

func GetEPPContactUpdateChange 

func GetEPPContactUpdateChange(Postal *PostalInfo, Voice, Fax *PhoneNumber, EmailAddress, Password string) ContactUpdateChange

GetEPPContactUpdateChange constructs the ContactUpdateChange object used for changing postalinfo, phone numbers, email addresses or auth info for contacts.

type Create 

type Create struct {
	XMLName xml.Name `xml:"create"  json:"-"`

	DomainCreateObj  *DomainCreate  `xml:",omitempty" json:"DomainCreate,omitempty"`
	HostCreateObj    *HostCreate    `xml:",omitempty" json:"HostCreate,omitempty"`
	ContactCreateObj *ContactCreate `xml:",omitempty" json:"ContactCreate,omitempty"`

	GenericCreateObj *GenericCreate `xml:",omitempty" json:"GenericaCreate,omitempty"`
}

Create is used to hold one of the subordinate create objects for either a Host, Domain or Contact.

func (*Create) MessageType 

func (c *Create) MessageType() string

MessageType is used to determine what the contained message type is based on the objects that are present in the structure.

func (Create) TypedMessage 

func (c Create) TypedMessage() Create

TypedMessage is used to convert generic versions of the object into a typed version after it is parsed.

type DSData 

type DSData struct {
	KeyTag     int    `xml:"secDNS:keyTag" json:"secDNS.keyTag"`
	Alg        int    `xml:"secDNS:alg" json:"secDNS.alg"`
	DigestType int    `xml:"secDNS:digestType" json:"secDNS.digestType"`
	Digest     string `xml:"secDNS:digest" json:"secDNS.digest"`
}

DSData contains DS data infomration about a domain stored in an SecDNSInfData extension.

type Delete 

type Delete struct {
	XMLName xml.Name `xml:"delete" json:"-"`

	DomainDeleteObj  *DomainDelete  `xml:",omitempty" json:"domain.delete"`
	HostDeleteObj    *HostDelete    `xml:",omitempty" json:"host.delete"`
	ContactDeleteObj *ContactDelete `xml:",omitempty" json:"contact.delete"`

	GenericDeleteObj *GenericDelete `xml:",omitempty" json:"delete"`
}

Delete is used to hold one of the subordinate delete objects for either a Host, Domain or Contact.

func (*Delete) MessageType 

func (d *Delete) MessageType() string

MessageType is used to determine what the contained message type is based on the objects that are present in the structure.

func (Delete) TypedMessage 

func (d Delete) TypedMessage() Delete

TypedMessage is used to convert generic versions of the object into a typed version after it is parsed.

type DomainAuth 

type DomainAuth struct {
	Password string `xml:"domain:pw,omitempty" json:"domain.pw"`
}

DomainAuth is used to hold the auth password for a domain.

type DomainCheck 

type DomainCheck struct {
	XMLName              xml.Name `xml:"domain:check" json:"-"`
	XMLNSDomain          string   `xml:"xmlns:domain,attr" json:"xmlns.domain"`
	XMLNSxsi             string   `xml:"xmlns:xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string   `xml:"xsi:schemaLocation,attr"  json:"xmlns.schemaLocation"`
	DomainNames          []string `xml:"domain:name" json:"domain.name"`
}

DomainCheck is used to construct and receive <domain:check> messages.

type DomainChkDataResp 

type DomainChkDataResp struct {
	XMLNS               string        `xml:"xmlns:domain,attr" json:"xmlns.domain"`
	XMLNsSchemaLocation string        `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`
	Domains             []CheckDomain `xml:"domain:cd" json:"domain.cd"`
}

DomainChkDataResp is used to receive a check domain response.

type DomainContact 

type DomainContact struct {
	XMLName xml.Name    `xml:"domain:contact"  json:"-"`
	Type    ContactType `xml:"type,attr" json:"type"`
	Value   string      `xml:",chardata" json:"value"`
}

DomainContact constructs a contact object used for mapping from domains to contacts while having the type of contact included in the object.

func GetEPPDomainContact 

func GetEPPDomainContact(ContactType ContactType, ContactID string) DomainContact

GetEPPDomainContact creates and returns a domain contact map object that has the value and type set.

type DomainCreDataResp 

type DomainCreDataResp struct {
	XMLNSDomain         string `xml:"xmlns:domain,attr" json:"xmlns.domain"`
	XMLNsSchemaLocation string `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`
	Name                string `xml:"domain:name" json:"domain.name"`
	CreateDate          string `xml:"domain:crDate" json:"domain.crDate"`
	ExpireDate          string `xml:"domain:exDate" json:"domain.exDate"`
}

DomainCreDataResp is the non generic form of GenericCreDataResp containing the server responses from the create request for the domain.

type DomainCreate 

type DomainCreate struct {
	XMLName              xml.Name `xml:"domain:create"  json:"-"`
	XMLNSDomain          string   `xml:"xmlns:domain,attr" json:"xmlns.domain"`
	XMLNSxsi             string   `xml:"xmlns:xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string   `xml:"xsi:schemaLocation,attr"  json:"xmlns.schemaLocation"`

	DomainName string          `xml:"domain:name" json:"domain.name"`
	Period     DomainPeriod    `xml:"domain:period" json:"domain.period"`
	Hosts      *DomainHostList `xml:",omitempty" json:"hosts"`
	Registrant string          `xml:"domain:registrant,omitempty" json:"domain.registrant"`
	Contacts   []DomainContact `xml:"domain:contact" json:"domain.contact"`

	DomainAuthObj *DomainAuth `xml:"domain:authInfo" json:"domain.authInfo"`
}

DomainCreate is used to generate a create message for a domain.

type DomainDelete 

type DomainDelete struct {
	XMLName              xml.Name `xml:"domain:delete" json:"-"`
	XMLNSDomain          string   `xml:"xmlns:domain,attr" json:"xmlns.domain"`
	XMLNSxsi             string   `xml:"xmlns:xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string   `xml:"xsi:schemaLocation,attr"  json:"xmlns.schemaLocation"`

	DomainName string `xml:"domain:name" json:"domain.name"`
}

DomainDelete is used to generate a delete message for a domain.

type DomainHost 

type DomainHost struct {
	XMLName xml.Name `xml:"domain:hostObj" json:"-"`
	Value   string   `xml:",chardata" json:"value"`
}

DomainHost is used to represent a host for a domain object.

type DomainHostList 

type DomainHostList struct {
	XMLName xml.Name     `xml:"domain:ns,omitempty" json:"-"`
	Hosts   []DomainHost `xml:"domain:hostObj" json:"hosts"`
}

DomainHostList is used to represent a list of host objects under a domain.

type DomainInfDataResp 

type DomainInfDataResp struct {
	XMLNSDomain         string          `xml:"xmlns:domain,attr" json:"xmlns.domain"`
	XMLNsSchemaLocation string          `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`
	Name                string          `xml:"domain:name" json:"domain.name"`
	ROID                string          `xml:"domain:roid" json:"domain:roid"`
	Status              []DomainStatus  `xml:"domain:status" json:"domain.status"`
	RegistrantID        string          `xml:"domain:registrant" json:"domain.registrant"`
	Contacts            []DomainContact `xml:"domain:contact" json:"domain.contact"`
	NSHosts             DomainHostList  `xml:"domain:ns" json:"domain.ns"`
	Hosts               []string        `xml:"domain:host" json:"domain.host"`
	ClientID            string          `xml:"domain:clID" json:"domain.clID"`
	CreateID            string          `xml:"domain:crID" json:"domain.crID"`
	CreateDate          string          `xml:"domain:crDate" json:"domain.crDate"`
	UpdateID            string          `xml:"domain:upID,omitempty" json:"domain.upID"`
	UpdateDate          string          `xml:"domain:upDate,omitempty" json:"domain.upDate"`
	ExpireDate          string          `xml:"domain:exDate" json:"domain.exDate"`
	TransferDate        string          `xml:"domain:trDate,omitempty" json:"domain.trDate"`
	AuthPW              *DomainAuth     `xml:"domain:authInfo" json:"domain.authInfo"`
}

DomainInfDataResp is used to represent a domain:infData response object from the server.

type DomainInfo 

type DomainInfo struct {
	XMLName             xml.Name       `xml:"domain:info" json:"-"`
	XMLNS               string         `xml:"xmlns:domain,attr" json:"xmlns.domain"`
	XMLNSxsi            string         `xml:"xmlns:xsi,attr" json:"xmlns.xsi"`
	XMLNSSchemaLocation string         `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`
	Domain              DomainNameInfo `xml:"domain:name" json:"domain.name"`
	DomainAuthObj       *DomainAuth    `xml:"domain:authInfo,omitempty" json:"domain.authInfo"`
}

DomainInfo is used to generate an info message for a domain.

type DomainInfoHosts 

type DomainInfoHosts string

DomainInfoHosts is a type used to check that the provided option is a valid DomainInfoHost option. 

const (
	// DomainInfoHostsAll is used to indicate that the domain info
	// request should include all host information.
	DomainInfoHostsAll DomainInfoHosts = "all"

	// DomainInfoHostsDelegated is used to indicate that the domain info
	// request should include delegated host information only.
	DomainInfoHostsDelegated DomainInfoHosts = "del"

	// DomainInfoHostsSubordinate is used to indicate that the domain info
	// request should include subordinate host information only.
	DomainInfoHostsSubordinate DomainInfoHosts = "sub"

	// DomainInfoHostsNone is used to indicate that the domain info
	// request should include no host information.
	DomainInfoHostsNone DomainInfoHosts = "none"
)

type DomainNameInfo 

type DomainNameInfo struct {
	XMLName xml.Name        `xml:"domain:name" json:"domain.name"`
	Hosts   DomainInfoHosts `xml:"hosts,attr" json:"hosts"`
	Name    string          `xml:",chardata" json:"name"`
}

DomainNameInfo is used to generate a NameInfo chunk for a domain with an indicator of all or no hosts.

type DomainPeriod 

type DomainPeriod struct {
	Unit  DomainPeriodUnit `xml:"unit,attr" json:"unit"`
	Value int              `xml:",chardata" json:"value"`
}

DomainPeriod is a period of time to be conveyed to the EPP server consisting of a unit (Years or Months) and a number of time units.

func GetEPPDomainPeriod 

func GetEPPDomainPeriod(Unit DomainPeriodUnit, Value int) DomainPeriod

GetEPPDomainPeriod is used to create an DomainPeriod.

type DomainPeriodUnit 

type DomainPeriodUnit string

DomainPeriodUnit represents the unit of time for EPP. 

const (
	// DomainPeriodYear is used to represent a unit of time corresponding
	// to a Year for EPP.
	DomainPeriodYear DomainPeriodUnit = "y"

	// DomainPeriodMonth is used to represent a unit of time corresponding
	// to a month for EPP.
	DomainPeriodMonth DomainPeriodUnit = "m"
)

type DomainRenDataResp 

type DomainRenDataResp struct {
	XMLNSDomain         string `xml:"xmlns:domain,attr" json:"xmlns.domain"`
	XMLNsSchemaLocation string `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`
	Name                string `xml:"domain:name" json:"name"`
	ExpireDate          string `xml:"domain:exDate" json:"expireDate"`
}

DomainRenDataResp is the non generic form of GenericRenDataResp containing the server responses from the renew request for the domain.

type DomainRenew 

type DomainRenew struct {
	XMLName              xml.Name `xml:"domain:renew" json:"-"`
	XMLNSDomain          string   `xml:"xmlns:domain,attr" json:"xmlns.domain"`
	XMLNSxsi             string   `xml:"xmlns:xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string   `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`

	DomainName     string       `xml:"domain:name" json:"domain.name"`
	CurrentExpDate string       `xml:"domain:curExpDate" json:"domain.curExpDate"`
	RenewPeriod    DomainPeriod `xml:"domain:period" json:"domain.period"`
}

DomainRenew is used to generate renew message for a domain.

type DomainStatus 

type DomainStatus struct {
	XMLName    xml.Name `xml:"domain:status" json:"-"`
	StatusFlag string   `xml:"s,attr" json:"status"`
}

DomainStatus is used to represent a status of a domain.

type DomainTransfer 

type DomainTransfer struct {
	XMLName              xml.Name `xml:"domain:transfer" json:"-"`
	XMLNSDomain          string   `xml:"xmlns:domain,attr" json:"xmlns.domain"`
	XMLNSxsi             string   `xml:"xmlns:xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string   `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`

	DomainName string        `xml:"domain:name" json:"domain.name"`
	Period     *DomainPeriod `xml:"domain:period,omitempty" json:"domain.period"`
	AuthInfo   *DomainAuth   `xml:"domain:authInfo,omitempty" json:"domain.authInfo"`
}

DomainTransfer is used to generate a transfer message for a domain.

type DomainTrnDataResp 

type DomainTrnDataResp struct {
	XMLNSDomain         string `xml:"xmlns:domain,attr" json:"xmlns.domain"`
	XMLNsSchemaLocation string `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`
	Name                string `xml:"domain:name" json:"domain.name"`
	TrStatus            string `xml:"domain:trStatus" json:"domain.trStatus"`
	ReID                string `xml:"domain:reID" json:"domain.reID"`
	ReDate              string `xml:"domain:reDate" json:"domain.reDate"`
	AcID                string `xml:"domain:acID" json:"domain.acID"`
	AcDate              string `xml:"domain:acDate" json:"domain.acDate"`
	ExpireDate          string `xml:"domain:exDate" json:"domain.exDate"`
}

DomainTrnDataResp is the non generic form of GenericTrnDataResp containing the server responses from the transfer request for the domain.

type DomainUpdate 

type DomainUpdate struct {
	XMLName              xml.Name `xml:"domain:update" json:"-"`
	XMLNSDomain          string   `xml:"xmlns:domain,attr" json:"xmlns.domain"`
	XMLNSxsi             string   `xml:"xmlns:xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string   `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`

	DomainName string `xml:"domain:name" json:"domain.name"`

	AddObject    DomainUpdateAddRemove `xml:"domain:add" json:"domain.add"`
	RemoveObject DomainUpdateAddRemove `xml:"domain:rem" json:"domain.rem"`
	ChangeObject DomainUpdateChange    `xml:"domain:chg" json:"domain.chg"`
}

DomainUpdate is used to generate an update message for a domain.

type DomainUpdateAddRemove 

type DomainUpdateAddRemove struct {
	Hosts    *DomainHostList `xml:"domain:ns" json:"domain.ns"`
	Contacts []DomainContact `xml:"domain:contact" json:"domain.contact"`
	Statuses []DomainStatus  `xml:"domain:status" json:"domain.status"`
}

DomainUpdateAddRemove is used to generate the add or rem portion of a domain update object.

func GetEPPDomainUpdateAddRemove 

func GetEPPDomainUpdateAddRemove(Hosts []string, Contacts []DomainContact, Statuses []string) DomainUpdateAddRemove

GetEPPDomainUpdateAddRemove constructs a DomainUpdateAddRemove object used for adding or removing properties from a domain.

type DomainUpdateChange 

type DomainUpdateChange struct {
	XMLName    xml.Name    `xml:"domain:chg" json:"-"`
	Registrant string      `xml:"domain:registrant,omitempty" json:"domain.registrant"`
	AuthInfo   *DomainAuth `xml:"domain:authInfo,omitempty" json:"domain.authInfo"`
}

DomainUpdateChange is used to generate the change portion of a domain update object.

func GetEPPDomainUpdateChange 

func GetEPPDomainUpdateChange(RegistrantID *string, AuthPassword *string) DomainUpdateChange

GetEPPDomainUpdateChange constructs a DomainUpdateChange object used for changing the registrant ID and the auth password for a domain.

type Epp 

type Epp struct {
	XMLName xml.Name `xml:"epp" json:"-"`
	// XMLNS                  string    `xml:"xmlns,omitempty,attr"`
	XMLNSxsi               string    `xml:"xmlns:xsi,attr,omitempty" json:"xmlns.xsi"`
	XMLNSxsiIn             string    `xml:"xsi,attr,omitempty" json:"xmlns.xsiin"`
	XMLxsiSchemaLocation   string    `xml:"xsi:schemaLocation,attr,omitempty" json:"xmlns.schemaLocation"`
	XMLxsiSchemaLocationIn string    `xml:"schemaLocation,attr,omitempty" json:"xmlns.schemaLocationIn"`
	CommandObject          *Command  `xml:",omitempty" json:"command"`
	GreetingObject         *Greeting `xml:",omitempty" json:"greeting"`
	HelloObject            *Hello    `xml:",omitempty" json:"hello"`
	ResponseObject         *Response `xml:",omitempty" json:"response"`
}

Epp is used to construct and receive <epp> messages.

func GetEPP 

func GetEPP() Epp

GetEPP Returns an uninitialized EPP object.

func GetEPPCheck 

func GetEPPCheck(TransactionID string) Epp

GetEPPCheck Returns an uninitialized EPP Check object.

func GetEPPCommand 

func GetEPPCommand(TransactionID string) Epp

GetEPPCommand Returns an uninitialized EPP Command object.

func GetEPPContactCheck 

func GetEPPContactCheck(ContactID string, TransactionID string) Epp

GetEPPContactCheck is used to generate a contact check message.

func GetEPPContactCreate 

func GetEPPContactCreate(contactID string, postalInfo PostalInfo, Email string,
	Voice PhoneNumber, Fax PhoneNumber, Password string,
	TransactionID string,
) Epp

GetEPPContactCreate is used to generate a contact create message.

func GetEPPContactDelete 

func GetEPPContactDelete(ContactID string, TransactionID string) Epp

GetEPPContactDelete is used to generate a contact delete message.

func GetEPPContactInfo 

func GetEPPContactInfo(ContactID string, TransactionID string, AuthPassword string) Epp

GetEPPContactInfo returns a populated EPP Contact Info object.

func GetEPPContactTransfer 

func GetEPPContactTransfer(ContactID string, Op TransferOperationType, TransactionID string) Epp

GetEPPContactTransfer is used to generate a contact transfer message with the provided contact id, operation type and transaction id.

func GetEPPContactTransferApprove 

func GetEPPContactTransferApprove(ContactID string, TransactionID string) Epp

GetEPPContactTransferApprove generates a Contact Transfer approve message using the contact id passed.

func GetEPPContactTransferCancel 

func GetEPPContactTransferCancel(ContactID string, TransactionID string) Epp

GetEPPContactTransferCancel generates a Contact Transfer cancel message using the contact id passed.

func GetEPPContactTransferQuery 

func GetEPPContactTransferQuery(ContactID string, TransactionID string) Epp

GetEPPContactTransferQuery generates a Contact Transfer query message using the contact id passed.

func GetEPPContactTransferReject 

func GetEPPContactTransferReject(ContactID string, TransactionID string) Epp

GetEPPContactTransferReject generates a Contact Transfer reject message using the contact id passed.

func GetEPPContactTransferRequest 

func GetEPPContactTransferRequest(ContactID string, Password string, TransactionID string) Epp

GetEPPContactTransferRequest generates a Contact Transfer request message using the contact id and password passed.

func GetEPPContactUpdate 

func GetEPPContactUpdate(ContactID string, Add ContactUpdateAddRemove, Rem ContactUpdateAddRemove, Chg ContactUpdateChange, TransactionID string) Epp

GetEPPContactUpdate is used to generate a contact update message.

func GetEPPCreate 

func GetEPPCreate(TransactionID string) Epp

GetEPPCreate is used to generate a create message envelope to later be populated with one of the create objects (Host, Domain or Contact).

func GetEPPDelete 

func GetEPPDelete(TransactionID string) Epp

GetEPPDelete is used to generate a delete message envelope to later be populated with one of the delte objects (Host, Domain or Contact).

func GetEPPDomainCheck 

func GetEPPDomainCheck(DomainName string, TransactionID string) Epp

GetEPPDomainCheck Returns an uninitialized EPP Domain Check object.

func GetEPPDomainCreate 

func GetEPPDomainCreate(DomainName string, Period DomainPeriod,
	Hosts []DomainHost, RegistrantID *string, adminID *string,
	techID *string, billingID *string, Password string,
	TransactionID string,
) Epp

GetEPPDomainCreate is used to generate a domain create message.

func GetEPPDomainDelete 

func GetEPPDomainDelete(DomainName string, TransactionID string) Epp

GetEPPDomainDelete is used to generate a domain delete message.

func GetEPPDomainInfo 

func GetEPPDomainInfo(DomainName string, TransactionID string, AuthPassword string, Hosts DomainInfoHosts) Epp

GetEPPDomainInfo returns an populated EPP Domain Info object.

func GetEPPDomainRenew 

func GetEPPDomainRenew(DomainName string, CurrentExpDate string, RenewPeriod DomainPeriod, TransactionID string) Epp

GetEPPDomainRenew returnes a populated EPP Domain renew object.

func GetEPPDomainRestoreReport 

func GetEPPDomainRestoreReport(DomainName string, Report *RestoreReport, TransactionID string) Epp

GetEPPDomainRestoreReport constructs a Restore Report message for the domain passed with the required report data.

func GetEPPDomainRestoreRequest 

func GetEPPDomainRestoreRequest(DomainName string, TransactionID string) Epp

GetEPPDomainRestoreRequest constructs a Restore Report message for the domain passed.

func GetEPPDomainSecDNSUpdate 

func GetEPPDomainSecDNSUpdate(DomainName string, DStoAdd, DStoRemove []DSData, TransactionID string) Epp

GetEPPDomainSecDNSUpdate constructs a SecDNS update message for the domain passed attempting to add or remove DS records for the domain.

func GetEPPDomainSyncUpdate 

func GetEPPDomainSyncUpdate(DomainName string, ExpMonth time.Month, ExpDay int, TransactionID string) Epp

GetEPPDomainSyncUpdate constructs a SyncUpdate message for the domain passed attempting to set the expiration date to the month and Day passed.

func GetEPPDomainTransfer 

func GetEPPDomainTransfer(DomainName string, Op TransferOperationType, TransactionID string) Epp

GetEPPDomainTransfer is used to generate a domain transfer message with the provided domain name, operation type and transaction id.

func GetEPPDomainTransferApprove 

func GetEPPDomainTransferApprove(DomainName string, TransactionID string) Epp

GetEPPDomainTransferApprove generates a Domain Transfer approve message using the domain name passed.

func GetEPPDomainTransferCancel 

func GetEPPDomainTransferCancel(DomainName string, TransactionID string) Epp

GetEPPDomainTransferCancel generates a Domain Transfer cancel message using the domain name passed.

func GetEPPDomainTransferQuery 

func GetEPPDomainTransferQuery(DomainName string, TransactionID string) Epp

GetEPPDomainTransferQuery generates a Domain Transfer query message using the domain name passed.

func GetEPPDomainTransferReject 

func GetEPPDomainTransferReject(DomainName string, TransactionID string) Epp

GetEPPDomainTransferReject generates a Domain Transfer reject message using the domain name passed.

func GetEPPDomainTransferRequest 

func GetEPPDomainTransferRequest(DomainName string, Period DomainPeriod, Password string, TransactionID string) Epp

GetEPPDomainTransferRequest generates a Domain Transfer request message using the domain name, period and passowrd passed.

func GetEPPDomainUpdate 

func GetEPPDomainUpdate(DomainName string, DomainAdd *DomainUpdateAddRemove, DomainRemove *DomainUpdateAddRemove, DomainChange *DomainUpdateChange, TransactionID string) Epp

GetEPPDomainUpdate is used to generate a doamin update message.

func GetEPPGreeting 

func GetEPPGreeting(svcMenu ServiceMenu) Epp

GetEPPGreeting will create an EPP <greeting> message.

func GetEPPHello 

func GetEPPHello() Epp

GetEPPHello will create an EPP <hello> message.

func GetEPPHostCheck 

func GetEPPHostCheck(HostName string, TransactionID string) Epp

GetEPPHostCheck is used to generate a host check message.

func GetEPPHostCreate 

func GetEPPHostCreate(hostname string, ipv4Addresses []string, ipv6Addresses []string, TransactionID string) Epp

GetEPPHostCreate is used to generate a host create message by providing a hostname, IPv4 and IPv6 addresses and a transaction ID.

func GetEPPHostDelete 

func GetEPPHostDelete(HostName string, TransactionID string) Epp

GetEPPHostDelete is used to generate a host delete message.

func GetEPPHostInfo 

func GetEPPHostInfo(HostName string, TransactionID string) Epp

GetEPPHostInfo returns a populated EPP Host Info object.

func GetEPPHostUpdate 

func GetEPPHostUpdate(HostName string, HostAdd *HostUpdateAddRemove, HostRemove *HostUpdateAddRemove, HostChange *HostUpdateChange, TransactionID string) Epp

GetEPPHostUpdate is used to generate a host update message.

func GetEPPInfo 

func GetEPPInfo(TransactionID string) Epp

GetEPPInfo is used to generate an info message envelope to later be populated with one of the info objects (Host, Domain or Contact).

func GetEPPLogin 

func GetEPPLogin(username string, password string, transactionID string, svcMenu ServiceMenu) Epp

GetEPPLogin will create an EPP <login> message.

func GetEPPLoginPasswordChange 

func GetEPPLoginPasswordChange(username string, password string, newPassword string, transactionID string, svcMenu ServiceMenu) Epp

func GetEPPLogout 

func GetEPPLogout(transactionID string) Epp

GetEPPLogout will create an EPP <logout> message.

func GetEPPPollAcknowledge 

func GetEPPPollAcknowledge(messageID string, transactionID string) Epp

GetEPPPollAcknowledge will create an epp <poll> command message with the operation type of acknowledge.

func GetEPPPollRequest 

func GetEPPPollRequest(transactionID string) Epp

GetEPPPollRequest will create an epp <poll> command message with the operation type of request.

func GetEPPRenew 

func GetEPPRenew(TransactionID string) Epp

GetEPPRenew is used to generate a renew message envelope to later be populated with one of the renew objects (Domain).

func GetEPPResponse 

func GetEPPResponse(ClientTXID string, ServerTXID string) Epp

GetEPPResponse Returns an uninitialized EPP Response object.

func GetEPPResponseResult 

func GetEPPResponseResult(ClientTXID string, ServerTXID string, Code int, Message string) Epp

GetEPPResponseResult Returns an populated EPP Response Result object.

func GetEPPTransfer 

func GetEPPTransfer(Op TransferOperationType, TransactionID string) Epp

GetEPPTransfer is used to generate a transfer message envelope to later be populated with one of the transfer objects (Domain or Contact).

func GetEPPUpdate 

func GetEPPUpdate(TransactionID string) Epp

GetEPPUpdate is used to generate an update message envelope to later be populated with one of the create objects (Host, Domain or Contact).

func UnmarshalMessage 

func UnmarshalMessage(message []byte) (output Epp, err error)

UnmarshalMessage takes a string of bytes and attempts to unmarshal the data into an EPP object. If an error occurs it is returned otherwise the error return value will be nil.

func (Epp) EncodeEPP 

func (e Epp) EncodeEPP() (buf []byte, err error)

EncodeEPP takes an EPP object and converts it into a stream of bytes that can be written to the wire to send an EPP message.

func (Epp) GetServerTransactionID 

func (e Epp) GetServerTransactionID() (string, error)

GetServerTransactionID will return the transaction ID from the server associated with the epp response object if it is set, otherwise an error is returned.

func (Epp) GetTransactionID 

func (e Epp) GetTransactionID() (string, error)

GetTransactionID will return the transaction ID associated with the epp command object if it is set otherwise an error is returned.

func (Epp) MessageType 

func (e Epp) MessageType() string

MessageType is used to determine what the contained message type is based on the objects that are present in the structure.

func (Epp) ToString 

func (e Epp) ToString() (string, error)

ToString turns the EPP message into an XML string so it can be printed.

func (Epp) ToStringCS 

func (e Epp) ToStringCS(prefix string) (string, error)

ToStringCS is used to convert an epp message into a multi-lined string of text representing the XML version of the epp object passed prefixed with the value provided as an argument 

eg. a hello prefixed with "S:" would look something like this:

C: <?xml version="1.0" encoding="UTF-8" standalone="no"?> C: <epp xmlns="urn:ietf:params:xml:ns:epp-1.0" 

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="urn:ietf:params:xml:ns:epp-1.0 epp-1.0.xsd">

C: <hello xmlns="urn:ietf:params:xml:ns:epp-1.0"/> C: </epp>.

func (Epp) TypedMessage 

func (e Epp) TypedMessage() Epp

TypedMessage is used to convert generic versions of the object into a typed version after it is parsed.

type Extension 

type Extension struct {
	XMLName                         xml.Name                   `xml:"extension" json:"-"`
	NameStoreExtensionObject        *NameStoreExtension        `xml:"namestoreExt:namestoreExt" json:"namestoreExt.namestoreExt"`
	GenericNameStoreExtensionObject *GenericNameStoreExtension `xml:"namestoreExt" json:"namestore"`
	SyncUpdateObject                *SyncUpdateExtension       `xml:"sync:update" json:"sync.update"`
	RestoreRequest                  *RestoreExtension          `xml:"rgp:update" json:"rgp.update"`
	SecDNSUpdate                    *SecDNSUpdate              `xml:"secDNS:update" json:"secDNS.update"`
}

Extension is used to construct and receive <extension> messages.

func GetCOMNamestoreExtension 

func GetCOMNamestoreExtension() Extension

GetCOMNamestoreExtension will return an extension object for the .COM verisign product.

func GetNETNamestoreExtension 

func GetNETNamestoreExtension() Extension

GetNETNamestoreExtension will return an extension object for the .NET verisign product.

func (Extension) TypedMessage 

func (e Extension) TypedMessage() Extension

TypedMessage is used to convert generic versions of the object into a typed version after it is parsed.

type GenereicUpdateChange 

type GenereicUpdateChange struct {
	XMLName     xml.Name           `xml:"chg" json:"-"`
	Registrant  string             `xml:"registrant,omitempty" json:"registrant"`
	Name        string             `xml:"name,omitempty" json:"name"`
	Postal      *GenericPostalInfo `xml:"postalInfo,omitempty" json:"postalInfo"`
	VoiceNumber *GenericPhone      `xml:"voice,omitempty" json:"voice"`
	FaxNumber   *GenericPhone      `xml:"fax" json:"fax"`
	Email       string             `xml:"email,omitempty" json:"email"`
	AuthInfo    *GenericAuthInfo   `xml:"authInfo,omitempty" json:"authInfo"`
}

GenereicUpdateChange is used to receive an UpdateChange request that has not been typed yet and can be used to generate the typed version of the object later.

type GenericAddr 

type GenericAddr struct {
	Streets    []string `xml:"street" json:"street"`
	City       string   `xml:"city" json:"city"`
	StateProv  string   `xml:"sp,omitempty" json:"sp"`
	PostalCode string   `xml:"pc,omitempty" json:"pc"`
	Country    string   `xml:"cc" json:"cc"`
}

GenericAddr is used to receive a PostalInfo>Address object from the server.

type GenericAuthInfo 

type GenericAuthInfo struct {
	XMLName  xml.Name `xml:"authInfo" json:"authInfo"`
	Password string   `xml:"pw" json:"pw"`
}

GenericAuthInfo is used to receive a AuthInfo block from a client.

type GenericCD 

type GenericCD struct {
	Name     LaunchCDName     `xml:"name" json:"name"`
	ClaimKey LaunchCDClaimKey `xml:"claimKey" json:"claimKey"`
}

GenericCD is used to receive a generic version of a cd object from the server.

type GenericCheck 

type GenericCheck struct {
	XMLNSDomain         string   `xml:"domain,attr" json:"xmlns.domain"`
	XMLNSHost           string   `xml:"host,attr" json:"xmlns.host"`
	XMLNSContact        string   `xml:"contact,attr" json:"xmlns.contact"`
	XMLNsSchemaLocation string   `xml:"schemaLocation,attr" json:"xmlns.schemaLocation"`
	IDs                 []string `xml:"id" json:"id"`
	Names               []string `xml:"name" json:"name"`
}

GenericCheck is used to receive a Check mesage from a client.

type GenericChkDataResp 

type GenericChkDataResp struct {
	XMLNamespace string              `xml:"xmlns:domain,attr" json:"xmlns,omitempty"`
	XMLNSDomain  string              `xml:"domain,attr" json:"xmlns.domain"`
	XMLNSHost    string              `xml:"host,attr" json:"host"`
	XMLNSContact string              `xml:"contact,attr" json:"contact"`
	Items        []CheckValueUntyped `xml:"cd" json:"cd"`
}

GenericChkDataResp is used to receive check responses where it is difficult to determine the type of the object due to a lacking feature in Go.

type GenericChkDataRespExt 

type GenericChkDataRespExt struct {
	XMLName     xml.Name    `xml:"chkData" json:"chkData"`
	XMLNSLaunch string      `xml:"launch,attr" json:"launch"`
	LaunchPhase string      `xml:"phase" json:"launchPhase"`
	GenericCDs  []GenericCD `xml:"cd" json:"genericCDs"`
}

GenericChkDataRespExt is used to receive a generic version of a chkData object from the server.

type GenericContact 

type GenericContact struct {
	Type  string `xml:"type,attr" json:"type"`
	Value string `xml:",chardata" json:"value"`
}

GenericContact is used to receive information related to a contact.

type GenericCreDataResp 

type GenericCreDataResp struct {
	XMLNSDomain         string `xml:"domain,attr" json:"xmlns.domain"`
	XMLNSHost           string `xml:"host,attr" json:"xmlns.host"`
	XMLNSContact        string `xml:"contact,attr" json:"xmlns.contact"`
	XMLNsSchemaLocation string `xml:"schemaLocation,attr" json:"xmlns.schemaLocation"`
	Name                string `xml:"name" json:"name"`
	ID                  string `xml:"id" json:"id"`
	CreateDate          string `xml:"crDate" json:"crDate"`
	ExpireDate          string `xml:"exDate" json:"exDate"`
}

GenericCreDataResp is used to receive a generic version of a creData object from the server.

type GenericCreate 

type GenericCreate struct {
	XMLName              xml.Name `xml:"create"  json:"-"`
	XMLNSDomain          string   `xml:"domain,attr" json:"xmlns.domain"`
	XMLNSHost            string   `xml:"host,attr" json:"xmlns.host"`
	XMLNSContact         string   `xml:"contact,attr" json:"xmlns.contact"`
	XMLNSxsi             string   `xml:"xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string   `xml:"schemaLocation,attr" json:"xmlns.schemaLocation"`

	ID             string              `xml:"id" json:"id"`
	Name           string              `xml:"name" json:"name"`
	Period         DomainPeriod        `xml:"period" json:"period"`
	Registrant     string              `xml:"registrant" json:"registrant"`
	Contacts       []GenericContact    `xml:"contact" json:"contact"`
	PostalInfoList []GenericPostalInfo `xml:"postalInfo" json:"postalInfo"`
	VoiceNumber    GenericPhone        `xml:"voice" json:"voice"`
	FaxNumber      GenericPhone        `xml:"fax" json:"fax"`
	Email          string              `xml:"email" json:"email"`
	Hosts          []string            `xml:"ns>hostObj" json:"ns.hostObj"`
	Addresses      []GenericHostAddr   `xml:"addr" json:"addresses"`

	AuthObj *GenericAuthInfo `xml:"authInfo"`
}

GenericCreate is used to receive a Create message from a client.

type GenericDSData 

type GenericDSData struct {
	KeyTag     int    `xml:"keyTag" json:"keyTag"`
	Alg        int    `xml:"alg" json:"alg"`
	DigestType int    `xml:"digestType" json:"digestType"`
	Digest     string `xml:"digest" json:"digest"`
}

GenericDSData is used to receive a DSData object from the server.

func (GenericDSData) ToDSData 

func (g GenericDSData) ToDSData() DSData

ToDSData converts from the generic version of GenericDSData to the specific version in the form of DSData.

type GenericDelete 

type GenericDelete struct {
	XMLName              xml.Name `xml:"delete" json:"-"`
	XMLNSDomain          string   `xml:"domain,attr" json:"xmlns.domain"`
	XMLNSHost            string   `xml:"host,attr" json:"xmlns.host"`
	XMLNSContact         string   `xml:"contact,attr" json:"xmlns.contact"`
	XMLNSxsi             string   `xml:"xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string   `xml:"schemaLocation,attr"  json:"xmlns.schemaLocation"`

	Name string `xml:"name" json:"name"`
	ID   string `xml:"id" json:"id"`
}

GenericDelete is used to receive a delete request that have not been typed yet and can be typed at a later time.

type GenericDisclose 

type GenericDisclose struct {
	Flag      int                 `xml:"flag,attr" json:"flag"`
	Names     []ContactTypedField `xml:"name" json:"name"`
	Orgs      []ContactTypedField `xml:"org" json:"org"`
	Addresses []ContactTypedField `xml:"addr" json:"addr"`
	Voice     string              `xml:"voice" json:"voice"`
	Fax       string              `xml:"fax" json:"fax"`
	Email     string              `xml:"email" json:"email"`
}

GenericDisclose is used to receive a Disclose object from the server.

func (GenericDisclose) ToContactDisclose 

func (g GenericDisclose) ToContactDisclose() (c ContactDisclose)

ToContactDisclose attempts to copy the required values from the called oject into a ContactDisclose object.

type GenericHostAddr 

type GenericHostAddr struct {
	IPVersion IPVersionName `xml:"ip,attr" json:"ip"`
	Address   string        `xml:",chardata" json:"address"`
}

GenericHostAddr is used to receive a Host Address object from the server.

type GenericInfDataResp 

type GenericInfDataResp struct {
	XMLNSDomain         string              `xml:"domain,attr" json:"xmlns.domain"`
	XMLNSHost           string              `xml:"host,attr" json:"xmlns.host"`
	XMLNSContact        string              `xml:"contact,attr" json:"xmlns.contact"`
	XMLNsSchemaLocation string              `xml:"schemaLocation,attr" json:"xmlns.schemaLocation"`
	Name                string              `xml:"name" json:"name"`
	ID                  string              `xml:"id" json:"id"`
	ROID                string              `xml:"roid" json:"roid"`
	Status              []GenericStatus     `xml:"status" json:"status"`
	RegistrantID        string              `xml:"registrant" json:"registrant"`
	Contacts            []GenericContact    `xml:"contact" json:"contact"`
	NSHosts             []string            `xml:"ns>hostObj" json:"hostObj"`
	HostAddrs           []GenericHostAddr   `xml:"addr" json:"addr"`
	Hosts               []string            `xml:"host" json:"host"`
	ClientID            string              `xml:"clID" json:"clID"`
	CreateID            string              `xml:"crID" json:"crID"`
	CreateDate          string              `xml:"crDate" json:"crDate"`
	ExpireDate          string              `xml:"exDate" json:"exDate"`
	UpdateID            string              `xml:"upID" json:"upID"`
	UpdateDate          string              `xml:"upDate" json:"upDate"`
	TransferDate        string              `xml:"trDate" json:"trDate"`
	Voice               GenericPhone        `xml:"voice" json:"voice"`
	Fax                 GenericPhone        `xml:"fax" json:"fax"`
	AuthPW              string              `xml:"authInfo>pw" json:"authInfoPW"`
	Email               string              `xml:"email" json:"email"`
	Disclose            *GenericDisclose    `xml:"disclose" json:"disclosure"`
	PostalInfos         []GenericPostalInfo `xml:"postalInfo" json:"postalInfo"`
}

GenericInfDataResp is used to receive a InfoResponse from a server.

func (GenericInfDataResp) GetObjectType 

func (g GenericInfDataResp) GetObjectType() string

GetObjectType is used to determine which type of info response object was created.

func (GenericInfDataResp) ToContactInfDataResp 

func (g GenericInfDataResp) ToContactInfDataResp() (c ContactInfDataResp, err error)

ToContactInfDataResp attempts to copy the required values from the called oject into a ContactInfDataResp object.

func (GenericInfDataResp) ToDomainInfDataResp 

func (g GenericInfDataResp) ToDomainInfDataResp() (d DomainInfDataResp, err error)

ToDomainInfDataResp attempts to copy the required values from the called oject into a DomainInfDataResp object.

func (GenericInfDataResp) ToHostInfDataResp 

func (g GenericInfDataResp) ToHostInfDataResp() (h HostInfDataResp, err error)

ToHostInfDataResp attempts to copy the required values from the called oject into a HostInfDataResp object.

type GenericInfDataRespExt 

type GenericInfDataRespExt struct {
	XMLNSsecDNS         string          `xml:"secDNS,attr" json:"xmlns.secdns"`
	XMLNSJobsContact    string          `xml:"jobsContact,attr" json:"xmlns.jobsContact"`
	XMLNsSchemaLocation string          `xml:"schemaLocation,attr" json:"xmlns.schemaLocation"`
	DSData              []GenericDSData `xml:"dsData" json:"dsData"`
	Title               string          `xml:"title" json:"title"`
	Website             string          `xml:"website" json:"website"`
	IndustryType        string          `xml:"industryType" json:"industryType"`
	IsAdminContact      string          `xml:"isAdminContact" json:"isAdminContacT"`
	IsAssociationMember string          `xml:"isAssociationMember" json:"isAssociationMember"`
}

GenericInfDataRespExt is used to receive a generic version of a infData extension object from the server.

func (GenericInfDataRespExt) ToJobsContact 

func (g GenericInfDataRespExt) ToJobsContact() (j *JobsContact)

ToJobsContact attempts to convert a GenericInfDataRespExt object into a JobsContact object.

type GenericInfo 

type GenericInfo struct {
	XMLName             xml.Name `xml:"info" json:"-"`
	XMLNSDomain         string   `xml:"domain,attr" json:"xmlns.domain"`
	XMLNSHost           string   `xml:"host,attr" json:"xmlns.host"`
	XMLNSContact        string   `xml:"contact,attr" json:"xmlns.contact"`
	XMLNsXSI            string   `xml:"xsi,attr" json:"xmlns.xsi"`
	XMLNsSchemaLocation string   `xml:"schemaLocation,attr" json:"xmlns.schemaLocation"`

	ID              string           `xml:"id" json:"id"`
	Name            GenericName      `xml:"name" json:"name"`
	GenericAuthInfo *GenericAuthInfo `xml:"authInfo" jason:"authInfo"`
}

GenericInfo is used to receive a Info message from a client.

type GenericName 

type GenericName struct {
	XMLName xml.Name        `xml:"name" json:"-"`
	Hosts   DomainInfoHosts `xml:"hosts,attr,omitempty" json:"hosts"`
	Name    string          `xml:",chardata" json:"name"`
}

GenericName is used to receive a Name block for an info object from a client.

type GenericNameStoreExtension 

type GenericNameStoreExtension struct {
	XMLName              xml.Name `xml:"namestoreExt" json:"-"`
	XMLNSNamestoreExt    string   `xml:"namestoreExt,attr" json:"xmlns.namestoreExt"`
	XMLNSxsi             string   `xml:"xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string   `xml:"schemaLocation,attr" json:"xmlns.schemaLocation"`
	SubProducts          []string `xml:"subProduct" json:"subProduct"`
}

GenericNameStoreExtension is used to receive <namestoreExt:namestoreExt> messages.

func (GenericNameStoreExtension) TypedMessage 

func (e GenericNameStoreExtension) TypedMessage() NameStoreExtension

TypedMessage is used to convert generic versions of the object into a typed version after it is parsed.

type GenericNamestore 

type GenericNamestore struct {
	XMLNSNamestoreExt   string   `xml:"namestoreExt,attr" json:"namestoreExt"`
	XMLNsSchemaLocation string   `xml:"schemaLocation,attr" json:"xmlns.schemaLocation"`
	Subproducts         []string `xml:"subProduct" json:"subProduct"`
}

GenericNamestore is used to receive a NameStore object from the server.

type GenericPhone 

type GenericPhone struct {
	Extension string `xml:"x,attr" json:"x"`
	Number    string `xml:",chardata" json:"Number"`
}

GenericPhone is used receive a Phone number without the namespacing being paid attention to.

type GenericPostalInfo 

type GenericPostalInfo struct {
	Type string      `xml:"type,attr" json:"type"`
	Name string      `xml:"name" json:"name"`
	Org  string      `xml:"org,omitempty" json:"org"`
	Addr GenericAddr `xml:"addr" json:"addr"`
}

GenericPostalInfo is used to receive a PostalInfo object from the server.

type GenericRenDataResp 

type GenericRenDataResp struct {
	XMLNSDomain         string `xml:"domain,attr" json:"xmlns.domain"`
	XMLNsSchemaLocation string `xml:"schemaLocation,attr" json:"xmlns.schemaLocation"`
	Name                string `xml:"name" json:"name"`
	ExpireDate          string `xml:"exDate" json:"exDate"`
}

GenericRenDataResp is used to receive a generic version of a renData object from the server.

type GenericRenew 

type GenericRenew struct {
	XMLName              xml.Name `xml:"renew" json:"-"`
	XMLNSDomain          string   `xml:"domain,attr" json:"xmlns.domain"`
	XMLNSxsi             string   `xml:"xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string   `xml:"schemaLocation,attr" json:"xmlns.schemaLocation"`

	DomainName     string       `xml:"name" json:"name"`
	CurrentExpDate string       `xml:"curExpDate" json:"currentExpDate"`
	RenewPeriod    DomainPeriod `xml:"period" json:"period"`
}

GenericRenew is used to receive a renew object from a client.

type GenericRgpStatus 

type GenericRgpStatus struct {
	Status string `xml:"s,attr" json:"status"`
}

GenericRgpStatus is used to receive a generic version of a RgpStatus object from the server.

type GenericStatus 

type GenericStatus struct {
	Value string `xml:"s,attr" json:"value"`
}

GenericStatus is used to receive object status indicators from the server.

type GenericTransfer 

type GenericTransfer struct {
	XMLName             xml.Name `xml:"transfer" json:"-"`
	XMLNSDomain         string   `xml:"domain,attr" json:"xmlns.domain"`
	XMLNSContact        string   `xml:"contact,attr" json:"xmlns.contact"`
	XMLNsXSI            string   `xml:"xsi,attr" json:"xmlns.xsi"`
	XMLNsSchemaLocation string   `xml:"schemaLocation,attr" json:"xmlns.schemaLocation"`

	DomainName string           `xml:"name" json:"name"`
	Period     *DomainPeriod    `xml:"period,omitempty" json:"period"`
	ContactID  string           `xml:"id" json:"id"`
	AuthInfo   *GenericAuthInfo `xml:"authInfo,omitempty" json:"authInfo"`
}

GenericTransfer is used to receive a Transfer message from a client.

type GenericTrnDataResp 

type GenericTrnDataResp struct {
	XMLNSDomain         string `xml:"domain,attr" json:"xmlns.domain"`
	XMLNSContact        string `xml:"contact,attr" json:"xml.contact"`
	XMLNsSchemaLocation string `xml:"schemaLocation,attr" json:"xmlns.schemaLocation"`
	Name                string `xml:"name" json:"name"`
	ID                  string `xml:"id" json:"id"`
	TrStatus            string `xml:"trStatus" json:"trStatus"`
	ReID                string `xml:"reID" json:"reID"`
	ReDate              string `xml:"reDate" json:"reDate"`
	AcID                string `xml:"acID" json:"acID"`
	AcDate              string `xml:"acDate" json:"acDate"`
	ExpireDate          string `xml:"exDate" json:"exDate"`
}

GenericTrnDataResp is used to receive a generic version of a trnData object from the server.

type GenericUpData 

type GenericUpData struct {
	XMLNSRgp            string             `xml:"rgp,attr" json:"xmlns.rgp"`
	XMLNsSchemaLocation string             `xml:"schemaLocation,attr" json:"xmlns.schemaLocation"`
	GenericRgpStatuses  []GenericRgpStatus `xml:"rgpStatus" json:"rgpStatus"`
}

GenericUpData is used to receive a generic version of a upData extension object from the server.

type GenericUpdate 

type GenericUpdate struct {
	XMLName              xml.Name `xml:"update" json:"-"`
	XMLNSDomain          string   `xml:"domain,attr" json:"xmlns.domain"`
	XMLNSHost            string   `xml:"host,attr" json:"xmlns.host"`
	XMLNSContact         string   `xml:"contact,attr" json:"xmlns.contact"`
	XMLNSxsi             string   `xml:"xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string   `xml:"schemaLocation,attr" json:"xmlns.schemaLocation"`

	Name string `xml:"name" json:"name"`
	ID   string `xml:"id" json:"id"`

	AddObject    GenericUpdateAddRemove `xml:"add" json:"add"`
	RemoveObject GenericUpdateAddRemove `xml:"rem" json:"rem"`
	ChangeObject GenereicUpdateChange   `xml:"chg" json:"chg"`
}

GenericUpdate is used to receive a Update request that has not been typed yet and can be used later to create a typed version.

type GenericUpdateAddRemove 

type GenericUpdateAddRemove struct {
	Hosts     []string          `xml:"ns>hostObj" json:"ns.hostObj"`
	Contacts  []GenericContact  `xml:"contact" json:"contact"`
	Statuses  []GenericStatus   `xml:"status" json:"status"`
	Addresses []GenericHostAddr `xml:"addr" json:"addr"`
}

GenericUpdateAddRemove is used to receive an AddRemove request that hast not been typed yet and can be used later to getnerate a typed version.

type Greeting 

type Greeting struct {
	XMLName    xml.Name    `xml:"greeting" json:"-"`
	ServerID   string      `xml:"svID" json:"svID"`
	ServerDate string      `xml:"svDate" json:"svDate"`
	SvcMenu    ServiceMenu `xml:"svcMenu" json:"svcMenu"`
	DCP        GreetingDCP `xml:"dcp" json:"dcp"`
}

Greeting is used to construct and receive <greeting> messages.

func (Greeting) MessageType 

func (g Greeting) MessageType() string

MessageType is used to determine what the contained message type is based on the objects that are present in the structure.

func (Greeting) TypedMessage 

func (g Greeting) TypedMessage() Greeting

TypedMessage is used to convert generic versions of the object into a typed version after it is parsed.

type GreetingDCP 

type GreetingDCP struct {
	XMLName   xml.Name             `xml:"dcp" json:"-"`
	Access    GreetingDCPAccess    `xml:"access" json:"access"`
	Statement GreetingDCPStateemnt `xml:"statement" json:"statement"`
}

GreetingDCP is used to for the DCP section of a Greeting message.

type GreetingDCPAccess 

type GreetingDCPAccess struct {
	XMLName xml.Name `xml:"access" json:"-"`
	All     string   `xml:"all" json:"all"`
}

GreetingDCPAccess represents the access section of a Greeting>DCP message.

type GreetingDCPStateemnt 

type GreetingDCPStateemnt struct {
	XMLName   xml.Name                      `xml:"statement" json:"-"`
	Purpose   GreetingDCPStateemntPurpose   `xml:"purpose" json:"purpose"`
	Recipient GreetingDCPStateemntRecipient `xml:"recipient" json:"recipient"`
	Retention GreetingDCPStateemntRetention `xml:"retention" json:"retention"`
}

GreetingDCPStateemnt represents the statement section of a Greeting>DCP message.

type GreetingDCPStateemntPurpose 

type GreetingDCPStateemntPurpose struct {
	XMLName xml.Name `xml:"purpose" json:"-"`
	Admin   string   `xml:"admin" json:"admin"`
	Prov    string   `xml:"prov" json:"prov"`
}

GreetingDCPStateemntPurpose represents the purpose section of a Greeting>DCP>Statement message.

type GreetingDCPStateemntRecipient 

type GreetingDCPStateemntRecipient struct {
	XMLName xml.Name `xml:"recipient" json:"-"`
	Ours    string   `xml:"ours" json:"ours"`
	Public  string   `xml:"public" json:"public"`
}

GreetingDCPStateemntRecipient represents the Recipient section of a Greeting>DCP>Statement message.

type GreetingDCPStateemntRetention 

type GreetingDCPStateemntRetention struct {
	XMLName xml.Name `xml:"retention" json:"-"`
	Stated  string   `xml:"stated" json:"started"`
}

GreetingDCPStateemntRetention represents the Retention section of a Greeting>DCP>Statement message.

type Hello 

type Hello struct {
	XMLName xml.Name `xml:"hello" json:"-"`
	XMLNS   string   `xml:"xmlns,attr,omitempty" json:"xmlns"`
}

Hello is used to construct and receive <hello> messages.

func (Hello) MessageType 

func (h Hello) MessageType() string

MessageType is used to determine what the contained message type is based on the objects that are present in the structure.

func (Hello) TypedMessage 

func (h Hello) TypedMessage() Hello

TypedMessage is used to convert generic versions of the object into a typed version after it is parsed.

type HostAddress 

type HostAddress struct {
	XMLName   xml.Name      `xml:"host:addr"  json:"-"`
	IPVersion IPVersionName `xml:"ip,attr" json:"ip"`
	Address   string        `xml:",chardata" json:"address"`
}

HostAddress is used to hold the required information for a HostAddress in a host create object. The values are Address, to contain the IP address and the IP version which is allowed to be "v4" and "v6" depending on the IP type.

type HostAuth 

type HostAuth struct {
	Password string `xml:"host:pw,omitempty" json:"host.pw"`
}

HostAuth is used to hold the auth password for a host.

type HostCheck 

type HostCheck struct {
	XMLName              xml.Name `xml:"host:check" json:"host.check"`
	XMLNSHost            string   `xml:"xmlns:host,attr" json:"xmlns.host"`
	XMLNSxsi             string   `xml:"xmlns:xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string   `xml:"xsi:schemaLocation,attr"  json:"xmlns.schemaLocation"`
	HostNames            []string `xml:"host:name" json:"host.name"`
}

HostCheck is used to construct and receive <host:check> messages.

type HostChkDataResp 

type HostChkDataResp struct {
	XMLNS               string      `xml:"xmlns:host,attr" json:"xmlns.host"`
	XMLNsSchemaLocation string      `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`
	Hosts               []CheckHost `xml:"host:cd" json:"host.cd"`
}

HostChkDataResp is used to receive a check host response.

type HostCreDataResp 

type HostCreDataResp struct {
	XMLNSHost           string `xml:"xmlns:host,attr" json:"xmlns.host"`
	XMLNsSchemaLocation string `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`
	Name                string `xml:"host:name" json:"host.name"`
	CreateDate          string `xml:"host:crDate" json:"host.crDate"`
}

HostCreDataResp is the non generic form of GenericCreDataResp containing the server responses from the create request for the host.

type HostCreate 

type HostCreate struct {
	XMLName              xml.Name      `xml:"host:create"  json:"-"`
	XMLNSHost            string        `xml:"xmlns:host,attr" json:"xmlns.host"`
	XMLNSxsi             string        `xml:"xmlns:xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string        `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`
	HostName             string        `xml:"host:name" json:"hostname"`
	Addresses            []HostAddress `xml:"host:addr" json:"address"`
}

HostCreate is used to generate a create message for a host.

type HostDelete 

type HostDelete struct {
	XMLName              xml.Name `xml:"host:delete" json:"-"`
	XMLNSHost            string   `xml:"xmlns:host,attr" json:"xmlns.host"`
	XMLNSxsi             string   `xml:"xmlns:xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string   `xml:"xsi:schemaLocation,attr"  json:"xmlns.schemaLocation"`

	HostName string `xml:"host:name" json:"host.name"`
}

HostDelete is used to generate a delete message for a host.

type HostInfDataResp 

type HostInfDataResp struct {
	XMLNSHost           string        `xml:"xmlns:host,attr" json:"xmlns.host"`
	XMLNsSchemaLocation string        `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`
	Name                string        `xml:"host:name" json:"host.name"`
	ROID                string        `xml:"host:roid" json:"host.roid"`
	Status              []HostStatus  `xml:"host:status" json:"host.status"`
	Addresses           []HostAddress `xml:"host:addr" json:"host.addr"`
	ClientID            string        `xml:"host:clID" json:"host.clID"`
	CreateID            string        `xml:"host:crID" json:"host.crID"`
	CreateDate          string        `xml:"host:crDate" json:"host.crDate"`
	UpdateID            string        `xml:"host:upID,omitempty" json:"host.upID"`
	UpdateDate          string        `xml:"host:upDate,omitempty" json:"upDate"`
	TransferDate        string        `xml:"host:trDate,omitempty" json:"trDate"`
}

HostInfDataResp is used to represent a host:infData response object from the server.

type HostInfo 

type HostInfo struct {
	XMLName             xml.Name  `xml:"host:info" json:"-"`
	XMLNS               string    `xml:"xmlns:host,attr" json:"xmlns.hosts"`
	XMLNSxsi            string    `xml:"xmlns:xsi,attr" json:"xmlns.xsi"`
	XMLNSSchemaLocation string    `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`
	Name                string    `xml:"host:name" json:"host.name"`
	HostAuthObj         *HostAuth `xml:"host:authInfo,omitempty" json:"host.authInfo"`
}

HostInfo is used to generate an info message for a host.

type HostStatus 

type HostStatus struct {
	XMLName    xml.Name `xml:"host:status" json:"-"`
	StatusFlag string   `xml:"s,attr" json:"status"`
}

HostStatus is used to represent a status of a host.

type HostUpdate 

type HostUpdate struct {
	XMLName              xml.Name `xml:"host:update" json:"-"`
	XMLNSHost            string   `xml:"xmlns:host,attr" json:"xmlns.host"`
	XMLNSxsi             string   `xml:"xmlns:xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string   `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`

	HostName string `xml:"host:name" json:"host.name"`

	AddObject    HostUpdateAddRemove `xml:"host:add" json:"host.add"`
	RemoveObject HostUpdateAddRemove `xml:"host:rem" json:"host.rem"`
	ChangeObject *HostUpdateChange   `xml:"host:chg,omitempty" json:"host.chg"`
}

HostUpdate is used to generate an update message for a host.

type HostUpdateAddRemove 

type HostUpdateAddRemove struct {
	Addresses []HostAddress `xml:"host:addr" json:"host.addr"`
	Statuses  []HostStatus  `xml:"host:status" json:"host.status"`
}

HostUpdateAddRemove is used to generate the add or rem portion of a host update object.

func GetEPPHostUpdateAddRemove 

func GetEPPHostUpdateAddRemove(Addresses []HostAddress, Statuses []string) HostUpdateAddRemove

GetEPPHostUpdateAddRemove constructs the HostUpdateAddRemove object used for adding or removing host addresses or statuses from a host.

type HostUpdateChange 

type HostUpdateChange struct {
	XMLName  xml.Name `xml:"host:chg" json:"-"`
	HostName string   `xml:"host:name,omitempty" json:"host.name"`
}

HostUpdateChange is used to generate the change portion of the host update object.

func GetEPPHostUpdateChange 

func GetEPPHostUpdateChange(NewHostName string) HostUpdateChange

GetEPPHostUpdateChange constructs a HostUpdateChange object used for changing the Hostname of a host object.

type IPVersionName 

type IPVersionName string

IPVersionName is a type to indicate which IP version an Address is. 

const (
	// IPv4 is used to indicate an IPv4 address.
	IPv4 IPVersionName = "v4"

	// IPv6 is used to indicate an IPv6 address.
	IPv6 IPVersionName = "v6"
)

type Info 

type Info struct {
	XMLName        xml.Name     `xml:"info" json:"-"`
	DomainInfoObj  *DomainInfo  `xml:",omitempty" json:"domain"`
	HostInfoObj    *HostInfo    `xml:",omitempty" json:"host"`
	ContactInfoObj *ContactInfo `xml:",omitempty" json:"contact"`

	GenericInfoObj *GenericInfo `xml:",omitempty" json:"info"`
}

Info is used to construct and receive <info> messages.

func (*Info) MessageType 

func (i *Info) MessageType() string

MessageType is used to determine what the contained message type is based on the objects that are present in the structure.

func (Info) TypedMessage 

func (i Info) TypedMessage() Info

TypedMessage is used to convert generic versions of the object into a typed version after it is parsed.

type JobsContact 

type JobsContact struct {
	XMLNSJobsContact    string `xml:"xmlns:jobsContact,attr" json:"xmlns.jobscontact"`
	XMLNsSchemaLocation string `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`
	Title               string `xml:"jobsContact:title" json:"title"`
	Website             string `xml:"jobsContact:website" json:"website"`
	IndustryType        string `xml:"jobsContact:industryType" json:"industryType"`
	IsAdminContact      string `xml:"jobsContact:isAdminContact" json:"isAdminContact"`
	IsAssociationMember string `xml:"jobsContact:isAssociationMember" json:"isAssociationMember"`
}

JobsContact is the non generic form of GenericInfDataRespExt containing the server responses from the job contact extenDomainHostListsion.

type LaunchCD 

type LaunchCD struct {
	Name     LaunchCDName     `xml:"launch:name" json:"launch.name"`
	ClaimKey LaunchCDClaimKey `xml:"launch:claimKey" json:"launch.claimKey"`
}

LaunchCD is used to represent a launch:cd object from the server.

type LaunchCDClaimKey 

type LaunchCDClaimKey struct {
	ValidatorID string `xml:"validatorID,attr" json:"validatorID"`
	Value       string `xml:",chardata" json:"value"`
}

LaunchCDClaimKey is used to represent a launch:cd>claimKey object allowing the validatorID attribute to be set.

type LaunchCDName 

type LaunchCDName struct {
	Exists int    `xml:"exists,attr" json:"exists"`
	Name   string `xml:",chardata" json:"chardata"`
}

LaunchCDName is used to represent a launch:cd>name object allowing the exists attribute to be set.

type LaunchChkData 

type LaunchChkData struct {
	XMLName     xml.Name   `xml:"launch:chkData" json:"launch.chkData"`
	XMLNSLaunch string     `xml:"xmlns:launch,attr" json:"xmlns.launch"`
	LaunchPhase string     `xml:"launch:phase" json:"launch.phase"`
	LaunchCDs   []LaunchCD `xml:"launch:cd" json:"launch.cd"`
}

LaunchChkData is used to represent a launch:chkData object from the server.

type Login 

type Login struct {
	XMLName      xml.Name `xml:"login" json:"-"`
	ClientID     string   `xml:"clID" json:"clID"`
	Password     string   `xml:"pw" json:"pw"`
	NewPassword  string   `xml:"newPW,omitempty" json:"newPW"`
	LoginOptions struct {
		XMLName  xml.Name `xml:"options" json:"-"`
		Version  string   `xml:"version" json:"version"` // default 1.0
		Language string   `xml:"lang" json:"lang"`       // default en
	} `xml:"options" json:"options"`
	Services struct {
		XMLName               xml.Name `xml:"svcs" json:"-"`
		URIs                  []string `xml:"objURI" json:"objURI"`
		ServiceExtensionsURIs []string `xml:"svcExtension>extURI" json:"svcExtensions.extURI"`
	} `xml:"svcs" json:"svcs"`
}

Login is used to construct and receive <login> messages.

func (Login) MessageType 

func (l Login) MessageType() string

MessageType is used to determine what the contained message type is based on the objects that are present in the structure.

func (Login) TypedMessage 

func (l Login) TypedMessage() Login

TypedMessage is used to convert generic versions of the object into a typed version after it is parsed.

type Logout 

type Logout struct {
	XMLName xml.Name `xml:"logout" json:"logout"`
}

Logout is used to construct and receive <logout> messages.

func (Logout) MessageType 

func (l Logout) MessageType() string

MessageType is used to determine what the contained message type is based on the objects that are present in the structure.

func (Logout) TypedMessage 

func (l Logout) TypedMessage() Logout

TypedMessage is used to convert generic versions of the object into a typed version after it is parsed.

type MessageQueue 

type MessageQueue struct {
	XMLName xml.Name `xml:"msgQ" json:"-"`
	Count   int64    `xml:"count,attr" json:"count"`
	ID      string   `xml:"id,attr" json:"id"`
	QDate   string   `xml:"qDate,omitempty" json:"qDate,omitempty"`
	Message string   `xml:"msg,omitempty" json:"msg,omitempty"`
}

MessageQueue is used to construct and receive <msgQ> messages as part of a respons message.

type NameStoreExtension 

type NameStoreExtension struct {
	XMLName              xml.Name `xml:"namestoreExt:namestoreExt" json:"-"`
	XMLNSNamestoreExt    string   `xml:"xmlns:namestoreExt,attr" json:"xmlns.namestoreExt"`
	XMLNSxsi             string   `xml:"xmlns:xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string   `xml:"xsi:schemaLocation,attr"  json:"xmlns.schemaLocation"`
	SubProducts          []string `xml:"namestoreExt:subProduct" json:"namestoreExt.subProduct"`
}

NameStoreExtension is used to construct and receive <namestoreExt:namestoreExt> messages.

func GetDefaultNameStoreExtension 

func GetDefaultNameStoreExtension() *NameStoreExtension

GetDefaultNameStoreExtension creates a default NameStoreExtension object with the standard namespaces set.

func GetNameStoreExtension 

func GetNameStoreExtension(productName NameStoreExtensionProduct) *NameStoreExtension

GetNameStoreExtension will create a NameStoreExtension object with the provided product name.

type NameStoreExtensionProduct 

type NameStoreExtensionProduct string

NameStoreExtensionProduct is used to indicate a namestore product type. 

const NameStoreProductCOM NameStoreExtensionProduct = "dotCOM"

NameStoreProductCOM holds the name of the verisign product that is used for domains in .COM. 

const NameStoreProductNET NameStoreExtensionProduct = "dotNET"

NameStoreProductNET holds the name of the verisign product that is used for domains in .NET.

type PhoneNumber 

type PhoneNumber struct {
	Number    string `xml:",chardata" json:"number"`
	Extension string `xml:"x,attr" json:"extension"`
}

PhoneNumber is used to hold the information related to a Phone Number as EPP needs is represnted.

func GetEPPPhoneNumber 

func GetEPPPhoneNumber(Number string, Extension string) PhoneNumber

GetEPPPhoneNumber is used to generate a PhoneNumber object from a phone number and extension (if valid).

type Poll 

type Poll struct {
	XMLName   xml.Name      `xml:"poll" json:"-"`
	MessageID string        `xml:"msgID,attr,omitempty" json:"msgID"`
	Operation PollOperation `xml:"op,attr" json:"op"`
}

Poll is used to construct and receive <poll> messages.

func (Poll) MessageType 

func (h Poll) MessageType() string

MessageType is used to determine what the contained message type is based on the objects that are present in the structure.

type PollOperation 

type PollOperation string

PollOperation is a type that represents the valid poll operations that may be requested. 

const (
	// PollOperationRequest represents a poll request operation.
	PollOperationRequest PollOperation = "req"

	// PollOperationAcknowledge represents a poll acknowledge operation.
	PollOperationAcknowledge PollOperation = "ack"
)

type PostalInfo 

type PostalInfo struct {
	XMLName        xml.Name          `xml:"contact:postalInfo" json:"-"`
	PostalInfoType string            `xml:"type,attr" json:"postalInfoType"`
	Name           string            `xml:"contact:name" json:"name"`
	Org            string            `xml:"contact:org" json:"org"`
	Address        PostalInfoAddress `xml:"contact:addr" json:"address"`
}

PostalInfo represents a Postal Info block of a create message for a contact.

func GetEPPPostalInfo 

func GetEPPPostalInfo(PostalType string, Name string, Org string,
	Street1 string, Street2 string, Street3 string, City string,
	StateProv string, PostalCode string, Country string,
) PostalInfo

GetEPPPostalInfo uses the parameters passed to generate a postal info object that can be used in a contact create message. There are three street values allowed but if a value is left blank it will be excluded from the list of entries created.

type PostalInfoAddress 

type PostalInfoAddress struct {
	XMLName xml.Name `xml:"contact:addr" json:"-"`
	Street  []string `xml:"contact:street" json:"street"`
	City    string   `xml:"contact:city" json:"city"`
	Sp      string   `xml:"contact:sp" json:"sp"`
	Pc      string   `xml:"contact:pc" json:"pc"`
	Cc      string   `xml:"contact:cc" json:"cc"`
}

PostalInfoAddress represents the address portion of a postal info object.

type Renew 

type Renew struct {
	XMLName xml.Name `xml:"renew" json:"-"`

	DomainRenewObj  *DomainRenew  `xml:",omitempty" json:"domain"`
	GenericRenewObj *GenericRenew `xml:",omitempty" json:"renew"`
}

Renew is used to construct a renew message.

func (Renew) MessageType 

func (r Renew) MessageType() string

MessageType is used to determine what the contained message type is based on the objects that are present in the structure.

func (Renew) TypedMessage 

func (r Renew) TypedMessage() Renew

TypedMessage is used to convert generic versions of the object into a typed version after it is parsed.

type Response 

type Response struct {
	XMLName       xml.Name           `xml:"response" json:"-"`
	Result        *Result            `xml:"result" json:"result"`
	MessageQueue  *MessageQueue      `xml:"msgQ" json:"msgQ"`
	ResultData    *ResultData        `xml:"resData,omitempty" json:"resData,omitempty"`
	Extension     *ResponseExtension `xml:"extension,omitempty" json:"extension,omitempty"`
	TransactionID struct {
		XMLName             xml.Name `xml:"trID" json:"-"`
		ClientTransactionID string   `xml:"clTRID" json:"clTRID"`
		ServerTransactionID string   `xml:"svTRID" json:"svTRID"`
	} `xml:"trID" json:"trID"`
}

Response is used to construct and receive <response> messages.

func (Response) GetError 

func (r Response) GetError() error

GetError will create an error object with the message contained in the response body.

func (Response) HasMessageQueue 

func (r Response) HasMessageQueue() bool

HasMessageQueue will returned true if the message has a msgQ component to it.

func (Response) IsError 

func (r Response) IsError() bool

IsError will return true if the response code indicates an error.

func (Response) IsFatalError 

func (r Response) IsFatalError() bool

IsFatalError will return true if the response code indicates an error that results in a closed connection.

func (Response) MessageType 

func (r Response) MessageType() string

MessageType is used to determine what the contained message type is based on the objects that are present in the structure.

func (Response) TypedMessage 

func (r Response) TypedMessage() Response

TypedMessage is used to convert generic versions of the object into a typed version after it is parsed.

type ResponseExtension 

type ResponseExtension struct {
	GenericChkDataRespExt *GenericChkDataRespExt `xml:"chkData" json:"chkData"`
	GenericNamestore      *GenericNamestore      `xml:"namestoreExt" json:"namespaceExt"`
	GenericInfDataResp    *GenericInfDataRespExt `xml:"infData" json:"infData"`
	GenericUpData         *GenericUpData         `xml:"upData" json:"upData"`

	LaunchChkData *LaunchChkData      `xml:"launch:chkData" json:"launch.chkData"`
	NameStore     *NameStoreExtension `xml:"namestoreExt:namestoreExt" json:"namestoreExt.namestoreExt"`
	SecDNSInfData *SecDNSInfData      `xml:"secDNS:infData" json:"secDNS.infData"`
	RgpUpData     *RgpUpData          `xml:"rgp:upData" json:"rgp.upData"`
	JobsContact   *JobsContact        `xml:"jobsContact:infData" json:"jobsContact.infData"`
}

ResponseExtension is used to receive a extension object from the server as part of the response or to serialize an object once the values have been converted to the non generic version of each object.

func (ResponseExtension) TypedMessage 

func (r ResponseExtension) TypedMessage() ResponseExtension

TypedMessage is used to convert generic versions of the object into a typed version after it is parsed.

type RestoreExtension 

type RestoreExtension struct {
	XMLName              xml.Name         `xml:"rgp:update" json:"-"`
	XMLNSRgp             string           `xml:"xmlns:rgp,attr" json:"xmlns.rgp"`
	XMLNSxsi             string           `xml:"xmlns:xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string           `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`
	Operation            RestoreOperation `xml:"rgp:restore" json:"rgp.restore"`
}

RestoreExtension is used to generate a Restore extension.

type RestoreOperation 

type RestoreOperation struct {
	XMLName   xml.Name             `xml:"rgp:restore" json:"-"`
	Operation RestoreOperationType `xml:"op,attr" json:"operation"`
	Report    *RestoreReport       `xml:",omitempty" json:"report"`
}

RestoreOperation is used to indicate which operation should be taken by the server and can pass the report to the registry.

type RestoreOperationType 

type RestoreOperationType string

RestoreOperationType is used to indicate which type of restore operation should be taken by the server. 

const (
	// RestoreOperationRequest is used to indicate that a restore request
	// is being sent to the server.
	RestoreOperationRequest RestoreOperationType = "request"

	// RestoreOperationReport is used to indicate that a restore report
	// is being sent to the server.
	RestoreOperationReport RestoreOperationType = "report"
)

type RestoreReport 

type RestoreReport struct {
	XMLName            xml.Name `xml:"rgp:report" json:"-"`
	PreWHOISData       string   `xml:"rgp:preData" json:"rgp.preData"`
	PostWHOISData      string   `xml:"rgp:postData" json:"rgp.postData"`
	DomainDeletedTime  string   `xml:"rgp:delTime" json:"rgp.delTime"`
	DomainRestoredTime string   `xml:"rgp:resTime" json:"rgp.resTime"`
	Reason             string   `xml:"rgp:resReason" json:"rgp.resReason"`
	Statements         []string `xml:"rgp:statement" json:"rgp.statement"`
	Other              string   `xml:"rgp:other" json:"rgp.other"`
}

RestoreReport is used to pass required data back to the registry when reporting a domain restoration.

func (*RestoreReport) SetDeleteTime 

func (r *RestoreReport) SetDeleteTime(t time.Time)

SetDeleteTime is used to set the timestamp that the Domain was deleted in the required format.

func (*RestoreReport) SetRestoreTime 

func (r *RestoreReport) SetRestoreTime(t time.Time)

SetRestoreTime is used to set the timestamp that the Domain was restored in the required format.

type Result 

type Result struct {
	Code int    `xml:"code,attr" json:"code"`
	Msg  string `xml:"msg" json:"msg"`
}

Result is used to receive a result object fromt he server containing a message code and a message if applicable.

func (Result) TypedMessage 

func (r Result) TypedMessage() Result

TypedMessage is used to convert generic versions of the object into a typed version after it is parsed.

type ResultData 

type ResultData struct {
	GenericChkDataResp *GenericChkDataResp `xml:"chkData,omitempty" json:"chkData,omitempty"`
	GenericCreDataResp *GenericCreDataResp `xml:"creData,omitempty" json:"creData,omitempty"`
	GenericInfDataResp *GenericInfDataResp `xml:"infData,omitempty" json:"infData,omitempty"`
	GenericRenDataResp *GenericRenDataResp `xml:"renData,omitempty" json:"renData,omitempty"`
	GenericTrnDataResp *GenericTrnDataResp `xml:"trnData,omitempty" json:"trnData,omitempty"`

	DomainChkDataResp *DomainChkDataResp `xml:"domain:chkData,omitempty" json:"domain:chkData,omitempty"`
	DomainCreDataResp *DomainCreDataResp `xml:"domain:creData,omitempty" json:"domain:creData,omitempty"`
	DomainInfDataResp *DomainInfDataResp `xml:"domain:infData,omitempty" json:"domain:infData,omitempty"`
	DomainRenDataResp *DomainRenDataResp `xml:"domain:renData,omitempty" json:"domain:renData,omitempty"`
	DomainTrnDataResp *DomainTrnDataResp `xml:"domain:trnData,omitempty" json:"domain:trnData,omitempty"`

	HostChkDataResp *HostChkDataResp `xml:"host:chkData,omitempty" json:"host:chkData,omitempty"`
	HostCreDataResp *HostCreDataResp `xml:"host:creData,omitempty" json:"host:creData,omitempty"`
	HostInfDataResp *HostInfDataResp `xml:"host:infData,omitempty" json:"host:infData,omitempty"`

	ContactChkDataResp *ContactChkDataResp `xml:"contact:chkData,omitempty" json:"contact:chkData,omitempty"`
	ContactCreDataResp *ContactCreDataResp `xml:"contact:creData,omitempty" json:"contact:creData,omitempty"`
	ContactInfDataResp *ContactInfDataResp `xml:"contact:infData,omitempty" json:"contact:infData,omitempty"`
	ContactTrnDataResp *ContactTrnDataResp `xml:"contact:trnData,omitempty" json:"contact:trnData,omitempty"`
}

ResultData is used to receive a resultData object from the server or to serialize an object once the values have been converted to the non generic version of each object.

func (ResultData) MessageType 

func (r ResultData) MessageType() string

MessageType is used to determine what the contained message type is based on the objects that are present in the structure.

func (ResultData) TypedMessage 

func (r ResultData) TypedMessage() ResultData

TypedMessage is used to convert generic versions of the object into a typed version after it is parsed.

type RgpStatus 

type RgpStatus struct {
	Status string `xml:"s,attr" json:"status"`
}

RgpStatus contains a status value associated with an rgp object.

type RgpUpData 

type RgpUpData struct {
	XMLNSRgp            string      `xml:"xmlns:rgp,attr" json:"xmlns.rgp"`
	XMLNsSchemaLocation string      `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`
	RgpStatuses         []RgpStatus `xml:"rgp:rgpStatus" json:"rgpStatus"`
}

RgpUpData is the non generic form of GenericUpData containing the server responses from the create request for the Rgp object.

type SecDNSInfData 

type SecDNSInfData struct {
	XMLNSsecDNS         string   `xml:"xmlns:secDNS,attr" json:"xmlns.secdns"`
	XMLNsSchemaLocation string   `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`
	DSData              []DSData `xml:"secDNS:dsData" json:"dsdata"`
}

SecDNSInfData is the non generic form of the GenericInfDataRespExt object containing a SecDNS:infData object.

type SecDNSUpdate 

type SecDNSUpdate struct {
	XMLName              xml.Name  `xml:"secDNS:update" json:"-"`
	XMLNSSecDNS          string    `xml:"xmlns:secDNS,attr" json:"xmlns.secDNS"`
	XMLNSxsi             string    `xml:"xmlns:xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string    `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`
	RemDS                *[]DSData `xml:"secDNS:rem>secDNS:dsData,omitempty" json:"secDNS.rem.secDNS.dsData"`
	AddDS                *[]DSData `xml:"secDNS:add>secDNS:dsData,omitempty" json:"secDNS.add.secDNS.dsData"`
}

SecDNSUpdate is used to represent an update for the DSData for a domain.

type ServiceMenu 

type ServiceMenu struct {
	XMLName               xml.Name `xml:"svcMenu" json:"-"`
	Version               string   `xml:"version" json:"version"`
	Language              string   `xml:"lang" json:"lang"`
	URIs                  []string `xml:"objURI" json:"objURI"`
	ServiceExtensionsURIs []string `xml:"svcExtension>extURI" json:"svcExtension.extURI"`
}

ServiceMenu allows the EPP Service menu object to be desreialized This object usually exists in the greeting message and values from it are used in resuests such as the login message.

func GetDefaultServiceMenu 

func GetDefaultServiceMenu() ServiceMenu

GetDefaultServiceMenu generates a default service menu as described by the verisign EPP testing tool.

type SyncUpdateExtension 

type SyncUpdateExtension struct {
	XMLName              xml.Name `xml:"sync:update" json:"-"`
	XMLNSSync            string   `xml:"xmlns:sync,attr" json:"xmlns.sync"`
	XMLNSxsi             string   `xml:"xmlns:xsi,attr" json:"xmlns.xsi"`
	XMLxsiSchemaLocation string   `xml:"xsi:schemaLocation,attr" json:"xmlns.schemaLocation"`
	ExpMonthDay          string   `xml:"sync:expMonthDay" json:"sync.expMonthDay"`
}

SyncUpdateExtension is used to hold an Expire Month and Day value used for passing a SyncUpdate extension to the registry.

type Transfer 

type Transfer struct {
	XMLName xml.Name `xml:"transfer" json:"-"`

	Operation TransferOperationType `xml:"op,attr" json:"op"`

	DomainTransferObj  *DomainTransfer  `xml:",omitempty" json:"domain"`
	ContactTransferObj *ContactTransfer `xml:",omitempty" json:"contact"`

	GenericTransferObj *GenericTransfer `xml:",omitempty" json:"transfer"`
}

Transfer is used to hold one of the subordinate transfer objects for either a Domain or a Contact.

func (*Transfer) MessageType 

func (t *Transfer) MessageType() string

MessageType is used to determine what the contained message type is based on the objects that are present in the structure.

func (Transfer) TypedMessage 

func (t Transfer) TypedMessage() Transfer

TypedMessage is used to convert generic versions of the object into a typed version after it is parsed.

type TransferOperationType 

type TransferOperationType string

TransferOperationType is a type that represents the possible transfer operations allowed in EPP. 

const (

	// TransferRequest represents an EPP transfer request message.
	TransferRequest TransferOperationType = "request"

	// TransferQuery represents an EPP transfer query message.
	TransferQuery TransferOperationType = "query"

	// TransferApprove represents an EPP transfer approve message.
	TransferApprove TransferOperationType = "approve"

	// TransferReject represents an EPP transfer reject message.
	TransferReject TransferOperationType = "reject"

	// TransferCancel represents an EPP transfer cancel message.
	TransferCancel TransferOperationType = "cancel"
)

type Update 

type Update struct {
	XMLName xml.Name `xml:"update" json:"-"`

	DomainUpdateObj  *DomainUpdate  `xml:",omitempty" json:"domain"`
	HostUpdateObj    *HostUpdate    `xml:",omitempty" json:"host"`
	ContactUpdateObj *ContactUpdate `xml:",omitempty" json:"contact"`

	GenericUpdateObj *GenericUpdate `xml:",omitempty" json:"update"`
}

Update is used to hold one of the subordinate create objects for either a Host, Domain or Contact.

func (*Update) MessageType 

func (u *Update) MessageType() string

MessageType is used to determine what the contained message type is based on the objects that are present in the structure.

func (Update) TypedMessage 

func (u Update) TypedMessage() Update

TypedMessage is used to convert generic versions of the object into a typed version after it is parsed.

Source Files

View all Source files

Directories

Path Synopsis
app
tools
epp-inspect

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.