# protocol.rnc:  RELAX NG schema for NZ Shared Registry System Protocol
# 
# Author:     Srdjan Jankovic
# Version:    Release version 5.1
# Revised:    SRS Development Team
# 
# Based on a prototype written by Ewen McNeill, 2002/03/05

# The NZ SRS registrar/registry protocol consists of an (externally)
#  signed XML request document containing a series of actions to be
#  performed on the register (updating it, or extracting information
#  from it), which is answered by an (externally) signed XML response
#  document containing answers to each of those actions, or an overall
#  error message.
# 
#  Each action has its own element to specify that action, and there
#  is also a response element which is used to enclose each response
#  to an action.
# 
#  Each update-type action has an id number which is the registrar's
#  identification for the action, which must be unique in all requests
#  made to the register by that registrar.  The status of each action
#  with an id number can be queried with the "getmsg" action.
# 
#  The registrar internally is the effective registrar of the
#  transaction.  This must normally match the registrar UID specified
#  externally.  However the registry may set this to a specific
#  registrar other than its own "psuedo registrar" to perform actions
#  "as if" it was that registrar, eg filter by that registrar.
# 
#  It is also included to assist debugging (by allowing network streams
#  to be more directly linked to the registrar).
# 
#  ====================================================================
# 
# Copyright 2002-2009 NZ Registry Services
# 
# This file is part of the Shared Registry System
# 
# The Shared Registry System is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
# 
# The Shared Registry System is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with the Shared Registry System; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
#

namespace a = "http://relaxng.org/ns/compatibility/annotations/1.0"

# == Common entities ====================================================

# Simple data types

Number = xsd:nonNegativeInteger
Dollars = xsd:decimal { fractionDigits = "2" }
True = "1"
False = "0"
Boolean = False | True

# Valid date
Date =
  attribute Year { Number },
  attribute Month { Number },
  attribute Day { Number }
# Valid time.
# If TimeZoneOffset omitted, NZ local time assumed. The mandatory format is
# (+/-)HH:MM (the sign is mandatory!), although (+/-)HHMM will be accepted
# with the ':' silently added.
# If Second is omitted, it defaults to 0
Time =
  attribute Hour { Number },
  attribute Minute { Number },
  attribute Second { Number }?,
  attribute TimeZoneOffset { text }?
  
TimeStamp = Date, Time

# Valid domain name
DomainName = string

# Valid DomainName details - for registering IDN
DomainNameUnicode = string
DomainNameUnicodeHex = string
DomainNameLanguage = string

# Valid unique identifier ?
UID = string

# Valid term
Term = xsd:positiveInteger

RegistrarId = xsd:positiveInteger

RegistrarIdOrOTHERS = RegistrarId | "OTHERS"

# Complex data types/definitions
ActionResponse =
  element.Error
  | element.Domain*
  | element.UDAIValid
  | element.DomainTransfer
  | element.BillingTrans*
  | element.DeferredRegistrarIncome*
  | element.Registrar*
  | element.SysParam*
  | element.RunLog*
  | element.Schedule*
  | element.AccessControlList*
  | (element.RawRequest, element.RawResponse)
  | element.BillingAmount*
  | element.Handle*
  | element.Message*

RegDomainStatus = "Active" | "PendingRelease"
DomainStatus = RegDomainStatus | "Available"
BillStatus = "PendingConfirmation" | "Confirmed"

Contact =
  element.PostalAddress?,
  element.Phone?,
  element.Fax?

ContactAttr =
  attribute HandleId { text }?,
  attribute Name { text }?,
  attribute Email { text }?,
  attribute ActionId { text }?

ContactFilter =
  element.PostalAddressFilter?,
  element.Phone?,
  element.Fax?

ContactAttrFilter =
  attribute HandleId { text }?,
  attribute Name { text }?,
  attribute Email { text }?

PhoneAttr =
  attribute CountryCode { text }?,
  attribute AreaCode { text }?,
  attribute LocalNumber { text }?

Role =
  "Registrar"
  | "Registry"
  | "Whois"
  | "Query"
  | "CreateDomain"
  | "UpdateDomain"
  | "TransferDomain"
  | "CancelDomain"
  | "UncancelDomain"
  | "UpdateRegistrar"
  | "Administer"
  | "Supervisor"
  | "Connect"
  | "ReleaseDomain"
  | "QueryACL"
  | "UpdateACL"
  | "QueryRegACL"

ScheduledJob =
  "BuildDnsZoneFiles"
  | "ReleaseDomains"
  | "RenewDomains"
  | "GenerateDomainReport"
  | "GenerateStatsReport"

DateRange =
  element.From?,
  element.To?

AccountingAction = "Credit" | "Debit"

