-- Module MTAAbstractService (X.411:06/1999)
MTAAbstractService {joint-iso-itu-t mhs(6) mts(3) modules(0)
  mta-abstract-service(2) version-1999(1)} DEFINITIONS IMPLICIT TAGS ::=
BEGIN

--	Prologue
--	Exports everything
IMPORTS
  -- Remote Operations
--  CONNECTION-PACKAGE, CONTRACT
    --==
--    FROM Remote-Operations-Information-Objects {joint-iso-itu-t
--      remote-operations(4) informationObjects(5) version1(0)}
  emptyUnbind
    --==
    FROM Remote-Operations-Useful-Definitions {joint-iso-itu-t
      remote-operations(4) useful-definitions(7) version1(0)}
  -- MTS Abstract Service Parameters
--  ABSTRACT-ERROR, ABSTRACT-OPERATION, administration, 
--    AdministrationDomainName,
--    certificate-selectors, certificate-selectors-override, Content,
--    ContentIdentifier, ContentLength, ContentType,
--    content-confidentiality-algorithm-identifier, content-correlator,
--    content-integrity-check, conversion-with-loss-prohibited,
--    ConvertedEncodedInformationTypes, CountryName, DeferredDeliveryTime,
--    delivery, dl-exempted-recipients, dl-expansion-history,
--    dl-expansion-prohibited, ExplicitConversion, EXTENSION, ExtensionField{},
--    GlobalDomainIdentifier, InitiatorCredentials, latest-delivery-time,
--    message-origin-authentication-check, message-security-label, message-token,
--    MHS-OBJECT, MTAName, MTSIdentifier, multiple-originator-certificates,
--    ORAddressAndOptionalDirectoryName, OriginalEncodedInformationTypes,
--    originator-and-DL-expansion-history, originator-certificate,
--    originator-return-address, PerMessageIndicators, physical-delivery-modes,
--    physical-delivery-report-request, physical-forwarding-address,
--    physical-forwarding-address-request, physical-forwarding-prohibited,
--    physical-rendition-attributes, PORT, Priority, PrivateDomainIdentifier,
--    PrivateExtensions, probe-origin-authentication-check, proof-of-delivery,
--    proof-of-delivery-request, recipient-certificate,
--    recipient-number-for-advice, recipient-reassignment-prohibited,
--    redirection-history, registered-mail-type, reporting-DL-name,
--    reporting-MTA-certificate, reporting-MTA-name, ReportType,
--    report-origin-authentication-check, requested-delivery-method,
--    ResponderCredentials, SecurityContext, submission,
--    SupplementaryInformation, Time
    --==
--    FROM MTSAbstractService {joint-iso-itu-t mhs(6) mts(3) modules(0)
--      mts-abstract-service(1) version-1999(1)}
  -- IPM Information Objects
  IPMPerRecipientEnvelopeExtensions
    --==
    FROM IPMSInformationObjects {joint-iso-itu-t mhs(6) ipms(1) modules(0)
      information-objects(2) version-1999(1)}
  -- Object Identifiers
--  id-cp-mta-connect, id-ct-mta-transfer, id-ot-mta, id-pt-transfer
    --==
--    FROM MTSObjectIdentifiers {joint-iso-itu-t mhs(6) mts(3) modules(0)
--      object-identifiers(0) version-1999(1)}
  -- Upper Bounds
  ub-bit-options, ub-integer-options, ub-recipients, ub-transfers
    --==
    FROM MTSUpperBounds {joint-iso-itu-t mhs(6) mts(3) modules(0)
      upper-bounds(3) version-1999(1)}
  Name
    --==
    FROM InformationFramework {joint-iso-itu-t ds(5) module(1)
      informationFramework(1) 3}
  PresentationAddress
    --==
    FROM SelectedAttributeTypes {joint-iso-itu-t ds(5) module(1)
      selectedAttributeTypes(5) 3}
  CertificateAssertion
    --==
    FROM CertificateExtensions {joint-iso-itu-t ds(5) module(1)
      certificateExtensions(26) 0}
  Certificates, AlgorithmIdentifier
    --==
    FROM AuthenticationFramework {joint-iso-itu-t ds(5) module(1)
      authenticationFramework(7) 3};

--	Objects
--mta MHS-OBJECT ::= {BOTH  {mta-transfer}
--                    ID    id-ot-mta
--}

--	Contracts
--mta-transfer CONTRACT ::= {
--  CONNECTION     mta-connect
--  OPERATIONS OF  {transfer}
--  ID             id-ct-mta-transfer
--}

--	Connection package
--mta-connect CONNECTION-PACKAGE ::= {
--  BIND    mta-bind
--  UNBIND  mta-unbind
--  ID      id-cp-mta-connect
--}

--	Ports
--transfer PORT ::= {
--  OPERATIONS  {message-transfer | probe-transfer | report-transfer}
--  ID          id-pt-transfer
--}

--	MTA-bind and MTA-unbind
--mta-bind ABSTRACT-OPERATION ::= {
--  ARGUMENT  MTABindArgument
--  RESULT    MTABindResult
--  ERRORS    {mta-bind-error}
--}

-- mta-unbind ABSTRACT-OPERATION ::= emptyUnbind

MTABindArgument ::= CHOICE {
  unauthenticated  NULL, -- if no authentication is required
  authenticated
    [1]  SET {-- if authentication is required--initiator-name
                                                  [0]  MTAName,
                                                initiator-credentials
                                                  [1]  InitiatorCredentials
                                                         (WITH COMPONENTS {
                                                            ...,
                                                            protected  ABSENT
                                                          }),
                                                security-context
                                                  [2]  SecurityContext OPTIONAL
  }
}

MTABindResult ::= CHOICE {
  unauthenticated  NULL, -- if no authentication is required
  authenticated
    [1]  SET {-- if authentication is required--responder-name
                                                  [0]  MTAName,
                                                responder-credentials
                                                  [1]  ResponderCredentials
--                                                         (WITH COMPONENTS {
--                                                            ...,
--                                                            protected  ABSENT
--                                                          })--}
}

--mta-bind-error ABSTRACT-ERROR -- MTABindError ::= -- {
--  PARAMETER
    INTEGER {busy(0), authentication-error(2), unacceptable-dialogue-mode(3),
             unacceptable-security-context(4),
             inadequate-association-confidentiality(5)}(0..ub-integer-options)
--}

--	Transfer Port
--message-transfer ABSTRACT-OPERATION ::= {ARGUMENT  Message
--}

--probe-transfer ABSTRACT-OPERATION ::= {ARGUMENT  Probe
--}

--report-transfer ABSTRACT-OPERATION ::= {ARGUMENT  Report
--}

-- taken from X.419
MTS-APDU ::= CHOICE {
message	[0] Message,
probe [2] Probe,
report [1] Report
}

Message ::= SEQUENCE {envelope  MessageTransferEnvelope,
                      content   Content
}

Probe ::= ProbeTransferEnvelope

Report ::= SEQUENCE {
  envelope  ReportTransferEnvelope,
  content   ReportTransferContent
}

--	Message Transfer Envelope
MessageTransferEnvelope ::= SET {
--  COMPONENTS OF PerMessageTransferFields,
--  per-recipient-fields
--    [2]  SEQUENCE SIZE (1..ub-recipients) OF PerRecipientMessageTransferFields
--}

--PerMessageTransferFields ::= SET {
  message-identifier                  MessageIdentifier,
  originator-name                     MTAOriginatorName,
  original-encoded-information-types  OriginalEncodedInformationTypes OPTIONAL,
  content-type                        ContentType,
-- asn2wrs seems to have a problem with untagged choices - so we will expand 'in situ' for now
-- it's not the greatest solution - but should be OK
--  built-in-content-type			BuiltInContentType OPTIONAL,
--  extended-content-type			ExtendedContentType OPTIONAL,
-- end of workaround
  content-identifier                  ContentIdentifier OPTIONAL,
  priority                            Priority DEFAULT normal,
  per-message-indicators              PerMessageIndicators DEFAULT {},
  deferred-delivery-time              [0]  DeferredDeliveryTime OPTIONAL,
  per-domain-bilateral-information
    [1]  SEQUENCE -- SIZE (1..ub-transfers) -- OF PerDomainBilateralInformation
      OPTIONAL,
  trace-information                   TraceInformation,
  extensions
    [3]  SET OF ExtensionField --{{MessageTransferExtensions}}-- DEFAULT {}
  ,per-recipient-fields
    [2]  SEQUENCE --SIZE  (1..ub-recipients) -- OF PerRecipientMessageTransferFields
}

--MessageTransferExtensions EXTENSION ::=
  --{- - May contain the following extensions, private extensions, and future standardised extensions,
   -- at most one instance of each extension type:
--   recipient-reassignment-prohibited | dl-expansion-prohibited |
--   conversion-with-loss-prohibited | latest-delivery-time |
--   originator-return-address | originator-certificate |
--   content-confidentiality-algorithm-identifier |
--   message-origin-authentication-check | message-security-label |
--   content-correlator | dl-exempted-recipients | certificate-selectors |
--   multiple-originator-certificates | dl-expansion-history |
--   internal-trace-information | PrivateExtensions, ...}

PerRecipientMessageTransferFields ::= SET {
  recipient-name                         MTARecipientName,
  originally-specified-recipient-number
    [0]  OriginallySpecifiedRecipientNumber,
  per-recipient-indicators               [1]  PerRecipientIndicators,
  explicit-conversion                    [2]  ExplicitConversion OPTIONAL,
  extensions
    [3]  SET OF ExtensionField --{{PerRecipientMessageTransferExtensions}}
      DEFAULT {}
}

--PerRecipientMessageTransferExtensions EXTENSION ::=
--  {- - May contain the following extensions, private extensions, and future standardised extensions,
   -- at most one instance of each extension type:
--   originator-requested-alternate-recipient | requested-delivery-method |
--   physical-forwarding-prohibited | physical-forwarding-address-request |
--   physical-delivery-modes | registered-mail-type | recipient-number-for-advice
--   | physical-rendition-attributes | physical-delivery-report-request |
--   message-token | content-integrity-check | proof-of-delivery-request |
--   certificate-selectors-override | recipient-certificate | redirection-history
--   | IPMPerRecipientEnvelopeExtensions | PrivateExtensions, ...}

--	Probe Transfer Envelope
ProbeTransferEnvelope ::= SET {
--  COMPONENTS OF PerProbeTransferFields,
--  per-recipient-fields
--    [2]  SEQUENCE SIZE (1..ub-recipients) OF PerRecipientProbeTransferFields
--}

--PerProbeTransferFields ::= SET {
  probe-identifier                    ProbeIdentifier,
  originator-name                     MTAOriginatorName,
  original-encoded-information-types  OriginalEncodedInformationTypes OPTIONAL,
  content-type                        ContentType,
  content-identifier                  ContentIdentifier OPTIONAL,
  content-length                      [0]  ContentLength OPTIONAL,
  per-message-indicators              PerMessageIndicators DEFAULT {},
  per-domain-bilateral-information
    [1]  SEQUENCE -- SIZE (1..ub-transfers) -- OF PerDomainBilateralInformation
      OPTIONAL,
  trace-information                   TraceInformation,
  extensions
    [3]  SET OF ExtensionField --{{ProbeTransferExtensions}}-- DEFAULT {}
  ,per-recipient-fields
    [2]  SEQUENCE -- SIZE (1..ub-recipients) -- OF PerRecipientProbeTransferFields
}

--ProbeTransferExtensions EXTENSION ::=
--  {- - May contain the following extensions, private extensions, and future standardised extensions,
   -- at most one instance of each extension type:
--   recipient-reassignment-prohibited | dl-expansion-prohibited |
--   conversion-with-loss-prohibited | originator-certificate |
--   message-security-label | content-correlator |
--   probe-origin-authentication-check | internal-trace-information |
--   PrivateExtensions, ...}

PerRecipientProbeTransferFields ::= SET {
  recipient-name                         MTARecipientName,
  originally-specified-recipient-number
    [0]  OriginallySpecifiedRecipientNumber,
  per-recipient-indicators               [1]  PerRecipientIndicators,
  explicit-conversion                    [2]  ExplicitConversion OPTIONAL,
  extensions
    [3]  SET OF ExtensionField --{{PerRecipientProbeTransferExtensions}}
      DEFAULT {}
}

--PerRecipientProbeTransferExtensions EXTENSION ::=
--  {- - May contain the following extensions, private extensions, and future standardised extensions,
   -- at most one instance of each extension type:
--   originator-requested-alternate-recipient | requested-delivery-method |
--   physical-rendition-attributes | redirection-history | PrivateExtensions, 
--   ...}

--	Report Transfer Envelope
ReportTransferEnvelope ::= SET {
  report-identifier        ReportIdentifier,
  report-destination-name  ReportDestinationName,
  trace-information        TraceInformation,
  extensions
    [1]  SET OF ExtensionField --{{ReportTransferEnvelopeExtensions}}-- DEFAULT {}
}

--ReportTransferEnvelopeExtensions EXTENSION ::=
--  {- - May contain the following extensions, private extensions, and future standardised extensions,
   -- at most one instance of each extension type:
--   message-security-label | redirection-history |
--   originator-and-DL-expansion-history | reporting-DL-name |
--   reporting-MTA-certificate | report-origin-authentication-check |
--   internal-trace-information | reporting-MTA-name | PrivateExtensions, 
--   ...}

--	Report Transfer Content
ReportTransferContent ::= SET {
--  COMPONENTS OF PerReportTransferFields,
--  per-recipient-fields
--    [0]  SEQUENCE SIZE (1..ub-recipients) OF PerRecipientReportTransferFields
--}

--PerReportTransferFields ::= SET {
  subject-identifier                      SubjectIdentifier,
  subject-intermediate-trace-information
    SubjectIntermediateTraceInformation OPTIONAL,
  original-encoded-information-types
    OriginalEncodedInformationTypes OPTIONAL,
  content-type                            ContentType OPTIONAL,
  content-identifier                      ContentIdentifier OPTIONAL,
  returned-content                        [1]  Content OPTIONAL,
  additional-information                  [2]  AdditionalInformation OPTIONAL,
  extensions
    [3]  SET OF ExtensionField --{{ReportTransferContentExtensions}}-- DEFAULT {}
  ,per-recipient-fields
    [0]  SEQUENCE -- SIZE (1..ub-recipients) -- OF PerRecipientReportTransferFields
}

--ReportTransferContentExtensions EXTENSION ::=
--  {- - May contain the following extensions, private extensions, and future standardised extensions,
   -- at most one instance of each extension type:
--   content-correlator | PrivateExtensions, ...}

PerRecipientReportTransferFields ::= SET {
  actual-recipient-name                  [0]  MTAActualRecipientName,
  originally-specified-recipient-number
    [1]  OriginallySpecifiedRecipientNumber,
  per-recipient-indicators               [2]  PerRecipientIndicators,
  last-trace-information                 [3]  LastTraceInformation,
  originally-intended-recipient-name
    [4]  MTAOriginallyIntendedRecipientName OPTIONAL,
  supplementary-information              [5]  SupplementaryInformation OPTIONAL,
  extensions
    [6]  SET OF ExtensionField --{{PerRecipientReportTransferExtensions}}
      DEFAULT {}
}