# == Root element =======================================================

element.NZSRSRequest =
  element NZSRSRequest {
    attribute VerMajor { Number },
    attribute VerMinor { Number },
    attribute RegistrarId { RegistrarId }?,
    (element.DomainCreate
     | element.DomainUpdate
     | element.HandleCreate
     | element.HandleUpdate
     | element.HandleDetailsQry
     | element.Whois
     | element.DomainDetailsQry
     | element.ActionDetailsQry
     | element.UDAIValidQry
     | element.RegistrarCreate
     | element.RegistrarUpdate
     | element.RegistrarDetailsQry
     | element.RegistrarAccountQry
     | element.GetMessages
     | element.AckMessage
     | element.SysParamsCreate
     | element.SysParamsUpdate
     | element.SysParamsQry
     | element.RunLogCreate
     | element.RunLogQry
     | element.ScheduleCreate
     | element.ScheduleCancel
     | element.ScheduleQry
     | element.ScheduleUpdate
     | element.BillingAmountUpdate
     | element.BillingAmountQry
     | element.DeferredIncomeSummaryQry
     | element.DeferredIncomeDetailQry
     | element.BilledUntilAdjustment
     | element.BuildDnsZoneFiles
     | element.GenerateDomainReport
     | element.AdjustRegistrarAccount
     | element.AccessControlListQry
     | element.AccessControlListAdd
     | element.AccessControlListRemove)+
  }

element.NZSRSResponse =
  element NZSRSResponse {
    attribute VerMajor { Number },
    attribute VerMinor { Number },
    attribute RegistrarId { RegistrarId }?,
    (element.Response+ | element.Error)
  }

# == Request actions ====================================================

# ++ Domain details update actions ++++++++++++++++++++++++++++++++++++++

# Create new domain name (record)
# ActionResponse: (Domain|Error)
element.DomainCreate =
  element DomainCreate {
    attribute ActionId { UID },
    attribute DomainName { DomainName },
    attribute DomainNameUnicode { DomainNameUnicode }?,
    attribute DomainNameLanguage { DomainNameLanguage }?,
    attribute RegistrantRef { UID }?,
    attribute Term { Term },
    [ a:defaultValue = "1" ] attribute Delegate { Boolean }?,
    element.RegistrantContact,
    element.AdminContact?,
    element.TechnicalContact?,
    element.NameServers?,
    element.AuditText?
  }

# Update domain record
# Usage:
#   - update all domain records that match DomainNameFilter
#     pattern (? replaces a single character, * replaces a group of characters);
#     not all updates are possible (sensible)
#   Following actions are invoked by setting corresponding attribute
#   to %True; or opposite actions when set to %False; - ommition of
#   the attribute means no action:
#   - newUDAI - force a new authentication UID to be generated
#   - renew
#   - cancel
#   - lock
#   Transfer to another registrar is an implied operation - if non-owner
#   registrar is doing an update, the domain is transferred to the new
#   registrar. For this operation UDAI is required, and the
#   DomainNameFilter must be a simple domain name (no wildcards!)
# ActionResponse: (Domain+|Error)
element.DomainUpdate =
  element DomainUpdate {
    attribute ActionId { UID },
    attribute UDAI { UID }?,
    attribute NewUDAI { Boolean }?,
    attribute RegistrantRef { UID }?,
    attribute Term { Term }?,
    attribute Delegate { Boolean }?,
    attribute Renew { Boolean }?,
    attribute NoAutoRenew { Boolean }?,
    attribute Lock { Boolean }?,
    attribute Cancel { Boolean }?,
    attribute Release { Boolean }?,
    [ a:defaultValue = "1" ] attribute FullResult { Boolean }?,
    element.DomainNameFilter+,
    element.RegistrantContact?,
    element.AdminContact?,
    element.TechnicalContact?,
    element.NameServers?,
    element.AuditText?
  }

element.HandleCreate =
  element HandleCreate {
    attribute ActionId { UID },
    attribute HandleId { UID },
    ContactAttr,
    Contact,
    element.AuditText?
  }

element.HandleUpdate =
  element HandleUpdate {
    attribute ActionId { UID },
    attribute HandleId { UID },
    attribute Delete { Boolean }?,
    ContactAttr,
    Contact,
    element.AuditText?
  }

element.HandleDetailsQry =
  element HandleDetailsQry {
    attribute MaxResults { Number }?,
    attribute SkipResults { Number }?,
    [ a:defaultValue = "0" ] attribute CountResults { Boolean }?,
    element.HandleIdFilter*,
    element.SearchDateRange?,
    element.ChangedInDateRange?,
    element.ContactFilter?
  }

element.DomainNameFilter =
  element DomainNameFilter {
    text
  }

# ++ Domain details query actions  ++++++++++++++++++++++++++++++++++++++

# Whois  (retrieve details of DomainName)
# ActionResponse: (Domain|Error)
element.Whois =
  element Whois {
    attribute QryId { UID }?,
    [ a:defaultValue = "1" ] attribute FullResult { Boolean }?,
    attribute SourceIP { text }?,
    attribute DomainName { DomainName },
    empty
  }

# UDAIValidQry - enquire if the UDAI for a domain is correct
# ActionResponse: (UDAIValid)
element.UDAIValidQry =
  element UDAIValidQry {
    attribute QryId { UID }?,
    attribute DomainName { DomainName },
    attribute UDAI { UID },
    empty
  }

# General register query
# ActionResponse: (Domain*|Error)
element.DomainDetailsQry =
  element DomainDetailsQry {
    attribute QryId { UID }?,
    attribute Status { RegDomainStatus }?,
    attribute Delegate { Boolean }?,
    attribute Term { Term }?,
    attribute RegistrantRef { UID }?,
    attribute MaxResults { Number }?,
    attribute SkipResults { Number }?,
    [ a:defaultValue = "0" ] attribute CountResults { Boolean }?,
    element.DomainNameFilter*,
    element.NameServerFilter?,
    element.RegistrantContactFilter?,
    element.AdminContactFilter?,
    element.TechnicalContactFilter?,
    element.ResultDateRange?,
    element.SearchDateRange?,
    element.ChangedInDateRange?,
    element.RegisteredDateRange?,
    element.LockedDateRange?,
    element.CancelledDateRange?,
    element.BilledUntilDateRange?,
    element.AuditTextFilter?,
    element.ActionIdFilter?,
    element.FieldList?
  }

element.AuditTextFilter =
  element AuditTextFilter {
    text
  }

element.ActionIdFilter =
  element ActionIdFilter {
    text
  }

# Query request - returns request-response pair
# ActionResponse: ((RawRequest,RawResponse)|Error)
element.ActionDetailsQry =
  element ActionDetailsQry {
    attribute QryId { UID }?,
    attribute ActionId { UID },
    attribute OriginatingRegistrarId { UID }?,
    empty
  }

# ++ Registar details update actions ++++++++++++++++++++++++++++++++++++
# ActionResponse: (Registrar|Error)
element.RegistrarCreate =
  element RegistrarCreate {
    attribute ActionId { UID },
    attribute Name { text },
    attribute AccRef { text },
    attribute RegistrarId { RegistrarId },
    attribute URL { text }?,
    element.RegistrarPublicContact,
    element.RegistrarSRSContact,
    element.DefaultTechnicalContact,
    element.EncryptKeys,
    element.EPPAuth?,
    element.Allowed2LDs?,
    element.Roles?,
    element.AuditText?
  }

element.RegistrarUpdate =
  element RegistrarUpdate {
    attribute ActionId { UID },
    attribute Name { text }?,
    attribute AccRef { text }?,
    attribute URL { text }?,
    element.RegistrarPublicContact?,
    element.RegistrarSRSContact?,
    element.DefaultTechnicalContact?,
    element.EncryptKeys?,
    element.EPPAuth?,
    element.Allowed2LDs?,
    element.Roles?,
    element.AuditText?
  }

# ++ Registar details query actions +++++++++++++++++++++++++++++++++++++

# ActionResponse: (Registrar*|Error)
element.RegistrarDetailsQry =
  element RegistrarDetailsQry {
    attribute QryId { UID }?,
    attribute RegistrarId { RegistrarId }?,
    attribute NameFilter { text }?,
    element.ResultDateRange?
  }

# RegistrarAccountQry (obtain billing records)
# ActionResponse: (BillingTrans*|Error)
element.RegistrarAccountQry =
  element RegistrarAccountQry {
    attribute QryId { UID }?,
    attribute RegistrantRef { UID }?,
    attribute DomainName { DomainName }?,
    attribute InvoiceId { UID }?,
    attribute MaxResults { Number }?,
    attribute SkipResults { Number }?,
    attribute TransStatus { BillStatus }?,
    [ a:defaultValue = "0" ] attribute CountResults { Boolean }?,
    element.TransDateRange?,
    element.InvoiceDateRange?
  }

# BillingAmount Transactions
# (To set the monthly charge for Billing)
# ActionResponse: (BillingAmount*|Error)
element.BillingAmountUpdate =
  element BillingAmountUpdate {
    attribute ActionId { UID },
    element.BillingAmount
  }

element.BillingAmountQry =
  element BillingAmountQry {
    attribute QryId { UID }?,
    empty
  }