--PerRecipientReportTransferExtensions EXTENSION ::=
--  {- - May contain the following extensions, private extensions, and future standardised extensions,
   -- at most one instance of each extension type:
--   redirection-history | physical-forwarding-address | recipient-certificate |
--   proof-of-delivery | PrivateExtensions, ...}

--	Envelope & Report Content Fields
MessageIdentifier ::= MTSIdentifier

MTAOriginatorName ::= ORAddressAndOptionalDirectoryName

PerDomainBilateralInformation ::= SEQUENCE {
--  COMPONENTS OF BILATERAL.&id,
--  bilateral-information  BILATERAL.&Type
--}

--BILATERAL ::= CLASS {&id    BilateralDomain UNIQUE,
--                     &Type  
--}WITH SYNTAX {&Type,
--              IDENTIFIED BY &id
--}

--BilateralDomain ::= SEQUENCE {
  country-name  CountryName,
  domain
    CHOICE {administration-domain-name  AdministrationDomainName,
            private-domain
              SEQUENCE {administration-domain-name
                          [0]  AdministrationDomainName,
                        private-domain-identifier
                          [1]  PrivateDomainIdentifier}}
}

MTARecipientName ::= ORAddressAndOptionalDirectoryName

OriginallySpecifiedRecipientNumber ::= INTEGER --(1..ub-recipients)

PerRecipientIndicators ::= BIT STRING {
  responsibility(0),
  -- responsible 'one', not-responsible 'zero'
  originating-MTA-report(1),
  originating-MTA-non-delivery-report(2),
  -- either originating-MTA-report, or originating-MTA-non-delivery-report,
  -- or both, shall be 'one':
  -- originating-MTA-report bit 'one' requests a 'report';
  -- originating-MTA-non-delivery-report bit 'one' requests a 'non-delivery-report';
  -- both bits 'one' requests an 'audited-report';
  -- bits 0 - 2 'don't care' for Report Transfer Content
  originator-report(3),
  originator-non-delivery-report(4),
  -- at most one bit shall be 'one':
  -- originator-report bit 'one' requests a 'report';
  -- originator-non-delivery-report bit 'one' requests a 'non-delivery-report';
  -- both bits 'zero' requests 'no-report'
  reserved-5(5), reserved-6(6), reserved-7(7)
                                
-- reserved- bits 5 - 7 shall be 'zero' --}--(SIZE (8..ub-bit-options))

ProbeIdentifier ::= MTSIdentifier

ReportIdentifier ::= MTSIdentifier

ReportDestinationName ::= ORAddressAndOptionalDirectoryName

SubjectIdentifier ::= MessageOrProbeIdentifier

MessageOrProbeIdentifier ::= MTSIdentifier

SubjectIntermediateTraceInformation ::= TraceInformation

--	AdditionalInformation is retained for backwards compatibility only, 
--	and use in new systems is strongly deprecated
--ADDITIONAL ::= CLASS {&Type  
--}

AdditionalInformation ::=
  ANY --ADDITIONAL.&Type - - maximum ub-additional-info octets including all encoding

MTAActualRecipientName ::= ORAddressAndOptionalDirectoryName

LastTraceInformation ::= SET {
  arrival-time                         [0]  ArrivalTime,
  converted-encoded-information-types
    ConvertedEncodedInformationTypes OPTIONAL,
  report-type                          [1]  ReportType
}

MTAOriginallyIntendedRecipientName ::= ORAddressAndOptionalDirectoryName

--	Extension Fields
--originator-requested-alternate-recipient EXTENSION ::= {
--  OriginatorRequestedAlternateRecipient,
--  IDENTIFIED BY  standard-extension:2
--}

MTAOriginatorRequestedAlternateRecipient ::= ORAddressAndOptionalDirectoryName

--trace-information EXTENSION ::= {
--  TraceInformation,
--  IDENTIFIED BY  standard-extension:37
--}

--internal-trace-information EXTENSION ::= {
--  InternalTraceInformation,
--  IDENTIFIED BY  standard-extension:38
--}

InternalTraceInformation ::=
  SEQUENCE -- SIZE (1..ub-transfers)-- OF InternalTraceInformationElement

InternalTraceInformationElement ::= SEQUENCE {
  global-domain-identifier  GlobalDomainIdentifier,
  mta-name                  MTAName,
  mta-supplied-information  MTASuppliedInformation
}

MTASuppliedInformation ::= SET {
  arrival-time    [0]  ArrivalTime,
  routing-action  [2]  RoutingAction,
  attempted       CHOICE {mta     MTAName,
                          domain  GlobalDomainIdentifier} OPTIONAL,
  -- additional-actions - -COMPONENTS OF InternalAdditionalActions
  deferred-time                        [1]  DeferredTime OPTIONAL,
  converted-encoded-information-types
    ConvertedEncodedInformationTypes OPTIONAL,
  other-actions                        [3]  OtherActions DEFAULT {}
}

--InternalAdditionalActions ::= AdditionalActions

--	Common Parameter Types
TraceInformation ::=
  [APPLICATION 9]  SEQUENCE -- SIZE (1..ub-transfers) -- OF TraceInformationElement

TraceInformationElement ::= SEQUENCE {
  global-domain-identifier     GlobalDomainIdentifier,
  domain-supplied-information  DomainSuppliedInformation
}

DomainSuppliedInformation ::= SET {
  arrival-time      [0]  ArrivalTime,
  routing-action    [2]  RoutingAction,
  attempted-domain  GlobalDomainIdentifier OPTIONAL,
  -- additional-actions - -COMPONENTS OF AdditionalActions
--}

--AdditionalActions ::= SET {
  deferred-time                        [1]  DeferredTime OPTIONAL,
  converted-encoded-information-types
    ConvertedEncodedInformationTypes OPTIONAL,
  other-actions                        [3]  OtherActions DEFAULT {}
}

RoutingAction ::= ENUMERATED {relayed(0), rerouted(1)}

DeferredTime ::= Time

ArrivalTime ::= Time

OtherActions ::= BIT STRING {redirected(0), dl-operation(1)
}--(SIZE (0..ub-bit-options))--

-- END - - of MTA Abstract Service

-- Generated by Asnp, the ASN.1 pretty-printer of France Telecom R&D

-- Module MTSAbstractService (X.411:06/1999)
--MTSAbstractService {joint-iso-itu-t mhs(6) mts(3) modules(0)
--  mts-abstract-service(1) version-1999(1)} DEFINITIONS IMPLICIT TAGS ::=
--BEGIN

--	Prologue
--	Exports everything
--IMPORTS
  -- Remote Operations
--  CONNECTION-PACKAGE, CONTRACT, ERROR, OPERATION, OPERATION-PACKAGE,
--    ROS-OBJECT-CLASS
    --==
--    FROM Remote-Operations-Information-Objects {joint-iso-itu-t
--      remote-operations(4) informationObjects(5) version1(0)}
--  emptyUnbind
    --==
--    FROM Remote-Operations-Useful-Definitions {joint-iso-itu-t
--      remote-operations(4) useful-definitions(7) version1(0)}
  -- MTA Abstract Service
--  internal-trace-information, trace-information
    --==
--    FROM MTAAbstractService {joint-iso-itu-t mhs(6) mts(3) modules(0)
--      mta-abstract-service(2) version-1999(1)}
  -- MS Abstract Service Extension
--  forwarding-request
    --==
--    FROM MSAbstractService {joint-iso-itu-t mhs(6) ms(4) modules(0)
--      abstract-service(1) version-1999(1)}
  -- IPM Information Objects
--  IPMPerRecipientEnvelopeExtensions
    --==
--    FROM IPMSInformationObjects {joint-iso-itu-t mhs(6) ipms(1) modules(0)
--      information-objects(2) version-1999(1)}
  -- Object Identifiers
--  id-att-physicalRendition-basic, id-cp-mts-connect, id-ct-mts-access,
--    id-ct-mts-forced-access, id-ot-mts, id-ot-mts-user, id-pt-administration,
--    id-pt-delivery, id-pt-submission, id-tok-asymmetricToken
    --==
--    FROM MTSObjectIdentifiers {joint-iso-itu-t mhs(6) mts(3) modules(0)
--      object-identifiers(0) version-1999(1)}
  -- Operation and Error Codes
--  err-control-violates-registration,
--    err-deferred-delivery-cancellation-rejected, err-delivery-control-violated,
--    err-element-of-service-not-subscribed, err-inconsistent-request,
--    err-message-submission-identifier-invalid,
--    err-new-credentials-unacceptable,
--    err-old-credentials-incorrectly-specified, err-operation-refused,
--    err-originator-invalid, err-recipient-improperly-specified,
--    err-register-rejected, err-remote-bind-error, err-security-error,
--    err-submission-control-violated, err-unsupported-critical-function,
--    op-cancel-deferred-delivery, op-change-credentials, op-delivery-control,
--    op-message-delivery, op-message-submission, op-probe-submission,
--    op-register, op-report-delivery, op-submission-control
    --==
--    FROM MTSAccessProtocol {joint-iso-itu-t mhs(6) protocols(0) modules(0)
--      mts-access-protocol(1) version-1999(1)}
  -- Directory Definitions
--  Name
    --==
--    FROM InformationFramework {joint-iso-itu-t ds(5) module(1)
--      informationFramework(1) 3}
--  PresentationAddress
    --==
--    FROM SelectedAttributeTypes {joint-iso-itu-t ds(5) module(1)
--      selectedAttributeTypes(5) 3}
--  ALGORITHM, AlgorithmIdentifier, Certificates, ENCRYPTED{}, SIGNATURE{},
--    SIGNED{}
    --==
--    FROM AuthenticationFramework {joint-iso-itu-t ds(5) module(1)
--      authenticationFramework(7) 3}
  -- Certificate Extensions
--  CertificateAssertion
    --==
--    FROM CertificateExtensions {joint-iso-itu-t ds(5) module(1)
--      certificateExtensions(26) 0}
  -- Upper Bounds
--  ub-bit-options, ub-built-in-content-type,
--    ub-built-in-encoded-information-types, ub-certificates,
--    ub-common-name-length, ub-content-id-length, ub-content-length,
--    ub-content-types, ub-country-name-alpha-length,
--    ub-country-name-numeric-length, ub-deliverable-class, ub-diagnostic-codes,
--    ub-dl-expansions, ub-domain-defined-attributes,
--    ub-domain-defined-attribute-type-length,
--    ub-domain-defined-attribute-value-length, ub-domain-name-length,
--    ub-encoded-information-types, ub-extension-attributes, ub-extension-types,
--    ub-e163-4-number-length, ub-e163-4-sub-address-length,
--    ub-generation-qualifier-length, ub-given-name-length, ub-initials-length,
--    ub-integer-options, ub-local-id-length, ub-mta-name-length,
--    ub-mts-user-types, ub-numeric-user-id-length, ub-organization-name-length,
--    ub-organizational-units, ub-organizational-unit-name-length,
--    ub-orig-and-dl-expansions, ub-password-length, ub-pds-name-length,
--    ub-pds-parameter-length, ub-pds-physical-address-lines,
--    ub-postal-code-length, ub-privacy-mark-length, ub-queue-size,
--    ub-reason-codes, ub-recipients, ub-recipient-number-for-advice-length,
--    ub-redirections, ub-redirection-classes, ub-restrictions,
--    ub-security-categories, ub-security-labels, ub-security-problems,
--    ub-supplementary-info-length, ub-surname-length, ub-terminal-id-length,
--    ub-tsap-id-length, ub-unformatted-address-length,
--    ub-universal-generation-qualifier-length, ub-universal-given-name-length,
--    ub-universal-initials-length, ub-universal-surname-length,
--    ub-x121-address-length
    --==
--    FROM MTSUpperBounds {joint-iso-itu-t mhs(6) mts(3) modules(0)
--      upper-bounds(3) version-1999(1)};

--operationObject1 OPERATION ::= {LINKED  {operationObject2}
--}

--operationObject2 OPERATION ::= {LINKED  {operationObject3}
--}

--operationObject3 OPERATION ::= {LINKED  {operationObject4}
--}

--operationObject4 OPERATION ::= {LINKED  {...}
--}

--	Objects
--MHS-OBJECT ::= ROS-OBJECT-CLASS

--mts MHS-OBJECT ::= {
--  INITIATES  {mts-forced-access-contract}
--  RESPONDS   {mts-access-contract}
--  ID         id-ot-mts
--}

--mts-user MHS-OBJECT ::= {
--  INITIATES  {mts-access-contract}
--  RESPONDS   {mts-forced-access-contract}
--  ID         id-ot-mts-user
--}

-- Contracts
--mts-access-contract CONTRACT ::= {
--  CONNECTION             mts-connect
--  INITIATOR CONSUMER OF  {submission | delivery | administration}
--  ID                     id-ct-mts-access
--}

--mts-forced-access-contract CONTRACT ::= {
--  CONNECTION             mts-connect
--  RESPONDER CONSUMER OF  {submission | delivery | administration}
--  ID                     id-ct-mts-forced-access
--}

-- Connection package
--mts-connect CONNECTION-PACKAGE ::= {
--  BIND    mts-bind
--  UNBIND  mts-unbind
--  ID      id-cp-mts-connect
--}

--	Ports
--PORT ::= OPERATION-PACKAGE

--submission PORT ::= {
--  OPERATIONS        {operationObject1, ...}
--  CONSUMER INVOKES
--    {message-submission | probe-submission | cancel-deferred-delivery, ...}
--  SUPPLIER INVOKES  {submission-control, ...}
--  ID                id-pt-submission
--}

--delivery PORT ::= {
--  OPERATIONS        {operationObject1, ...}
--  CONSUMER INVOKES  {delivery-control, ...}
--  SUPPLIER INVOKES  {message-delivery | report-delivery, ...}
--  ID                id-pt-delivery
--}

--administration PORT ::= {
--  OPERATIONS        {change-credentials, ...}
--  CONSUMER INVOKES  {register, ...}
--  SUPPLIER INVOKES  {operationObject1, ...}
--  ID                id-pt-administration
--}

--	MTS-bind and MTS-unbind
--ABSTRACT-OPERATION ::= OPERATION

--ABSTRACT-ERROR ::= ERROR

--mts-bind ABSTRACT-OPERATION ::= {
--  ARGUMENT  MTSBindArgument
--  RESULT    MTSBindResult
--  ERRORS    {mts-bind-error}
--}

MTSBindArgument ::= SET {
  initiator-name         ObjectName,
  messages-waiting       [1] EXPLICIT MessagesWaiting OPTIONAL,
  initiator-credentials  [2]  InitiatorCredentials,
  security-context       [3]  SecurityContext OPTIONAL,
--  ...,
  extensions
    [5]  SET OF ExtensionField --{{MTSBindExtensions}}-- DEFAULT {}
}