element.BillingAmount =
  element BillingAmount {
    attribute Amount { Dollars },
    element.EffectiveDate?
  }

element.EffectiveDate =
  element EffectiveDate {
    TimeStamp,
    empty
  }

# ++ Query date ranges ++++++++++++++++++++++++++++++++++++++++++++++++++

element.ResultDateRange =
  element ResultDateRange {
    DateRange
  }

element.SearchDateRange =
  element SearchDateRange {
    DateRange
  }

element.ChangedInDateRange =
  element ChangedInDateRange {
    DateRange
  }

element.RegisteredDateRange =
  element RegisteredDateRange {
    DateRange
  }

element.CancelledDateRange =
  element CancelledDateRange {
    DateRange
  }

element.LockedDateRange =
  element LockedDateRange {
    DateRange
  }

element.BilledUntilDateRange =
  element BilledUntilDateRange {
    DateRange
  }

element.InvoiceDateRange =
  element InvoiceDateRange {
    DateRange
  }

element.TransDateRange =
  element TransDateRange {
    DateRange
  }

# ++ Query field list +++++++++++++++++++++++++++++++++++++++++++++++++++

element.FieldList =
  element FieldList {
    attribute Status { Boolean }?,
    attribute NameServers { Boolean }?,
    attribute RegistrantContact { Boolean }?,
    attribute RegisteredDate { Boolean }?,
    attribute AdminContact { Boolean }?,
    attribute TechnicalContact { Boolean }?,
    attribute LockedDate { Boolean }?,
    attribute Delegate { Boolean }?,
    attribute RegistrarId { Boolean }?,
    attribute RegistrarName { Boolean }?,
    attribute RegistrantRef { Boolean }?,
    attribute LastActionId { Boolean }?,
    attribute ChangedByRegistrarId { Boolean }?,
    attribute Term { Boolean }?,
    attribute BilledUntil { Boolean }?,
    attribute CancelledDate { Boolean }?,
    attribute AuditText { Boolean }?,
    attribute EffectiveFrom { Boolean }?,
    empty
  }

# ++ Registry actions +++++++++++++++++++++++++++++++++++++++++++++++++++

# ActionResponse: (SysParam*|Error)
element.SysParamsCreate =
  element SysParamsCreate {
    attribute ActionId { UID },
    element.SysParam+,
    element.AuditText?
  }

element.SysParamsUpdate =
  element SysParamsUpdate {
    attribute ActionId { UID },
    element.SysParam+,
    element.AuditText?
  }

element.SysParamsQry =
  element SysParamsQry {
    attribute QryId { UID }?,
    empty
  }

# ActionResponse: (RunLog|Error)
element.RunLogCreate =
  element RunLogCreate {
    attribute ActionId { UID },
    element.FirstRunDate,
    element.RunLog
  }

# ActionResponse: (RunLog*|Error)
element.RunLogQry =
  element RunLogQry {
    attribute QryId { UID }?,
    attribute ProcessName { text }?,
    attribute Parameters { text }?,
    element.LogDateRange?
  }

element.LogDateRange =
  element LogDateRange {
    DateRange,
    empty
  }

# ActionResponse: (Schedule|Error)
element.ScheduleCreate =
  element ScheduleCreate {
    attribute ProcessName { ScheduledJob },
    attribute Frequency { text },
    attribute Parameters { text }?,
    attribute ActionId { UID },
    element.FirstRunDate,
    element.FinalRunDate?,
    element.AuditText?
  }

element.ScheduleCancel =
  element ScheduleCancel {
    attribute ActionId { UID },
    attribute ProcessName { ScheduledJob },
    attribute Parameters { text }?,
    element.FirstRunDate,
    element.AuditText?
  }

element.ScheduleUpdate =
  element ScheduleUpdate {
    attribute ActionId { UID },
    attribute Parameters { text }?,
    attribute Frequency { text }?,
    attribute ProcessName { ScheduledJob },
    element.FirstRunDate,
    element.LastRunDate?,
    element.AuditText?
  }

element.FinalRunDate =
  element FinalRunDate {
    TimeStamp,
    empty
  }

element.ScheduleQry =
  element ScheduleQry {
    attribute QryId { UID }?,
    attribute ProcessName { text }?,
    attribute Parameters { text }?, 
    element.ActiveOn?,
    element.FirstRunDate?
  }

element.ActiveOn =
  element ActiveOn {
    TimeStamp
  }

element.DeferredIncomeSummaryQry =
  element DeferredIncomeSummaryQry {
    attribute BaseMonth { text },
    attribute BaseYear { text },
    attribute IncomeMonth { text },
    attribute IncomeYear { text },
    attribute QryId { UID }?,
    empty
  }

element.DeferredRegistrarIncome =
  element DeferredRegistrarIncome {
    attribute BaseMonth { text },
    attribute BaseYear { text },
    attribute IncomeMonth { text },
    attribute IncomeYear { text },
    attribute RegistrarId { RegistrarId },
    attribute BilledAmount { Dollars },
    attribute BilledCount { Number },
    empty
  }

element.DeferredIncomeDetailQry =
  element DeferredIncomeDetailQry {
    attribute BaseMonth { text },
    attribute BaseYear { text },
    attribute IncomeMonth { text },
    attribute IncomeYear { text },
    attribute QryId { UID }?,
    empty
  }

element.BilledUntilAdjustment =
  element BilledUntilAdjustment {
    attribute DomainName { DomainName },
    attribute ActionId { UID },
    element.NewBilledUntilDate,
    element.AuditText
  }

element.NewBilledUntilDate =
  element NewBilledUntilDate {
    TimeStamp,
    empty
  }

element.BuildDnsZoneFiles =
  element BuildDnsZoneFiles {
    attribute ActionId { UID },
    element.RunDate
  }

element.GenerateDomainReport =
  element GenerateDomainReport {
    attribute ActionId { UID },
    element.RunDate
  }

element.RunDate =
  element RunDate {
    TimeStamp,
    empty
  }

element.AdjustRegistrarAccount =
  element AdjustRegistrarAccount {
    attribute RegistrarId { RegistrarId },
    attribute DomainName { DomainName },
    attribute ActionId { UID },
    attribute Months { Number },
    attribute ActionType { AccountingAction },
    element.TransactionDate,
    element.BillPeriodStart,
    element.BillPeriodEnd,
    element.AuditText
  }

element.TransactionDate =
  element TransactionDate {
    TimeStamp,
    empty
  }

element.AccessControlListQry =
  element AccessControlListQry {
    attribute Resource { text }?,
    attribute List { text }?,
    attribute Type { text }?,
    [ a:defaultValue = "0" ] attribute FullResult { Boolean }?,
    AccessControlListContentFilter*
  }

AccessControlListContentFilter =
  element.DomainNameFilter
  | element.RegistrarIdFilter
  | element.AddressFilter

element.RegistrarIdFilter =
  element RegistrarIdFilter {
    text
  }

element.AddressFilter =
  element AddressFilter {
    text
  }

element.AccessControlListRemove =
  element AccessControlListRemove {
    attribute Resource { text },
    attribute List { text },
    attribute ActionId { UID },
    [ a:defaultValue = "1" ] attribute FullResult { Boolean }?,
    element.AccessControlListEntry*,
    element.AuditText?
  }

element.AccessControlListAdd =
  element AccessControlListAdd {
    attribute Resource { text },
    attribute List { text },
    attribute ActionId { UID },
    [ a:defaultValue = "1" ] attribute FullResult { Boolean }?,
    element.AccessControlListEntry+,
    element.AuditText?
  }

element.AccessControlList =
  element AccessControlList {
    attribute Resource { text },
    attribute List { text },
    ( attribute Size { Number }
      | attribute SizeChange { Number } )?,
    attribute Type { text }?,
    element.AccessControlListEntry*
  }

element.AccessControlListEntry =
  element AccessControlListEntry {
    attribute Address { text }?,
    attribute DomainName { text }?,
    attribute RegistrarId { RegistrarId }?,
    attribute Comment { text }?,
    element.EffectiveDate?
  }

# == GetMessages ========================================================

# Get message by UID, or messages since date/time for the Effective registrar
# Non-DTD enforced compliance:
#   - either UID or date range must be supplied
# ActionResponses: (Response|Error)
element.GetMessages =
  element GetMessages {
    attribute QryId { UID }?,
    attribute OriginatingRegistrarId { RegistrarIdOrOTHERS }?,
    attribute ActionId { UID }?,
    attribute RecipientRegistrarId { RegistrarId }?,
    attribute MaxResults { Number }?,
    attribute SkipResults { Number }?,
    [ a:defaultValue = "0" ] attribute CountResults { Boolean }?,
    [ a:defaultValue = "0" ] attribute QueueMode { Boolean }?,   
    element.TransDateRange?,
    element.AuditTextFilter?,
    element.TypeFilter*
  }

GetMessagesTypes = "third-party" | "server-generated-data"

element.TypeFilter =
  element TypeFilter {
    attribute Type { GetMessagesTypes }
  }

# == AckMessage ========================================================

# ACK message by originating RegistrarId/UID
# ActionResponse: (Response|Error)
element.AckMessage =
  element AckMessage {
    attribute ActionId { UID },
    attribute OriginatingRegistrarId { RegistrarId },
    attribute TransId { UID }
  }