--MTSBindExtensions EXTENSION ::= {PrivateExtensions, ...}

-- May contain private extensions and future standardised extensions
MTSBindResult ::= SET {
  responder-name         ObjectName,
  messages-waiting       [1] EXPLICIT MessagesWaiting OPTIONAL,
  responder-credentials  [2]  ResponderCredentials,
  ...,
  extensions
    [5]  SET OF ExtensionField --{{MTSBindResultExtensions}}-- DEFAULT {}
}

--MTSBindResultExtensions EXTENSION ::= {PrivateExtensions, ...}

-- May contain private extensions and future standardised extensions
MTSBindError --mts-bind-error ABSTRACT-ERROR-- ::= --{
--  PARAMETER
    INTEGER {busy(0), authentication-error(2), unacceptable-dialogue-mode(3),
             unacceptable-security-context(4),
             inadequate-association-confidentiality(5)}--(0..ub-integer-options)
--}

--mts-unbind ABSTRACT-OPERATION ::= emptyUnbind

--	Association Control Parameters
ObjectName ::= CHOICE {
  user-agent     ORAddressAndOptionalDirectoryName,
  mTA            [0]  MTAName,
  message-store  [4]  ORAddressAndOptionalDirectoryName
}

MessagesWaiting ::= SET {
  urgent      [0]  DeliveryQueue,
  normal      [1]  DeliveryQueue,
  non-urgent  [2]  DeliveryQueue
}

DeliveryQueue ::= SET {
  messages  [0]  INTEGER --(0..ub-queue-size)--,
  octets    [1]  INTEGER --(0..ub-content-length)-- OPTIONAL
}

InitiatorCredentials ::= Credentials

ResponderCredentials ::= Credentials

Credentials ::= CHOICE {
  simple     Password,
  strong     [0]  StrongCredentials,
--  ...,
  protected  [1]  ProtectedPassword
}

Password ::= CHOICE {
  ia5-string    IA5String --(SIZE (0..ub-password-length))--,
  octet-string  OCTET STRING --(SIZE (0..ub-password-length))
}

StrongCredentials ::= SET {
  bind-token               [0]  Token OPTIONAL,
  certificate              [1]  Certificates OPTIONAL,
--  ...,
  certificate-selector     [2]  CertificateAssertion OPTIONAL
}

ProtectedPassword ::= SET {
  signature
--    SIGNATURE{SET {password  Password,
--                   time1     [0]  UTCTime OPTIONAL,
--                   time2     [1]  UTCTime OPTIONAL,
--                   random1   [2]  BIT STRING OPTIONAL,
--                   random2   [3]  BIT STRING OPTIONAL}},
  Signature,
  time1      [0]  UTCTime OPTIONAL,
  time2      [1]  UTCTime OPTIONAL,
  random1    [2]  BIT STRING OPTIONAL,
  random2    [3]  BIT STRING OPTIONAL
}

Signature ::= SEQUENCE {
  algorithmIdentifier	AlgorithmIdentifier,
  encrypted		BIT STRING
}

SecurityContext ::= SET --SIZE (1..ub-security-labels)-- OF SecurityLabel

--	Submission Port
--message-submission ABSTRACT-OPERATION ::= {
--  ARGUMENT         MessageSubmissionArgument
--  RESULT           MessageSubmissionResult
--  ERRORS
--    {submission-control-violated | element-of-service-not-subscribed |
--      originator-invalid | recipient-improperly-specified |
--      inconsistent-request | security-error | unsupported-critical-function |
--      remote-bind-error}
--  LINKED           {operationObject1, ...}
--  INVOKE PRIORITY  {4 | 6 | 7}
--  CODE             op-message-submission
--}

MessageSubmissionArgument ::= SEQUENCE {
  envelope  MessageSubmissionEnvelope,
  content   Content
}

MessageSubmissionResult ::= SET {
  message-submission-identifier  MessageSubmissionIdentifier,
  message-submission-time        [0]  MessageSubmissionTime,
  content-identifier             ContentIdentifier OPTIONAL,
  extensions
    [1]  SET OF ExtensionField --{{MessageSubmissionResultExtensions}}-- DEFAULT {}
}

--MessageSubmissionResultExtensions EXTENSION ::=
--  {- - May contain the following extensions, private extensions, and future standardised extensions,
--   - - at most one instance of each extension type:
--   originating-MTA-certificate | proof-of-submission | PrivateExtensions, 
--   ...}

--probe-submission ABSTRACT-OPERATION ::= {
--  ARGUMENT         ProbeSubmissionArgument
--  RESULT           ProbeSubmissionResult
--  ERRORS
--    {submission-control-violated | element-of-service-not-subscribed |
--      originator-invalid | recipient-improperly-specified |
--      inconsistent-request | security-error | unsupported-critical-function |
--      remote-bind-error}
--  LINKED           {operationObject1, ...}
--  INVOKE PRIORITY  {5}
--  CODE             op-probe-submission
--}

ProbeSubmissionArgument ::= ProbeSubmissionEnvelope

ProbeSubmissionResult ::= SET {
  probe-submission-identifier  ProbeSubmissionIdentifier,
  probe-submission-time        [0]  ProbeSubmissionTime,
  content-identifier           ContentIdentifier OPTIONAL,
  extensions
    [1]  SET OF ExtensionField --{{ProbeResultExtensions}}-- DEFAULT {}
}

--ProbeResultExtensions EXTENSION ::= {PrivateExtensions, ...}

-- May contain private extensions and future standardised extensions,
-- at most one instance of each extension type
--cancel-deferred-delivery ABSTRACT-OPERATION ::= {
--  ARGUMENT         CancelDeferredDeliveryArgument
--  RESULT           CancelDeferredDeliveryResult
--  ERRORS
--    {deferred-delivery-cancellation-rejected |
--      message-submission-identifier-invalid | remote-bind-error}
--  LINKED           {operationObject1, ...}
--  INVOKE PRIORITY  {3}
--  CODE             op-cancel-deferred-delivery
--}

CancelDeferredDeliveryArgument ::= MessageSubmissionIdentifier

CancelDeferredDeliveryResult ::= NULL

--submission-control ABSTRACT-OPERATION ::= {
--  ARGUMENT         SubmissionControlArgument
--  RESULT           SubmissionControlResult
--  ERRORS           {security-error | remote-bind-error}
--  LINKED           {operationObject1, ...}
--  INVOKE PRIORITY  {3}
--  CODE             op-submission-control
--}

SubmissionControlArgument ::= SubmissionControls

SubmissionControlResult ::= Waiting

--submission-control-violated ABSTRACT-ERROR ::= {
--  PARAMETER  NULL
--  CODE       err-submission-control-violated
--}

--element-of-service-not-subscribed ABSTRACT-ERROR ::= {
--  PARAMETER  NULL
--  CODE       err-element-of-service-not-subscribed
--}

--deferred-delivery-cancellation-rejected ABSTRACT-ERROR ::= {
--  PARAMETER  NULL
--  CODE       err-deferred-delivery-cancellation-rejected
--}

--originator-invalid ABSTRACT-ERROR ::= {
--  PARAMETER  NULL
--  CODE       err-originator-invalid
--}

--recipient-improperly-specified ABSTRACT-ERROR ::= {
--  PARAMETER  ImproperlySpecifiedRecipients
--  CODE       err-recipient-improperly-specified
--}

ImproperlySpecifiedRecipients ::=
  SEQUENCE --SIZE (1..ub-recipients)-- OF MTSRecipientName

--message-submission-identifier-invalid ABSTRACT-ERROR ::= {
--  PARAMETER  NULL
--  CODE       err-message-submission-identifier-invalid
--}

--inconsistent-request ABSTRACT-ERROR ::= {
--  PARAMETER  NULL
--  CODE       err-inconsistent-request
--}

--security-error ABSTRACT-ERROR ::= {
--  PARAMETER  SecurityProblem
--  CODE       err-security-error
--}

SecurityProblem ::= INTEGER {
  assemby-instructions-conflict-with-security-services(0),
  authentication-problem(1), authentication-failure-on-subject-message(2),
  confidentiality-association-problem(3), decryption-failed(4),
  decryption-key-unobtainable(5), failure-of-proof-of-message(6),
  forbidden-user-security-label-register(7),
  incompatible-change-with-original-security-context(8),
  integrity-failure-on-subject-message(9), invalid-security-label(10),
  invalid-security-label-update(11), key-failure(12),
  mandatory-parameter-absence(13), operation-security-failure(14),
  redirection-prohibited(15), refused-alternate-recipient-name(16),
  repudiation-failure-of-message(17),
  responder-credentials-checking-problem(18), security-context-failure(19),
  security-context-problem(20), security-policy-violation(21),
  security-services-refusal(22), token-decryption-failed(23), token-error(24),
  unable-to-aggregate-security-labels(25), unauthorised-dl-name(26),
  unauthorised-entry-class(27),
  unauthorised-originally-intended-recipient-name(28),
  unauthorised-originator-name(29), unauthorised-recipient-name(30),
  unauthorised-security-label-update(31), unauthorised-user-name(32),
  unknown-security-label(33), unsupported-algorithm-identifier(34),
  unsupported-security-policy(35)}(0..ub-security-problems)

--unsupported-critical-function ABSTRACT-ERROR ::= {
--  PARAMETER  NULL
--  CODE       err-unsupported-critical-function
--}

--remote-bind-error ABSTRACT-ERROR ::= {
--  PARAMETER  NULL
--  CODE       err-remote-bind-error
--}

--	Submission Port Parameters
MessageSubmissionIdentifier ::= MTSIdentifier

MessageSubmissionTime ::= Time

ProbeSubmissionIdentifier ::= MTSIdentifier

ProbeSubmissionTime ::= Time

SubmissionControls ::=
  Controls
    (WITH COMPONENTS {
       ...,
       permissible-content-types              ABSENT,
       permissible-encoded-information-types  ABSENT
     })

Waiting ::= SET {
  waiting-operations                 [0]  Operations DEFAULT {},
  waiting-messages                   [1]  WaitingMessages DEFAULT {},
  waiting-content-types
    [2]  SET --SIZE (0..ub-content-types)-- OF ContentType DEFAULT {},
  waiting-encoded-information-types  EncodedInformationTypes OPTIONAL
}

Operations ::= BIT STRING {
  probe-submission-or-report-delivery(0),
  message-submission-or-message-delivery(1)}(SIZE (0..ub-bit-options))

-- holding 'one', not-holding 'zero'
WaitingMessages ::= BIT STRING {
  long-content(0), low-priority(1), other-security-labels(2)
}(SIZE (0..ub-bit-options))

--	Delivery Port
--message-delivery ABSTRACT-OPERATION ::= {
--  ARGUMENT         MessageDeliveryArgument
--  RESULT           MessageDeliveryResult
--  ERRORS
--    {delivery-control-violated | security-error |
--      unsupported-critical-function}
--  LINKED           {operationObject1, ...}
--  INVOKE PRIORITY  {4 | 6 | 7}
--  CODE             op-message-delivery
--}

MessageDeliveryArgument ::= SEQUENCE {
--  COMPONENTS OF MessageDeliveryEnvelope,
  message-delivery-identifier  MessageDeliveryIdentifier,
  message-delivery-time        MessageDeliveryTime,
  other-fields                 OtherMessageDeliveryFields,
  content  Content
}

MessageDeliveryResult ::= SET {
  recipient-certificate  [0]  RecipientCertificate OPTIONAL,
  proof-of-delivery      [1] IMPLICIT ProofOfDelivery OPTIONAL,
  ...,
  extensions
    [2]  SET OF ExtensionField --{{MessageDeliveryResultExtensions}}-- DEFAULT {}
}

--MessageDeliveryResultExtensions EXTENSION ::= {PrivateExtensions, ...}

-- May contain private extensions and future standardised extensions
--report-delivery ABSTRACT-OPERATION ::= {
--  ARGUMENT         ReportDeliveryArgument
--  RESULT           ReportDeliveryResult
--  ERRORS
--    {delivery-control-violated | security-error |
--      unsupported-critical-function}
--  LINKED           {operationObject1, ...}
--  INVOKE PRIORITY  {5}
--  CODE             op-report-delivery
--}

ReportDeliveryArgument ::= SET {
--  COMPONENTS OF ReportDeliveryEnvelope
  subject-submission-identifier       SubjectSubmissionIdentifier,
  content-identifier                  ContentIdentifier OPTIONAL,
  content-type                        ContentType OPTIONAL,
  original-encoded-information-types  OriginalEncodedInformationTypes OPTIONAL,
  extensions
    [1]  SET OF ExtensionField --{{ReportDeliveryExtensions}}-- DEFAULT {},
  per-recipient-fields
    SEQUENCE --SIZE (1..ub-recipients)-- OF PerRecipientReportDeliveryFields,
  returned-content  [0]  Content OPTIONAL
}

ReportDeliveryResult ::= CHOICE {
  empty-result  NULL,
  ...,
  extensions
    SET --SIZE (1..MAX)-- OF ExtensionField --{{ReportDeliveryResultExtensions}}--
}

--ReportDeliveryResultExtensions EXTENSION ::= {PrivateExtensions, ...}

-- May contain private extensions and future standardised extensions
--delivery-control ABSTRACT-OPERATION ::= {
--  ARGUMENT         DeliveryControlArgument
--  RESULT           DeliveryControlResult
--  ERRORS
--    {control-violates-registration | security-error | operation-refused}
--  LINKED           {operationObject1, ...}
--  INVOKE PRIORITY  {3}
--  CODE             op-delivery-control
--}

DeliveryControlArgument ::= SET {
--  COMPONENTS OF DeliveryControls,
  restrict                               [0]  BOOLEAN DEFAULT TRUE,
  -- update 'TRUE', remove 'FALSE'
  permissible-operations                 [1]  Operations OPTIONAL,
  permissible-maximum-content-length     [2]  ContentLength OPTIONAL,
  permissible-lowest-priority            Priority OPTIONAL,
  permissible-content-types              [4]  ContentTypes OPTIONAL,
  permissible-encoded-information-types
    PermissibleEncodedInformationTypes OPTIONAL,
  permissible-security-context           [5]  SecurityContext OPTIONAL,
  extensions
    [6]  SET OF ExtensionField --{{DeliveryControlExtensions}}-- DEFAULT {}
}

--DeliveryControlExtensions EXTENSION ::= {PrivateExtensions, ...}

-- May contain private extensions and future standardised extensions
DeliveryControlResult ::= SET {
--  COMPONENTS OF Waiting,
  waiting-operations                 [0]  Operations DEFAULT {},
  waiting-messages                   [1]  WaitingMessages DEFAULT {},
  waiting-content-types
    [2]  SET --SIZE (0..ub-content-types)-- OF ContentType DEFAULT {},
  waiting-encoded-information-types  EncodedInformationTypes OPTIONAL,
  extensions
    [6]  SET OF ExtensionField --{{DeliveryControlResultExtensions}}--  DEFAULT {}
}