# == ActionResponse =====================================================

# ++ Response +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# This is a "one size fits all" response, which
# can contain any type of response.  Errors to individual actions
# can be specified within the response (errors in parsing the total
# request are handled by the error ELEMENT).  The response may
# contain multiple domain records (eg, for queries), and may contain
# a complete history of the domain.
# The registrar and id will match those passed in for most requests,
# but will be present to uniquely identify a getmsg response.
# Most requests will result in a single response; but getmsg requests
# for messages since a date/time will result in one response per
# response found.
# The DomainTransfer differs from the rest in that it is not a direct
# response to an action, but a message for the registrar generated by
# an action of another registrar. It may be returned in response to a
# GetMessages action.
DomainWriteAction =
  "DomainCreate"
  | "DomainUpdate"

DomainQueryAction =
  "Whois"
  | "DomainDetailsQry"
  | "ActionDetailsQry"
  | "UDAIValidQry"

HandleWriteAction = 
  "HandleCreate"
  | "HandleUpdate"

HandleQueryAction = 
  "HandleDetailsQry"

RegistrarWriteAction =
  "RegistrarCreate"
  | "RegistrarUpdate"

RegistrarQueryAction =
  "RegistrarDetailsQry"
  | "RegistrarAccountQry"
  | "GetMessages"

RegistryAction =
  "SysParamsUpdate"
  | "SysParamsCreate"
  | "SysParamsQry"
  | "RunLogCreate"
  | "RunLogQry"
  | "ScheduleCreate"
  | "ScheduleCancel"
  | "ScheduleQry"
  | "ScheduleUpdate"
  | "BillingExtract"
  | "SetBillingAmount"
  | "BillingAmountQry"
  | "DeferredIncomeSummaryQry"
  | "DeferredIncomeDetailQry"
  | "BilledUntilAdjustment"
  | "BuildDnsZoneFiles"
  | "GenerateDomainReport"
  | "AdjustRegistrarAccount"
  | "AccessControlListQry"
  | "AccessControlListAdd"
  | "AccessControlListRemove"
  | "BillingAmountUpdate"

Action =
  DomainWriteAction
  | DomainQueryAction
  | HandleWriteAction
  | HandleQueryAction
  | RegistrarWriteAction
  | RegistrarQueryAction
  | RegistryAction

ActionEtc = 
  Action
  | "UnknownTransaction"
  | "DomainTransfer"
  | "AckMessage"

element.Response =
  element Response {
    attribute Action { ActionEtc },
    attribute FeId { Number },
    attribute FeSeq { Number },
    attribute OrigRegistrarId { RegistrarId },
    attribute TransId { UID }?,
    attribute Rows { Number }?,
    attribute Count { Number }?,
    attribute MoreRowsAvailable { Boolean }?,
    attribute RecipientRegistrarId { RegistrarId }?,
    element.FeTimeStamp,
    (element.Response* | ActionResponse | element.AckResponse)?
  }

element.AckResponse =
  element AckResponse {
    attribute OriginatingRegistrarId { RegistrarId },
    attribute TransId { UID },
    attribute Remaining { Number }
  }


# ++ Error ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# Errors can be either specific to a requested action, or generic
# to the whole request.  A globally unique errorid identifies the
# error that occured, and a human-readable string describing the
# error is enclosed.
# The errorids are assigned like HTTP, where there are three digits
# to identify the error.  The first digit indicates approximately
# the status (success, failure, etc); the second is a subcategory of
# that, and the third is used for fine detail indications.
# The exact list of errors is in SRS::Error module.
element.Error =
  element Error {
    attribute ErrorId { UID },
    attribute Severity { Number },
    attribute Hint { UID },
    element.Description,
    element.ErrorDetails*
  }

element.Description =
  element Description {
    text
  }

element.ErrorDetails =
  element ErrorDetails {
    text
  }

element.FeTimeStamp =
  element FeTimeStamp {
    TimeStamp,
    empty
  }

# == Lower level elements ===============================================

# Zone information: fields held in the register, that can be obtained
# through the registrar/registry protocol.
# and/or maintainable through the registry protocol.

# ++ Domain details +++++++++++++++++++++++++++++++++++++++++++++++++++++
# NOTE: the domain authid (UDAI) is sent ONLY if it has been newly
# generated; otherwise it is assumed that the registrar has the
# previous value cached.
element.Domain =
  element Domain {
    attribute DomainName { DomainName },
    attribute DomainNameUnicode { DomainNameUnicode }?,
    attribute DomainNameUnicodeHex { DomainNameUnicodeHex }?,
    attribute DomainNameLanguage { DomainNameLanguage }?,
    attribute RegistrantRef { UID }?,
    attribute RegistrarName { text }?,
    attribute Status { DomainStatus }?,
    attribute Delegate { Boolean }?,
    attribute Term { Term }?,
    attribute RegistrarId { RegistrarId }?,
    attribute UDAI { UID }?,
    element.NameServers?,
    element.RegistrantContact?,
    element.RegistrarPublicContact?,
    element.AdminContact?,
    element.TechnicalContact?,
    element.BilledUntil?,
    element.RegisteredDate?,
    element.CancelledDate?,
    element.LockedDate?,
    element.AuditDetails?
  }

element.BilledUntil =
  element BilledUntil {
    TimeStamp,
    empty
  }

element.LockedDate =
  element LockedDate {
    TimeStamp,
    empty
  }

element.RegisteredDate =
  element RegisteredDate {
    TimeStamp,
    empty
  }

element.CancelledDate =
  element CancelledDate {
    TimeStamp,
    empty
  }

element.DomainTransfer =
  element DomainTransfer {
    attribute RegistrarName { text },
    TimeStamp,
    element.TransferredDomain+
  }

element.TransferredDomain =
  element TransferredDomain {
    text
  }

element.UDAIValid =
  element UDAIValid {
    attribute Valid { Boolean },
    empty
  }

# Name servers
# The IP address should be included if and only if the fqdn is within
# the zone that it is associated with 
# the IP6Addr may be in any of the formats specified by RFC 2373, ie.
#     1.  X:X:X:X:X:X:X:X         (Fully Specified)
#     2.  X:X:X::X                ('::' denotes compressed zeroes )
#     3.  X:X:X:X:X:X:d.d.d.d     ('d.d.d.d' denotes an IP4 Address)
element.NameServers =
  element NameServers {
    element.Server*
  }

element.Server =
  element Server {
    attribute FQDN { text },
    attribute IP4Addr { text }?,
    attribute IP6Addr { text }?,
    empty
  }

# Name server Filter
# As above, but a filter for a search
element.NameServerFilter =
  element NameServerFilter {
    element.ServerFilter+
  }

element.ServerFilter =
  element ServerFilter {
    attribute FQDN { text }?,
    attribute IP4Addr { text }?,
    attribute IP6Addr { text }?,
    empty
  }

# ++ Registrar details ++++++++++++++++++++++++++++++++++++++++++++++++++

element.Registrar =
  element Registrar {
    attribute RegistrarId { RegistrarId },
    attribute Name { text },
    attribute AccRef { text },
    attribute URL { text }?,
    element.RegistrarPublicContact,
    element.RegistrarSRSContact,
    element.DefaultTechnicalContact,
    element.EncryptKeys,
    element.EPPAuth?,
    element.Allowed2LDs?,
    element.Roles?,
    element.AuditDetails?
  }

element.Allowed2LDs =
  element Allowed2LDs {
    element.SecondLD*
  }

element.SecondLD =
  element SecondLD {
    attribute DomainName { DomainName },
    empty
  }

element.Roles =
  element Roles {
    element.Role*
  }

element.Role =
  element Role {
    attribute RoleName { Role },
    empty
  }

element.EncryptKeys =
  element EncryptKeys {
    element.EncryptKey*
  }

element.EncryptKey =
  element EncryptKey {
    text
  }

element.EPPAuth =
  element EPPAuth {
    attribute Password { text }
  }

# ++ Billing transaction ++++++++++++++++++++++++++++++++++++++++++++++++

element.BillingTrans =
  element BillingTrans {
    attribute RegistrarId { RegistrarId },
    attribute Type { text },
    attribute TransStatus { BillStatus },
    attribute DomainName { DomainName },
    attribute RegistrantRef { UID }?,
    attribute BillingTerm { Term },
    attribute InvoiceId { UID }?,
    attribute Amount { Dollars },
    element.InvoiceDate?,
    element.TransDate,
    element.BillPeriodStart,
    element.BillPeriodEnd
  }

element.InvoiceDate =
  element InvoiceDate {
    TimeStamp,
    empty
  }

element.TransDate =
  element TransDate {
    TimeStamp,
    empty
  }

element.BillPeriodStart =
  element BillPeriodStart {
    TimeStamp,
    empty
  }

element.BillPeriodEnd =
  element BillPeriodEnd {
    TimeStamp,
    empty
  }

# ++ Contact information: for registrant, admin, technical ++++++++++++++

element.RegistrantContact =
  element RegistrantContact {
    ContactAttr,
    Contact
  }

element.RegistrantContactFilter =
  element RegistrantContactFilter {
    ContactAttrFilter,
    ContactFilter
  }