--DeliveryControlResultExtensions EXTENSION ::= {PrivateExtensions, ...}

-- May contain private extensions and future standardised extensions
--delivery-control-violated ABSTRACT-ERROR ::= {
--  PARAMETER  NULL
--  CODE       err-delivery-control-violated
--}

--control-violates-registration ABSTRACT-ERROR ::= {
--  PARAMETER  NULL
--  CODE       err-control-violates-registration
--}

--operation-refused ABSTRACT-ERROR ::= {
--  PARAMETER  RefusedOperation
--  CODE       err-operation-refused
--}

RefusedOperation ::= SET {
  refused-argument
    CHOICE {built-in-argument  [1]  RefusedArgument,
            refused-extension  ANY --EXTENSION.&id --},
  refusal-reason    [2]  RefusalReason
}

RefusedArgument ::= INTEGER {
  user-name(0), user-address(1), deliverable-content-types(2),
  deliverable-maximum-content-length(3),
  deliverable-encoded-information-types-constraints(4),
  deliverable-security-labels(5), recipient-assigned-redirections(6),
  restricted-delivery(7),
  retrieve-registrations(8), -- value 9 reserved for possible future extension to Register arguments
  restrict(10), permissible-operations(11), permissible-lowest-priority(12),
  permissible-encoded-information-types(13), permissible-content-types(14),
  permissible-maximum-content-length(15), permissible-security-context(16)
}(0..ub-integer-options)

RefusalReason ::= INTEGER {
  facility-unavailable(0), facility-not-subscribed(1),
  parameter-unacceptable(2)}(0..ub-integer-options)

--	Delivery Port Parameters
RecipientCertificate ::= Certificates

ProofOfDelivery ::= Signature
--  SIGNATURE
--    {SEQUENCE {algorithm-identifier
--                 ProofOfDeliveryAlgorithmIdentifier,
--               delivery-time                       MessageDeliveryTime,
--               this-recipient-name                 ThisRecipientName,
--               originally-intended-recipient-name
--                 MTSOriginallyIntendedRecipientName OPTIONAL,
--               content                             Content,
--               content-identifier                  ContentIdentifier OPTIONAL,
--               message-security-label
--                 MessageSecurityLabel OPTIONAL}}

ProofOfDeliveryAlgorithmIdentifier ::= AlgorithmIdentifier

DeliveryControls ::= Controls

Controls ::= SET {
  restrict                               [0]  BOOLEAN DEFAULT TRUE,
  -- update 'TRUE', remove 'FALSE'
  permissible-operations                 [1]  Operations OPTIONAL,
  permissible-maximum-content-length     [2]  ContentLength OPTIONAL,
  permissible-lowest-priority            Priority OPTIONAL,
  permissible-content-types              [4]  ContentTypes OPTIONAL,
  permissible-encoded-information-types
    PermissibleEncodedInformationTypes OPTIONAL,
  permissible-security-context           [5]  SecurityContext OPTIONAL
}

--	Note - The Tags [0], [1] and [2] are altered for the Register operation only.
PermissibleEncodedInformationTypes ::=
  EncodedInformationTypesConstraints

--	Administration Port
--register ABSTRACT-OPERATION ::= {
--  ARGUMENT         RegisterArgument
--  RESULT           RegisterResult
--  ERRORS
--    {register-rejected | remote-bind-error | operation-refused |
--      security-error}
--  LINKED           {operationObject1, ...}
--  INVOKE PRIORITY  {5}
--  CODE             op-register
--}

RegisterArgument ::= SET {
  user-name                  UserName OPTIONAL,
  user-address               [0]  UserAddress OPTIONAL,
  deliverable-class
    SET --SIZE (1..ub-deliverable-class)-- OF DeliverableClass OPTIONAL,
  default-delivery-controls  [2] EXPLICIT DefaultDeliveryControls OPTIONAL,
  redirections               [3]  Redirections OPTIONAL,
  restricted-delivery        [4]  RestrictedDelivery OPTIONAL,
  retrieve-registrations     [5]  RegistrationTypes OPTIONAL,
  extensions
    [6]  SET OF ExtensionField --{{RegisterExtensions}}-- DEFAULT {}
}

--RegisterExtensions EXTENSION ::= {PrivateExtensions, ...}

-- May contain private extensions and future standardised extensions
RegisterResult ::= CHOICE {
  empty-result      NULL,
  non-empty-result
    SET {registered-information
           [0]  RegisterArgument
--                  (WITH COMPONENTS {
--                     ...,
--                     retrieve-registrations  ABSENT
--                   }) OPTIONAL--,
         extensions
           [1]  SET OF ExtensionField --{{RegisterResultExtensions}}-- DEFAULT {}
  }
}

--RegisterResultExtensions EXTENSION ::= {PrivateExtensions, ...}

-- May contain private extensions and future standardised extensions
--change-credentials ABSTRACT-OPERATION ::= {
--  ARGUMENT         ChangeCredentialsArgument
--  RESULT           NULL
--  ERRORS
--    {new-credentials-unacceptable | old-credentials-incorrectly-specified |
--      remote-bind-error | security-error}
--  LINKED           {operationObject1, ...}
--  INVOKE PRIORITY  {5}
--  CODE             op-change-credentials
--}

ChangeCredentialsArgument ::= SET {
  old-credentials  [0]  Credentials(WITH COMPONENTS {
                                      simple  
                                    }),
  new-credentials  [1]  Credentials(WITH COMPONENTS {
                                      simple  
                                    })
}

--register-rejected ABSTRACT-ERROR ::= {
--  PARAMETER  NULL
--  CODE       err-register-rejected
--}

--new-credentials-unacceptable ABSTRACT-ERROR ::= {
--  PARAMETER  NULL
--  CODE       err-new-credentials-unacceptable
--}

--old-credentials-incorrectly-specified ABSTRACT-ERROR ::= {
--  PARAMETER  NULL
--  CODE       err-old-credentials-incorrectly-specified
--}

--	Administration Port Parameters
UserName ::= ORAddressAndOptionalDirectoryName

UserAddress ::= CHOICE {
  x121
    [0]  SEQUENCE {x121-address
                     NumericString --(SIZE (1..ub-x121-address-length))-- OPTIONAL,
                   tsap-id
                     PrintableString --(SIZE (1..ub-tsap-id-length))-- OPTIONAL
  },
  presentation  [1]  PSAPAddress
}

PSAPAddress ::= PresentationAddress

DeliverableClass ::=
  MessageClass
    (WITH COMPONENTS {
       ...,
       priority         ABSENT,
       -- The 'objects' component shall always be defaulted.
       -- objects ABSENT,
       -- A component with a DEFAULT clause cannot be ABSENT 
       applies-only-to  ABSENT
     })

DefaultDeliveryControls ::=
  Controls
    (WITH COMPONENTS {
       ...,
       
       -- The 'restrict' component shall always be defaulted.
       -- restrict ABSENT,
       -- A component with a DEFAULT clause cannot be ABSENT 
       permissible-security-context  ABSENT
     })

Redirections ::= SEQUENCE SIZE (1..ub-redirections) OF RecipientRedirection

RecipientRedirection ::= SET {
  redirection-classes
    [0]  SET --SIZE (1..ub-redirection-classes)-- OF RedirectionClass OPTIONAL,
  recipient-assigned-alternate-recipient
    [1]  RecipientAssignedAlternateRecipient OPTIONAL
}

RedirectionClass ::= MessageClass

MessageClass ::= SET {
  content-types                          [0]  ContentTypes OPTIONAL,
  maximum-content-length                 [1]  ContentLength OPTIONAL,
  encoded-information-types-constraints
    [2]  EncodedInformationTypesConstraints OPTIONAL,
  security-labels                        [3]  SecurityContext OPTIONAL,
  priority                               [4]  SET OF Priority OPTIONAL,
  objects
    [5]  ENUMERATED {messages(0), reports(1), both(2), ...
                     } DEFAULT both,
  applies-only-to                        [6]  SEQUENCE OF Restriction OPTIONAL, -- Not considered in the case of Reports 
  extensions
    [7]  SET OF ExtensionField --{{MessageClassExtensions}}-- DEFAULT {}
}

EncodedInformationTypesConstraints ::= SEQUENCE {
  unacceptable-eits            [0]  ExtendedEncodedInformationTypes OPTIONAL,
  acceptable-eits              [1]  ExtendedEncodedInformationTypes OPTIONAL,
  exclusively-acceptable-eits  [2]  ExtendedEncodedInformationTypes OPTIONAL
}

--MessageClassExtensions EXTENSION ::= {PrivateExtensions, ...}

-- May contain private extensions and future standardised extensions
RecipientAssignedAlternateRecipient ::=
  ORAddressAndOrDirectoryName

RestrictedDelivery ::= SEQUENCE SIZE (1..ub-restrictions) OF Restriction

Restriction ::= SET {
  permitted    BOOLEAN DEFAULT TRUE,
  source-type
    BIT STRING {originated-by(0), redirected-by(1), dl-expanded-by(2)}
--      DEFAULT {originated-by, redirected-by, dl-expanded-by}--,
  source-name  ExactOrPattern OPTIONAL
}

ExactOrPattern ::= CHOICE {
  exact-match    [0]  ORName,
  pattern-match  [1]  ORName
}

RegistrationTypes ::= SEQUENCE {
  standard-parameters
    [0]  BIT STRING {user-name(0), user-address(1), deliverable-class(2),
                     default-delivery-controls(3), redirections(4),
                     restricted-delivery(5)} OPTIONAL,
  extensions           [1]  SET OF ANY --EXTENSION.&id({RegisterExtensions})-- OPTIONAL
}

--	Message Submission Envelope
MessageSubmissionEnvelope ::= SET {
--  COMPONENTS OF PerMessageSubmissionFields,
--  per-recipient-fields
--    [1]  SEQUENCE SIZE (1..ub-recipients) OF
--           PerRecipientMessageSubmissionFields
--}

--PerMessageSubmissionFields ::= SET {
  originator-name                     MTSOriginatorName,
  original-encoded-information-types  OriginalEncodedInformationTypes OPTIONAL,
  content-type                        ContentType,
  content-identifier                  ContentIdentifier OPTIONAL,
  priority                            Priority DEFAULT normal,
  per-message-indicators              PerMessageIndicators DEFAULT {},
  deferred-delivery-time              [0]  DeferredDeliveryTime OPTIONAL,
  extensions
    [2]  SET OF ExtensionField --{{PerMessageSubmissionExtensions}}-- DEFAULT {}
    ,per-recipient-fields
    [1]  SEQUENCE --SIZE (1..ub-recipients)-- OF
           PerRecipientMessageSubmissionFields

}

--PerMessageSubmissionExtensions EXTENSION ::=
--  {- - May contain the following extensions, private extensions, and future standardised extensions,
   -- at most one instance of each extension type:
--   recipient-reassignment-prohibited | dl-expansion-prohibited |
--   conversion-with-loss-prohibited | latest-delivery-time |
--   originator-return-address | originator-certificate |
--   content-confidentiality-algorithm-identifier |
--   message-origin-authentication-check | message-security-label |
--   proof-of-submission-request | content-correlator | dl-exempted-recipients |
--   certificate-selectors | multiple-originator-certificates |
--   forwarding-request - - for MS Abstract Service only - - | PrivateExtensions, 
--   ...}

PerRecipientMessageSubmissionFields ::= SET {
  recipient-name             MTSRecipientName,
  originator-report-request  [0]  OriginatorReportRequest,
  explicit-conversion        [1]  ExplicitConversion OPTIONAL,
  extensions
    [2]  SET OF ExtensionField --{{PerRecipientMessageSubmissionExtensions}}--
      DEFAULT {}
}

--PerRecipientMessageSubmissionExtensions EXTENSION ::=
--  {- - May contain the following extensions, private extensions, and future standardised extensions,
   -- at most one instance of each extension type:
--   originator-requested-alternate-recipient | requested-delivery-method |
--   physical-forwarding-prohibited | physical-forwarding-address-request |
--   physical-delivery-modes | registered-mail-type | recipient-number-for-advice
--   | physical-rendition-attributes | physical-delivery-report-request |
--   message-token | content-integrity-check | proof-of-delivery-request |
--   certificate-selectors-override | recipient-certificate |
--   IPMPerRecipientEnvelopeExtensions | PrivateExtensions, ...}

--	Probe Submission Envelope
ProbeSubmissionEnvelope ::= SET {
--  COMPONENTS OF PerProbeSubmissionFields,
--  per-recipient-fields
--    [3]  SEQUENCE SIZE (1..ub-recipients) OF PerRecipientProbeSubmissionFields
--}

--PerProbeSubmissionFields ::= SET {
  originator-name                     MTSOriginatorName,
  original-encoded-information-types  OriginalEncodedInformationTypes OPTIONAL,
  content-type                        ContentType,
  content-identifier                  ContentIdentifier OPTIONAL,
  content-length                      [0]  ContentLength OPTIONAL,
  per-message-indicators              PerMessageIndicators DEFAULT {},
  extensions
    [2]  SET OF ExtensionField --{{PerProbeSubmissionExtensions}}-- DEFAULT {}
  ,per-recipient-fields
    [3]  SEQUENCE --SIZE (1..ub-recipients)-- OF PerRecipientProbeSubmissionFields

}

--PerProbeSubmissionExtensions EXTENSION ::=
--  {- - May contain the following extensions, private extensions, and future standardised extensions,
   -- at most one instance of each extension type:
--   recipient-reassignment-prohibited | dl-expansion-prohibited |
--   conversion-with-loss-prohibited | originator-certificate |
--   message-security-label | content-correlator |
--   probe-origin-authentication-check | PrivateExtensions, ...}

PerRecipientProbeSubmissionFields ::= SET {
  recipient-name             MTSRecipientName,
  originator-report-request  [0]  OriginatorReportRequest,
  explicit-conversion        [1]  ExplicitConversion OPTIONAL,
  extensions
    [2]  SET OF ExtensionField --{{PerRecipientProbeSubmissionExtensions}}
      DEFAULT {}
}

--PerRecipientProbeSubmissionExtensions EXTENSION ::=
--  {- - May contain the following extensions, private extensions, and future standardised extensions,
   -- at most one instance of each extension type:
--   originator-requested-alternate-recipient | requested-delivery-method |
--   physical-rendition-attributes | PrivateExtensions, ...}

--	Message Delivery Envelope
MessageDeliveryEnvelope ::= SEQUENCE {
  message-delivery-identifier  MessageDeliveryIdentifier,
  message-delivery-time        MessageDeliveryTime,
  other-fields                 OtherMessageDeliveryFields
}

OtherMessageDeliveryFields ::= SET {
  content-type                         DeliveredContentType,
  originator-name                      DeliveredOriginatorName,
  original-encoded-information-types
    [1]  OriginalEncodedInformationTypes OPTIONAL,
  priority                             Priority DEFAULT normal,
  delivery-flags                       [2]  DeliveryFlags OPTIONAL,
  other-recipient-names                [3]  OtherRecipientNames OPTIONAL,
  this-recipient-name                  [4]  ThisRecipientName,
  originally-intended-recipient-name
    [5]  MTSOriginallyIntendedRecipientName OPTIONAL,
  converted-encoded-information-types
    [6]  ConvertedEncodedInformationTypes OPTIONAL,
  message-submission-time              [7]  MessageSubmissionTime,
  content-identifier                   [8]  ContentIdentifier OPTIONAL,
  extensions
    [9]  SET OF ExtensionField --{{MessageDeliveryExtensions}}-- DEFAULT {}
}

--MessageDeliveryExtensions EXTENSION ::=
--  {- - May contain the following extensions, private extensions, and future standardised extensions,
   -- at most one instance of each extension type:
--   conversion-with-loss-prohibited | requested-delivery-method |
--   physical-forwarding-prohibited | physical-forwarding-address-request |
--   physical-delivery-modes | registered-mail-type | recipient-number-for-advice
--   | physical-rendition-attributes | originator-return-address |
--   physical-delivery-report-request | originator-certificate | message-token |
--   content-confidentiality-algorithm-identifier | content-integrity-check |
--   message-origin-authentication-check | message-security-label |
--   proof-of-delivery-request | dl-exempted-recipients | certificate-selectors |
--   certificate-selectors-override | multiple-originator-certificates |
--   recipient-certificate | IPMPerRecipientEnvelopeExtensions |
--   redirection-history | dl-expansion-history | trace-information |
--   internal-trace-information | PrivateExtensions, ...}

--	Report Delivery Envelope
ReportDeliveryEnvelope ::= SET {
--  COMPONENTS OF PerReportDeliveryFields,
--  per-recipient-fields
--    SEQUENCE SIZE (1..ub-recipients) OF PerRecipientReportDeliveryFields
--}

--PerReportDeliveryFields ::= SET {
  subject-submission-identifier       SubjectSubmissionIdentifier,
  content-identifier                  ContentIdentifier OPTIONAL,
  content-type                        ContentType OPTIONAL,
  original-encoded-information-types  OriginalEncodedInformationTypes OPTIONAL,
  extensions
    [1]  SET OF ExtensionField --{{ReportDeliveryExtensions}}-- DEFAULT {}
  ,per-recipient-fields
    SEQUENCE --SIZE (1..ub-recipients)-- OF PerRecipientReportDeliveryFields

}

--ReportDeliveryExtensions EXTENSION ::=
--  {- - May contain the following extensions, private extensions, and future standardised extensions,
   -- at most one instance of each extension type:
--   message-security-label | content-correlator | redirection-history |
--   originator-and-DL-expansion-history | reporting-DL-name |
--   reporting-MTA-certificate | report-origin-authentication-check |
--   trace-information | internal-trace-information | reporting-MTA-name |
--   PrivateExtensions, ...}

PerRecipientReportDeliveryFields ::= SET {
  actual-recipient-name                [0]  MTSActualRecipientName,
  report-type                          [1]  ReportType,
  converted-encoded-information-types
    ConvertedEncodedInformationTypes OPTIONAL,
  originally-intended-recipient-name
    [2]  MTSOriginallyIntendedRecipientName OPTIONAL,
  supplementary-information            [3]  SupplementaryInformation OPTIONAL,
  extensions
    [4]  SET OF ExtensionField --{{PerRecipientReportDeliveryExtensions}}--
      DEFAULT {}
}

--PerRecipientReportDeliveryExtensions EXTENSION ::=
--  {- - May contain the following extensions, private extensions, and future standardised extensions,
   -- at most one instance of each extension type:
--   redirection-history | physical-forwarding-address | recipient-certificate |
--   proof-of-delivery | PrivateExtensions, ...}

ReportType ::= CHOICE {
  delivery      [0]  DeliveryReport,
  non-delivery  [1]  NonDeliveryReport
}

DeliveryReport ::= SET {
  message-delivery-time  [0]  MessageDeliveryTime,
  type-of-MTS-user       [1]  TypeOfMTSUser DEFAULT public
}

NonDeliveryReport ::= SET {
  non-delivery-reason-code      [0]  NonDeliveryReasonCode,
  non-delivery-diagnostic-code  [1]  NonDeliveryDiagnosticCode OPTIONAL
}

--	Envelope Fields
MTSOriginatorName ::= ORAddressAndOrDirectoryName

DeliveredOriginatorName ::= ORAddressAndOptionalDirectoryName

OriginalEncodedInformationTypes ::= EncodedInformationTypes

ContentTypes ::= SET --SIZE (1..ub-content-types)-- OF ContentType

ContentType ::= CHOICE {
  built-in  BuiltInContentType,
  extended  ExtendedContentType
}

BuiltInContentType ::= [APPLICATION 6]  INTEGER {
  unidentified(0),
  external(1), -- identified by the object-identifier of the EXTERNAL content
  interpersonal-messaging-1984(2), interpersonal-messaging-1988(22),
  edi-messaging(35), voice-messaging(40)} --(0..ub-built-in-content-type)

ExtendedContentType ::= OBJECT IDENTIFIER -- RELATIVE-OID

DeliveredContentType ::= CHOICE {
  built-in  [0]  BuiltInContentType,
  extended  ExtendedContentType
}

ContentIdentifier ::=
  [APPLICATION 10]  PrintableString --(SIZE (1..ub-content-id-length))

PerMessageIndicators ::= [APPLICATION 8]  BIT STRING {
  disclosure-of-other-recipients(0), -- disclosure-of-other-recipients-requested 'one',
  
  -- disclosure-of-other-recipients-prohibited 'zero';
  -- ignored for Probe-submission
  implicit-conversion-prohibited(1), -- implicit-conversion-prohibited 'one', 
  
  -- implicit-conversion-allowed 'zero'
  alternate-recipient-allowed(2), -- alternate-recipient-allowed 'one',
  
  -- alternate-recipient-prohibited 'zero'
  content-return-request(3), -- content-return-requested 'one', 
  
  -- content-return-not-requested 'zero';
  -- ignored for Probe-submission
  reserved(4), -- bit reserved by MOTIS 1986
  bit-5(5),
  bit-6(6), -- notification type-1 : bit 5 'zero' and bit 6 'one'
  
  -- notification type-2 : bit 5 'one' and bit 6 'zero'
  -- notification type-3 : bit 5 'one' and bit 6 'one'
  -- the mapping between notification type 1, 2, 3
  -- and the content specific notification types are defined
  -- in relevant content specifications
  service-message(7) -- the message content is for service purposes;
  
  
-- it may be a notification related to a service message;
-- used only by bilateral agreement --}(SIZE (0..ub-bit-options))

MTSRecipientName ::= ORAddressAndOrDirectoryName

OriginatorReportRequest ::= BIT STRING {report(3), non-delivery-report(4)
                                                   
-- at most one bit shall be 'one':
-- report bit 'one' requests a 'report';
-- non-delivery-report bit 'one' requests a 'non-delivery-report';
-- both bits 'zero' requests 'no-report' --}(SIZE (0..ub-bit-options))

ExplicitConversion ::= INTEGER {
  ia5-text-to-teletex(0),
  -- values 1 to 7 are no longer defined
  ia5-text-to-g3-facsimile(8), ia5-text-to-g4-class-1(9),
  ia5-text-to-videotex(10), teletex-to-ia5-text(11),
  teletex-to-g3-facsimile(12), teletex-to-g4-class-1(13),
  teletex-to-videotex(14),
  -- value 15 is no longer defined
  videotex-to-ia5-text(16), videotex-to-teletex(17)}(0..ub-integer-options)

DeferredDeliveryTime ::= Time

Priority ::= [APPLICATION 7]  ENUMERATED {normal(0), non-urgent(1), urgent(2)}

ContentLength ::= INTEGER(0..ub-content-length)

MessageDeliveryIdentifier ::= MTSIdentifier

MessageDeliveryTime ::= Time

DeliveryFlags ::= BIT STRING {
  implicit-conversion-prohibited(1) -- implicit-conversion-prohibited 'one', 
  
  -- implicit-conversion-allowed 'zero' --}(SIZE (0..ub-bit-options))

OtherRecipientNames ::= SEQUENCE --SIZE (1..ub-recipients)-- OF OtherRecipientName

OtherRecipientName ::= ORAddressAndOptionalDirectoryName

ThisRecipientName ::= ORAddressAndOptionalDirectoryName

MTSOriginallyIntendedRecipientName ::= ORAddressAndOptionalDirectoryName

ConvertedEncodedInformationTypes ::= EncodedInformationTypes

SubjectSubmissionIdentifier ::= MTSIdentifier

MTSActualRecipientName ::= ORAddressAndOrDirectoryName

TypeOfMTSUser ::= INTEGER {
  public(0), private(1), ms(2), dl(3), pdau(4), physical-recipient(5), other(6)
}(0..ub-mts-user-types)

NonDeliveryReasonCode ::= INTEGER {
  transfer-failure(0), unable-to-transfer(1), conversion-not-performed(2),
  physical-rendition-not-performed(3), physical-delivery-not-performed(4),
  restricted-delivery(5), directory-operation-unsuccessful(6),
  deferred-delivery-not-performed(7), transfer-failure-for-security-reason(8)
}(0..ub-reason-codes)

NonDeliveryDiagnosticCode ::= INTEGER {
  unrecognised-OR-name(0), ambiguous-OR-name(1), mts-congestion(2),
  loop-detected(3), recipient-unavailable(4), maximum-time-expired(5),
  encoded-information-types-unsupported(6), content-too-long(7),
  conversion-impractical(8), implicit-conversion-prohibited(9),
  implicit-conversion-not-subscribed(10), invalid-arguments(11),
  content-syntax-error(12), size-constraint-violation(13),
  protocol-violation(14), content-type-not-supported(15),
  too-many-recipients(16), no-bilateral-agreement(17),
  unsupported-critical-function(18), conversion-with-loss-prohibited(19),
  line-too-long(20), page-split(21), pictorial-symbol-loss(22),
  punctuation-symbol-loss(23), alphabetic-character-loss(24),
  multiple-information-loss(25), recipient-reassignment-prohibited(26),
  redirection-loop-detected(27), dl-expansion-prohibited(28),
  no-dl-submit-permission(29), dl-expansion-failure(30),
  physical-rendition-attributes-not-supported(31),
  undeliverable-mail-physical-delivery-address-incorrect(32),
  undeliverable-mail-physical-delivery-office-incorrect-or-invalid(33),
  undeliverable-mail-physical-delivery-address-incomplete(34),
  undeliverable-mail-recipient-unknown(35),
  undeliverable-mail-recipient-deceased(36),
  undeliverable-mail-organization-expired(37),
  undeliverable-mail-recipient-refused-to-accept(38),
  undeliverable-mail-recipient-did-not-claim(39),
  undeliverable-mail-recipient-changed-address-permanently(40),
  undeliverable-mail-recipient-changed-address-temporarily(41),
  undeliverable-mail-recipient-changed-temporary-address(42),
  undeliverable-mail-new-address-unknown(43),
  undeliverable-mail-recipient-did-not-want-forwarding(44),
  undeliverable-mail-originator-prohibited-forwarding(45),
  secure-messaging-error(46), unable-to-downgrade(47),
  unable-to-complete-transfer(48), transfer-attempts-limit-reached(49),
  incorrect-notification-type(50),
  dl-expansion-prohibited-by-security-policy(51),
  forbidden-alternate-recipient(52), security-policy-violation(53),
  security-services-refusal(54), unauthorised-dl-member(55),
  unauthorised-dl-name(56),
  unauthorised-originally-intended-recipient-name(57),
  unauthorised-originator-name(58), unauthorised-recipient-name(59),
  unreliable-system(60), authentication-failure-on-subject-message(61),
  decryption-failed(62), decryption-key-unobtainable(63),
  double-envelope-creation-failure(64),
  double-enveloping-message-restoring-failure(65),
  failure-of-proof-of-message(66), integrity-failure-on-subject-message(67),
  invalid-security-label(68), key-failure(69), mandatory-parameter-absence(70),
  operation-security-failure(71), repudiation-failure-of-message(72),
  security-context-failure(73), token-decryption-failed(74), token-error(75),
  unknown-security-label(76), unsupported-algorithm-identifier(77),
  unsupported-security-policy(78)}(0..ub-diagnostic-codes)

SupplementaryInformation ::=
  PrintableString(SIZE (1..ub-supplementary-info-length))

--	Extension Fields
--EXTENSION ::= CLASS {
--  &id           ExtensionType UNIQUE,
--  &Type         OPTIONAL,
--  &absent       &Type OPTIONAL,
--  &recommended  Criticality DEFAULT {}
--}
--WITH SYNTAX {
--  [&Type
--   [IF ABSENT &absent],]
--  [RECOMMENDED CRITICALITY &recommended,]
--  IDENTIFIED BY &id
--}

ExtensionType ::= CHOICE {
  standard-extension  [0]  INTEGER --(0..ub-extension-types)--,
  private-extension   [3]  OBJECT IDENTIFIER
}

Criticality ::= BIT STRING {for-submission(0), for-transfer(1), for-delivery(2)
} -- (SIZE (0..ub-bit-options)) - - critical 'one', non-critical 'zero'
 

ExtensionField --{EXTENSION:ChosenFrom}-- ::= SEQUENCE {
  type         ExtensionType --EXTENSION.&id({ChosenFrom})--,
  criticality  [1]  Criticality DEFAULT {},
  value        [2]  ANY --EXTENSION.&Type({ChosenFrom}{@type}) DEFAULT NULL:NULL
}

--PrivateExtensions EXTENSION ::=
--  {- - Any value shall be relayed and delivered if not Critical (see Table 27)
   -- except those values whose semantics the MTA obeys which are defined to be removed when obeyed.
--   - - Shall be IDENTIFIED BY ExtensionType.private-extension - -...}

--recipient-reassignment-prohibited EXTENSION ::= {
--  RecipientReassignmentProhibited
--  IF ABSENT                recipient-reassignment-allowed,
--  RECOMMENDED CRITICALITY  {for-delivery},
--  IDENTIFIED BY            standard-extension:1
--}

RecipientReassignmentProhibited ::= ENUMERATED {
  recipient-reassignment-allowed(0), recipient-reassignment-prohibited(1)
}

--originator-requested-alternate-recipient EXTENSION ::= {
--  OriginatorRequestedAlternateRecipient,
--  RECOMMENDED CRITICALITY  {for-submission},
--  IDENTIFIED BY            standard-extension:2
--}

MTSOriginatorRequestedAlternateRecipient ::= ORAddressAndOrDirectoryName