element.AdminContact =
  element AdminContact {
    ContactAttr,
    Contact
  }

element.AdminContactFilter =
  element AdminContactFilter {
    ContactAttrFilter,
    ContactFilter
  }

element.TechnicalContact =
  element TechnicalContact {
    ContactAttr,
    Contact
  }

element.TechnicalContactFilter =
  element TechnicalContactFilter {
    ContactAttrFilter,
    ContactFilter
  }

element.ChangedDomains =
  element ChangedDomains {
     element.Domain*
  }

element.Handle =
  element Handle {
    attribute RegistrarId { RegistrarId },
    ContactAttr,
    Contact,
    element.AuditDetails?,
    element.ChangedDomains?
  }


element.Message =
  element Message {
  	element.Response,
  	attribute Remaining { Number }?
  }

element.HandleIdFilter =
  element HandleIdFilter {
    text
  }

element.ContactFilter =
  element ContactFilter {
    ContactAttrFilter,
    ContactFilter
  }

element.RegistrarPublicContact =
  element RegistrarPublicContact {
    ContactAttr,
    Contact
  }

element.DefaultTechnicalContact =
  element DefaultTechnicalContact {
    ContactAttr,
    Contact
  }

element.RegistrarSRSContact =
  element RegistrarSRSContact {
    ContactAttr,
    Contact
  }

# Country is an ISO 3166-1 country code
element.PostalAddress =
  element PostalAddress {
    attribute Address1 { text }?,
    attribute Address2 { text }?,
    attribute City { text }?,
    attribute Province { text }?,
    attribute CountryCode { text }?,
    attribute PostalCode { text }?,
    empty
  }

element.PostalAddressFilter =
  element PostalAddressFilter {
    attribute Address1 { text }?,
    attribute Address2 { text }?,
    attribute City { text }?,
    attribute Province { text }?,
    attribute CountryCode { text }?,
    attribute PostalCode { text }?,
    empty
  }

element.Phone =
  element Phone {
    PhoneAttr,
    empty
  }

element.Fax =
  element Fax {
    PhoneAttr,
    empty
  }

# ++ Raw responses ++++++++++++++++++++++++++++++++++++++++++++++++++++++

element.RawRequest =
  element RawRequest {
    element.XML,
    element.Signature
  }

element.RawResponse =
  element RawResponse {
    element.XML,
    element.Signature
  }

element.XML =
  element XML {
    text
  }

element.Signature =
  element Signature {
    text
  }

# ++ System Parameters ++++++++++++++++++++++++++++++++++++++++++++++++++

element.SysParam =
  element SysParam {
    attribute Name { text },
    element.ParamValue,
    element.AuditDetails?
  }

element.ParamValue =
  element ParamValue {
    text
  }

# ++ Run Log ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

element.RunLog =
  element RunLog {
    attribute ProcessName { text },
    attribute Parameters { text }?,
    attribute ActionStatus { text },
    attribute Control { text }?,
    element.RunLogTimeStamp,
    element.RunLogDetails?
  }

element.RunLogDetails =
  element RunLogDetails {
    text
  }

element.RunLogTimeStamp =
  element RunLogTimeStamp {
    TimeStamp,
    empty
  }

# ++ Schedule +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

# Frequency in ?
element.Schedule =
  element Schedule {
    attribute ProcessName { ScheduledJob },
    attribute Frequency { text },
    attribute Parameters { text }?,
    attribute CreateByRegistrarId { UID },
    attribute CreateActionId { UID },
    attribute CancelByRegistrarId { UID }?,
    attribute CancelActionId { UID }?,
    element.FirstRunDate,
    element.FinalRunDate?,
    element.CreateAuditText?,
    element.CancelAuditText?
  }

element.FirstRunDate =
  element FirstRunDate {
    TimeStamp,
    empty
  }

element.LastRunDate =
  element LastRunDate {
    TimeStamp,
    empty
  }

element.CreateAuditText =
  element CreateAuditText {
    text
  }

element.CancelAuditText =
  element CancelAuditText {
    text
  }

# ++ Audit details ++++++++++++++++++++++++++++++++++++++++++

element.AuditDetails =
  element AuditDetails {
    attribute RegistrarId { text }?,
    attribute ActionId { UID }?,
    element.AuditTime?,
    element.AuditText?
  }

element.AuditTime =
  element AuditTime {
    DateRange
  }

element.AuditText =
  element AuditText {
    text
  }

# == Various ============================================================

element.From =
  element From {
    TimeStamp,
    empty
  }

element.To =
  element To {
    TimeStamp,
    empty
  }

start = element.NZSRSRequest | element.NZSRSResponse