-- OriginatorRequestedAlternateRecipient as defined here differs from the field of the same name 
-- defined in Figure 4, since on submission the OR-address need not be present, but on 
-- transfer the OR-address must be present.
--dl-expansion-prohibited EXTENSION ::= {
--  DLExpansionProhibited
--  IF ABSENT                dl-expansion-allowed,
--  RECOMMENDED CRITICALITY  {for-delivery},
--  IDENTIFIED BY            standard-extension:3
--}

DLExpansionProhibited ::= ENUMERATED {
  dl-expansion-allowed(0), dl-expansion-prohibited(1)}

--conversion-with-loss-prohibited EXTENSION ::= {
--  ConversionWithLossProhibited
--  IF ABSENT                conversion-with-loss-allowed,
--  RECOMMENDED CRITICALITY  {for-delivery},
--  IDENTIFIED BY            standard-extension:4
--}

ConversionWithLossProhibited ::= ENUMERATED {
  conversion-with-loss-allowed(0), conversion-with-loss-prohibited(1)
}

--latest-delivery-time EXTENSION ::= {
--  LatestDeliveryTime,
--  RECOMMENDED CRITICALITY  {for-delivery},
--  IDENTIFIED BY            standard-extension:5
--}

LatestDeliveryTime ::= Time

--requested-delivery-method EXTENSION ::= {
--  RequestedDeliveryMethod
--  IF ABSENT      {any-delivery-method},
--  IDENTIFIED BY  standard-extension:6
--}

RequestedDeliveryMethod ::=
  SEQUENCE OF INTEGER { -- each different in order of preference,
      -- most preferred first
      any-delivery-method(0), mhs-delivery(1), physical-delivery(2),
      telex-delivery(3), teletex-delivery(4), g3-facsimile-delivery(5),
  
    g4-facsimile-delivery(6), ia5-terminal-delivery(7), videotex-delivery(8),
      telephone-delivery(9)}(0..ub-integer-options)

--physical-forwarding-prohibited EXTENSION ::= {
--  PhysicalForwardingProhibited
--  IF ABSENT                physical-forwarding-allowed,
--  RECOMMENDED CRITICALITY  {for-delivery},
--  IDENTIFIED BY            standard-extension:7
--}

PhysicalForwardingProhibited ::= ENUMERATED {
  physical-forwarding-allowed(0), physical-forwarding-prohibited(1)}

--physical-forwarding-address-request EXTENSION ::= {
--  PhysicalForwardingAddressRequest
--  IF ABSENT                physical-forwarding-address-not-requested,
--  RECOMMENDED CRITICALITY  {for-delivery},
--  IDENTIFIED BY            standard-extension:8
--}

PhysicalForwardingAddressRequest ::= ENUMERATED {
  physical-forwarding-address-not-requested(0),
  physical-forwarding-address-requested(1)}

--physical-delivery-modes EXTENSION ::= {
--  PhysicalDeliveryModes
--  IF ABSENT                {ordinary-mail},
--  RECOMMENDED CRITICALITY  {for-delivery},
--  IDENTIFIED BY            standard-extension:9
--}

PhysicalDeliveryModes ::= BIT STRING {
  ordinary-mail(0), special-delivery(1), express-mail(2),
  counter-collection(3), counter-collection-with-telephone-advice(4),
  counter-collection-with-telex-advice(5),
  counter-collection-with-teletex-advice(6), bureau-fax-delivery(7)
                                             
-- bits 0 to 6 are mutually exclusive
-- bit 7 can be set independently of any of bits 0 to 6 --}
--(SIZE (0..ub-bit-options))

--registered-mail-type EXTENSION ::= {
--  RegisteredMailType
--  IF ABSENT                non-registered-mail,
--  RECOMMENDED CRITICALITY  {for-delivery},
--  IDENTIFIED BY            standard-extension:10
--}

RegisteredMailType ::= INTEGER {
  non-registered-mail(0), registered-mail(1),
  registered-mail-to-addressee-in-person(2)}(0..ub-integer-options)

--recipient-number-for-advice EXTENSION ::= {
--  RecipientNumberForAdvice,
--  RECOMMENDED CRITICALITY  {for-delivery},
--  IDENTIFIED BY            standard-extension:11
--}

RecipientNumberForAdvice ::=
  TeletexString --(SIZE (1..ub-recipient-number-for-advice-length))

--physical-rendition-attributes EXTENSION ::= {
--  PhysicalRenditionAttributes
--  IF ABSENT                id-att-physicalRendition-basic,
--  RECOMMENDED CRITICALITY  {for-delivery},
--  IDENTIFIED BY            standard-extension:12
--}

PhysicalRenditionAttributes ::= OBJECT IDENTIFIER

--originator-return-address EXTENSION ::= {
--  OriginatorReturnAddress,
--  IDENTIFIED BY  standard-extension:13
--}

OriginatorReturnAddress ::= ORAddress

--physical-delivery-report-request EXTENSION ::= {
--  PhysicalDeliveryReportRequest
--  IF ABSENT                return-of-undeliverable-mail-by-PDS,
--  RECOMMENDED CRITICALITY  {for-delivery},
--  IDENTIFIED BY            standard-extension:14
--}

PhysicalDeliveryReportRequest ::= INTEGER {
  return-of-undeliverable-mail-by-PDS(0), return-of-notification-by-PDS(1),
  return-of-notification-by-MHS(2), return-of-notification-by-MHS-and-PDS(3)
} -- (0..ub-integer-options)

--originator-certificate EXTENSION ::= {
--  OriginatorCertificate,
--  IDENTIFIED BY  standard-extension:15
--}

OriginatorCertificate ::= Certificates

--message-token EXTENSION ::= {
--  MessageToken,
--  RECOMMENDED CRITICALITY  {for-delivery},
--  IDENTIFIED BY            standard-extension:16
--}

--MessageToken ::= Token

--content-confidentiality-algorithm-identifier EXTENSION ::= {
--  ContentConfidentialityAlgorithmIdentifier,
--  RECOMMENDED CRITICALITY  {for-delivery},
--  IDENTIFIED BY            standard-extension:17
--}

ContentConfidentialityAlgorithmIdentifier ::= AlgorithmIdentifier

--content-integrity-check EXTENSION ::= {
--  ContentIntegrityCheck,
--  RECOMMENDED CRITICALITY  {for-delivery},
--  IDENTIFIED BY            standard-extension:18
--}

ContentIntegrityCheck ::= Signature
--  SIGNATURE
--    {SEQUENCE {algorithm-identifier
--                 ContentIntegrityAlgorithmIdentifier OPTIONAL,
--               content               Content}}

ContentIntegrityAlgorithmIdentifier ::= AlgorithmIdentifier

--message-origin-authentication-check EXTENSION ::= {
--  MessageOriginAuthenticationCheck,
--  RECOMMENDED CRITICALITY  {for-delivery},
--  IDENTIFIED BY            standard-extension:19
--}

MessageOriginAuthenticationCheck ::= Signature
--  SIGNATURE
--    {SEQUENCE {algorithm-identifier
--                 MessageOriginAuthenticationAlgorithmIdentifier,
--               content                 Content,
--               content-identifier      ContentIdentifier OPTIONAL,
--               message-security-label  MessageSecurityLabel OPTIONAL}}

MessageOriginAuthenticationAlgorithmIdentifier ::= AlgorithmIdentifier

--message-security-label EXTENSION ::= {
--  MessageSecurityLabel,
--  RECOMMENDED CRITICALITY  {for-delivery},
--  IDENTIFIED BY            standard-extension:20
--}

MessageSecurityLabel ::= SecurityLabel

--proof-of-submission-request EXTENSION ::= {
--  ProofOfSubmissionRequest
--  IF ABSENT                proof-of-submission-not-requested,
--  RECOMMENDED CRITICALITY  {for-submission},
--  IDENTIFIED BY            standard-extension:21
--}

ProofOfSubmissionRequest ::= ENUMERATED {
  proof-of-submission-not-requested(0), proof-of-submission-requested(1)
}

--proof-of-delivery-request EXTENSION ::= {
--  ProofOfDeliveryRequest
--  IF ABSENT                proof-of-delivery-not-requested,
--  RECOMMENDED CRITICALITY  {for-delivery},
--  IDENTIFIED BY            standard-extension:22
--}

ProofOfDeliveryRequest ::= ENUMERATED {
  proof-of-delivery-not-requested(0), proof-of-delivery-requested(1)}

--content-correlator EXTENSION ::= {
--  ContentCorrelator,
--  IDENTIFIED BY  standard-extension:23
--}

ContentCorrelator ::= CHOICE {ia5text  IA5String,
                              octets   OCTET STRING
}

--probe-origin-authentication-check EXTENSION ::= {
--  ProbeOriginAuthenticationCheck,
--  RECOMMENDED CRITICALITY  {for-delivery},
--  IDENTIFIED BY            standard-extension:24
--}

ProbeOriginAuthenticationCheck ::= Signature
--  SIGNATURE
--    {SEQUENCE {algorithm-identifier
--                 ProbeOriginAuthenticationAlgorithmIdentifier,
--               content-identifier      ContentIdentifier OPTIONAL,
--               message-security-label  MessageSecurityLabel OPTIONAL}}

ProbeOriginAuthenticationAlgorithmIdentifier ::= AlgorithmIdentifier

--redirection-history EXTENSION ::= {
--  RedirectionHistory,
--  IDENTIFIED BY  standard-extension:25
--}

RedirectionHistory ::= SEQUENCE SIZE (1..ub-redirections) OF Redirection

Redirection ::= SEQUENCE {
  intended-recipient-name  IntendedRecipientName,
  redirection-reason       RedirectionReason
}

IntendedRecipientName ::= SEQUENCE {
  intended-recipient  ORAddressAndOptionalDirectoryName,
  redirection-time    Time
}

RedirectionReason ::= ENUMERATED {
  recipient-assigned-alternate-recipient(0),
  originator-requested-alternate-recipient(1),
  recipient-MD-assigned-alternate-recipient(2),
  -- The following values may not be supported by implementations of earlier versions of this Service Definition
  directory-look-up(3), alias(4), ...
  }

--dl-expansion-history EXTENSION ::= {
--  DLExpansionHistory,
--  IDENTIFIED BY  standard-extension:26
--}

DLExpansionHistory ::= SEQUENCE -- SIZE (1..ub-dl-expansions)-- OF DLExpansion

DLExpansion ::= SEQUENCE {
  dl                 ORAddressAndOptionalDirectoryName,
  dl-expansion-time  Time
}

--physical-forwarding-address EXTENSION ::= {
--  PhysicalForwardingAddress,
--  IDENTIFIED BY  standard-extension:27
--}

PhysicalForwardingAddress ::= ORAddressAndOptionalDirectoryName

--recipient-certificate EXTENSION ::= {
--  RecipientCertificate,
--  IDENTIFIED BY  standard-extension:28
--}

--proof-of-delivery EXTENSION ::= {
--  ProofOfDelivery,
--  IDENTIFIED BY  standard-extension:29
--}

--originator-and-DL-expansion-history EXTENSION ::= {
--  OriginatorAndDLExpansionHistory,
--  IDENTIFIED BY  standard-extension:30
--}

OriginatorAndDLExpansionHistory ::=
  SEQUENCE --SIZE (2..ub-orig-and-dl-expansions)-- OF OriginatorAndDLExpansion

OriginatorAndDLExpansion ::= SEQUENCE {
  originator-or-dl-name          ORAddressAndOptionalDirectoryName,
  origination-or-expansion-time  Time
}

--reporting-DL-name EXTENSION ::= {
--  ReportingDLName,
--  IDENTIFIED BY  standard-extension:31
--}

ReportingDLName ::= ORAddressAndOptionalDirectoryName

--reporting-MTA-certificate EXTENSION ::= {
--  ReportingMTACertificate,
--  RECOMMENDED CRITICALITY  {for-delivery},
--  IDENTIFIED BY            standard-extension:32
--}

ReportingMTACertificate ::= Certificates

--report-origin-authentication-check EXTENSION ::= {
--  ReportOriginAuthenticationCheck,
--  RECOMMENDED CRITICALITY  {for-delivery},
--  IDENTIFIED BY            standard-extension:33
--}

ReportOriginAuthenticationCheck ::= Signature
--  SIGNATURE
--    {SEQUENCE {algorithm-identifier
--                 ReportOriginAuthenticationAlgorithmIdentifier,
--               content-identifier      ContentIdentifier OPTIONAL,
--               message-security-label  MessageSecurityLabel OPTIONAL,
--               per-recipient
--                 SEQUENCE SIZE (1..ub-recipients) OF PerRecipientReportFields
--    }}

ReportOriginAuthenticationAlgorithmIdentifier ::= AlgorithmIdentifier

PerRecipientReportFields ::= SEQUENCE {
  actual-recipient-name               MTSActualRecipientName,
  originally-intended-recipient-name  MTSOriginallyIntendedRecipientName OPTIONAL,
  report-type
    CHOICE {delivery      [0]  PerRecipientDeliveryReportFields,
            non-delivery  [1]  PerRecipientNonDeliveryReportFields}
}

PerRecipientDeliveryReportFields ::= SEQUENCE {
  message-delivery-time  MessageDeliveryTime,
  type-of-MTS-user       TypeOfMTSUser,
  recipient-certificate  [0]  RecipientCertificate OPTIONAL
--  proof-of-delivery      [1]  ProofOfDelivery OPTIONAL
}

PerRecipientNonDeliveryReportFields ::= SEQUENCE {
  non-delivery-reason-code      NonDeliveryReasonCode,
  non-delivery-diagnostic-code  NonDeliveryDiagnosticCode OPTIONAL
}

--originating-MTA-certificate EXTENSION ::= {
--  OriginatingMTACertificate,
--  IDENTIFIED BY  standard-extension:34
--}

OriginatingMTACertificate ::= Certificates

--proof-of-submission EXTENSION ::= {
--  ProofOfSubmission,
--  IDENTIFIED BY  standard-extension:35
--}

ProofOfSubmission ::= Signature
--  SIGNATURE
--    {SEQUENCE {algorithm-identifier
--                 ProofOfSubmissionAlgorithmIdentifier,
--               message-submission-envelope    MessageSubmissionEnvelope,
--               content                        Content,
--               message-submission-identifier  MessageSubmissionIdentifier,
--               message-submission-time        MessageSubmissionTime}}

--ProofOfSubmissionAlgorithmIdentifier ::= AlgorithmIdentifier

--reporting-MTA-name EXTENSION ::= {
--  ReportingMTAName,
--  IDENTIFIED BY  standard-extension:39
--}

ReportingMTAName ::= SEQUENCE {
  domain              GlobalDomainIdentifier,
  mta-name            MTAName,
  mta-directory-name  [0]  Name OPTIONAL
}

--multiple-originator-certificates EXTENSION ::= {
--  ExtendedCertificates,
--  IDENTIFIED BY  standard-extension:40
--}

ExtendedCertificates ::= SET --SIZE (1..ub-certificates)-- OF ExtendedCertificate

ExtendedCertificate ::= CHOICE {
  directory-entry  [0]  Name, -- Name of a Directory entry where the certificate can be found
  certificate      [1]  Certificates
}

--dl-exempted-recipients EXTENSION ::= {
--  DLExemptedRecipients,
--  IDENTIFIED BY  standard-extension:42
--}

DLExemptedRecipients ::= SET OF ORAddressAndOrDirectoryName

--certificate-selectors EXTENSION ::= {
--  CertificateSelectors,
--  IDENTIFIED BY  standard-extension:45
--}

CertificateSelectors ::= SET {
  encryption-recipient           [0]  CertificateAssertion OPTIONAL,
  encryption-originator          [1]  CertificateAssertion OPTIONAL,
  content-integrity-check        [2]  CertificateAssertion OPTIONAL,
  token-signature                [3]  CertificateAssertion OPTIONAL,
  message-origin-authentication  [4]  CertificateAssertion OPTIONAL
}

--certificate-selectors-override EXTENSION ::= {
--  CertificateSelectors
--    (WITH COMPONENTS {
--       ...,
--       message-origin-authentication  ABSENT
--     }),
--  IDENTIFIED BY  standard-extension:46
--}

-- Some standard-extensions are defined elsewhere:
--	36 (forwarding-request) in ITU-T Rec. X.413 | ISO/IEC 10021-5;
--	37 (trace-information), and 38 (internal-trace-information) in Figure 4;
--	41 (blind-copy-recipients), 43 (body-part-encryption-token), and 44 (forwarded-content-token) in 
--		ITU-T Rec. X.420 | ISO/IEC 10021-7
--	Common Parameter Types
Content ::=
  OCTET
    STRING -- when the content-type has the integer value external, the value of the

-- content octet string is the ASN.1 encoding of the external-content;
-- an external-content is a data type EXTERNAL
MTSIdentifier ::= [APPLICATION 4]  SEQUENCE {
  global-domain-identifier  GlobalDomainIdentifier,
  local-identifier          LocalIdentifier
}

LocalIdentifier ::= IA5String --(SIZE (1..ub-local-id-length))

GlobalDomainIdentifier ::= [APPLICATION 3]  SEQUENCE {
  country-name                CountryName,
  administration-domain-name  AdministrationDomainName,
  private-domain-identifier   PrivateDomainIdentifier OPTIONAL
}

PrivateDomainIdentifier ::= CHOICE {
  numeric    NumericString --(SIZE (1..ub-domain-name-length))--,
  printable  PrintableString --(SIZE (1..ub-domain-name-length))
}

MTAName ::= IA5String --(SIZE (1..ub-mta-name-length))

Time ::= UTCTime


--	OR Names
ORAddressAndOrDirectoryName ::= ORName

ORAddressAndOptionalDirectoryName ::= ORName

ORName ::= [APPLICATION 0]  SEQUENCE {
  -- address - -COMPONENTS OF ORAddress,
  built-in-standard-attributes        BuiltInStandardAttributes,
  built-in-domain-defined-attributes  BuiltInDomainDefinedAttributes OPTIONAL,
  -- see also teletex-domain-defined-attributes
  extension-attributes                ExtensionAttributes OPTIONAL,
  directory-name  [0]  Name OPTIONAL
}

ORAddress ::= SEQUENCE {
  built-in-standard-attributes        BuiltInStandardAttributes,
  built-in-domain-defined-attributes  BuiltInDomainDefinedAttributes OPTIONAL,
  -- see also teletex-domain-defined-attributes
  extension-attributes                ExtensionAttributes OPTIONAL
}

--	The OR-address is semantically absent from the OR-name if the built-in-standard-attribute
--	sequence is empty and the built-in-domain-defined-attributes and extension-attributes are both omitted.
--	Built-in Standard Attributes
BuiltInStandardAttributes ::= SEQUENCE {
  country-name                CountryName OPTIONAL,
  administration-domain-name  AdministrationDomainName OPTIONAL,
  network-address             [0]  NetworkAddress OPTIONAL,
  -- see also extended-network-address
  terminal-identifier         [1]  TerminalIdentifier OPTIONAL,
  private-domain-name         [2]  PrivateDomainName OPTIONAL,
  organization-name           [3]  OrganizationName OPTIONAL,
  -- see also teletex-organization-name
  numeric-user-identifier     [4]  NumericUserIdentifier OPTIONAL,
  personal-name               [5]  PersonalName OPTIONAL,
  -- see also teletex-personal-name
  organizational-unit-names   [6]  OrganizationalUnitNames OPTIONAL
  -- see also teletex-organizational-unit-names 
}

CountryName ::= [APPLICATION 1]  CHOICE {
  x121-dcc-code         NumericString --(SIZE (ub-country-name-numeric-length))--,
  iso-3166-alpha2-code  PrintableString --(SIZE (ub-country-name-alpha-length))
}

AdministrationDomainName ::= [APPLICATION 2]  CHOICE {
  numeric    NumericString --(SIZE (0..ub-domain-name-length))--,
  printable  PrintableString --(SIZE (0..ub-domain-name-length))
}

NetworkAddress ::= X121Address

-- see also extended-network-address
X121Address ::= NumericString --(SIZE (1..ub-x121-address-length))

TerminalIdentifier ::= PrintableString --(SIZE (1..ub-terminal-id-length))

PrivateDomainName ::= CHOICE {
  numeric    NumericString --(SIZE (1..ub-domain-name-length))--,
  printable  PrintableString --(SIZE (1..ub-domain-name-length))
}

OrganizationName ::= PrintableString --(SIZE (1..ub-organization-name-length))

-- see also teletex-organization-name
NumericUserIdentifier ::= NumericString --(SIZE (1..ub-numeric-user-id-length))

PersonalName ::= SET {
  surname               [0]  PrintableString --(SIZE (1..ub-surname-length)) --,
  given-name
    [1]  PrintableString --(SIZE (1..ub-given-name-length))-- OPTIONAL,
  initials
    [2]  PrintableString --(SIZE (1..ub-initials-length))-- OPTIONAL,
  generation-qualifier
    [3]  PrintableString --(SIZE (1..ub-generation-qualifier-length))-- OPTIONAL
}

-- see also teletex-personal-name
OrganizationalUnitNames ::=
  SEQUENCE --SIZE (1..ub-organizational-units)-- OF OrganizationalUnitName

-- see also teletex-organizational-unit-names
OrganizationalUnitName ::=
  PrintableString --(SIZE (1..ub-organizational-unit-name-length))

--	Built-in Domain-defined Attributes
BuiltInDomainDefinedAttributes ::=
  SEQUENCE --SIZE (1..ub-domain-defined-attributes)-- OF
    BuiltInDomainDefinedAttribute

BuiltInDomainDefinedAttribute ::= SEQUENCE {
  type   PrintableString--(SIZE (1..ub-domain-defined-attribute-type-length))--,
  value  PrintableString --(SIZE (1..ub-domain-defined-attribute-value-length))
}

--	Extension Attributes
ExtensionAttributes ::=
  SET --SIZE (1..ub-extension-attributes)-- OF ExtensionAttribute

ExtensionAttribute ::= SEQUENCE {
  extension-attribute-type
    [0]  INTEGER --EXTENSION-ATTRIBUTE.&id({ExtensionAttributeTable}) --,
  extension-attribute-value
    [1]  ANY --EXTENSION-ATTRIBUTE.&Type
--           ({ExtensionAttributeTable}{@extension-attribute-type})
}

--EXTENSION-ATTRIBUTE ::= CLASS {
--  &id    INTEGER(0..ub-extension-attributes) UNIQUE,
--  &Type  
--}WITH SYNTAX {&Type
--              IDENTIFIED BY &id
--}

--ExtensionAttributeTable EXTENSION-ATTRIBUTE ::=
--  {common-name | teletex-common-name | universal-common-name |
--   teletex-organization-name | universal-organization-name |
--   teletex-personal-name | universal-personal-name |
--   teletex-organizational-unit-names | universal-organizational-unit-names |
--   teletex-domain-defined-attributes | universal-domain-defined-attributes |
--   pds-name | physical-delivery-country-name | postal-code |
--   physical-delivery-office-name | universal-physical-delivery-office-name |
--   physical-delivery-office-number | universal-physical-delivery-office-number
--   | extension-OR-address-components |
--   universal-extension-OR-address-components | physical-delivery-personal-name
--   | universal-physical-delivery-personal-name |
--   physical-delivery-organization-name |
--   universal-physical-delivery-organization-name |
--   extension-physical-delivery-address-components |
--   universal-extension-physical-delivery-address-components |
--   unformatted-postal-address | universal-unformatted-postal-address |
--   street-address | universal-street-address | post-office-box-address |
--   universal-post-office-box-address | poste-restante-address |
--   universal-poste-restante-address | unique-postal-name |
--   universal-unique-postal-name | local-postal-attributes |
--   universal-local-postal-attributes | extended-network-address | terminal-type
--  }

--	Extension Standard Attributes
--common-name EXTENSION-ATTRIBUTE ::= {CommonName
--                                     IDENTIFIED BY  1
--}

CommonName ::= PrintableString --(SIZE (1..ub-common-name-length))

--teletex-common-name EXTENSION-ATTRIBUTE ::= {TeletexCommonName
--                                             IDENTIFIED BY  2
--}

TeletexCommonName ::= TeletexString --(SIZE (1..ub-common-name-length))

--universal-common-name EXTENSION-ATTRIBUTE ::= {
--  UniversalCommonName
--  IDENTIFIED BY  24
--}

UniversalCommonName ::= UniversalOrBMPString --{ub-common-name-length}

--teletex-organization-name EXTENSION-ATTRIBUTE ::= {
--  TeletexOrganizationName
--  IDENTIFIED BY  3
--}

TeletexOrganizationName ::=
  TeletexString --(SIZE (1..ub-organization-name-length))

--universal-organization-name EXTENSION-ATTRIBUTE ::= {
--  UniversalOrganizationName
--  IDENTIFIED BY  25
--}

UniversalOrganizationName ::= UniversalOrBMPString --{ub-organization-name-length}

--teletex-personal-name EXTENSION-ATTRIBUTE ::= {
--  TeletexPersonalName
--  IDENTIFIED BY  4
--}

TeletexPersonalName ::= SET {
  surname               [0]  TeletexString --(SIZE (1..ub-surname-length))--,
  given-name
    [1]  TeletexString --(SIZE (1..ub-given-name-length))-- OPTIONAL,
  initials
    [2]  TeletexString --(SIZE (1..ub-initials-length))-- OPTIONAL,
  generation-qualifier
    [3]  TeletexString --(SIZE (1..ub-generation-qualifier-length))-- OPTIONAL
}

--universal-personal-name EXTENSION-ATTRIBUTE ::= {
--  UniversalPersonalName
--  IDENTIFIED BY  26
--}

UniversalPersonalName ::= SET {
  surname               [0]  UniversalOrBMPString --{ub-universal-surname-length}--,
  --	If a language is specified within surname, then that language applies to each of the following
  --	optional components unless the component specifies another language.
  given-name
    [1]  UniversalOrBMPString --{ub-universal-given-name-length}-- OPTIONAL,
  initials
    [2]  UniversalOrBMPString --{ub-universal-initials-length}-- OPTIONAL,
  generation-qualifier
    [3]  UniversalOrBMPString --{ub-universal-generation-qualifier-length}
      OPTIONAL
}

--teletex-organizational-unit-names EXTENSION-ATTRIBUTE ::= {
--  TeletexOrganizationalUnitNames
--  IDENTIFIED BY  5
--}

TeletexOrganizationalUnitNames ::=
  SEQUENCE --SIZE (1..ub-organizational-units)-- OF TeletexOrganizationalUnitName

TeletexOrganizationalUnitName ::=
  TeletexString --(SIZE (1..ub-organizational-unit-name-length))

--universal-organizational-unit-names EXTENSION-ATTRIBUTE ::= {
--  UniversalOrganizationalUnitNames
--  IDENTIFIED BY  27
--}

UniversalOrganizationalUnitNames ::=
  SEQUENCE --SIZE (1..ub-organizational-units)-- OF UniversalOrganizationalUnitName

--	If a unit name specifies a language, then that language applies to subordinate unit names unless
--	the subordinate specifies another language.
UniversalOrganizationalUnitName ::=
  UniversalOrBMPString --{ub-organizational-unit-name-length}

UniversalOrBMPString --{INTEGER:ub-string-length}-- ::= SET {
  character-encoding
    CHOICE {two-octets   BMPString --(SIZE (1..ub-string-length))--,
            four-octets  UniversalString --(SIZE (1..ub-string-length))-- },
  iso-639-language-code  PrintableString --(SIZE (2 | 5))-- OPTIONAL
}

--pds-name EXTENSION-ATTRIBUTE ::= {PDSName
--                                  IDENTIFIED BY  7
--}

PDSName ::= PrintableString --(SIZE (1..ub-pds-name-length))

--physical-delivery-country-name EXTENSION-ATTRIBUTE ::= {
--  PhysicalDeliveryCountryName
--  IDENTIFIED BY  8
--}

PhysicalDeliveryCountryName ::= CHOICE {
  x121-dcc-code         NumericString --(SIZE (ub-country-name-numeric-length)) --,
  iso-3166-alpha2-code  PrintableString --(SIZE (ub-country-name-alpha-length))
}

--postal-code EXTENSION-ATTRIBUTE ::= {PostalCode
--                                     IDENTIFIED BY  9
--}

PostalCode ::= CHOICE {
  numeric-code    NumericString --(SIZE (1..ub-postal-code-length))--,
  printable-code  PrintableString --(SIZE (1..ub-postal-code-length))
}

--physical-delivery-office-name EXTENSION-ATTRIBUTE ::= {
--  PhysicalDeliveryOfficeName
--  IDENTIFIED BY  10
--}

PhysicalDeliveryOfficeName ::= PDSParameter

--universal-physical-delivery-office-name EXTENSION-ATTRIBUTE ::= {
--  UniversalPhysicalDeliveryOfficeName
--  IDENTIFIED BY  29
--}

UniversalPhysicalDeliveryOfficeName ::= UniversalPDSParameter

--physical-delivery-office-number EXTENSION-ATTRIBUTE ::= {
--  PhysicalDeliveryOfficeNumber
--  IDENTIFIED BY  11
--}

PhysicalDeliveryOfficeNumber ::= PDSParameter

--universal-physical-delivery-office-number EXTENSION-ATTRIBUTE ::= {
--  UniversalPhysicalDeliveryOfficeNumber
--  IDENTIFIED BY  30
--}

UniversalPhysicalDeliveryOfficeNumber ::= UniversalPDSParameter

--extension-OR-address-components EXTENSION-ATTRIBUTE ::= {
--  ExtensionORAddressComponents
--  IDENTIFIED BY  12
--}

ExtensionORAddressComponents ::= PDSParameter

--universal-extension-OR-address-components EXTENSION-ATTRIBUTE ::= {
--  UniversalExtensionORAddressComponents
--  IDENTIFIED BY  31
--}

UniversalExtensionORAddressComponents ::= UniversalPDSParameter

--physical-delivery-personal-name EXTENSION-ATTRIBUTE ::= {
--  PhysicalDeliveryPersonalName
--  IDENTIFIED BY  13
--}

PhysicalDeliveryPersonalName ::= PDSParameter

--universal-physical-delivery-personal-name EXTENSION-ATTRIBUTE ::= {
--  UniversalPhysicalDeliveryPersonalName
--  IDENTIFIED BY  32
--}

UniversalPhysicalDeliveryPersonalName ::= UniversalPDSParameter

--physical-delivery-organization-name EXTENSION-ATTRIBUTE ::= {
--  PhysicalDeliveryOrganizationName
--  IDENTIFIED BY  14
--}

PhysicalDeliveryOrganizationName ::= PDSParameter

--universal-physical-delivery-organization-name EXTENSION-ATTRIBUTE ::= 
--{UniversalPhysicalDeliveryOrganizationName
-- IDENTIFIED BY  33
--}

UniversalPhysicalDeliveryOrganizationName ::= UniversalPDSParameter

--extension-physical-delivery-address-components EXTENSION-ATTRIBUTE ::= 
--{ExtensionPhysicalDeliveryAddressComponents
-- IDENTIFIED BY  15
--}

ExtensionPhysicalDeliveryAddressComponents ::= PDSParameter

--universal-extension-physical-delivery-address-components EXTENSION-ATTRIBUTE
--  ::= {UniversalExtensionPhysicalDeliveryAddressComponents
--       IDENTIFIED BY  34
--}

UniversalExtensionPhysicalDeliveryAddressComponents ::= UniversalPDSParameter

--unformatted-postal-address EXTENSION-ATTRIBUTE ::= {
--  UnformattedPostalAddress
--  IDENTIFIED BY  16
--}

UnformattedPostalAddress ::= SET {
  printable-address
    SEQUENCE --SIZE (1..ub-pds-physical-address-lines)-- OF
      PrintableString --(SIZE (1..ub-pds-parameter-length))-- OPTIONAL,
  teletex-string
    TeletexString --(SIZE (1..ub-unformatted-address-length))-- OPTIONAL
}

--universal-unformatted-postal-address EXTENSION-ATTRIBUTE ::= {
--  UniversalUnformattedPostalAddress
--  IDENTIFIED BY  35
--}

UniversalUnformattedPostalAddress ::=
  UniversalOrBMPString --{ub-unformatted-address-length}

--street-address EXTENSION-ATTRIBUTE ::= {StreetAddress
--                                        IDENTIFIED BY  17
--}

StreetAddress ::= PDSParameter

--universal-street-address EXTENSION-ATTRIBUTE ::= {
--  UniversalStreetAddress
--  IDENTIFIED BY  36
--}

UniversalStreetAddress ::= UniversalPDSParameter

--post-office-box-address EXTENSION-ATTRIBUTE ::= {
--  PostOfficeBoxAddress
--  IDENTIFIED BY  18
--}

PostOfficeBoxAddress ::= PDSParameter

--universal-post-office-box-address EXTENSION-ATTRIBUTE ::= {
--  UniversalPostOfficeBoxAddress
--  IDENTIFIED BY  37
--}

UniversalPostOfficeBoxAddress ::= UniversalPDSParameter

--poste-restante-address EXTENSION-ATTRIBUTE ::= {
--  PosteRestanteAddress
--  IDENTIFIED BY  19
--}

--PosteRestanteAddress ::= PDSParameter

--universal-poste-restante-address EXTENSION-ATTRIBUTE ::= {
--  UniversalPosteRestanteAddress
--  IDENTIFIED BY  38
--}

UniversalPosteRestanteAddress ::= UniversalPDSParameter

--unique-postal-name EXTENSION-ATTRIBUTE ::= {UniquePostalName
--                                            IDENTIFIED BY  20
--}

UniquePostalName ::= PDSParameter

--universal-unique-postal-name EXTENSION-ATTRIBUTE ::= {
--  UniversalUniquePostalName
--  IDENTIFIED BY  39
--}

UniversalUniquePostalName ::= UniversalPDSParameter

--local-postal-attributes EXTENSION-ATTRIBUTE ::= {
--  LocalPostalAttributes
--  IDENTIFIED BY  21
--}

LocalPostalAttributes ::= PDSParameter

--universal-local-postal-attributes EXTENSION-ATTRIBUTE ::= {
--  UniversalLocalPostalAttributes
--  IDENTIFIED BY  40
--}

UniversalLocalPostalAttributes ::= UniversalPDSParameter

PDSParameter ::= SET {
  printable-string  PrintableString --(SIZE (1..ub-pds-parameter-length))-- OPTIONAL,
  teletex-string    TeletexString --(SIZE (1..ub-pds-parameter-length))-- OPTIONAL
}

UniversalPDSParameter ::= UniversalOrBMPString --{ub-pds-parameter-length}

--extended-network-address EXTENSION-ATTRIBUTE ::= {
--  ExtendedNetworkAddress
--  IDENTIFIED BY  22
--}

ExtendedNetworkAddress ::= CHOICE {
  e163-4-address
    SEQUENCE {number
                [0]  NumericString --(SIZE (1..ub-e163-4-number-length))--,
              sub-address
                [1]  NumericString --(SIZE (1..ub-e163-4-sub-address-length))--
                  OPTIONAL},
  psap-address    [0]  PresentationAddress
}

--terminal-type EXTENSION-ATTRIBUTE ::= {TerminalType
--                                       IDENTIFIED BY  23
--}

TerminalType ::= INTEGER {
  telex(3), teletex(4), g3-facsimile(5), g4-facsimile(6), ia5-terminal(7),
  videotex(8)} --(0..ub-integer-options)

--	Extension Domain-defined Attributes
--teletex-domain-defined-attributes EXTENSION-ATTRIBUTE ::= {
--  TeletexDomainDefinedAttributes
--  IDENTIFIED BY  6
--}

TeletexDomainDefinedAttributes ::=
  SEQUENCE --SIZE (1..ub-domain-defined-attributes)-- OF
    TeletexDomainDefinedAttribute

TeletexDomainDefinedAttribute ::= SEQUENCE {
  type   TeletexString --(SIZE (1..ub-domain-defined-attribute-type-length))--,
  value  TeletexString --(SIZE (1..ub-domain-defined-attribute-value-length))

}

--universal-domain-defined-attributes EXTENSION-ATTRIBUTE ::= {
--  UniversalDomainDefinedAttributes
--  IDENTIFIED BY  28
--}

UniversalDomainDefinedAttributes ::=
  SEQUENCE --SIZE (1..ub-domain-defined-attributes)-- OF
    UniversalDomainDefinedAttribute

UniversalDomainDefinedAttribute ::= SEQUENCE {
  type   UniversalOrBMPString --{ub-domain-defined-attribute-type-length}--,
  value  UniversalOrBMPString --{ub-domain-defined-attribute-value-length}
}

--	Encoded Information Types
EncodedInformationTypes ::= [APPLICATION 5]  SET {
  built-in-encoded-information-types  [0]  BuiltInEncodedInformationTypes,
  -- non-basic-parameters - -COMPONENTS OF NonBasicParameters,
  g3-facsimile  [1]  G3FacsimileNonBasicParameters DEFAULT {},
  teletex       [2]  TeletexNonBasicParameters DEFAULT {},
  extended-encoded-information-types
    [4]  ExtendedEncodedInformationTypes OPTIONAL
}

--	Built-in Encoded Information Types
BuiltInEncodedInformationTypes ::= BIT STRING {
  unknown(0), ia5-text(2), g3-facsimile(3), g4-class-1(4), teletex(5),
  videotex(6), voice(7), sfd(8), mixed-mode(9)
} --(SIZE (0..ub-built-in-encoded-information-types))

--	Extended Encoded Information Types
ExtendedEncodedInformationTypes ::=
  SET --SIZE (1..ub-encoded-information-types)-- OF ExtendedEncodedInformationType

ExtendedEncodedInformationType ::= OBJECT IDENTIFIER

--	Non-basic Parameters
NonBasicParameters ::= SET {
  g3-facsimile  [1]  G3FacsimileNonBasicParameters DEFAULT {},
  teletex       [2]  TeletexNonBasicParameters DEFAULT {}
}

G3FacsimileNonBasicParameters ::= BIT STRING {
  two-dimensional(8), -- As defined in ITU-T Recommendation T.30
  fine-resolution(9), --
  unlimited-length(20), -- These bit values are chosen such that when
  b4-length(21), -- encoded using ASN.1 Basic Encoding Rules
  a3-width(22), -- the resulting octets have the same values
  b4-width(23), -- as for T.30 encoding
  t6-coding(25), --
  uncompressed(30), -- Trailing zero bits are not significant.
  width-middle-864-of-1728(37), -- It is recommended that implementations
  width-middle-1216-of-1728(38), -- should not encode more than 32 bits unless
  resolution-type(44), -- higher numbered bits are non-zero.
  resolution-400x400(45), resolution-300x300(46), resolution-8x15(47), 
  edi(49), dtm(50), bft(51), mixed-mode(58), character-mode(60),
  twelve-bits(65), preferred-huffmann(66), full-colour(67), jpeg(68),
  processable-mode-26(71)}

TeletexNonBasicParameters ::= SET {
  graphic-character-sets               [0]  TeletexString OPTIONAL,
  control-character-sets               [1]  TeletexString OPTIONAL,
  page-formats                         [2]  OCTET STRING OPTIONAL,
  miscellaneous-terminal-capabilities  [3]  TeletexString OPTIONAL,
  private-use
    [4]  OCTET STRING
      OPTIONAL -- maximum ub-teletex-private-use-length octets --
}

-- as defined in CCITT Recommendation T.62
--	Token
Token ::= SEQUENCE {
  token-type-identifier  [0]  -- TOKEN.&id({TokensTable})-- TokenTypeIdentifier,
  token
    [1]  --TOKEN.&Type({TokensTable}{@token-type-identifier})-- TokenTypeData
}

--TOKEN ::= TYPE-IDENTIFIER
TokenTypeIdentifier ::= OBJECT IDENTIFIER
TokenTypeData ::= ANY

--TokensTable TOKEN ::= {asymmetric-token, ...}

--asymmetric-token TOKEN ::= {
--  AsymmetricToken
--  IDENTIFIED BY  id-tok-asymmetricToken
--}

AsymmetricTokenData ::=
--  SIGNED
--    {--SEQUENCE {signature-algorithm-identifier   AlgorithmIdentifier,
               name
                 CHOICE {recipient-name  MTSRecipientName,
                         mta  [3]  MTANameAndOptionalGDI },
               time                             Time,
               signed-data                      [0]  TokenData OPTIONAL,
               encryption-algorithm-identifier
                 [1]  AlgorithmIdentifier OPTIONAL,
               encrypted-data
                 [2] -- ENCRYPTED{TokenData}-- BIT STRING OPTIONAL} --}

MTANameAndOptionalGDI ::= SEQUENCE {
     global-domain-identifier       GlobalDomainIdentifier OPTIONAL,
     mta-name                  MTAName
}

AsymmetricToken ::= SEQUENCE {
  asymmetric-token-data		AsymmetricTokenData,
  algorithm-identifier		AlgorithmIdentifier,
  encrypted			BIT STRING
}

--TokenData ::= SEQUENCE {
--  type   [0]  TOKEN-DATA.&id({TokenDataTable}),
--  value  [1]  TOKEN-DATA.&Type({TokenDataTable}{@type})
--}

--TOKEN-DATA ::= CLASS {&id    INTEGER UNIQUE,
--                      &Type  
--}WITH SYNTAX {&Type
--              IDENTIFIED BY &id
--}

--TokenDataTable TOKEN-DATA ::=
--  {bind-token-signed-data | message-token-signed-data |
--   message-token-encrypted-data | bind-token-encrypted-data, ...}

--bind-token-signed-data TOKEN-DATA ::= {BindTokenSignedData
--                                       IDENTIFIED BY  1
--}

-- This is the only Token Data we know
TokenData ::= BindTokenSignedData

BindTokenSignedData ::= RandomNumber

RandomNumber ::= BIT STRING

--message-token-signed-data TOKEN-DATA ::= {
--  MessageTokenSignedData
--  IDENTIFIED BY  2
--}

--MessageTokenSignedData ::= SEQUENCE {
--  content-confidentiality-algorithm-identifier
--    [0]  ContentConfidentialityAlgorithmIdentifier OPTIONAL,
--  content-integrity-check
--    [1]  ContentIntegrityCheck OPTIONAL,
--  message-security-label
--    [2]  MessageSecurityLabel OPTIONAL,
--  proof-of-delivery-request
--    [3]  ProofOfDeliveryRequest OPTIONAL,
--  message-sequence-number                       [4]  INTEGER OPTIONAL
--}

--message-token-encrypted-data TOKEN-DATA ::= {
--  MessageTokenEncryptedData
--  IDENTIFIED BY  3
--}

--MessageTokenEncryptedData ::= SEQUENCE {
--  content-confidentiality-key  [0]  EncryptionKey OPTIONAL,
--  content-integrity-check      [1]  ContentIntegrityCheck OPTIONAL,
--  message-security-label       [2]  MessageSecurityLabel OPTIONAL,
--  content-integrity-key        [3]  EncryptionKey OPTIONAL,
--  message-sequence-number      [4]  INTEGER OPTIONAL
--}

--EncryptionKey ::= BIT STRING

--bind-token-encrypted-data TOKEN-DATA ::= {
--  BindTokenEncryptedData
--  IDENTIFIED BY  4
--}

--BindTokenEncryptedData ::= EXTERNAL

--	Security Label
SecurityLabel ::= SET {
  security-policy-identifier  SecurityPolicyIdentifier OPTIONAL,
  security-classification     SecurityClassification OPTIONAL,
  privacy-mark                PrivacyMark OPTIONAL,
  security-categories         SecurityCategories OPTIONAL
}

SecurityPolicyIdentifier ::= OBJECT IDENTIFIER

SecurityClassification ::= INTEGER {
  unmarked(0), unclassified(1), restricted(2), confidential(3), secret(4),
  top-secret(5)}(0..ub-integer-options)

PrivacyMark ::= PrintableString(SIZE (1..ub-privacy-mark-length))

SecurityCategories ::= SET SIZE (1..ub-security-categories) OF SecurityCategory

SecurityCategory ::= SEQUENCE {
  type   [0]  OBJECT IDENTIFIER --SECURITY-CATEGORY.&id({SecurityCategoriesTable})--,
  value  [1]  ANY -- SECURITY-CATEGORY.&Type({SecurityCategoriesTable}{@type})
}

--SECURITY-CATEGORY ::= TYPE-IDENTIFIER

--SecurityCategoriesTable SECURITY-CATEGORY ::=
--  {...}

END -- of MTSAbstractService

-- Generated by Asnp, the ASN.1 pretty-printer of France Telecom R&D